Check for optional type in nullness checks (#522)

We forgot to check that the value type is an optional type in type
inference. This causes various compilation errors in some of the
strongly typed languages as you can not compare non-null types with
null (*e.g.*, in C++ or Go).

In this patch, we fix the type inference to correctly detect the invalid
(non-)nullness checks and report them.

Author: mristin

aas_core_codegen/intermediate/type_inference.py

@@ -1458,11 +1458,22 @@ def transform_constant(
     def transform_is_none(
         self, node: parse_tree.IsNone
     ) -> Optional["TypeAnnotationUnion"]:
-        # Just recurse to fill ``type_map`` on ``value`` even though we know the type in
-        # advance
-        success = self.transform(node.value) is not None
+        value_type = self.transform(node.value)
 
-        if not success:
+        # NOTE (mristin):
+        # Something went wrong if we could not infer the type of the ``value``.
+        if value_type is None:
+            return None
+
+        if not isinstance(value_type, OptionalTypeAnnotation):
+            self.errors.append(
+                Error(
+                    node.value.original_node,
+                    f"Expected the value to be of an optional type for "
+                    f"a nullness check (``is None``), "
+                    f"but got {value_type}",
+                )
+            )
             return None
 
         result = PrimitiveTypeAnnotation(PrimitiveType.BOOL)
@@ -1472,11 +1483,22 @@ def transform_is_none(
     def transform_is_not_none(
         self, node: parse_tree.IsNotNone
     ) -> Optional["TypeAnnotationUnion"]:
-        # Just recurse to fill ``type_map`` on ``value`` even though we know the type in
-        # advance
-        success = self.transform(node.value) is not None
+        value_type = self.transform(node.value)
 
-        if not success:
+        # NOTE (mristin):
+        # Something went wrong if we could not infer the type of the ``value``.
+        if value_type is None:
+            return None
+
+        if not isinstance(value_type, OptionalTypeAnnotation):
+            self.errors.append(
+                Error(
+                    node.value.original_node,
+                    f"Expected the value to be of an optional type "
+                    f"for a non-nullness check (``is not None``), "
+                    f"but got {value_type}",
+                )
+            )
             return None
 
         result = PrimitiveTypeAnnotation(PrimitiveType.BOOL)

tests/intermediate/test_type_inference.py

@@ -2,6 +2,7 @@
 
 import textwrap
 import unittest
+from typing import List
 
 import tests.common
 from aas_core_codegen import intermediate
@@ -51,6 +52,59 @@ def execute(source: str) -> None:
                         len(inferrer.errors) == 0
                     ), tests.common.most_underlying_messages(inferrer.errors)
 
+    def expect_type_inference_to_fail(
+        self, source: str, expected_joined_message: str
+    ) -> None:
+        """Execute a smoke test and expect type inference to fail."""
+        symbol_table, error = tests.common.translate_source_to_intermediate(
+            source=source
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+
+        assert symbol_table is not None
+
+        base_environment = intermediate_type_inference.populate_base_environment(
+            symbol_table=symbol_table
+        )
+
+        type_inference_errors = []  # type: List[str]
+
+        for our_type in symbol_table.our_types:
+            if isinstance(
+                our_type, (intermediate.AbstractClass, intermediate.ConcreteClass)
+            ):
+                environment = intermediate_type_inference.MutableEnvironment(
+                    parent=base_environment
+                )
+                environment.set(
+                    Identifier("self"),
+                    intermediate_type_inference.OurTypeAnnotation(our_type=our_type),
+                )
+
+                for invariant in our_type.invariants:
+                    canonicalizer = intermediate_type_inference.Canonicalizer()
+                    canonicalizer.transform(invariant.body)
+
+                    inferrer = intermediate_type_inference.Inferrer(
+                        symbol_table=symbol_table,
+                        environment=environment,
+                        representation_map=canonicalizer.representation_map,
+                    )
+
+                    inferrer.transform(invariant.body)
+                    if len(inferrer.errors) > 0:
+                        type_inference_errors.append(
+                            tests.common.most_underlying_messages(inferrer.errors)
+                        )
+
+            assert len(type_inference_errors) > 0, (
+                f"Expected one or more type inference errors, "
+                f"but got none on the source code:\n{source}"
+            )
+
+            joined_message = "\n".join(type_inference_errors)
+            self.assertEqual(expected_joined_message, joined_message, source)
+
     def test_enumeration_literal_as_member(self) -> None:
         source = textwrap.dedent(
             """\
@@ -165,6 +219,60 @@ def __init__(self, some_instance: Optional[Some_class] = None) -> None:
 
         Test_with_smoke.execute(source=source)
 
+    def test_is_none_fails_on_non_optional(self) -> None:
+        source = textwrap.dedent(
+            """\
+            @invariant(
+                lambda self:
+                self.something is None,
+                "Dummy invariant description"
+            )
+            class Some_class:
+                something: str
+
+                def __init__(self, something: str) -> None:
+                    self.something = something
+
+            __version__ = "dummy"
+            __xml_namespace__ = "https://dummy.com"
+            """
+        )
+
+        self.expect_type_inference_to_fail(
+            source=source,
+            expected_joined_message=(
+                "Expected the value to be of an optional type "
+                "for a nullness check (``is None``), but got str"
+            ),
+        )
+
+    def test_is_not_none_fails_on_non_optional(self) -> None:
+        source = textwrap.dedent(
+            """\
+            @invariant(
+                lambda self:
+                self.something is not None,
+                "Dummy invariant description"
+            )
+            class Some_class:
+                something: str
+
+                def __init__(self, something: str) -> None:
+                    self.something = something
+
+            __version__ = "dummy"
+            __xml_namespace__ = "https://dummy.com"
+            """
+        )
+
+        self.expect_type_inference_to_fail(
+            source=source,
+            expected_joined_message=(
+                "Expected the value to be of an optional type "
+                "for a non-nullness check (``is not None``), but got str"
+            ),
+        )
+
 
 if __name__ == "__main__":
     unittest.main()