nac3core/src/typecheck/type_inferencer/mod.rs

@@ -1181,38 +1181,21 @@ impl<'a> Inferencer<'a> {
                         slice.location,
                     ),
                     TypeEnum::TNDArray { ty: elem_ty, num_dims } => {
-                        let num_idxs = match &*self.unifier.get_ty(slice.custom.unwrap()) {
-                            TypeEnum::TTuple { ty: idx_tys } => {
-                                for idx_ty in idx_tys.iter() {
-                                    // xxx: NumPy supports a tuple of tuples for "advanced indexing"
-                                    // of multidimensional arrays (sequence index -> subset). We
-                                    // don't support this, but could give a better error message.
-                                    self.constrain(
-                                        *idx_ty,
-                                        self.primitives.int32,
-                                        &slice.location,
-                                    )?;
-                                }
-                                idx_tys.len()
-                            }
-                            TypeEnum::TList { .. } | TypeEnum::TNDArray { .. } => {
-                                return report_error(
-                                    concat!(
-                                        "ndarray index is list/array, but NumPy advanced (subset)",
-                                        "indexing is not supported yet"
-                                    ),
-                                    slice.location,
-                                );
-                            }
-                            _ => {
-                                // xxx: Could lead to suboptimal error message, as higher-dimensional indexing is not mentioned?!
-                                self.constrain(
-                                    slice.custom.unwrap(),
-                                    self.primitives.int32,
-                                    &slice.location,
-                                )?;
-                                1
+                        let num_idxs = if let TypeEnum::TTuple { ty: idx_tys } =
+                            &*self.unifier.get_ty(slice.custom.unwrap())
+                        {
+                            for idx_ty in idx_tys.iter() {
+                                self.constrain(*idx_ty, self.primitives.int32, &slice.location)?;
                             }
+                            idx_tys.len()
+                        } else {
+                            // xxx: Could lead to suboptimal error message, as higher-dimensional indexing is not mentioned?!
+                            self.constrain(
+                                slice.custom.unwrap(),
+                                self.primitives.int32,
+                                &slice.location,
+                            )?;
+                            1
                         };
 
                         if *num_dims < num_idxs {

nac3core/src/typecheck/type_inferencer/test.rs

@@ -518,13 +518,12 @@ impl TestEnvironment {
         a = array([1, 2])
         a0 = a[0]
         b = array([[1, 2], [3, 4]])
-        b0 = b[0]
+        # b0 = b[0]
         b00 = b[0, 0]
         c = 1
         ac = a[c]
     "},
-    [("a", "ndarray[int32, 1]"), ("a0", "int32"), ("b", "ndarray[int32, 2]"),
-     ("b0", "ndarray[int32, 1]"), ("b00", "int32"), ("ac", "int32")].iter().cloned().collect(),
+    [("a", "ndarray[int32, 1]"), ("b", "ndarray[int32, 2]"), ("a0", "int32"), ("b00", "int32"), ("ac", "int32")].iter().cloned().collect(),
     &[]
     ; "array test")]
 #[test_case(indoc! {"

nac3core/src/typecheck/typedef/mod.rs

@@ -662,17 +662,13 @@ impl Unifier {
                 for (k, v) in fields.iter() {
                     match *k {
                         RecordKey::Int(_) => {
-                            // .<n> is generated during generic scalar indexing lowering.
-                            let indexed_ty = if *num_dims == 1 {
-                                *ty
-                            } else {
-                                self.add_ty(TNDArray { ty: *ty, num_dims: *num_dims - 1 })
-                            };
-                            self.unify_impl(v.ty, indexed_ty, false).map_err(|e| e.at(v.loc))?
+                            if *num_dims > 1 {
+                                unreachable!("xxx implement unification for scalar indexing of multidimensional array");
+                            }
+                            self.unify_impl(v.ty, *ty, false).map_err(|e| e.at(v.loc))?
                         }
                         RecordKey::Str(_) => {
-                            // xxx: Implement .shape here?
-                            return Err(TypeError::new(TypeErrorKind::NoSuchField(*k, b), v.loc));
+                            return Err(TypeError::new(TypeErrorKind::NoSuchField(*k, b), v.loc))
                         }
                     }
                 }