added tests for expressions up to switch and reconfigured coverage to exclude java parser

Author: smythi93

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+omit = src/jast/_parser/Java*

src/jast/_jast.py

@@ -1331,7 +1331,7 @@ def __init__(
     def __iter__(self) -> Iterator[Tuple[str, JAST | List[JAST]]]:
         if self.type_args:
             yield "type_args", self.type_args
-        yield "jtype", self.type
+        yield "type", self.type
         if self.template_args:
             yield "template_args", self.template_args
         if self.args:
@@ -1366,12 +1366,12 @@ def __init__(
                 "expr_dims and initializer are mutually exclusive for ArrayCreation"
             )
         self.type = type
-        self.expr_dims = expr_dims
-        self.dims = dims
+        self.expr_dims = expr_dims or []
+        self.dims = dims or []
         self.initializer = initializer
 
     def __iter__(self) -> Iterator[Tuple[str, JAST | List[JAST]]]:
-        yield "jtype", self.type
+        yield "type", self.type
         if self.expr_dims:
             yield "expr_dims", self.expr_dims
         if self.dims:

src/jast/_parser/_convert.py

@@ -607,7 +607,7 @@ def visitArrayInitializer(
         self, ctx: JavaParser.ArrayInitializerContext
     ) -> jast.arrayinit:
         return jast.arrayinit(
-            initializers=[
+            values=[
                 self.visitVariableInitializer(variable_initializer)
                 for variable_initializer in ctx.variableInitializer()
             ],
@@ -1468,7 +1468,7 @@ def visitTypeExpression(self, ctx: JavaParser.TypeExpressionContext) -> jast.exp
                 type=jast.typebound(
                     types=[self.visitTypeType(typeType) for typeType in ctx.typeType()],
                 ),
-                expression=self.visitTypeExpression(ctx.typeExpression()),
+                value=self.visitTypeExpression(ctx.typeExpression()),
                 **self._get_location_rule(ctx),
             )
 
@@ -2129,7 +2129,11 @@ def visitExplicitGenericInvocationSuffix(
             )
 
     def visitArguments(self, ctx: JavaParser.ArgumentsContext) -> List[jast.expr]:
-        return self.visitExpressionList(ctx.expressionList())
+        return (
+            self.visitExpressionList(ctx.expressionList())
+            if ctx.expressionList()
+            else []
+        )
 
     def visitDeclarationStart(
         self, ctx: JavaParser.DeclarationStartContext

src/jast/_unparse.py

@@ -91,14 +91,16 @@ def fill(self, text=""):
             self.write(" " * self._indent_spaces * self._indent)
         self.write(text)
 
-    def interleave(self, items, sep, end=""):
+    def interleave(self, items, sep, start="", end=""):
         """
         Interleave a list of items with a separator.
         :param items:   The items to interleave.
         :param sep:     The separator.
+        :param start:   A text to add at the start.
         :param end:     A text to add at the end.
         """
         if items:
+            self.write(start)
             seq = iter(items)
             try:
                 self.visit(next(seq))
@@ -344,21 +346,22 @@ def visit_variabledeclaratorid(self, node):
         self.traverse(node.dims)
 
     def visit_typebound(self, node: jast.typebound):
-        self.write(" extends ")
         self.traverse(node.annotations, end=" ")
         self.interleave(node.types, " & ")
 
     def visit_typeparam(self, node: jast.typeparam):
         self.traverse(node.annotations, end=" ")
         self.visit_identifier(node.id)
-        self.visit(node.bound)
+        if node.bound:
+            self.write(" extends ")
+            self.visit(node.bound)
 
     def visit_typeparams(self, node: jast.typeparams):
         with self.diamond():
             self.items_view(node.parameters)
 
     def visit_pattern(self, node: jast.pattern):
-        self.interleave(node.modifiers, " ", " ")
+        self.interleave(node.modifiers, " ", end=" ")
         self.visit(node.type)
         self.write(" ")
         self.traverse(node.annotations, end=" ")
@@ -537,22 +540,26 @@ def visit_NewObject(self, node: jast.NewObject):
             self.write(")")
             if node.body:
                 with self.delimit(" {", "}"):
-                    self.traverse(node.body)
+                    with self.block():
+                        self.traverse(node.body)
+                    self.fill()
 
     def visit_NewArray(self, node: jast.NewArray):
         with self.require_parens(_Precedence.TYPE, node):
             self.write("new ")
             self.visit(node.type)
-            self.traverse(node.expr_dims)
+            self.interleave(node.expr_dims, "][", "[", "]")
             self.traverse(node.dims)
             if node.initializer:
-                self.visit(node.initializer)
+                self.write(" ")
+                self.visit_arrayinit(node.initializer)
 
     def visit_Cast(self, node: jast.Cast):
         with self.require_parens(_Precedence.TYPE, node):
             with self.parens():
                 self.traverse(node.annotations, end=" ")
                 self.visit(node.type)
+            self.write(" ")
             self.set_precedence(_Precedence.TYPE, node.value)
             self.visit(node.value)
 
@@ -646,13 +653,13 @@ def visit_receiver(self, node: jast.receiver):
         self.write("this")
 
     def visit_param(self, node: jast.param):
-        self.interleave(node.modifiers, " ", " ")
+        self.interleave(node.modifiers, " ", end=" ")
         self.visit(node.type)
         self.write(" ")
         self.visit_variabledeclaratorid(node.id)
 
     def visit_arity(self, node: jast.arity):
-        self.interleave(node.modifiers, " ", " ")
+        self.interleave(node.modifiers, " ", end=" ")
         self.visit(node.type)
         self.write(" ")
         self.traverse(node.annotations, end=" ")
@@ -673,7 +680,7 @@ def visit_LocalRecord(self, node: jast.LocalRecord):
 
     def visit_LocalVariable(self, node: jast.LocalVariable):
         self.fill()
-        self.interleave(node.modifiers, " ", " ")
+        self.interleave(node.modifiers, " ", end=" ")
         self.visit(node.type)
         self.write(" ")
         self.items_view(node.declarators)
@@ -834,7 +841,7 @@ def visit_Module(self, node: jast.Module):
 
     def visit_Field(self, node: jast.Field):
         self.fill()
-        self.interleave(node.modifiers, " ", " ")
+        self.interleave(node.modifiers, " ", end=" ")
         self.visit(node.type)
         self.write(" ")
         self.items_view(node.declarators)
@@ -843,7 +850,7 @@ def visit_Field(self, node: jast.Field):
     def visit_Method(self, node: jast.Method):
         self.fill()
         self.fill()
-        self.interleave(node.modifiers, " ", " ")
+        self.interleave(node.modifiers, " ", end=" ")
         self.visit(node.return_type)
         self.write(" ")
         self.visit_identifier(node.id)
@@ -862,7 +869,7 @@ def visit_Method(self, node: jast.Method):
     def visit_Class(self, node: jast.Class):
         self.fill()
         self.fill()
-        self.interleave(node.modifiers, " ", " ")
+        self.interleave(node.modifiers, " ", end=" ")
         self.write("class ")
         self.visit_identifier(node.id)
         self.visit(node.type_params)

tests/test_jast.py

@@ -9,7 +9,7 @@ def _test_iteration(self, tree):
         for field, value in tree:
             self.assertIsInstance(field, str)
             self.assertIsInstance(value, jast.JAST | List)
-            self.assertTrue(hasattr(tree, field))
+            self.assertTrue(hasattr(tree, field), f"{field} not in {tree.__class__}")
             self.assertEqual(getattr(tree, field), value)
 
     def test_identifier(self):
@@ -863,3 +863,187 @@ def test_BinOp_error(self):
             left=jast.Constant(jast.IntLiteral(42)),
             right=jast.Constant(jast.IntLiteral(0)),
         )
+
+    def test_InstanceOf(self):
+        instance_of = jast.InstanceOf(
+            value=jast.identifier("foo"),
+            type=jast.Int(),
+        )
+        self.assertIsInstance(instance_of, jast.InstanceOf)
+        self.assertIsInstance(instance_of, jast.JAST)
+        self.assertIsInstance(instance_of.value, jast.identifier)
+        self.assertEqual("foo", instance_of.value)
+        self.assertIsInstance(instance_of.type, jast.Int)
+        self._test_iteration(instance_of)
+
+    def test_InstanceOf_error(self):
+        self.assertRaises(
+            ValueError,
+            jast.InstanceOf,
+            type=jast.Int(),
+        )
+        self.assertRaises(
+            ValueError,
+            jast.InstanceOf,
+            value=jast.identifier("foo"),
+        )
+
+    def test_UnaryOp(self):
+        unary_op = jast.UnaryOp(
+            op=jast.USub(),
+            operand=jast.Constant(jast.IntLiteral(42)),
+        )
+        self.assertIsInstance(unary_op, jast.UnaryOp)
+        self.assertIsInstance(unary_op, jast.JAST)
+        self.assertIsInstance(unary_op.op, jast.USub)
+        self.assertIsInstance(unary_op.operand, jast.Constant)
+        self.assertIsInstance(unary_op.operand.value, jast.IntLiteral)
+        self.assertEqual(42, unary_op.operand.value)
+        self._test_iteration(unary_op)
+
+    def test_UnaryOp_error(self):
+        self.assertRaises(
+            ValueError,
+            jast.UnaryOp,
+            operand=jast.Constant(jast.IntLiteral(42)),
+        )
+        self.assertRaises(
+            ValueError,
+            jast.UnaryOp,
+            op=jast.USub(),
+        )
+
+    def test_PostOp(self):
+        post_op = jast.PostOp(
+            operand=jast.identifier("foo"),
+            op=jast.PostInc(),
+        )
+        self.assertIsInstance(post_op, jast.PostOp)
+        self.assertIsInstance(post_op, jast.JAST)
+        self.assertIsInstance(post_op.operand, jast.identifier)
+        self.assertEqual("foo", post_op.operand)
+        self.assertIsInstance(post_op.op, jast.PostInc)
+        self._test_iteration(post_op)
+
+    def test_PostOp_error(self):
+        self.assertRaises(
+            ValueError,
+            jast.PostOp,
+            op=jast.PostInc(),
+        )
+        self.assertRaises(
+            ValueError,
+            jast.PostOp,
+            operand=jast.identifier("foo"),
+        )
+
+    def test_Cast(self):
+        cast = jast.Cast(
+            annotations=[jast.Annotation(jast.qname([jast.identifier("foo")]))],
+            type=jast.Int(),
+            value=jast.Constant(jast.IntLiteral(42)),
+        )
+        self.assertIsInstance(cast, jast.Cast)
+        self.assertIsInstance(cast, jast.JAST)
+        self.assertEqual(1, len(cast.annotations))
+        self.assertIsInstance(cast.annotations[0], jast.Annotation)
+        self.assertIsInstance(cast.type, jast.Int)
+        self.assertIsInstance(cast.value, jast.Constant)
+        self.assertIsInstance(cast.value.value, jast.IntLiteral)
+        self.assertEqual(42, cast.value.value)
+        self._test_iteration(cast)
+
+    def test_Cast_error(self):
+        self.assertRaises(
+            ValueError,
+            jast.Cast,
+            value=jast.Constant(jast.IntLiteral(42)),
+        )
+        self.assertRaises(
+            ValueError,
+            jast.Cast,
+            type=jast.Int(),
+        )
+
+    def test_NewObject(self):
+        new_object = jast.NewObject(
+            type_args=jast.typeargs([jast.Int(), jast.Boolean()]),
+            type=jast.Coit(id=jast.identifier("A")),
+            args=[jast.Constant(jast.IntLiteral(42))],
+            body=[jast.EmptyDecl()],
+        )
+        self.assertIsInstance(new_object, jast.NewObject)
+        self.assertIsInstance(new_object, jast.JAST)
+        self.assertIsInstance(new_object.type_args, jast.typeargs)
+        self.assertEqual(2, len(new_object.type_args.types))
+        self.assertIsInstance(new_object.type_args.types[0], jast.Int)
+        self.assertIsInstance(new_object.type_args.types[1], jast.Boolean)
+        self.assertIsInstance(new_object.type, jast.Coit)
+        self.assertEqual("A", new_object.type.id)
+        self.assertEqual(1, len(new_object.args))
+        self.assertIsInstance(new_object.args[0], jast.Constant)
+        self.assertIsInstance(new_object.args[0].value, jast.IntLiteral)
+        self.assertEqual(42, new_object.args[0].value)
+        self.assertEqual(1, len(new_object.body))
+        self.assertIsInstance(new_object.body[0], jast.EmptyDecl)
+        self._test_iteration(new_object)
+
+    def test_NewObject_error(self):
+        self.assertRaises(
+            ValueError,
+            jast.NewObject,
+            type_args=jast.typeargs([jast.Int(), jast.Boolean()]),
+            args=[jast.Constant(jast.IntLiteral(42))],
+            body=[jast.EmptyDecl()],
+        )
+
+    def test_NewArray(self):
+        new_array = jast.NewArray(
+            type=jast.Int(),
+            expr_dims=[jast.Constant(jast.IntLiteral(1))],
+            dims=[jast.dim(), jast.dim()],
+        )
+        self.assertIsInstance(new_array, jast.NewArray)
+        self.assertIsInstance(new_array, jast.JAST)
+        self.assertIsInstance(new_array.type, jast.Int)
+        self.assertEqual(1, len(new_array.expr_dims))
+        expr_dim = new_array.expr_dims[0]
+        self.assertIsInstance(expr_dim, jast.Constant)
+        self.assertIsInstance(expr_dim.value, jast.IntLiteral)
+        self.assertEqual(1, expr_dim.value)
+        self.assertEqual(2, len(new_array.dims))
+        self.assertIsInstance(new_array.dims[0], jast.dim)
+        self.assertIsInstance(new_array.dims[1], jast.dim)
+        self._test_iteration(new_array)
+
+    def test_NewArray_initializer(self):
+        new_array = jast.NewArray(
+            type=jast.Int(),
+            dims=[jast.dim()],
+            initializer=jast.arrayinit(values=[jast.Constant(jast.IntLiteral(1))]),
+        )
+        self.assertIsInstance(new_array, jast.NewArray)
+        self.assertIsInstance(new_array, jast.JAST)
+        self.assertIsInstance(new_array.type, jast.Int)
+        self.assertEqual(1, len(new_array.dims))
+        self.assertIsInstance(new_array.dims[0], jast.dim)
+        self.assertIsInstance(new_array.initializer, jast.arrayinit)
+        self.assertEqual(1, len(new_array.initializer.values))
+        self.assertIsInstance(new_array.initializer.values[0], jast.Constant)
+        self.assertIsInstance(new_array.initializer.values[0].value, jast.IntLiteral)
+        self.assertEqual(1, new_array.initializer.values[0].value)
+        self._test_iteration(new_array)
+
+    def test_NewArray_error(self):
+        self.assertRaises(
+            ValueError,
+            jast.NewArray,
+            dims=[jast.dim()],
+        )
+        self.assertRaises(
+            ValueError,
+            jast.NewArray,
+            type=jast.Int(),
+            expr_dims=[jast.Constant(jast.IntLiteral(1))],
+            initializer=jast.arrayinit(values=[jast.Constant(jast.IntLiteral(1))]),
+        )