Visitors for TypeScript

tested/dsl/ast_translator.py

@@ -42,7 +42,7 @@
 )
 from tested.parsing import get_converter
 from tested.serialisation import (
-    Assignment,
+    AbstractAssignment,
     Expression,
     FunctionCall,
     FunctionType,
@@ -95,7 +95,7 @@ def _is_type_cast(node: ast.expr) -> bool:
     return any(node.func.id in x.__members__.values() for x in get_args(AllTypes))
 
 
-def _convert_ann_assignment(node: ast.AnnAssign) -> Assignment:
+def _convert_ann_assignment(node: ast.AnnAssign) -> AbstractAssignment:
     if not isinstance(node.target, ast.Name):
         actual = ast.dump(node)
         raise InvalidDslError(
@@ -127,7 +127,7 @@ def _convert_ann_assignment(node: ast.AnnAssign) -> Assignment:
     )
 
 
-def _convert_assignment(node: ast.Assign) -> Assignment:
+def _convert_assignment(node: ast.Assign) -> AbstractAssignment:
     if n := len(node.targets) != 1:
         raise InvalidDslError(
             f"You must assign to exactly one variable, but got {n} variables."

tested/languages/kotlin/generators.py

@@ -23,7 +23,7 @@
 )
 from tested.languages.utils import convert_unknown_type
 from tested.serialisation import (
-    Assignment,
+    AbstractAssignment,
     Expression,
     FunctionCall,
     FunctionType,

tested/languages/preparation.py

@@ -21,7 +21,7 @@
     submission_name,
 )
 from tested.serialisation import (
-    Assignment,
+    AbstractAssignment,
     Expression,
     FunctionCall,
     FunctionType,
@@ -201,7 +201,7 @@ def prepare_argument(
     return prepare_expression(bundle, argument)
 
 
-def prepare_assignment(bundle: Bundle, assignment: Assignment) -> Assignment:
+def prepare_assignment(bundle: Bundle, assignment: AbstractAssignment) -> AbstractAssignment:
     if isinstance(assignment, VariableAssignment):
         if isinstance(assignment.type, VariableType):
             class_type = conventionalize_class(bundle.language, assignment.type.data)
@@ -409,7 +409,7 @@ def prepare_testcase(
                 names.append(evaluator_name)
             if result_channel == IgnoredChannel.IGNORED:
                 value_function_call = None
-        elif isinstance(testcase.input, Assignment):
+        elif isinstance(testcase.input, AbstractAssignment):
             command = prepare_assignment(bundle, testcase.input)
             assert (
                 result_channel == IgnoredChannel.IGNORED

tested/languages/python/generators.py

@@ -19,7 +19,7 @@
 )
 from tested.languages.utils import convert_unknown_type
 from tested.serialisation import (
-    Assignment,
+    AbstractAssignment,
     Expression,
     FunctionCall,
     FunctionType,

tested/serialisation.py

@@ -21,6 +21,7 @@
 import logging
 import math
 import operator
+from abc import abstractmethod
 from collections.abc import Iterable
 from decimal import Decimal
 from enum import StrEnum, auto, unique
@@ -52,7 +53,7 @@
     resolve_to_basic,
 )
 from tested.features import Construct, FeatureSet, WithFeatures, combine_features
 from tested.parsing import parse_json_value
 from tested.utils import flatten, sorted_no_duplicates
 
 logger = logging.getLogger(__name__)
@@ -152,8 +153,38 @@
     NEG_INFINITY = "-inf"
 
 
+#   class Statement(WithFeatures, WithFunctions):
+#       """
+#           Base class for representing Statements which represent Expressions and Assignments
+#       """
+#
+#       def accept(self, visitor: "ConvertStatementVisitor") -> None:
+#           visitor.visit(self)
+#
+
+class Expression(WithFeatures, WithFunctions):
+    """
+        Base class for representing Expressions which represent Values, Identifiers
+        and FunctionCalls.
+    """
+
+    type: Any
+    data: Any
+    diagnostic: Any
+
+#
+#
+#   # These visitors are defined for the generation files of each language.
+#   @define
+#   class ConvertStatementVisitor:
+#
+#       @abstractmethod
+#       def visit(self, statement: Statement) -> str:
+#           raise AssertionError(f"Unknown statement: {statement!r}")
+
+
 @define
-class NumberType(WithFeatures, WithFunctions):
+class NumberType(Expression):
     type: NumericTypes = field(validator=validators.instance_of(NumericTypes))
     data: SpecialNumbers | int | float | Decimal = field(
         validator=validators.instance_of(Union[SpecialNumbers, int, float, Decimal])
@@ -162,15 +193,15 @@
 
     def __attrs_post_init__(self):
         if (
-            isinstance(self.data, SpecialNumbers)
-            and resolve_to_basic(self.type) == BasicNumericTypes.INTEGER
+                isinstance(self.data, SpecialNumbers)
+                and resolve_to_basic(self.type) == BasicNumericTypes.INTEGER
         ):
             raise ValueError(
                 f"SpecialNumber '{self.data}' is only supported for " f"real numbers."
             )
 
         if resolve_to_basic(self.type) == BasicNumericTypes.INTEGER and isinstance(
-            self.data, Decimal
+                self.data, Decimal
         ):
             self.data = self.data.to_integral_value()
 
@@ -182,7 +213,7 @@
 
 
 @define
-class StringType(WithFeatures, WithFunctions):
+class StringType(Expression):
     type: StringTypes = field(validator=validators.instance_of(StringTypes))
     data: str = field(validator=validators.instance_of(str))
 
@@ -200,7 +231,7 @@
 
 
 @define
-class BooleanType(WithFeatures, WithFunctions):
+class BooleanType(Expression):
     type: BooleanTypes = field(validator=validators.instance_of(BooleanTypes))
     data: bool = field(validator=validators.instance_of(bool))
     diagnostic: Literal[None] = None  # Unused in this type.
@@ -213,7 +244,7 @@
 
 
 @define
-class SequenceType(WithFeatures, WithFunctions):
+class SequenceType(Expression):
     type: SequenceTypes = field(validator=validators.instance_of(SequenceTypes))
     data: list["Expression"]
     diagnostic: Literal[None] = None  # Unused in this type.
@@ -276,7 +307,7 @@
 
 
 @define
-class ObjectType(WithFeatures, WithFunctions):
+class ObjectType(Expression):
     type: ObjectTypes = field(validator=validators.instance_of(ObjectTypes))
     data: list[ObjectKeyValuePair]
     diagnostic: Literal[None] = None  # Unused in this type.
@@ -312,7 +343,7 @@
 
 
 @define
-class NothingType(WithFeatures, WithFunctions):
+class NothingType(Expression):
     type: NothingTypes = field(
         default=BasicNothingTypes.NOTHING,
         validator=validators.instance_of(NothingTypes),  # type: ignore
@@ -333,7 +364,7 @@
 ]
 
 
-class Identifier(str, WithFeatures, WithFunctions):
+class Identifier(str, Expression):
     """Represents an variable name."""
 
     is_raw: bool
@@ -391,7 +422,7 @@
 
 
 @define
-class FunctionCall(WithFeatures, WithFunctions):
+class FunctionCall(Expression):
     """
     Represents a function expression.
     """
@@ -413,8 +444,8 @@
 
         # Get OOP features.
         if self.type in (
-            FunctionType.PROPERTY,
-            FunctionType.CONSTRUCTOR,
+                FunctionType.PROPERTY,
+                FunctionType.CONSTRUCTOR,
         ) or not isinstance(self.namespace, (Identifier, NoneType)):
             constructs.add(Construct.OBJECTS)
 
@@ -544,6 +575,7 @@
 # If changing this, also update is_statement_strict in the utils.
 Statement = Assignment | Expression
 
+
 # Update the forward references, which fixes the schema generation.
 resolve_types(ObjectType)
 resolve_types(SequenceType)
@@ -597,8 +629,8 @@
     if isinstance(value.type, SimpleTypes):
         # If we have floats or ints, convert them to Python.
         if value.type in (
-            AdvancedNumericTypes.SINGLE_PRECISION,
-            AdvancedNumericTypes.DOUBLE_PRECISION,
+                AdvancedNumericTypes.SINGLE_PRECISION,
+                AdvancedNumericTypes.DOUBLE_PRECISION,
         ):
             return float(str(value.data))
         if value.type != AdvancedNumericTypes.FIXED_PRECISION:
@@ -740,11 +772,11 @@
         assert isinstance(value, NumberType)
         return value.data
     if basic_type in (
-        BasicBooleanTypes.BOOLEAN,
-        BasicStringTypes.TEXT,
-        BasicNothingTypes.NOTHING,
-        BasicStringTypes.ANY,
-        BasicStringTypes.UNKNOWN,
+            BasicBooleanTypes.BOOLEAN,
+            BasicStringTypes.TEXT,
+            BasicNothingTypes.NOTHING,
+            BasicStringTypes.ANY,
+            BasicStringTypes.UNKNOWN,
     ):
         return value.data
 

tested/utils.py

@@ -11,7 +11,7 @@
 from typing import get_args as typing_get_args
 
 if TYPE_CHECKING:
-    from tested.serialisation import Assignment
+    from tested.serialisation import AbstractAssignment
 
 _logger = logging.getLogger(__name__)
 
@@ -316,14 +316,14 @@
     return no_dup
 
 
-def is_statement_strict(statement: Any) -> TypeGuard["Assignment"]:
+def is_statement_strict(statement: Any) -> TypeGuard["AbstractAssignment"]:
     """
     Check that the given value is a strict statement: it must be a statement but
     not an expression.
 
     :param statement: The potential statement to check.
     :return: True if it is, False otherwise.
     """
-    from tested.serialisation import Assignment
+    from tested.serialisation import AbstractAssignment
 
-    return isinstance(statement, Assignment)
+    return isinstance(statement, AbstractAssignment)