Typecheck multi dimensional array aggregates

Author: kraigher

vhdl_lang/src/analysis/expression.rs

@@ -835,20 +835,15 @@ impl<'a> AnalyzeContext<'a> {
                 Type::Array {
                     elem_type, indexes, ..
                 } => {
-                    if let [index_type] = indexes.as_slice() {
-                        for assoc in assocs.iter_mut() {
-                            as_fatal(self.analyze_1d_array_assoc_elem(
-                                scope,
-                                target_base,
-                                *index_type,
-                                *elem_type,
-                                assoc,
-                                diagnostics,
-                            ))?;
-                        }
-                    } else {
-                        // @TODO multi dimensional array
-                        self.analyze_aggregate(scope, assocs, diagnostics)?;
+                    for assoc in assocs.iter_mut() {
+                        as_fatal(self.array_assoc_elem(
+                            scope,
+                            target_base,
+                            indexes,
+                            *elem_type,
+                            assoc,
+                            diagnostics,
+                        ))?;
                     }
                 }
                 Type::Record(record_scope) => {
@@ -978,15 +973,16 @@ impl<'a> AnalyzeContext<'a> {
         Ok(())
     }
 
-    pub fn analyze_1d_array_assoc_elem(
+    pub fn array_assoc_elem(
         &self,
         scope: &Scope<'a>,
         array_type: TypeEnt<'a>,
-        index_type: Option<BaseType<'a>>,
+        index_types: &[Option<BaseType<'a>>],
         elem_type: TypeEnt<'a>,
         assoc: &mut ElementAssociation,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> EvalResult {
+        let index_type = index_types.first().and_then(|x| *x);
         let mut can_be_array = true;
 
         let expr = match assoc {
@@ -1045,7 +1041,28 @@ impl<'a> AnalyzeContext<'a> {
             ElementAssociation::Positional(ref mut expr) => expr,
         };
 
-        if can_be_array {
+        if index_types.len() > 1 {
+            if let Expression::Aggregate(ref mut inner) = expr.item {
+                for assoc in inner.iter_mut() {
+                    as_fatal(self.array_assoc_elem(
+                        scope,
+                        array_type,
+                        &index_types[1..],
+                        elem_type,
+                        assoc,
+                        diagnostics,
+                    ))?;
+                }
+            } else {
+                diagnostics.error(
+                    &expr.pos,
+                    format!(
+                        "Expected sub-aggregate for target {}",
+                        array_type.describe()
+                    ),
+                );
+            }
+        } else if can_be_array {
             // If the choice is only a range or positional the expression can be an array
             let types = self.expr_type(scope, expr, diagnostics)?;
             let is_array = self.is_possible(&types, array_type.base());

vhdl_lang/src/analysis/tests/typecheck_expression.rs

@@ -797,6 +797,39 @@ constant bad1 : integer := (3, 4, 5);
     );
 }
 
+#[test]
+fn typecheck_multi_dimensional_array_aggregate() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.in_declarative_region(
+        "
+type arr2_t is array (0 to 1, 2 to 3) of integer;
+type arr1_t is array (0 to 1) of integer;
+constant good1 : arr2_t := (others => (0, 1));
+constant good2 : arr2_t := (others => (others => 0));
+constant good3 : arr2_t := ((others => 0), (others => 0));
+
+constant a1 : arr1_t := (0, 1);
+constant bad1 : arr2_t := (others => 1 & 1);
+constant bad2 : arr2_t := (others => a1);
+        ",
+    );
+
+    let diagnostics = builder.analyze();
+    check_diagnostics(
+        diagnostics,
+        vec![
+            Diagnostic::error(
+                code.s1("1 & 1"),
+                "Expected sub-aggregate for target array type 'arr2_t'",
+            ),
+            Diagnostic::error(
+                code.s1("=> a1").s1("a1"),
+                "Expected sub-aggregate for target array type 'arr2_t'",
+            ),
+        ],
+    );
+}
+
 #[test]
 fn record_aggregate_must_be_simple_name() {
     let mut builder = LibraryBuilder::new();