Make real a real type

Author: kraigher

vhdl_lang/src/analysis/declarative.rs

@@ -717,11 +717,13 @@ impl<'a> AnalyzeContext<'a> {
                 self.analyze_range(parent, range, diagnostics)?;
                 let implicit = ImplicitVecBuilder::default();
 
-                let type_ent = TypeEnt::define_with_opt_id(
-                    overwrite_id,
-                    &mut type_decl.ident,
-                    Type::Integer(implicit.inner()),
-                );
+                let kind = match integer_or_real_range(range) {
+                    ScalarType::Integer => Type::Integer(implicit.inner()),
+                    ScalarType::Real => Type::Real(implicit.inner()),
+                };
+
+                let type_ent =
+                    TypeEnt::define_with_opt_id(overwrite_id, &mut type_decl.ident, kind);
                 parent.add(type_ent.clone().into(), diagnostics);
 
                 if !self.is_standard_package() {
@@ -1062,3 +1064,25 @@ fn signature_error(pos: impl AsRef<SrcPos>) -> Diagnostic {
         "Alias should only have a signature for subprograms and enum literals",
     )
 }
+
+enum ScalarType {
+    Integer,
+    Real,
+}
+
+/// @TODO A simple and incomplete way to disambiguate integer and real in standard.vhd
+fn integer_or_real_range(range: &ast::Range) -> ScalarType {
+    if let ast::Range::Range(RangeConstraint { left_expr, .. }) = range {
+        let expr = if let Expression::Unary(_, ref expr) = left_expr.item {
+            &expr.item
+        } else {
+            &left_expr.item
+        };
+
+        if let Expression::Literal(Literal::AbstractLiteral(AbstractLiteral::Real(_))) = expr {
+            return ScalarType::Real;
+        }
+    }
+
+    ScalarType::Integer
+}

vhdl_lang/src/analysis/named_entity.rs

@@ -27,6 +27,7 @@ pub enum Type {
     },
     Enum(ImplicitVec, FnvHashSet<Designator>),
     Integer(ImplicitVec),
+    Real(ImplicitVec),
     Physical(ImplicitVec),
     Access(Subtype, ImplicitVec),
     Record(Arc<Region<'static>>),
@@ -50,6 +51,7 @@ impl Type {
         match self {
             Type::Array { ref implicit, .. } => Some(implicit),
             Type::Enum(ref implicit, _) => Some(implicit),
+            Type::Real(ref implicit) => Some(implicit),
             Type::Integer(ref implicit) => Some(implicit),
             Type::Physical(ref implicit) => Some(implicit),
             Type::File(ref implicit) => Some(implicit),
@@ -70,6 +72,7 @@ impl Type {
             Type::Array { .. } => "array type",
             Type::Enum(..) => "type",
             Type::Integer(..) => "integer type",
+            Type::Real(..) => "real type",
             Type::Physical(..) => "physical type",
             Type::Access(..) => "access type",
             Type::Subtype(..) => "subtype",

vhdl_lang/src/analysis/semantic.rs

@@ -1060,6 +1060,17 @@ impl<'a> AnalyzeContext<'a> {
                 }
                 Some(is_correct)
             }
+            Literal::AbstractLiteral(AbstractLiteral::Real(_)) => {
+                let is_correct = matches!(target_base.kind(), Type::Real(..));
+
+                if !is_correct {
+                    diagnostics.push(Diagnostic::error(
+                        pos,
+                        format!("real literal does not match {}", target_type.describe()),
+                    ));
+                }
+                Some(is_correct)
+            }
             Literal::Character(char) => match target_base.kind() {
                 Type::Enum(_, literals) => {
                     if literals.contains(&Designator::Character(*char)) {

vhdl_lang/src/analysis/tests/typecheck_expression.rs

@@ -567,3 +567,32 @@ constant const : natural := thefun('c');
         ],
     );
 }
+
+#[test]
+fn check_real_vs_integer() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.in_declarative_region(
+        "
+constant rgood : real := 1.2;
+constant rbad : real := 3;
+
+constant igood : integer := 4;
+constant ibad : integer := 5.6;
+
+",
+    );
+    let diagnostics = builder.analyze();
+    check_diagnostics(
+        diagnostics,
+        vec![
+            Diagnostic::error(
+                code.s1("3"),
+                "integer literal does not match real type 'REAL'",
+            ),
+            Diagnostic::error(
+                code.s1("5.6"),
+                "real literal does not match integer type 'INTEGER'",
+            ),
+        ],
+    );
+}