Allow array type in array aggregates

Author: kraigher

vhdl_lang/src/analysis/semantic.rs

@@ -672,68 +672,99 @@ impl<'a> AnalyzeContext<'a> {
     pub fn analyze_1d_array_assoc_elem(
         &self,
         region: &Region<'_>,
+        array_type: &TypeEnt,
         index_type: Option<&TypeEnt>,
         elem_type: &TypeEnt,
         assoc: &mut ElementAssociation,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult<TypeCheck> {
-        match assoc {
+        let mut can_be_array = true;
+        let mut check = TypeCheck::Ok;
+
+        let expr = match assoc {
             ElementAssociation::Named(ref mut choices, ref mut expr) => {
-                if let &[Choice::Others] = choices.as_slice() {
-                    self.analyze_expression_with_target_type(
-                        region,
-                        elem_type,
-                        &expr.pos,
-                        &mut expr.item,
-                        diagnostics,
-                    )
-                } else {
-                    let mut check = TypeCheck::Ok;
-                    for choice in choices.iter_mut() {
-                        match choice {
-                            Choice::Expression(index_expr) => {
-                                if let Some(index_type) = index_type {
-                                    check.add(self.analyze_expression_with_target_type(
-                                        region,
-                                        index_type,
-                                        &index_expr.pos,
-                                        &mut index_expr.item,
-                                        diagnostics,
-                                    )?);
-                                }
-                            }
-                            Choice::DiscreteRange(ref mut drange) => {
-                                if let Some(index_type) = index_type {
-                                    check.add(self.analyze_discrete_range_with_target_type(
-                                        region,
-                                        index_type,
-                                        drange,
-                                        diagnostics,
-                                    )?);
-                                } else {
-                                    self.analyze_discrete_range(region, drange, diagnostics)?;
-                                    check.add(TypeCheck::Unknown)
-                                }
+                for choice in choices.iter_mut() {
+                    match choice {
+                        Choice::Expression(index_expr) => {
+                            if let Some(index_type) = index_type {
+                                check.add(self.analyze_expression_with_target_type(
+                                    region,
+                                    index_type,
+                                    &index_expr.pos,
+                                    &mut index_expr.item,
+                                    diagnostics,
+                                )?);
                             }
-                            Choice::Others => {
-                                // @TODO choice must be alone so cannot appear here
-                                check.add(TypeCheck::Unknown);
+                            can_be_array = false;
+                        }
+                        Choice::DiscreteRange(ref mut drange) => {
+                            if let Some(index_type) = index_type {
+                                check.add(self.analyze_discrete_range_with_target_type(
+                                    region,
+                                    index_type,
+                                    drange,
+                                    diagnostics,
+                                )?);
+                            } else {
+                                self.analyze_discrete_range(region, drange, diagnostics)?;
+                                check.add(TypeCheck::Unknown)
                             }
                         }
+                        Choice::Others => {
+                            // @TODO choice must be alone so cannot appear here
+                            check.add(TypeCheck::Unknown);
+                            can_be_array = false;
+                        }
                     }
-                    self.analyze_expression(region, expr, diagnostics)?;
-                    Ok(check)
                 }
+                expr
             }
-            ElementAssociation::Positional(ref mut expr) => self
-                .analyze_expression_with_target_type(
+            ElementAssociation::Positional(ref mut expr) => expr,
+        };
+
+        if can_be_array {
+            // If the choice is only a range or positional the expression can be an array
+            let mut elem_diagnostics = Vec::new();
+
+            let elem_check = self.analyze_expression_with_target_type(
+                region,
+                elem_type,
+                &expr.pos,
+                &mut expr.item,
+                &mut elem_diagnostics,
+            )?;
+
+            if elem_check == TypeCheck::Ok {
+                diagnostics.append(elem_diagnostics);
+                check.add(elem_check);
+            } else {
+                let mut array_diagnostics = Vec::new();
+                let array_check = self.analyze_expression_with_target_type(
                     region,
-                    elem_type,
+                    array_type,
                     &expr.pos,
                     &mut expr.item,
-                    diagnostics,
-                ),
+                    &mut array_diagnostics,
+                )?;
+
+                if array_check == TypeCheck::Ok {
+                    diagnostics.append(array_diagnostics);
+                    check.add(array_check);
+                } else {
+                    diagnostics.append(elem_diagnostics);
+                    check.add(elem_check);
+                }
+            };
+        } else {
+            check.add(self.analyze_expression_with_target_type(
+                region,
+                elem_type,
+                &expr.pos,
+                &mut expr.item,
+                diagnostics,
+            )?);
         }
+        Ok(check)
     }
 
     fn analyze_qualified_expression(
@@ -1184,13 +1215,12 @@ impl<'a> AnalyzeContext<'a> {
         for name in overloaded.entities() {
             if let Some(sig) = name.signature() {
                 let is_correct = if sig.match_return_type(target_type) {
-                    let mut temp_diagnostics = Vec::new();
                     self.analyze_assoc_elems_with_formal_region(
                         pos,
                         &sig.params,
                         region,
                         parameters,
-                        &mut temp_diagnostics,
+                        &mut NullDiagnostics,
                     )?
                 } else {
                     TypeCheck::NotOk
@@ -1335,6 +1365,7 @@ impl<'a> AnalyzeContext<'a> {
                         for assoc in assocs.iter_mut() {
                             check.add(self.analyze_1d_array_assoc_elem(
                                 region,
+                                target_base,
                                 index_type.as_ref(),
                                 elem_type,
                                 assoc,

vhdl_lang/src/analysis/tests/typecheck_expression.rs

@@ -743,7 +743,8 @@ constant good2 : arr2_t := ((0, 1), (2, 3));
 constant good3 : rec_t := (field => 0);
 constant bad1 : integer_vector := (3, 4, 'c');
 constant bad2 : integer_vector := (others => 'd');
-constant bad3 : rec_t := (field => 'e');
+constant bad3 : integer_vector := (1 to 3 => 'e');
+constant bad4 : rec_t := (field => 'f');
 
         ",
     );
@@ -764,6 +765,10 @@ constant bad3 : rec_t := (field => 'e');
                 code.s1("'e'"),
                 "character literal does not match integer type 'INTEGER'",
             ),
+            Diagnostic::error(
+                code.s1("'f'"),
+                "character literal does not match integer type 'INTEGER'",
+            ),
         ],
     );
 }
@@ -798,3 +803,19 @@ constant bad2 : integer_vector := ('a' to 'z' => 0);
         ],
     );
 }
+
+/// LRM 9.3.3.3 Array aggregates
+#[test]
+fn array_element_association_may_be_array_of_element_type() {
+    let mut builder = LibraryBuilder::new();
+    builder.in_declarative_region(
+        "
+constant good1 : integer_vector := (0 to 2 => (0, 1, 2));
+constant good2 : string(1 to 6) := (\"text\", others => ' ');
+
+        ",
+    );
+
+    let diagnostics = builder.analyze();
+    check_no_diagnostics(&diagnostics);
+}

vhdl_lang/src/data/diagnostic.rs

@@ -147,6 +147,14 @@ impl DiagnosticHandler for Vec<Diagnostic> {
     }
 }
 
+pub struct NullDiagnostics;
+
+impl DiagnosticHandler for NullDiagnostics {
+    fn push(&mut self, _diagnostic: Diagnostic) {
+        // Ignore
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;