Hover physical type literals

kraigher · kraigher · commit e77590680f35 · 2023-01-03T18:19:44.000+01:00
diff --git a/vhdl_lang/src/analysis/declarative.rs b/vhdl_lang/src/analysis/declarative.rs
@@ -692,22 +692,37 @@ impl<'a> AnalyzeContext<'a> {
                     &mut type_decl.ident,
                     Type::Physical(Implicits::default()),
                 );
+                parent.add(phys_type.clone().into(), diagnostics);
 
                 parent.add(
                     physical
                         .primary_unit
                         .define(NamedEntityKind::PhysicalLiteral(phys_type.clone())),
                     diagnostics,
                 );
-                for (secondary_unit_name, _) in physical.secondary_units.iter_mut() {
+                for (secondary_unit_name, value) in physical.secondary_units.iter_mut() {
+                    match self.resolve_physical_unit(parent, &mut value.unit) {
+                        Ok(secondary_unit_type) => {
+                            if secondary_unit_type.base_type() != &phys_type {
+                                diagnostics.error(
+                                    &value.unit.item.pos,
+                                    format!(
+                                        "Physical unit of type '{}' does not match {}",
+                                        secondary_unit_type.designator(),
+                                        phys_type.describe()
+                                    ),
+                                )
+                            }
+                        }
+                        Err(err) => diagnostics.push(err),
+                    }
+
                     parent.add(
                         secondary_unit_name
                             .define(NamedEntityKind::PhysicalLiteral(phys_type.clone())),
                         diagnostics,
                     )
                 }
-
-                parent.add(phys_type.into(), diagnostics);
             }
             TypeDefinition::Incomplete(..) => {
                 unreachable!("Handled elsewhere");
diff --git a/vhdl_lang/src/analysis/semantic.rs b/vhdl_lang/src/analysis/semantic.rs
@@ -571,7 +571,15 @@ impl<'a> AnalyzeContext<'a> {
                     self.analyze_subtype_indication(region, subtype, diagnostics)
                 }
             },
-            Expression::Literal(_) => Ok(()),
+            Expression::Literal(ref mut literal) => match literal {
+                Literal::Physical(PhysicalLiteral { ref mut unit, .. }) => {
+                    if let Err(diagnostic) = self.resolve_physical_unit(region, unit) {
+                        diagnostics.push(diagnostic);
+                    }
+                    Ok(())
+                }
+                _ => Ok(()),
+            },
         }
     }
 
@@ -1041,9 +1049,10 @@ impl<'a> AnalyzeContext<'a> {
     /// None if it was uncertain
     pub fn analyze_literal_with_target_type(
         &self,
+        region: &Region<'_>,
         target_type: &TypeEnt,
         pos: &SrcPos,
-        literal: &Literal,
+        literal: &mut Literal,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult<Option<bool>> {
         let target_base = target_type.base_type();
@@ -1154,12 +1163,48 @@ impl<'a> AnalyzeContext<'a> {
                 }
             },
 
+            Literal::Physical(PhysicalLiteral { ref mut unit, .. }) => {
+                match self.resolve_physical_unit(region, unit) {
+                    Ok(physical_type) => Some(physical_type.base_type() == target_base),
+                    Err(diagnostic) => {
+                        diagnostics.push(diagnostic);
+                        Some(false)
+                    }
+                }
+            }
             _ => None,
         };
 
         Ok(is_correct)
     }
 
+    pub fn resolve_physical_unit(
+        &self,
+        region: &Region<'_>,
+        unit: &mut WithRef<Ident>,
+    ) -> Result<TypeEnt, Diagnostic> {
+        match region.lookup_within(
+            &unit.item.pos,
+            &Designator::Identifier(unit.item.item.clone()),
+        )? {
+            NamedEntities::Single(unit_ent) => {
+                unit.set_unique_reference(&unit_ent);
+                if let NamedEntityKind::PhysicalLiteral(physical_ent) = unit_ent.actual_kind() {
+                    Ok(physical_ent.clone())
+                } else {
+                    Err(Diagnostic::error(
+                        &unit.item.pos,
+                        format!("{} is not a physical unit", unit_ent.describe()),
+                    ))
+                }
+            }
+            NamedEntities::Overloaded(_) => Err(Diagnostic::error(
+                &unit.item.pos,
+                "Overloaded name may not be physical unit",
+            )),
+        }
+    }
+
     /// Returns true if the name actually matches the target type
     /// None if it was uncertain
     pub fn analyze_expression_with_target_type(
@@ -1171,9 +1216,13 @@ impl<'a> AnalyzeContext<'a> {
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult<Option<bool>> {
         match expr {
-            Expression::Literal(ref lit) => {
-                self.analyze_literal_with_target_type(target_type, expr_pos, lit, diagnostics)
-            }
+            Expression::Literal(ref mut lit) => self.analyze_literal_with_target_type(
+                region,
+                target_type,
+                expr_pos,
+                lit,
+                diagnostics,
+            ),
             Expression::Name(ref mut name) => {
                 self.analyze_name_with_target_type(region, target_type, expr_pos, name, diagnostics)
             }
diff --git a/vhdl_lang/src/analysis/tests/homographs.rs b/vhdl_lang/src/analysis/tests/homographs.rs
@@ -815,6 +815,10 @@ end package;
             // Secondary units
             duplicate(&code, "bugs", 1, 2),
             duplicate(&code, "bugs", 1, 3),
+            Diagnostic::error(
+                code.s("10 bangs", 2).s1("bangs"),
+                "Physical unit of type 'phys_t' does not match physical type 'phys2_t'",
+            ),
         ],
     );
 }
diff --git a/vhdl_lang/src/analysis/tests/resolves_names.rs b/vhdl_lang/src/analysis/tests/resolves_names.rs
@@ -1471,3 +1471,42 @@ end architecture;
         ],
     );
 }
+
+#[test]
+fn hover_for_physical_type_units() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.in_declarative_region(
+        "
+type time_t is range -9223372036854775807 to 9223372036854775807
+units
+  small;
+  big = 1000 small;
+end units;
+
+constant the_time1 : time_t := small;
+constant the_time2 : time_t := 1000 small;
+constant the_time3 : time_t := big;
+constant the_time4 : time_t := 1000 big;
+    
+",
+    );
+
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_no_diagnostics(&diagnostics);
+
+    for i in 0..3 {
+        let ent = root
+            .search_reference(code.source(), code.s("small", 1 + i).start())
+            .unwrap();
+        assert_eq!(ent.decl_pos().unwrap(), &code.s1("small").pos());
+        assert_eq!(root.format_declaration(ent), Some("small".to_string()));
+    }
+
+    for i in 0..2 {
+        let ent = root
+            .search_reference(code.source(), code.s("big", 1 + i).start())
+            .unwrap();
+        assert_eq!(ent.decl_pos().unwrap(), &code.s1("big").pos());
+        assert_eq!(root.format_declaration(ent), Some("1000 small".to_string()));
+    }
+}
diff --git a/vhdl_lang/src/ast.rs b/vhdl_lang/src/ast.rs
@@ -214,14 +214,20 @@ pub struct BitString {
     pub value: Latin1String,
 }
 
+#[derive(PartialEq, Debug, Clone)]
+pub struct PhysicalLiteral {
+    pub value: AbstractLiteral,
+    pub unit: WithRef<Ident>,
+}
+
 /// LRM 9.3.2 Literals
 #[derive(PartialEq, Debug, Clone)]
 pub enum Literal {
     String(Latin1String),
     BitString(BitString),
     Character(u8),
     AbstractLiteral(AbstractLiteral),
-    Physical(AbstractLiteral, Symbol),
+    Physical(PhysicalLiteral),
     Null,
 }
 
@@ -498,7 +504,7 @@ pub struct ProtectedTypeBody {
 pub struct PhysicalTypeDeclaration {
     pub range: Range,
     pub primary_unit: WithDecl<Ident>,
-    pub secondary_units: Vec<(WithDecl<Ident>, Literal)>,
+    pub secondary_units: Vec<(WithDecl<Ident>, PhysicalLiteral)>,
 }
 
 /// LRM 5.2.2 Enumeration types
diff --git a/vhdl_lang/src/ast/display.rs b/vhdl_lang/src/ast/display.rs
@@ -266,14 +266,20 @@ impl Display for BitString {
     }
 }
 
+impl Display for PhysicalLiteral {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "{} {}", self.value, self.unit)
+    }
+}
+
 impl Display for Literal {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         match self {
             Literal::String(ref val) => write!(f, "\"{}\"", val),
             Literal::BitString(ref val) => write!(f, "{}", val),
             Literal::Character(byte) => write!(f, "'{}'", *byte as char),
             Literal::AbstractLiteral(ref val) => write!(f, "{}", val),
-            Literal::Physical(ref val, ref sym) => write!(f, "{} {}", val, sym),
+            Literal::Physical(ref val) => write!(f, "{}", val),
             Literal::Null => write!(f, "null"),
         }
     }
diff --git a/vhdl_lang/src/ast/search.rs b/vhdl_lang/src/ast/search.rs
@@ -47,6 +47,8 @@ pub enum FoundDeclaration<'a> {
     InterfaceObject(&'a InterfaceObjectDeclaration),
     File(&'a FileDeclaration),
     Type(&'a TypeDeclaration),
+    PhysicalTypePrimary(&'a WithDecl<Ident>),
+    PhysicalTypeSecondary(&'a WithDecl<Ident>, &'a PhysicalLiteral),
     Component(&'a ComponentDeclaration),
     //Attribute(&'a AttributeDeclaration),
     Alias(&'a AliasDeclaration),
@@ -750,11 +752,22 @@ impl Search for TypeDeclaration {
                         .or_not_found());
                 }
             }
-            // @TODO others
-            _ => {
+            TypeDefinition::Physical(ref physical) => {
+                let PhysicalTypeDeclaration {
+                    range,
+                    primary_unit,
+                    secondary_units,
+                } = physical;
+                return_if_found!(range.search(searcher));
                 return_if_found!(searcher
-                    .search_decl(FoundDeclaration::Type(self))
+                    .search_decl(FoundDeclaration::PhysicalTypePrimary(primary_unit))
                     .or_not_found());
+                for (ident, literal) in secondary_units.iter() {
+                    return_if_found!(searcher
+                        .search_decl(FoundDeclaration::PhysicalTypeSecondary(ident, literal))
+                        .or_not_found());
+                    return_if_found!(searcher.search_ident_ref(&literal.unit).or_not_found());
+                }
             }
         }
         NotFound
@@ -779,7 +792,12 @@ fn search_pos_expr(pos: &SrcPos, expr: &Expression, searcher: &mut impl Searcher
                 Allocator::Subtype(ref subtype) => subtype.search(searcher),
             }
         }
-        Expression::Literal(_) => NotFound,
+        Expression::Literal(literal) => match literal {
+            Literal::Physical(PhysicalLiteral { unit, .. }) => {
+                searcher.search_ident_ref(unit).or_not_found()
+            }
+            _ => NotFound,
+        },
     }
 }
 
@@ -1329,6 +1347,8 @@ impl<'a> HasNamedEntity for FoundDeclaration<'a> {
             FoundDeclaration::EnumerationLiteral(_, elem) => elem.decl.as_ref(),
             FoundDeclaration::File(value) => value.ident.decl.as_ref(),
             FoundDeclaration::Type(value) => value.ident.decl.as_ref(),
+            FoundDeclaration::PhysicalTypePrimary(value) => value.decl.as_ref(),
+            FoundDeclaration::PhysicalTypeSecondary(value, _) => value.decl.as_ref(),
             FoundDeclaration::Component(value) => value.ident.decl.as_ref(),
             FoundDeclaration::Alias(value) => value.designator.decl.as_ref(),
             FoundDeclaration::Package(value) => value.ident.decl.as_ref(),
@@ -1357,6 +1377,8 @@ impl<'a> HasSrcPos for FoundDeclaration<'a> {
             FoundDeclaration::EnumerationLiteral(_, elem) => &elem.tree.pos,
             FoundDeclaration::File(value) => value.ident.pos(),
             FoundDeclaration::Type(value) => value.ident.pos(),
+            FoundDeclaration::PhysicalTypePrimary(value) => value.pos(),
+            FoundDeclaration::PhysicalTypeSecondary(value, _) => value.as_ref(),
             FoundDeclaration::Component(value) => value.ident.pos(),
             FoundDeclaration::Alias(value) => &value.designator.tree.pos,
             FoundDeclaration::Package(value) => value.ident.pos(),
@@ -1407,6 +1429,12 @@ impl std::fmt::Display for FoundDeclaration<'_> {
             FoundDeclaration::File(ref value) => {
                 write!(f, "{}", value)
             }
+            FoundDeclaration::PhysicalTypePrimary(ref value) => {
+                write!(f, "{}", value)
+            }
+            FoundDeclaration::PhysicalTypeSecondary(_, ref literal) => {
+                write!(f, "{}", literal)
+            }
             FoundDeclaration::Type(ref value) => {
                 write!(f, "{}", value)
             }
diff --git a/vhdl_lang/src/syntax/expression.rs b/vhdl_lang/src/syntax/expression.rs
diff --git a/vhdl_lang/src/syntax/type_declaration.rs b/vhdl_lang/src/syntax/type_declaration.rs

Original file line number	Diff line number	Diff line change
`@@ -266,14 +266,20 @@ impl Display for BitString {`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`
	`269`	`+impl Display for PhysicalLiteral {`
	`270`	`+ fn fmt(&self, f: &mut Formatter<'_>) -> Result {`
	`271`	`+ write!(f, "{} {}", self.value, self.unit)`
	`272`	`+ }`
	`273`	`+}`
	`274`	`+`
`269`	`275`	`impl Display for Literal {`
`270`	`276`	`fn fmt(&self, f: &mut Formatter<'_>) -> Result {`
`271`	`277`	`match self {`
`272`	`278`	`Literal::String(ref val) => write!(f, "\"{}\"", val),`
`273`	`279`	`Literal::BitString(ref val) => write!(f, "{}", val),`
`274`	`280`	`Literal::Character(byte) => write!(f, "'{}'", *byte as char),`
`275`	`281`	`Literal::AbstractLiteral(ref val) => write!(f, "{}", val),`
`276`		`- Literal::Physical(ref val, ref sym) => write!(f, "{} {}", val, sym),`
	`282`	`+ Literal::Physical(ref val) => write!(f, "{}", val),`
`277`	`283`	`Literal::Null => write!(f, "null"),`
`278`	`284`	`}`
`279`	`285`	`}`