diff --git a/cpg-language-python/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/python/StatementHandler.kt b/cpg-language-python/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/python/StatementHandler.kt index f2b9b79553..a582583823 100644 --- a/cpg-language-python/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/python/StatementHandler.kt +++ b/cpg-language-python/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/python/StatementHandler.kt @@ -33,8 +33,20 @@ import de.fraunhofer.aisec.cpg.frontends.python.PythonLanguage.Companion.MODIFIE import de.fraunhofer.aisec.cpg.graph.* import de.fraunhofer.aisec.cpg.graph.Annotation import de.fraunhofer.aisec.cpg.graph.declarations.* -import de.fraunhofer.aisec.cpg.graph.statements.* -import de.fraunhofer.aisec.cpg.graph.statements.expressions.* +import de.fraunhofer.aisec.cpg.graph.statements.AssertStatement +import de.fraunhofer.aisec.cpg.graph.statements.CatchClause +import de.fraunhofer.aisec.cpg.graph.statements.DeclarationStatement +import de.fraunhofer.aisec.cpg.graph.statements.ForEachStatement +import de.fraunhofer.aisec.cpg.graph.statements.Statement +import de.fraunhofer.aisec.cpg.graph.statements.TryStatement +import de.fraunhofer.aisec.cpg.graph.statements.expressions.AssignExpression +import de.fraunhofer.aisec.cpg.graph.statements.expressions.Block +import de.fraunhofer.aisec.cpg.graph.statements.expressions.DeleteExpression +import de.fraunhofer.aisec.cpg.graph.statements.expressions.Expression +import de.fraunhofer.aisec.cpg.graph.statements.expressions.InitializerListExpression +import de.fraunhofer.aisec.cpg.graph.statements.expressions.MemberExpression +import de.fraunhofer.aisec.cpg.graph.statements.expressions.ProblemExpression +import de.fraunhofer.aisec.cpg.graph.statements.expressions.Reference import de.fraunhofer.aisec.cpg.graph.types.FunctionType import de.fraunhofer.aisec.cpg.helpers.Util import kotlin.collections.plusAssign diff --git a/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/ExpressionHandlerTest.kt b/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/ExpressionHandlerTest.kt index 1d0be6d624..51da0d504d 100644 --- a/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/ExpressionHandlerTest.kt +++ b/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/ExpressionHandlerTest.kt @@ -43,9 +43,8 @@ class ExpressionHandlerTest { } assertNotNull(result) - val twoBoolOpCondition = - result.functions["twoBoolOp"]?.ifs?.singleOrNull()?.condition as? BinaryOperator - assertNotNull(twoBoolOpCondition) + val twoBoolOpCondition = result.functions["twoBoolOp"]?.ifs?.singleOrNull()?.condition + assertIs(twoBoolOpCondition) assertEquals("and", twoBoolOpCondition.operatorCode) assertLocalName("a", twoBoolOpCondition.lhs) assertLiteralValue(true, twoBoolOpCondition.rhs) @@ -53,24 +52,23 @@ class ExpressionHandlerTest { // We expect that lhs comes first in the EOG and then the rhs. assertContains(twoBoolOpCondition.lhs.nextEOG, twoBoolOpCondition.rhs) - val threeBoolOpCondition = - result.functions["threeBoolOp"]?.ifs?.singleOrNull()?.condition as? BinaryOperator - assertNotNull(threeBoolOpCondition) + val threeBoolOpCondition = result.functions["threeBoolOp"]?.ifs?.singleOrNull()?.condition + assertIs(threeBoolOpCondition) assertEquals("and", threeBoolOpCondition.operatorCode) assertLocalName("a", threeBoolOpCondition.lhs) - val threeBoolOpConditionRhs = threeBoolOpCondition.rhs as? BinaryOperator - assertNotNull(threeBoolOpConditionRhs) + val threeBoolOpConditionRhs = threeBoolOpCondition.rhs + assertIs(threeBoolOpConditionRhs) assertEquals("and", threeBoolOpConditionRhs.operatorCode) assertLiteralValue(true, threeBoolOpConditionRhs.lhs) assertLocalName("b", threeBoolOpConditionRhs.rhs) val threeBoolOpNoBoolCondition = - result.functions["threeBoolOpNoBool"]?.ifs?.singleOrNull()?.condition as? BinaryOperator - assertNotNull(threeBoolOpNoBoolCondition) + result.functions["threeBoolOpNoBool"]?.ifs?.singleOrNull()?.condition + assertIs(threeBoolOpNoBoolCondition) assertEquals("and", threeBoolOpNoBoolCondition.operatorCode) assertLocalName("a", threeBoolOpNoBoolCondition.lhs) - val threeBoolOpNoBoolConditionRhs = threeBoolOpNoBoolCondition.rhs as? BinaryOperator - assertNotNull(threeBoolOpNoBoolConditionRhs) + val threeBoolOpNoBoolConditionRhs = threeBoolOpNoBoolCondition.rhs + assertIs(threeBoolOpNoBoolConditionRhs) assertEquals("and", threeBoolOpNoBoolConditionRhs.operatorCode) assertLiteralValue(true, threeBoolOpNoBoolConditionRhs.lhs) assertLiteralValue("foo", threeBoolOpNoBoolConditionRhs.rhs) @@ -82,12 +80,12 @@ class ExpressionHandlerTest { val nestedBoolOpDifferentOp = result.functions["nestedBoolOpDifferentOp"]?.ifs?.singleOrNull()?.condition - as? BinaryOperator - assertNotNull(nestedBoolOpDifferentOp) + + assertIs(nestedBoolOpDifferentOp) assertEquals("or", nestedBoolOpDifferentOp.operatorCode) assertLocalName("b", nestedBoolOpDifferentOp.rhs) - val nestedBoolOpDifferentOpLhs = nestedBoolOpDifferentOp.lhs as? BinaryOperator - assertNotNull(nestedBoolOpDifferentOpLhs) + val nestedBoolOpDifferentOpLhs = nestedBoolOpDifferentOp.lhs + assertIs(nestedBoolOpDifferentOpLhs) assertEquals("and", nestedBoolOpDifferentOpLhs.operatorCode) assertLiteralValue(true, nestedBoolOpDifferentOpLhs.rhs) assertLocalName("a", nestedBoolOpDifferentOpLhs.lhs) @@ -100,12 +98,11 @@ class ExpressionHandlerTest { val nestedBoolOpDifferentOp2 = result.functions["nestedBoolOpDifferentOp2"]?.ifs?.singleOrNull()?.condition - as? BinaryOperator - assertNotNull(nestedBoolOpDifferentOp2) + assertIs(nestedBoolOpDifferentOp2) assertEquals("or", nestedBoolOpDifferentOp2.operatorCode) assertLocalName("a", nestedBoolOpDifferentOp2.lhs) - val nestedBoolOpDifferentOp2Rhs = nestedBoolOpDifferentOp2.rhs as? BinaryOperator - assertNotNull(nestedBoolOpDifferentOp2Rhs) + val nestedBoolOpDifferentOp2Rhs = nestedBoolOpDifferentOp2.rhs + assertIs(nestedBoolOpDifferentOp2Rhs) assertEquals("and", nestedBoolOpDifferentOp2Rhs.operatorCode) assertLiteralValue(true, nestedBoolOpDifferentOp2Rhs.lhs) assertLocalName("b", nestedBoolOpDifferentOp2Rhs.rhs) diff --git a/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/PythonFrontendTest.kt b/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/PythonFrontendTest.kt index c643d9408f..4873153a00 100644 --- a/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/PythonFrontendTest.kt +++ b/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/PythonFrontendTest.kt @@ -57,19 +57,25 @@ class PythonFrontendTest : BaseTest() { assertNotNull(b) assertLocalName("b", b) assertEquals(assertResolvedType("bool"), b.type) - assertEquals(true, (b.firstAssignment as? Literal<*>)?.value) + val bFirstAssignment = b.firstAssignment + assertIs>(bFirstAssignment) + assertEquals(true, bFirstAssignment.value) val i = p.variables["i"] assertNotNull(i) assertLocalName("i", i) assertEquals(assertResolvedType("int"), i.type) - assertEquals(42L, (i.firstAssignment as? Literal<*>)?.value) + val iFirstAssignment = i.firstAssignment + assertIs>(iFirstAssignment) + assertEquals(42L, iFirstAssignment.value) val f = p.variables["f"] assertNotNull(f) assertLocalName("f", f) assertEquals(assertResolvedType("float"), f.type) - assertEquals(1.0, (f.firstAssignment as? Literal<*>)?.value) + val fFirstAssignment = f.firstAssignment + assertIs>(fFirstAssignment) + assertEquals(1.0, fFirstAssignment.value) val c = p.variables["c"] assertNotNull(c) @@ -82,13 +88,17 @@ class PythonFrontendTest : BaseTest() { assertNotNull(t) assertLocalName("t", t) assertEquals(assertResolvedType("str"), t.type) - assertEquals("Hello", (t.firstAssignment as? Literal<*>)?.value) + val tAssignment = t.firstAssignment + assertIs>(tAssignment) + assertEquals("Hello", tAssignment.value) val n = p.variables["n"] assertNotNull(n) assertLocalName("n", n) assertEquals(assertResolvedType("None"), n.type) - assertEquals(null, (n.firstAssignment as? Literal<*>)?.value) + val nAssignment = n.firstAssignment + assertIs>(nAssignment) + assertEquals(null, nAssignment.value) } } @@ -104,76 +114,82 @@ class PythonFrontendTest : BaseTest() { val p = tu.namespaces["function"] assertNotNull(p) - val foo = p.declarations.first() as? FunctionDeclaration - assertNotNull(foo) + val foo = p.declarations.firstOrNull() + assertIs(foo) - val bar = p.declarations[1] as? FunctionDeclaration - assertNotNull(bar) + val bar = p.declarations[1] + assertIs(bar) assertEquals(2, bar.parameters.size) - var callExpression = (foo.body as? Block)?.statements?.get(0) as? CallExpression - assertNotNull(callExpression) + val fooBody = foo.body + assertIs(fooBody) + var callExpression = fooBody.statements[0] + assertIs(callExpression) assertLocalName("bar", callExpression) - assertEquals(bar, callExpression.invokes.first()) + assertInvokes(callExpression, bar) val edge = callExpression.argumentEdges[1] assertNotNull(edge) assertEquals("s2", edge.name) - val s = bar.parameters.first() + val s = bar.parameters.firstOrNull() assertNotNull(s) assertLocalName("s", s) assertEquals(tu.primitiveType("str"), s.type) assertLocalName("bar", bar) - val compStmt = bar.body as? Block - assertNotNull(compStmt) + val compStmt = bar.body + assertIs(compStmt) assertNotNull(compStmt.statements) - callExpression = compStmt.statements[0] as? CallExpression - assertNotNull(callExpression) + callExpression = compStmt.statements[0] + assertIs(callExpression) assertFullName("print", callExpression) - val literal = callExpression.arguments.first() as? Literal<*> - assertNotNull(literal) + val literal = callExpression.arguments.firstOrNull() + assertIs>(literal) assertEquals("bar(s) here: ", literal.value) assertEquals(tu.primitiveType("str"), literal.type) - val ref = callExpression.arguments[1] as? Reference - assertNotNull(ref) + val ref = callExpression.arguments[1] + assertIs(ref) assertLocalName("s", ref) - assertEquals(s, ref.refersTo) + assertRefersTo(ref, s) - val stmt = compStmt.statements[1] as? AssignExpression - assertNotNull(stmt) + val stmt = compStmt.statements[1] + assertIs(stmt) - val a = stmt.declarations.first() as? VariableDeclaration + val a = stmt.declarations.firstOrNull() assertNotNull(a) assertLocalName("a", a) - val op = a.firstAssignment as? BinaryOperator - assertNotNull(op) + val op = a.firstAssignment + assertIs(op) assertEquals("+", op.operatorCode) - val lhs = op.lhs as? Literal<*> - assertNotNull(lhs) + val lhs = op.lhs + assertIs>(lhs) - assertEquals(1, (lhs.value as? Long)?.toInt()) + val lhsValue = lhs.value + assertIs(lhsValue) + assertEquals(1, lhsValue.toInt()) - val rhs = op.rhs as? Literal<*> - assertNotNull(rhs) + val rhs = op.rhs + assertIs>(rhs) - assertEquals(2, (rhs.value as? Long)?.toInt()) + val rhsValue = rhs.value + assertIs(rhsValue) + assertEquals(2, rhsValue.toInt()) - val r = compStmt.statements[3] as? ReturnStatement - assertNotNull(r) + val r = compStmt.statements[3] + assertIs(r) val s3 = tu.variables["s3"] assertNotNull(s3) @@ -197,21 +213,23 @@ class PythonFrontendTest : BaseTest() { val main = p.functions["foo"] assertNotNull(main) - val body = main.body as? Block - assertNotNull(body) + val body = main.body + assertIs(body) - val sel = (body.statements.first() as? AssignExpression)?.declarations?.first() + val bodyFirstStmt = body.statements.firstOrNull() + assertIs(bodyFirstStmt) + val sel = bodyFirstStmt.declarations.firstOrNull() assertNotNull(sel) assertLocalName("sel", sel) assertEquals(tu.primitiveType("bool"), sel.type) - val firstAssignment = sel.firstAssignment as? Literal<*> - assertNotNull(firstAssignment) + val firstAssignment = sel.firstAssignment + assertIs>(firstAssignment) assertEquals(tu.primitiveType("bool"), firstAssignment.type) assertEquals("True", firstAssignment.code) - val `if` = body.statements[1] as? IfStatement - assertNotNull(`if`) + val `if` = body.statements[1] + assertIs(`if`) } @Test @@ -239,31 +257,31 @@ class PythonFrontendTest : BaseTest() { assertLocalName("SomeClass", cls) assertEquals(1, cls.methods.size) - val clsfunc = cls.methods.first() + val clsfunc = cls.methods.firstOrNull() assertLocalName("someFunc", clsfunc) assertLocalName("foo", foo) - val body = foo.body as? Block - assertNotNull(body) + val body = foo.body + assertIs(body) assertNotNull(body.statements) assertEquals(2, body.statements.size) - val s1 = body.statements[0] as? AssignExpression - assertNotNull(s1) - val s2 = body.statements[1] as? MemberCallExpression - assertNotNull(s2) + val s1 = body.statements[0] + assertIs(s1) + val s2 = body.statements[1] + assertIs(s2) - val c1 = s1.declarations.first() as? VariableDeclaration + val c1 = s1.declarations.firstOrNull() assertNotNull(c1) assertLocalName("c1", c1) - val ctor = c1.firstAssignment as? ConstructExpression - assertNotNull(ctor) - assertEquals(ctor.constructor, cls.constructors.first() as? ConstructorDeclaration) + val ctor = c1.firstAssignment + assertIs(ctor) + assertEquals(ctor.constructor, cls.constructors.firstOrNull()) assertFullName("simple_class.SomeClass", c1.type) - assertEquals(c1, (s2.base as? Reference)?.refersTo) + assertRefersTo(s2.base, c1) assertEquals(1, s2.invokes.size) - assertEquals(clsfunc, s2.invokes.first()) + assertInvokes(s2, clsfunc) // member } @@ -281,33 +299,39 @@ class PythonFrontendTest : BaseTest() { val main = p.functions["foo"] assertNotNull(main) - val assignExpr = (main.body as? Block)?.statements?.first() as? AssignExpression - assertNotNull(assignExpr) + val mainBody = main.body + assertIs(mainBody) + val assignExpr = mainBody.statements.firstOrNull() + assertIs(assignExpr) - val foo = assignExpr.declarations.firstOrNull() as? VariableDeclaration + val foo = assignExpr.declarations.firstOrNull() assertNotNull(foo) assertLocalName("foo", foo) assertEquals(tu.primitiveType("int"), foo.type) - val initializer = foo.firstAssignment as? ConditionalExpression - assertNotNull(initializer) + val initializer = foo.firstAssignment + assertIs(initializer) assertEquals(tu.primitiveType("int"), initializer.type) - val ifCond = initializer.condition as? Literal<*> - assertNotNull(ifCond) - val thenExpr = initializer.thenExpression as? Literal<*> - assertNotNull(thenExpr) - val elseExpr = initializer.elseExpression as? Literal<*> - assertNotNull(elseExpr) + val ifCond = initializer.condition + assertIs>(ifCond) + val thenExpr = initializer.thenExpression + assertIs>(thenExpr) + val elseExpr = initializer.elseExpression + assertIs>(elseExpr) assertEquals(tu.primitiveType("bool"), ifCond.type) assertEquals(false, ifCond.value) assertEquals(tu.primitiveType("int"), thenExpr.type) - assertEquals(21, (thenExpr.value as? Long)?.toInt()) + val thenValue = thenExpr.value + assertIs(thenValue) + assertEquals(21, thenValue.toInt()) + val elseValue = elseExpr.value + assertIs(elseValue) assertEquals(tu.primitiveType("int"), elseExpr.type) - assertEquals(42, (elseExpr.value as? Long)?.toInt()) + assertEquals(42, elseValue.toInt()) } @Test @@ -360,14 +384,16 @@ class PythonFrontendTest : BaseTest() { assertNotNull(methBar) assertLocalName("bar", methBar) - val barZ = (methBar.body as? Block)?.statements?.get(0) as? MemberExpression - assertNotNull(barZ) - assertEquals(fieldZ, barZ.refersTo) + val methBarBody = methBar.body + assertIs(methBarBody) + val barZ = methBarBody.statements[0] + assertIs(barZ) + assertRefersTo(barZ, fieldZ) - val barBaz = (methBar.body as? Block)?.statements?.get(1) as? AssignExpression - assertNotNull(barBaz) - val barBazInner = barBaz.declarations[0] as? FieldDeclaration - assertNotNull(barBazInner) + val barBaz = methBarBody.statements[1] + assertIs(barBaz) + val barBazInner = barBaz.declarations[0] + assertIs(barBazInner) assertLocalName("baz", barBazInner) assertNotNull(barBazInner.firstAssignment) } @@ -418,23 +444,27 @@ class PythonFrontendTest : BaseTest() { // assertEquals(tu.primitiveType("int"), i.type) // self.somevar = i - val someVarDeclaration = - ((bar.body as? Block)?.statements?.get(0) as? AssignExpression)?.declarations?.first() - as? FieldDeclaration - assertNotNull(someVarDeclaration) + val barBody = bar.body + assertIs(barBody) + val barBodyFirstStmt = barBody.statements[0] + assertIs(barBodyFirstStmt) + val someVarDeclaration = barBodyFirstStmt.declarations.firstOrNull() + assertIs(someVarDeclaration) assertLocalName("somevar", someVarDeclaration) - assertEquals(i, (someVarDeclaration.firstAssignment as? Reference)?.refersTo) + assertRefersTo(someVarDeclaration.firstAssignment, i) - val fooMemCall = (foo.body as? Block)?.statements?.get(0) as? MemberCallExpression - assertNotNull(fooMemCall) + val fooBody = foo.body + assertIs(fooBody) + val fooMemCall = fooBody.statements[0] + assertIs(fooMemCall) - val mem = fooMemCall.callee as? MemberExpression - assertNotNull(mem) + val mem = fooMemCall.callee + assertIs(mem) assertLocalName("bar", mem) assertEquals(".", fooMemCall.operatorCode) assertFullName("class_self.Foo.bar", fooMemCall) assertEquals(1, fooMemCall.invokes.size) - assertEquals(bar, fooMemCall.invokes[0]) + assertInvokes(fooMemCall, bar) assertLocalName("self", fooMemCall.base) } @@ -489,9 +519,9 @@ class PythonFrontendTest : BaseTest() { assertEquals(1, recordFoo.methods.size) assertEquals(1, recordFoo.constructors.size) - val fooCtor = recordFoo.constructors[0] as? ConstructorDeclaration + val fooCtor = recordFoo.constructors[0] assertNotNull(fooCtor) - val foobar = recordFoo.methods[0] as? MethodDeclaration + val foobar = recordFoo.methods[0] assertNotNull(foobar) assertLocalName("__init__", fooCtor) @@ -501,22 +531,27 @@ class PythonFrontendTest : BaseTest() { assertNotNull(bar) assertLocalName("bar", bar) - assertEquals(2, (bar.body as? Block)?.statements?.size) - val line1 = (bar.body as? Block)?.statements?.get(0) as? AssignExpression - assertNotNull(line1) - val line2 = (bar.body as? Block)?.statements?.get(1) as? MemberCallExpression - assertNotNull(line2) + val barBody = bar.body + assertIs(barBody) + + assertEquals(2, barBody.statements.size) + val line1 = barBody.statements[0] + assertIs(line1) + + val line2 = barBody.statements[1] + assertIs(line2) assertEquals(1, line1.declarations.size) val fooDecl = line1.declarations[0] assertNotNull(fooDecl) assertLocalName("foo", fooDecl) assertFullName("class_ctor.Foo", fooDecl.type) - val initializer = fooDecl.firstAssignment as? ConstructExpression - assertEquals(fooCtor, initializer?.constructor) + val initializer = fooDecl.firstAssignment + assertIs(initializer) + assertEquals(fooCtor, initializer.constructor) - assertEquals(fooDecl, (line2.base as? Reference)?.refersTo) - assertEquals(foobar, line2.invokes[0]) + assertRefersTo(line2.base, fooDecl) + assertInvokes(line2, foobar) } @Test @@ -553,27 +588,34 @@ class PythonFrontendTest : BaseTest() { assertNotNull(countParam) assertLocalName("c", countParam) - val countStmt = (methCount.body as? Block)?.statements?.get(0) as? IfStatement - assertNotNull(countStmt) + val methCountBody = methCount.body + assertIs(methCountBody) + + val countStmt = methCountBody.statements[0] + assertIs(countStmt) - val ifCond = countStmt.condition as? BinaryOperator - assertNotNull(ifCond) + val ifCond = countStmt.condition + assertIs(ifCond) - val lhs = ifCond.lhs as? MemberCallExpression - assertNotNull(lhs) - assertEquals(countParam, (lhs.base as? Reference)?.refersTo) + val lhs = ifCond.lhs + assertIs(lhs) + assertRefersTo(lhs.base, countParam) assertLocalName("inc", lhs) assertEquals(0, lhs.arguments.size) - val ifThen = (countStmt.thenStatement as? Block)?.statements?.get(0) as? CallExpression - assertNotNull(ifThen) - assertEquals(methCount, ifThen.invokes.first()) - assertEquals(countParam, (ifThen.arguments.first() as? Reference)?.refersTo) + val ifThenBody = countStmt.thenStatement + assertIs(ifThenBody) + val ifThenFirstStmt = ifThenBody.statements[0] + assertIs(ifThenFirstStmt) + assertInvokes(ifThenFirstStmt, methCount) + assertRefersTo(ifThenFirstStmt.arguments.firstOrNull(), countParam) assertNull(countStmt.elseStatement) // class c1(counter) assertLocalName("c1", clsC1) - assertEquals(clsCounter, (clsC1.superClasses.first() as? ObjectType)?.recordDeclaration) + val cls1Super = clsC1.superClasses.firstOrNull() + assertIs(cls1Super) + assertEquals(clsCounter, cls1Super.recordDeclaration) assertEquals(1, clsC1.fields.size) val field = clsC1.fields[0] @@ -592,32 +634,29 @@ class PythonFrontendTest : BaseTest() { assertLocalName("self", selfReceiver) assertEquals(0, meth.parameters.size) // self is receiver and not a parameter - val methBody = meth.body as? Block - assertNotNull(methBody) + val methBody = meth.body + assertIs(methBody) - val assign = methBody.statements[0] as? AssignExpression - assertNotNull(assign) + val assign = methBody.statements[0] + assertIs(assign) val assignLhs = assign.lhs() val assignRhs = assign.rhs() assertEquals("=", assign.operatorCode) assertNotNull(assignLhs) assertNotNull(assignRhs) - assertEquals(selfReceiver, (assignLhs.base as? Reference)?.refersTo) + assertRefersTo(assignLhs.base, selfReceiver) assertEquals("+", assignRhs.operatorCode) - val assignRhsLhs = - assignRhs.lhs - as? MemberExpression // the second "self.total" in "self.total = self.total + 1" - assertNotNull(assignRhsLhs) - assertEquals(selfReceiver, (assignRhsLhs.base as? Reference)?.refersTo) + val assignRhsLhs = assignRhs.lhs // the second "self.total" in "self.total = self.total + 1" + assertIs(assignRhsLhs) + assertRefersTo(assignRhsLhs.base, selfReceiver) - val r = methBody.statements[1] as? ReturnStatement - assertNotNull(r) - assertEquals( - selfReceiver, - ((r.returnValue as? MemberExpression)?.base as? Reference)?.refersTo - ) + val r = methBody.statements[1] + assertIs(r) + val retVal = r.returnValue + assertIs(retVal) + assertRefersTo(retVal.base, selfReceiver) // TODO last line "count(c1())" } @@ -655,54 +694,52 @@ class PythonFrontendTest : BaseTest() { assertNotNull(classFieldWithInit) // classFieldNoInitializer = classFieldWithInit - val assignClsFieldOutsideFunc = clsFoo.statements[2] as? AssignExpression - assertNotNull(assignClsFieldOutsideFunc) - assertEquals( - classFieldNoInitializer, - (assignClsFieldOutsideFunc.lhs())?.refersTo - ) - assertEquals(classFieldWithInit, (assignClsFieldOutsideFunc.rhs())?.refersTo) + val assignClsFieldOutsideFunc = clsFoo.statements[2] + assertIs(assignClsFieldOutsideFunc) + assertRefersTo(assignClsFieldOutsideFunc.lhs(), classFieldNoInitializer) + assertRefersTo((assignClsFieldOutsideFunc.rhs()), classFieldWithInit) assertEquals("=", assignClsFieldOutsideFunc.operatorCode) - val barBody = methBar.body as? Block - assertNotNull(barBody) + val barBody = methBar.body + assertIs(barBody) // self.classFieldDeclaredInFunction = 456 - val barStmt0 = barBody.statements[0] as? AssignExpression - val decl0 = barStmt0?.declarations?.get(0) as? FieldDeclaration - assertNotNull(decl0) + val barStmt0 = barBody.statements[0] + assertIs(barStmt0) + val decl0 = barStmt0.declarations[0] + assertIs(decl0) assertLocalName("classFieldDeclaredInFunction", decl0) assertNotNull(decl0.firstAssignment) // self.classFieldNoInitializer = 789 - val barStmt1 = barBody.statements[1] as? AssignExpression - assertNotNull(barStmt1) - assertEquals(classFieldNoInitializer, (barStmt1.lhs())?.refersTo) + val barStmt1 = barBody.statements[1] + assertIs(barStmt1) + assertRefersTo((barStmt1.lhs()), classFieldNoInitializer) // self.classFieldWithInit = 12 - val barStmt2 = barBody.statements[2] as? AssignExpression - assertNotNull(barStmt2) - assertEquals(classFieldWithInit, (barStmt2.lhs())?.refersTo) + val barStmt2 = barBody.statements[2] + assertIs(barStmt2) + assertRefersTo((barStmt2.lhs()), classFieldWithInit) // classFieldNoInitializer = "shadowed" - val barStmt3 = barBody.statements[3] as? AssignExpression - assertNotNull(barStmt3) + val barStmt3 = barBody.statements[3] + assertIs(barStmt3) assertEquals("=", barStmt3.operatorCode) - assertEquals(classFieldNoInitializer, (barStmt3.lhs())?.refersTo) + assertRefersTo((barStmt3.lhs()), classFieldNoInitializer) assertEquals("shadowed", (barStmt3.rhs>())?.value) // classFieldWithInit = "shadowed" - val barStmt4 = barBody.statements[4] as? AssignExpression - assertNotNull(barStmt4) + val barStmt4 = barBody.statements[4] + assertIs(barStmt4) assertEquals("=", barStmt4.operatorCode) - assertEquals(classFieldWithInit, (barStmt4.lhs())?.refersTo) + assertRefersTo((barStmt4.lhs()), classFieldWithInit) assertEquals("shadowed", (barStmt4.rhs>())?.value) // classFieldDeclaredInFunction = "shadowed" - val barStmt5 = barBody.statements[5] as? AssignExpression - assertNotNull(barStmt5) + val barStmt5 = barBody.statements[5] + assertIs(barStmt5) assertEquals("=", barStmt5.operatorCode) - assertEquals(classFieldDeclaredInFunction, (barStmt5.lhs())?.refersTo) + assertRefersTo((barStmt5.lhs()), classFieldDeclaredInFunction) assertEquals("shadowed", (barStmt5.rhs>())?.value) /* TODO: @@ -753,19 +790,19 @@ class PythonFrontendTest : BaseTest() { val foo = p.variables["foo"] assertNotNull(foo) - val firstAssignment = foo.firstAssignment as? MemberCallExpression - assertNotNull(firstAssignment) + val firstAssignment = foo.firstAssignment + assertIs(firstAssignment) assertLocalName("zzz", firstAssignment) - val base = firstAssignment.base as? MemberExpression - assertNotNull(base) + val base = firstAssignment.base + assertIs(base) assertLocalName("baz", base) - val baseBase = base.base as? Reference - assertNotNull(baseBase) + val baseBase = base.base + assertIs(baseBase) assertLocalName("bar", baseBase) - val memberExpression = firstAssignment.callee as? MemberExpression - assertNotNull(memberExpression) + val memberExpression = firstAssignment.callee + assertIs(memberExpression) assertLocalName("zzz", memberExpression) } @@ -784,24 +821,24 @@ class PythonFrontendTest : BaseTest() { val main = p.functions["main"] assertNotNull(main) - val mainBody = (main as? FunctionDeclaration)?.body as? Block - assertNotNull(mainBody) + val mainBody = main.body + assertIs(mainBody) - val whlStmt = mainBody.statements[3] as? WhileStatement - assertNotNull(whlStmt) + val whlStmt = mainBody.statements[3] + assertIs(whlStmt) - val whlBody = whlStmt.statement as? Block - assertNotNull(whlBody) + val whlBody = whlStmt.statement + assertIs(whlBody) - val xDeclaration = whlBody.statements[0] as? AssignExpression - assertNotNull(xDeclaration) + val xDeclaration = whlBody.statements[0] + assertIs(xDeclaration) - val ifStatement = whlBody.statements[1] as? IfStatement - assertNotNull(ifStatement) + val ifStatement = whlBody.statements[1] + assertIs(ifStatement) - val brk = ifStatement.elseStatement as? Block - assertNotNull(brk) - brk.statements[0] as? BreakStatement + val brk = ifStatement.elseStatement + assertIs(brk) + assertIs(brk.statements[0]) } @Test @@ -918,31 +955,37 @@ class PythonFrontendTest : BaseTest() { val p = tu.namespaces["issue473"] assertNotNull(p) - val ifStatement = p.statements[0] as? IfStatement - assertNotNull(ifStatement) - val ifCond = ifStatement.condition as? BinaryOperator - assertNotNull(ifCond) - val ifThen = ifStatement.thenStatement as? Block - assertNotNull(ifThen) - val ifElse = ifStatement.elseStatement as? Block - assertNotNull(ifElse) + val ifStatement = p.statements[0] + assertIs(ifStatement) + val ifCond = ifStatement.condition + assertIs(ifCond) + val ifThen = ifStatement.thenStatement + assertIs(ifThen) + val ifElse = ifStatement.elseStatement + assertIs(ifElse) // sys.version_info.minor > 9 assertEquals(">", ifCond.operatorCode) - assertLocalName("minor", ifCond.lhs as? Reference) + assertIs(ifCond.lhs) + assertLocalName("minor", ifCond.lhs) // phr = {"user_id": user_id} | content - val phrDeclaration = (ifThen.statements[0] as? AssignExpression)?.declarations?.get(0) + val ifThenFirstStmt = ifThen.statements.firstOrNull() + assertIs(ifThenFirstStmt) + val phrDeclaration = ifThenFirstStmt.declarations[0] assertNotNull(phrDeclaration) assertLocalName("phr", phrDeclaration) - val phrInitializer = phrDeclaration.firstAssignment as? BinaryOperator - assertNotNull(phrInitializer) + val phrInitializer = phrDeclaration.firstAssignment + assertIs(phrInitializer) assertEquals("|", phrInitializer.operatorCode) - assertEquals(true, phrInitializer.lhs is InitializerListExpression) + val phrInitializerLhs = phrInitializer.lhs + assertIs(phrInitializerLhs) // z = {"user_id": user_id} - val elseStmt1 = (ifElse.statements[0] as? AssignExpression)?.declarations?.get(0) + val elseFirstStmt = ifElse.statements.firstOrNull() + assertIs(elseFirstStmt) + val elseStmt1 = elseFirstStmt.declarations[0] assertNotNull(elseStmt1) assertLocalName("z", elseStmt1) @@ -971,12 +1014,12 @@ class PythonFrontendTest : BaseTest() { assertEquals(1, functions.size) assertEquals( "# a function", - functions.first().comment, + functions.firstOrNull()?.comment, ) val literals = commentedNodes.filterIsInstance>() assertEquals(1, literals.size) - assertEquals("# comment start", literals.first().comment) + assertEquals("# comment start", literals.firstOrNull()?.comment) val params = commentedNodes.filterIsInstance() assertEquals(2, params.size) @@ -985,17 +1028,17 @@ class PythonFrontendTest : BaseTest() { val assignment = commentedNodes.filterIsInstance() assertEquals(2, assignment.size) - assertEquals("# A comment# a number", assignment.first().comment) + assertEquals("# A comment# a number", assignment.firstOrNull()?.comment) assertEquals("# comment end", assignment.last().comment) val block = commentedNodes.filterIsInstance() assertEquals(1, block.size) - assertEquals("# foo", block.first().comment) + assertEquals("# foo", block.firstOrNull()?.comment) val kvs = commentedNodes.filterIsInstance() assertEquals(2, kvs.size) - assertEquals("# a entry", kvs.first { it.code?.contains("a") ?: false }.comment) - assertEquals("# b entry", kvs.first { it.code?.contains("b") ?: false }.comment) + assertEquals("# a entry", kvs.first { it.code?.contains("a") == true }.comment) + assertEquals("# b entry", kvs.first { it.code?.contains("b") == true }.comment) } @Test @@ -1034,30 +1077,32 @@ class PythonFrontendTest : BaseTest() { val varDefinedInLoop = forloopFunc.variables["varDefinedInLoop"] assertNotNull(varDefinedInLoop) - val functionBody = forloopFunc.body as? Block - assertNotNull(functionBody) + val functionBody = forloopFunc.body + assertIs(functionBody) - val firstLoop = functionBody.statements[1] as? ForEachStatement - assertNotNull(firstLoop) + val firstLoop = functionBody.statements[1] + assertIs(firstLoop) - val secondLoop = functionBody.statements[2] as? ForEachStatement - assertNotNull(secondLoop) + val secondLoop = functionBody.statements[2] + assertIs(secondLoop) - val fooCall = functionBody.statements[3] as? CallExpression - assertNotNull(fooCall) + val fooCall = functionBody.statements[3] + assertIs(fooCall) - val barCall = functionBody.statements[4] as? CallExpression - assertNotNull(barCall) + val barCall = functionBody.statements[4] + assertIs(barCall) + + val bodyFirstStmt = functionBody.statements.firstOrNull() + assertIs(bodyFirstStmt) + val varDefinedBeforeLoopRef = bodyFirstStmt.lhs.firstOrNull() + assertIs(varDefinedBeforeLoopRef) - val varDefinedBeforeLoopRef = - (functionBody.statements.firstOrNull() as? AssignExpression)?.lhs?.firstOrNull() - as? Reference ?: TODO() // no dataflow from var declaration to loop variable because it's a write access assert((firstLoop.variable?.prevDFG?.contains(varDefinedBeforeLoopRef) == false)) // dataflow from range call to loop variable - val firstLoopIterable = firstLoop.iterable as? CallExpression - assertNotNull(firstLoopIterable) + val firstLoopIterable = firstLoop.iterable + assertIs(firstLoopIterable) assert((firstLoop.variable?.prevDFG?.contains((firstLoopIterable)) == true)) // dataflow from var declaration to loop iterable call @@ -1067,25 +1112,23 @@ class PythonFrontendTest : BaseTest() { ) // dataflow from first loop to foo call - val loopVar = firstLoop.variable as? Reference - assertNotNull(loopVar) - assert(fooCall.arguments.first().prevDFG.contains(loopVar)) + val loopVar = firstLoop.variable + assertIs(loopVar) + assertTrue(fooCall.arguments.firstOrNull()?.prevDFG?.contains(loopVar) == true) // dataflow from var declaration to foo call (in case for loop is not executed) - assert(fooCall.arguments.first().prevDFG.contains(varDefinedBeforeLoopRef)) + assert(fooCall.arguments.firstOrNull()?.prevDFG?.contains(varDefinedBeforeLoopRef) == true) // dataflow from range call to loop variable - val secondLoopIterable = secondLoop.iterable as? CallExpression - assertNotNull(secondLoopIterable) - assert( - ((secondLoop.variable as? Reference)?.prevDFG?.contains((secondLoopIterable)) == true) - ) + val secondLoopIterable = secondLoop.iterable + assertIs(secondLoopIterable) + + val secondLoopVar = secondLoop.variable + assertIs(secondLoopVar) + assert(secondLoopVar.prevDFG.contains(secondLoopIterable) == true) // dataflow from second loop var to bar call - assertEquals( - (secondLoop.variable as? Reference), - barCall.arguments.first().prevDFG.firstOrNull() - ) + assertEquals(secondLoopVar, barCall.arguments.firstOrNull()?.prevDFG?.firstOrNull()) } @Test @@ -1105,73 +1148,96 @@ class PythonFrontendTest : BaseTest() { val bAugAssign = tu.allChildren().singleOrNull { - (it.lhs.singleOrNull() as? Reference)?.name?.localName == "b" && - it.location?.region?.startLine == 4 + val itLhs = it.lhs.singleOrNull() + assertIs(itLhs) + itLhs.name.localName == "b" && it.location?.region?.startLine == 4 } assertNotNull(bAugAssign) assertEquals("*=", bAugAssign.operatorCode) assertEquals("b", bAugAssign.lhs.singleOrNull()?.name?.localName) - assertEquals(2L, (bAugAssign.rhs.singleOrNull() as? Literal<*>)?.value) + val bAugAssignRhs = bAugAssign.rhs.singleOrNull() + assertIs>(bAugAssignRhs) + assertEquals(2L, bAugAssignRhs.value) // c = (not True and False) or True val cAssign = tu.allChildren() - .singleOrNull { (it.lhs.singleOrNull() as? Reference)?.name?.localName == "c" } + .singleOrNull { + val itLhs = it.lhs.singleOrNull() + assertIs(itLhs) + itLhs.name.localName == "c" + } ?.rhs - ?.singleOrNull() as? BinaryOperator - assertNotNull(cAssign) + ?.singleOrNull() + assertIs(cAssign) assertEquals("or", cAssign.operatorCode) - assertEquals(true, (cAssign.rhs as? Literal<*>)?.value) - assertEquals("and", (cAssign.lhs as? BinaryOperator)?.operatorCode) - assertEquals(false, ((cAssign.lhs as? BinaryOperator)?.rhs as? Literal<*>)?.value) - assertEquals("not", ((cAssign.lhs as? BinaryOperator)?.lhs as? UnaryOperator)?.operatorCode) - assertEquals( - true, - (((cAssign.lhs as? BinaryOperator)?.lhs as? UnaryOperator)?.input as? Literal<*>)?.value - ) + val cAssignRhs = cAssign.rhs + assertIs>(cAssignRhs) + assertEquals(true, cAssignRhs.value) + val cAssignLhs = cAssign.lhs + assertIs(cAssignLhs) + assertEquals("and", cAssignLhs.operatorCode) + val cAssignLhsRhs = cAssignLhs.rhs + assertIs>(cAssignLhsRhs) + assertEquals(false, cAssignLhsRhs.value) + val cAssignLhsLhs = cAssignLhs.lhs + assertIs(cAssignLhsLhs) + assertEquals("not", cAssignLhsLhs.operatorCode) + val cAssignLhsLhsInput = cAssignLhsLhs.input + assertIs>(cAssignLhsLhsInput) + assertEquals(true, cAssignLhsLhsInput.value) // d = ((-5 >> 2) & ~7 | (+4 << 1)) ^ 0xffff val dAssign = tu.allChildren() - .singleOrNull { (it.lhs.singleOrNull() as? Reference)?.name?.localName == "d" } + .singleOrNull { + val itLhs = it.lhs.singleOrNull() + assertIs(itLhs) + itLhs.name.localName == "d" + } ?.rhs - ?.singleOrNull() as? BinaryOperator - assertNotNull(dAssign) + ?.singleOrNull() + assertIs(dAssign) assertEquals("^", dAssign.operatorCode) - assertEquals(0xffffL, (dAssign.rhs as? Literal<*>)?.value) - assertEquals("|", (dAssign.lhs as? BinaryOperator)?.operatorCode) - assertEquals("<<", ((dAssign.lhs as? BinaryOperator)?.rhs as? BinaryOperator)?.operatorCode) - assertEquals( - 1L, - (((dAssign.lhs as? BinaryOperator)?.rhs as? BinaryOperator)?.rhs as? Literal<*>)?.value - ) - assertEquals( - "+", - (((dAssign.lhs as? BinaryOperator)?.rhs as? BinaryOperator)?.lhs as? UnaryOperator) - ?.operatorCode - ) - assertEquals( - 4L, - ((((dAssign.lhs as? BinaryOperator)?.rhs as? BinaryOperator)?.lhs as? UnaryOperator) - ?.input as? Literal<*>) - ?.value - ) - val dAssignLhsOfOr = (dAssign.lhs as? BinaryOperator)?.lhs as? BinaryOperator - assertNotNull(dAssignLhsOfOr) + val dAssignRhs = dAssign.rhs + assertIs>(dAssignRhs) + assertEquals(0xffffL, dAssignRhs.value) + val dAssignLhs = dAssign.lhs + assertIs(dAssignLhs) + assertEquals("|", dAssignLhs.operatorCode) + val dAssignLhsRhs = dAssignLhs.rhs + assertIs(dAssignLhsRhs) + assertEquals("<<", dAssignLhsRhs.operatorCode) + val dAssignLhsRhsRhs = dAssignLhsRhs.rhs + assertIs>(dAssignLhsRhsRhs) + assertEquals(1L, dAssignLhsRhsRhs.value) + val dAssignLhsRhsLhs = dAssignLhsRhs.lhs + assertIs(dAssignLhsRhsLhs) + assertEquals("+", dAssignLhsRhsLhs.operatorCode) + val dAssignLhsRhsLhsInput = dAssignLhsRhsLhs.input + assertIs>(dAssignLhsRhsLhsInput) + assertEquals(4L, dAssignLhsRhsLhsInput.value) + val dAssignLhsOfOr = dAssignLhs.lhs + assertIs(dAssignLhsOfOr) assertEquals("&", dAssignLhsOfOr.operatorCode) - assertEquals("~", (dAssignLhsOfOr.rhs as? UnaryOperator)?.operatorCode) - assertEquals(7L, ((dAssignLhsOfOr.rhs as? UnaryOperator)?.input as? Literal<*>)?.value) - assertEquals(">>", (dAssignLhsOfOr.lhs as? BinaryOperator)?.operatorCode) - assertEquals(2L, ((dAssignLhsOfOr.lhs as? BinaryOperator)?.rhs as? Literal<*>)?.value) - assertEquals( - "-", - ((dAssignLhsOfOr.lhs as? BinaryOperator)?.lhs as? UnaryOperator)?.operatorCode - ) - assertEquals( - 5L, - (((dAssignLhsOfOr.lhs as? BinaryOperator)?.lhs as? UnaryOperator)?.input as? Literal<*>) - ?.value - ) + val dAssignLhsOfOrRhs = dAssignLhsOfOr.rhs + assertIs(dAssignLhsOfOrRhs) + assertEquals("~", dAssignLhsOfOrRhs.operatorCode) + val dAssignLhsOfOrRhsInput = dAssignLhsOfOrRhs.input + assertIs>(dAssignLhsOfOrRhsInput) + assertEquals(7L, dAssignLhsOfOrRhsInput.value) + val dAssignLhsOfOrLhs = dAssignLhsOfOr.lhs + assertIs(dAssignLhsOfOrLhs) + assertEquals(">>", dAssignLhsOfOrLhs.operatorCode) + val dAssignLhsOfOrLhsRhs = dAssignLhsOfOrLhs.rhs + assertIs>(dAssignLhsOfOrLhsRhs) + assertEquals(2L, dAssignLhsOfOrLhsRhs.value) + val dAssignLhsOfOrLhsLhs = dAssignLhsOfOrLhs.lhs + assertIs(dAssignLhsOfOrLhsLhs) + assertEquals("-", dAssignLhsOfOrLhsLhs.operatorCode) + val dAssignLhsOfOrLhsLhsInput = dAssignLhsOfOrLhsLhs.input + assertIs>(dAssignLhsOfOrLhsLhsInput) + assertEquals(5L, dAssignLhsOfOrLhsLhsInput.value) } @Test @@ -1188,63 +1254,70 @@ class PythonFrontendTest : BaseTest() { assertNotNull(tu) val namespace = tu.namespaces.singleOrNull() assertNotNull(namespace) - val aStmt = namespace.statements[0] as? AssignExpression - assertNotNull(aStmt) - assertEquals( - "list", - (aStmt.rhs.singleOrNull() as? InitializerListExpression)?.type?.name?.localName - ) - val bStmt = namespace.statements[1] as? AssignExpression - assertNotNull(bStmt) - assertEquals( - "set", - (bStmt.rhs.singleOrNull() as? InitializerListExpression)?.type?.name?.localName - ) - val cStmt = namespace.statements[2] as? AssignExpression - assertNotNull(cStmt) - assertEquals( - "tuple", - (cStmt.rhs.singleOrNull() as? InitializerListExpression)?.type?.name?.localName - ) - val dStmt = namespace.statements[3] as? AssignExpression - assertNotNull(dStmt) - assertEquals( - "dict", - (dStmt.rhs.singleOrNull() as? InitializerListExpression)?.type?.name?.localName - ) - val eStmtRhs = - (namespace.statements[4] as? AssignExpression)?.rhs?.singleOrNull() as? BinaryOperator - assertNotNull(eStmtRhs) - assertEquals("Values of a: ", (eStmtRhs.lhs as? Literal<*>)?.value) - val eStmtRhsRhs = (eStmtRhs.rhs as? BinaryOperator) + val aStmt = namespace.statements[0] + assertIs(aStmt) + val aStmtRhs = aStmt.rhs.singleOrNull() + assertIs(aStmtRhs) + assertEquals("list", aStmtRhs.type.name.localName) + + val bStmt = namespace.statements[1] + assertIs(bStmt) + val bStmtRhs = bStmt.rhs.singleOrNull() + assertIs(bStmtRhs) + assertEquals("set", bStmtRhs.type.name.localName) + + val cStmt = namespace.statements[2] + assertIs(cStmt) + val cStmtRhs = cStmt.rhs.singleOrNull() + assertIs(cStmtRhs) + assertEquals("tuple", cStmtRhs.type.name.localName) + + val dStmt = namespace.statements[3] + assertIs(dStmt) + val dStmtRhs = dStmt.rhs.singleOrNull() + assertIs(dStmtRhs) + assertEquals("dict", dStmtRhs.type.name.localName) + + val fourthStmt = namespace.statements[4] + assertIs(fourthStmt) + val eStmtRhs = fourthStmt.rhs.singleOrNull() + assertIs(eStmtRhs) + val eStmtRhsLhs = eStmtRhs.lhs + assertIs>(eStmtRhsLhs) + assertEquals("Values of a: ", eStmtRhsLhs.value) + val eStmtRhsRhs = eStmtRhs.rhs + assertIs(eStmtRhsRhs) assertNotNull(eStmtRhsRhs) - val aRef = eStmtRhsRhs.lhs as? Reference - assertEquals("a", aRef?.name?.localName) - val eStmtRhsRhsRhs = (eStmtRhsRhs.rhs as? BinaryOperator) - assertEquals(" and b: ", (eStmtRhsRhsRhs?.lhs as? Literal<*>)?.value) - val bCall = eStmtRhsRhsRhs?.rhs as? CallExpression - assertEquals("str", bCall?.name?.localName) - assertEquals("b", bCall?.arguments?.singleOrNull()?.name?.localName) - - val fStmtRhs = - (namespace.statements[5] as? AssignExpression)?.rhs?.singleOrNull() - as? SubscriptExpression - assertNotNull(fStmtRhs) + val aRef = eStmtRhsRhs.lhs + assertEquals("a", aRef.name.localName) + val eStmtRhsRhsRhs = eStmtRhsRhs.rhs + assertIs(eStmtRhsRhsRhs) + val eStmtRhsRhsRhsLhs = eStmtRhsRhsRhs.lhs + assertIs>(eStmtRhsRhsRhsLhs) + assertEquals(" and b: ", eStmtRhsRhsRhsLhs.value) + val bCall = eStmtRhsRhsRhs.rhs + assertIs(bCall) + assertEquals("str", bCall.name.localName) + assertEquals("b", bCall.arguments.singleOrNull()?.name?.localName) + + val fifthStmt = namespace.statements[5] + assertIs(fifthStmt) + val fStmtRhs = fifthStmt.rhs.singleOrNull() + + assertIs(fStmtRhs) assertEquals("a", fStmtRhs.arrayExpression.name.localName) - assertTrue(fStmtRhs.subscriptExpression is RangeExpression) - assertEquals( - 1L, - ((fStmtRhs.subscriptExpression as RangeExpression).floor as? Literal<*>)?.value - ) - assertEquals( - 3L, - ((fStmtRhs.subscriptExpression as RangeExpression).ceiling as? Literal<*>)?.value - ) - assertEquals( - 2L, - ((fStmtRhs.subscriptExpression as RangeExpression).third as? Literal<*>)?.value - ) + val subscriptExpression = fStmtRhs.subscriptExpression + assertIs(subscriptExpression) + val fStmtRhsFloor = subscriptExpression.floor + assertIs>(fStmtRhsFloor) + assertEquals(1L, fStmtRhsFloor.value) + val fStmtRhsCeiling = subscriptExpression.ceiling + assertIs>(fStmtRhsCeiling) + assertEquals(3L, fStmtRhsCeiling.value) + val fStmtRhsThird = subscriptExpression.third + assertIs>(fStmtRhsThird) + assertEquals(2L, fStmtRhsThird.value) } @Test @@ -1362,19 +1435,20 @@ class PythonFrontendTest : BaseTest() { val namedExpression = result.functions["named_expression"] assertNotNull(namedExpression) - val assignExpression = result.statements[1] as? AssignExpression - assertNotNull(assignExpression) + val assignExpression = result.statements[1] + assertIs(assignExpression) assertEquals(":=", assignExpression.operatorCode) assertEquals(true, assignExpression.usedAsExpression) - val lhs = assignExpression.lhs.firstOrNull() as? Reference - assertNotNull(lhs) + val lhs = assignExpression.lhs.firstOrNull() + assertIs(lhs) - val lhsVariable = lhs.refersTo as? VariableDeclaration + val lhsVariable = lhs.refersTo + assertIs(lhsVariable) assertLocalName("x", lhsVariable) - val rhs = assignExpression.rhs.firstOrNull() as? Literal<*> - assertNotNull(rhs) + val rhs = assignExpression.rhs.firstOrNull() + assertIs>(rhs) assertEquals(4.toLong(), rhs.evaluate()) } diff --git a/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/statementHandler/StatementHandlerTest.kt b/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/statementHandler/StatementHandlerTest.kt index 4ea13e479b..f13e054207 100644 --- a/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/statementHandler/StatementHandlerTest.kt +++ b/cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/statementHandler/StatementHandlerTest.kt @@ -154,7 +154,7 @@ class StatementHandlerTest : BaseTest() { val add = result.operators["__add__"] assertNotNull(add) - assertEquals(add, opCall.invokes.singleOrNull()) + assertInvokes(opCall, add) // ... and one to __pos__ (+) opCall = result.operatorCalls("+").getOrNull(1) @@ -163,7 +163,7 @@ class StatementHandlerTest : BaseTest() { val pos = result.operators["__pos__"] assertNotNull(pos) - assertEquals(pos, opCall.invokes.singleOrNull()) + assertInvokes(opCall, pos) } } @@ -174,16 +174,15 @@ class StatementHandlerTest : BaseTest() { val func = result.functions["test_assert"] assertNotNull(func, "Function 'test_assert' should be found") - val assertStatement = - func.body.statements.firstOrNull { it is AssertStatement } as? AssertStatement - assertNotNull(assertStatement, "Assert statement should be found") + val assertStatement = func.body.statements.firstOrNull { it is AssertStatement } + assertIs(assertStatement, "Assert statement should be found") val condition = assertStatement.condition assertNotNull(condition, "Assert statement should have a condition") assertEquals("1 == 1", condition.code, "The condition is incorrect") - val message = assertStatement.message as? Literal<*> - assertNotNull(message, "Assert statement should have a message") + val message = assertStatement.message + assertIs>(message, "Assert statement should have a message") assertEquals("Test message", message.value, "The assert message is incorrect") } @@ -202,13 +201,13 @@ class StatementHandlerTest : BaseTest() { // Test for `del my_list[2]` val deleteStmt2 = deleteExpressions[1] assertEquals(1, deleteStmt2.operands.size) - assertTrue(deleteStmt2.operands.first() is SubscriptExpression) + assertIs(deleteStmt2.operands.firstOrNull()) assertTrue(deleteStmt2.additionalProblems.isEmpty()) // Test for `del my_dict['b']` val deleteStmt3 = deleteExpressions[2] assertEquals(1, deleteStmt3.operands.size) - assertTrue(deleteStmt3.operands.first() is SubscriptExpression) + assertIs(deleteStmt3.operands.firstOrNull()) assertTrue(deleteStmt3.additionalProblems.isEmpty()) // Test for `del obj.d`