Add support for matching operators

Author: kraigher

vhdl_lang/src/analysis/analyze.rs

@@ -135,6 +135,7 @@ pub(super) struct AnalyzeContext<'a> {
     pub work_sym: Symbol,
     std_sym: Symbol,
     standard_sym: Symbol,
+    pub(super) is_std_logic_1164: bool,
 
     // Record dependencies and sensitivies when
     // analyzing design units
@@ -166,6 +167,11 @@ impl<'a> AnalyzeContext<'a> {
             work_sym: root.symbol_utf8("work"),
             std_sym: root.symbol_utf8("std"),
             standard_sym: root.symbol_utf8("standard"),
+            is_std_logic_1164: current_unit
+                == &UnitId::package(
+                    &root.symbol_utf8("ieee"),
+                    &root.symbol_utf8("std_logic_1164"),
+                ),
             root,
             current_unit: current_unit.clone(),
             arena,

vhdl_lang/src/analysis/declarative.rs

@@ -567,7 +567,7 @@ impl<'a> AnalyzeContext<'a> {
 
                 scope.add(enum_type.into(), diagnostics);
 
-                for ent in self.enum_implicits(enum_type) {
+                for ent in self.enum_implicits(enum_type, self.has_matching_op(enum_type)) {
                     unsafe {
                         self.arena.add_implicit(enum_type.id(), ent);
                     }
@@ -766,6 +766,7 @@ impl<'a> AnalyzeContext<'a> {
                         }
                     };
 
+                let is_1d = indexes.len() == 1;
                 let array_ent = TypeEnt::define_with_opt_id(
                     self.arena,
                     overwrite_id,
@@ -775,7 +776,8 @@ impl<'a> AnalyzeContext<'a> {
 
                 scope.add(array_ent.into(), diagnostics);
 
-                for ent in self.array_implicits(array_ent) {
+                for ent in self.array_implicits(array_ent, is_1d && self.has_matching_op(elem_type))
+                {
                     unsafe {
                         self.arena.add_implicit(array_ent.id(), ent);
                     }
@@ -928,6 +930,28 @@ impl<'a> AnalyzeContext<'a> {
         Ok(())
     }
 
+    /// The matching operators such as ?= are defined for 1d arrays of bit and std_ulogic element type
+    fn has_matching_op(&self, typ: TypeEnt<'a>) -> bool {
+        if self.is_std_logic_1164 {
+            // Within the std_logic_1164 we do not have efficient access to the types
+            typ.designator() == &Designator::Identifier(self.root.symbol_utf8("std_ulogic"))
+        } else {
+            if let Some(ref standard_types) = self.root.standard_types {
+                if typ.id() == standard_types.bit {
+                    return true;
+                }
+            }
+
+            if let Some(id) = self.root.std_ulogic {
+                if typ.id() == id {
+                    return true;
+                }
+            }
+
+            false
+        }
+    }
+
     pub fn resolve_signature(
         &self,
         scope: &Scope<'a>,

vhdl_lang/src/analysis/expression.rs

@@ -385,10 +385,6 @@ impl<'a> AnalyzeContext<'a> {
         exprs: &mut [&mut WithPos<Expression>],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> EvalResult<ExpressionType<'a>> {
-        if !can_handle(op.item.item) {
-            return Err(EvalError::Unknown);
-        }
-
         let op_candidates = match self.lookup_operator(scope, &op.pos, op.item.item, exprs.len()) {
             Ok(candidates) => candidates,
             Err(err) => {
@@ -750,47 +746,41 @@ impl<'a> AnalyzeContext<'a> {
                 }
             }
             Expression::Binary(ref mut op, ref mut left, ref mut right) => {
-                if can_handle(op.item.item) {
-                    let op_candidates = match self.lookup_operator(scope, &op.pos, op.item.item, 2)
-                    {
-                        Ok(candidates) => candidates,
-                        Err(err) => {
-                            diagnostics.push(err.into_non_fatal()?);
-                            return Ok(());
-                        }
-                    };
+                let op_candidates = match self.lookup_operator(scope, &op.pos, op.item.item, 2) {
+                    Ok(candidates) => candidates,
+                    Err(err) => {
+                        diagnostics.push(err.into_non_fatal()?);
+                        return Ok(());
+                    }
+                };
 
-                    match as_fatal(self.disambiguate_op(
-                        scope,
-                        Some(target_type),
-                        op,
-                        op_candidates,
-                        &mut [left.as_mut(), right.as_mut()],
-                        diagnostics,
-                    ))? {
-                        Some(Disambiguated::Unambiguous(overloaded)) => {
-                            let op_type = overloaded.return_type().unwrap();
-
-                            if !self.can_be_target_type(op_type, target_type.base()) {
-                                diagnostics.push(Diagnostic::type_mismatch(
-                                    expr_pos,
-                                    &op_type.describe(),
-                                    target_type,
-                                ));
-                            }
-                        }
-                        Some(Disambiguated::Ambiguous(candidates)) => {
-                            diagnostics.push(Diagnostic::ambiguous_op(
-                                &op.pos,
-                                op.item.item,
-                                candidates,
+                match as_fatal(self.disambiguate_op(
+                    scope,
+                    Some(target_type),
+                    op,
+                    op_candidates,
+                    &mut [left.as_mut(), right.as_mut()],
+                    diagnostics,
+                ))? {
+                    Some(Disambiguated::Unambiguous(overloaded)) => {
+                        let op_type = overloaded.return_type().unwrap();
+
+                        if !self.can_be_target_type(op_type, target_type.base()) {
+                            diagnostics.push(Diagnostic::type_mismatch(
+                                expr_pos,
+                                &op_type.describe(),
+                                target_type,
                             ));
                         }
-                        None => {}
                     }
-                } else {
-                    self.expr_unknown_ttyp(scope, left, diagnostics)?;
-                    self.expr_unknown_ttyp(scope, right, diagnostics)?;
+                    Some(Disambiguated::Ambiguous(candidates)) => {
+                        diagnostics.push(Diagnostic::ambiguous_op(
+                            &op.pos,
+                            op.item.item,
+                            candidates,
+                        ));
+                    }
+                    None => {}
                 }
             }
             Expression::Unary(ref mut op, ref mut expr) => {
@@ -1091,19 +1081,6 @@ impl<'a> AnalyzeContext<'a> {
     }
 }
 
-// @TODO skip operators we do not handle yet
-fn can_handle(op: Operator) -> bool {
-    !matches!(
-        op,
-        Operator::QueEQ
-            | Operator::QueNE
-            | Operator::QueGT
-            | Operator::QueGTE
-            | Operator::QueLT
-            | Operator::QueLTE
-    )
-}
-
 impl Diagnostic {
     fn ambiguous_op<'a>(
         pos: &SrcPos,

vhdl_lang/src/analysis/standard.rs

@@ -737,14 +737,37 @@ impl<'a> AnalyzeContext<'a> {
         .chain(self.comparators(typ).into_iter())
     }
 
-    pub fn enum_implicits(&self, typ: TypeEnt<'a>) -> impl Iterator<Item = EntRef<'a>> {
+    pub fn enum_implicits(
+        &self,
+        typ: TypeEnt<'a>,
+        matching_op: bool,
+    ) -> impl Iterator<Item = EntRef<'a>> {
         [
             self.create_to_string(typ),
             self.minimum(typ),
             self.maximum(typ),
         ]
         .into_iter()
         .chain(self.comparators(typ).into_iter())
+        .chain(
+            if matching_op {
+                Some(
+                    [
+                        self.symmetric_binary(Operator::QueEQ, typ),
+                        self.symmetric_binary(Operator::QueNE, typ),
+                        self.symmetric_binary(Operator::QueGT, typ),
+                        self.symmetric_binary(Operator::QueGTE, typ),
+                        self.symmetric_binary(Operator::QueLT, typ),
+                        self.symmetric_binary(Operator::QueLTE, typ),
+                    ]
+                    .into_iter(),
+                )
+            } else {
+                None
+            }
+            .into_iter()
+            .flatten(),
+        )
     }
 
     pub fn record_implicits(&self, typ: TypeEnt<'a>) -> impl Iterator<Item = EntRef<'a>> {
@@ -787,7 +810,11 @@ impl<'a> AnalyzeContext<'a> {
         .into_iter()
     }
 
-    pub fn array_implicits(&self, typ: TypeEnt<'a>) -> impl Iterator<Item = EntRef<'a>> {
+    pub fn array_implicits(
+        &self,
+        typ: TypeEnt<'a>,
+        matching_op: bool,
+    ) -> impl Iterator<Item = EntRef<'a>> {
         let Type::Array{indexes, elem_type, ..}  = typ.kind() else {
             unreachable!("Must be array type")
         };
@@ -833,6 +860,25 @@ impl<'a> AnalyzeContext<'a> {
             .into_iter()
             .flatten(),
         )
+        .chain(
+            if matching_op {
+                Some(
+                    [
+                        self.binary(Operator::QueEQ, typ, typ, typ, *elem_type),
+                        self.binary(Operator::QueNE, typ, typ, typ, *elem_type),
+                        self.binary(Operator::QueGT, typ, typ, typ, *elem_type),
+                        self.binary(Operator::QueGTE, typ, typ, typ, *elem_type),
+                        self.binary(Operator::QueLT, typ, typ, typ, *elem_type),
+                        self.binary(Operator::QueLTE, typ, typ, typ, *elem_type),
+                    ]
+                    .into_iter(),
+                )
+            } else {
+                None
+            }
+            .into_iter()
+            .flatten(),
+        )
     }
 
     pub fn access_implicits(&self, typ: TypeEnt<'a>) -> impl Iterator<Item = EntRef<'a>> {
@@ -1112,10 +1158,11 @@ impl<'a> AnalyzeContext<'a> {
             }
         }
 
-        // ?? for bit
+        // ?? operator for bit
         {
             let typ = self.bit();
             let qq = self.unary(Operator::QueQue, typ, self.boolean());
+
             unsafe {
                 self.arena.add_implicit(typ.id(), qq);
             };

vhdl_lang/src/analysis/tests/typecheck_expression.rs

@@ -1649,3 +1649,71 @@ end units;
         ],
     );
 }
+
+#[test]
+fn scalar_bit_matching_operators() {
+    let mut builder = LibraryBuilder::new();
+    builder.in_declarative_region(
+        "
+constant good1 : bit := '0' ?= '1';
+constant good2 : bit := '0' ?/= '1';
+constant good3 : bit := '0' ?< '1';
+constant good4 : bit := '0' ?<= '1';
+constant good5 : bit := '0' ?> '1';
+constant good6 : bit := '0' ?>= '1';
+        ",
+    );
+
+    let diagnostics = builder.analyze();
+    check_no_diagnostics(&diagnostics);
+}
+
+#[test]
+fn bit_vector_matching_operators() {
+    let mut builder = LibraryBuilder::new();
+    builder.in_declarative_region(
+        "
+constant good1 : bit := \"01\" ?= \"10\";
+constant good2 : bit := \"01\" ?/= \"10\";
+constant good3 : bit := \"01\" ?< \"10\";
+constant good4 : bit := \"01\" ?<= \"10\";
+constant good5 : bit := \"01\" ?> \"10\";
+constant good6 : bit := \"01\" ?>= \"10\";
+        ",
+    );
+
+    let diagnostics = builder.analyze();
+    check_no_diagnostics(&diagnostics);
+}
+
+#[test]
+fn std_ulogic_matching_operators() {
+    let mut builder = LibraryBuilder::new();
+    builder.add_std_logic_1164();
+    builder.code(
+        "libname",
+        "
+library ieee;
+use ieee.std_logic_1164.all;
+
+package pkg is
+    constant good1s : std_ulogic := '0' ?= '1';
+    constant good2s : std_ulogic := '0' ?/= '1';
+    constant good3s : std_ulogic := '0' ?< '1';
+    constant good4s : std_ulogic := '0' ?<= '1';
+    constant good5s : std_ulogic := '0' ?> '1';
+    constant good6s : std_ulogic := '0' ?>= '1';
+
+    constant good1v : std_ulogic := \"10\" ?= \"10\";
+    constant good2v : std_ulogic := \"10\" ?/= \"10\";
+    constant good3v : std_ulogic := \"10\" ?< \"10\";
+    constant good4v : std_ulogic := \"10\" ?<= \"10\";
+    constant good5v : std_ulogic := \"10\" ?> \"10\";
+    constant good6v : std_ulogic := \"10\" ?>= \"10\";
+end package;        
+",
+    );
+
+    let diagnostics = builder.analyze();
+    check_no_diagnostics(&diagnostics);
+}

vhdl_lang/src/analysis/tests/util.rs

@@ -64,6 +64,11 @@ end architecture;"
         )
     }
 
+    pub fn add_std_logic_1164(&mut self) {
+        let std_logic_1164 = self.code_builder.code_from_source(std_logic_1164_package());
+        self.add_code("ieee", std_logic_1164);
+    }
+
     pub fn get_analyzed_root(&self) -> (DesignRoot, Vec<Diagnostic>) {
         let mut root = DesignRoot::new(self.code_builder.symbols.clone());
         let mut diagnostics = Vec::new();
@@ -122,6 +127,16 @@ fn env_package() -> Source {
     )
 }
 
+fn std_logic_1164_package() -> Source {
+    Source::inline(
+        Path::new("std_logic_1164.vhd"),
+        &Latin1String::new(include_bytes!(
+            "../../../../vhdl_libraries/ieee2008/std_logic_1164.vhdl"
+        ))
+        .to_string(),
+    )
+}
+
 pub fn add_standard_library(symbols: Arc<Symbols>, root: &mut DesignRoot) {
     let builder = CodeBuilder {
         symbols: symbols.clone(),