Support type name as discrete range in aggregate choices #148

Author: kraigher

vhdl_lang/src/analysis/expression.rs

@@ -738,16 +738,33 @@ impl<'a> AnalyzeContext<'a> {
                 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(
-                                    scope,
-                                    index_type,
-                                    &index_expr.pos,
-                                    &mut index_expr.item,
-                                    diagnostics,
-                                )?);
+                            match self.expr_as_discrete_range_type(
+                                scope,
+                                &index_expr.pos,
+                                &mut index_expr.item,
+                                diagnostics,
+                            ) {
+                                Ok(Some(_)) => {
+                                    // @TODO check type matches index type
+                                    can_be_array = true;
+                                }
+                                Ok(None) => {
+                                    if let Some(index_type) = index_type {
+                                        check.add(self.analyze_expression_with_target_type(
+                                            scope,
+                                            index_type,
+                                            &index_expr.pos,
+                                            &mut index_expr.item,
+                                            diagnostics,
+                                        )?);
+                                    }
+                                    can_be_array = false;
+                                }
+                                Err(err) => {
+                                    diagnostics.push(err.into_non_fatal()?);
+                                    return Ok(TypeCheck::Unknown);
+                                }
                             }
-                            can_be_array = false;
                         }
                         Choice::DiscreteRange(ref mut drange) => {
                             if let Some(index_type) = index_type {

vhdl_lang/src/analysis/names.rs

@@ -428,35 +428,58 @@ impl<'a> AnalyzeContext<'a> {
     /// Example:
     /// subtype sub_t is natural range 0 to 1;
     /// arr(sub_t) := (others => 0);
-    fn could_be_slice_with_type_name(
+    fn assoc_as_discrete_range_type(
         &self,
         scope: &Scope<'a>,
         assocs: &mut [AssociationElement],
         diagnostics: &mut dyn DiagnosticHandler,
-    ) -> AnalysisResult<bool> {
+    ) -> AnalysisResult<Option<TypeEnt<'a>>> {
         if !could_be_indexed_name(assocs) {
-            return Ok(false);
+            return Ok(None);
         }
 
         if let [ref mut assoc] = assocs {
-            if let ActualPart::Expression(Expression::Name(name)) = &mut assoc.actual.item {
-                let resolved = self.name_resolve(scope, &assoc.actual.pos, name, diagnostics)?;
+            if let ActualPart::Expression(expr) = &mut assoc.actual.item {
+                return self.expr_as_discrete_range_type(
+                    scope,
+                    &assoc.actual.pos,
+                    expr,
+                    diagnostics,
+                );
+            }
+        }
+        Ok(None)
+    }
 
-                if let Some(ResolvedName::Type(typ)) = resolved {
-                    return if matches!(typ.base_type().kind(), Type::Enum { .. } | Type::Integer(_))
-                    {
-                        Ok(true)
-                    } else {
-                        Err(Diagnostic::error(
-                            &assoc.actual.pos,
-                            format!("{} cannot be used as a discrete range", typ.describe()),
-                        )
-                        .into())
-                    };
-                }
+    pub fn expr_as_discrete_range_type(
+        &self,
+        scope: &Scope<'a>,
+        expr_pos: &SrcPos,
+        expr: &mut Expression,
+        diagnostics: &mut dyn DiagnosticHandler,
+    ) -> AnalysisResult<Option<TypeEnt<'a>>> {
+        if let Expression::Name(name) = expr {
+            if !name.is_selected_name() {
+                // Early exit
+                return Ok(None);
+            }
+
+            let resolved = self.name_resolve(scope, expr_pos, name, diagnostics)?;
+
+            if let Some(ResolvedName::Type(typ)) = resolved {
+                return if matches!(typ.base_type().kind(), Type::Enum { .. } | Type::Integer(_)) {
+                    Ok(Some(typ))
+                } else {
+                    Err(Diagnostic::error(
+                        expr_pos,
+                        format!("{} cannot be used as a discrete range", typ.describe()),
+                    )
+                    .into())
+                };
             }
         }
-        Ok(false)
+
+        Ok(None)
     }
 
     // Apply suffix when prefix is known to have a type
@@ -496,7 +519,10 @@ impl<'a> AnalyzeContext<'a> {
             // @TODO Prefix must non-overloaded
             Suffix::CallOrIndexed(assocs) => {
                 if let Some(typ) = prefix_typ.sliced_as() {
-                    if self.could_be_slice_with_type_name(scope, assocs, diagnostics)? {
+                    if self
+                        .assoc_as_discrete_range_type(scope, assocs, diagnostics)?
+                        .is_some()
+                    {
                         return Ok(Some(TypeOrMethod::Type(typ)));
                     }
                 }

vhdl_lang/src/analysis/tests/typecheck_expression.rs

@@ -913,6 +913,20 @@ constant good2 : string(1 to 6) := (\"text\", others => ' ');
     check_no_diagnostics(&diagnostics);
 }
 
+#[test]
+fn array_element_association_may_be_type_denoting_discrete_range() {
+    let mut builder = LibraryBuilder::new();
+    builder.in_declarative_region(
+        "
+subtype sub_t is natural range 1 to 3;
+constant good1 : integer_vector := (sub_t => 0);
+        ",
+    );
+
+    let diagnostics = builder.analyze();
+    check_no_diagnostics(&diagnostics);
+}
+
 #[test]
 fn evaluates_unary_expressions() {
     let mut builder = LibraryBuilder::new();

vhdl_lang/src/ast/util.rs

@@ -363,6 +363,16 @@ impl Name {
             Self::Slice(name, ..) => name.item.prefix(),
         }
     }
+
+    /// Returns true if the name is purely a selected name
+    /// Example: a.b.c
+    pub fn is_selected_name(&self) -> bool {
+        match self {
+            Name::Designator(_) => true,
+            Name::Selected(prefix, _) => prefix.item.is_selected_name(),
+            _ => false,
+        }
+    }
 }
 
 impl CallOrIndexed {