Implement AST parent edges

cpg-analysis/src/main/kotlin/de/fraunhofer/aisec/cpg/analysis/MultiValueEvaluator.kt

@@ -33,7 +33,6 @@ import de.fraunhofer.aisec.cpg.graph.statements.DeclarationStatement
 import de.fraunhofer.aisec.cpg.graph.statements.ForStatement
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.*
 import de.fraunhofer.aisec.cpg.passes.EdgeCachePass
-import de.fraunhofer.aisec.cpg.passes.astParent
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 

cpg-analysis/src/main/kotlin/de/fraunhofer/aisec/cpg/analysis/fsm/DFAOrderEvaluator.kt

@@ -35,7 +35,6 @@ import de.fraunhofer.aisec.cpg.graph.statements.expressions.CallExpression
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.ConstructExpression
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.MemberCallExpression
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.Reference
-import de.fraunhofer.aisec.cpg.passes.astParent
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 

cpg-analysis/src/test/kotlin/de/fraunhofer/aisec/cpg/analysis/ValueEvaluatorTest.kt

@@ -783,19 +783,34 @@ class ValueEvaluatorTest {
             comparison.lhs = aRef
             comparison.rhs = newLiteral(1)
 
-            var cond = newConditionalExpression(comparison, newLiteral(2), aRef)
+            var cond =
+                newConditionalExpression().withChildren {
+                    it.condition = comparison
+                    it.thenExpression = newLiteral(2)
+                    it.elseExpression = aRef
+                }
             assertEquals(1, cond.evaluate())
 
             // handle equals
             comparison = newBinaryOperator("==")
             comparison.lhs = aRef
             comparison.rhs = newLiteral(1)
 
-            cond = newConditionalExpression(comparison, newLiteral(2), aRef)
+            cond =
+                newConditionalExpression().withChildren {
+                    it.condition = comparison
+                    it.thenExpression = newLiteral(2)
+                    it.elseExpression = aRef
+                }
             assertEquals(2, cond.evaluate())
 
             // handle invalid
-            cond = newConditionalExpression(newProblemExpression(), newLiteral(2), aRef)
+            cond =
+                newConditionalExpression().withChildren {
+                    it.condition = newProblemExpression()
+                    it.thenExpression = newLiteral(2)
+                    it.elseExpression = aRef
+                }
             assertEquals("{}", cond.evaluate())
         }
     }

cpg-analysis/src/test/kotlin/de/fraunhofer/aisec/cpg/testcases/ValueEvaluationTests.kt

@@ -294,11 +294,11 @@ class ValueEvaluationTests {
                                 declare {
                                     variable("a", t("int")) {
                                         this.initializer =
-                                            newConditionalExpression(
-                                                ref("b") lt literal(2, t("int")),
-                                                literal(3, t("int")),
-                                                literal(5, t("int")).inc()
-                                            )
+                                            newConditionalExpression().withChildren {
+                                                it.condition = ref("b") lt literal(2, t("int"))
+                                                it.thenExpression = literal(3, t("int"))
+                                                it.elseExpression = literal(5, t("int")).inc()
+                                            }
                                     }
                                 }
 

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/Handler.kt

@@ -54,7 +54,8 @@ abstract class Handler<ResultNode : Node?, HandlerNode, L : LanguageFrontend<in
     ScopeProvider by frontend,
     NamespaceProvider by frontend,
     ContextProvider by frontend,
-    RawNodeTypeProvider<HandlerNode> {
+    RawNodeTypeProvider<HandlerNode>,
+    AstStackProvider by frontend {
     protected val map = HashMap<Class<out HandlerNode>, HandlerInterface<ResultNode, HandlerNode>>()
     private val typeOfT: Class<*>?
 

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/LanguageFrontend.kt

@@ -34,6 +34,7 @@ import de.fraunhofer.aisec.cpg.sarif.PhysicalLocation
 import de.fraunhofer.aisec.cpg.sarif.Region
 import java.io.File
 import java.util.*
+import kotlin.collections.ArrayDeque
 import org.slf4j.LoggerFactory
 
 /**
@@ -61,13 +62,16 @@ abstract class LanguageFrontend<AstNode, TypeNode>(
     ScopeProvider,
     NamespaceProvider,
     ContextProvider,
-    RawNodeTypeProvider<AstNode> {
+    RawNodeTypeProvider<AstNode>,
+    AstStackProvider {
     val scopeManager: ScopeManager = ctx.scopeManager
     val typeManager: TypeManager = ctx.typeManager
     val config: TranslationConfiguration = ctx.config
 
     var currentTU: TranslationUnitDeclaration? = null
 
+    override val astStack: ArrayDeque<Node> = ArrayDeque()
+
     @Throws(TranslationException::class)
     fun parseAll(): List<TranslationUnitDeclaration> {
         val units = ArrayList<TranslationUnitDeclaration>()

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/DeclarationBuilder.kt

@@ -48,8 +48,8 @@ fun MetadataProvider.newTranslationUnitDeclaration(
 ): TranslationUnitDeclaration {
     val node = TranslationUnitDeclaration()
     node.applyMetadata(this, name, rawNode, true)
-
     log(node)
+
     return node
 }
 
@@ -59,16 +59,16 @@ fun MetadataProvider.newTranslationUnitDeclaration(
  * requires an appropriate [MetadataProvider], such as a [LanguageFrontend] as an additional
  * prepended argument.
  */
-@JvmOverloads
 fun MetadataProvider.newFunctionDeclaration(
     name: CharSequence?,
     localNameOnly: Boolean = false,
-    rawNode: Any? = null,
+    rawNode: Any? = null
 ): FunctionDeclaration {
     val node = FunctionDeclaration()
     node.applyMetadata(this@MetadataProvider, name, rawNode, localNameOnly)
 
     log(node)
+
     return node
 }
 
@@ -83,7 +83,7 @@ fun MetadataProvider.newMethodDeclaration(
     name: CharSequence?,
     isStatic: Boolean = false,
     recordDeclaration: RecordDeclaration? = null,
-    rawNode: Any? = null
+    rawNode: Any? = null,
 ): MethodDeclaration {
     val node = MethodDeclaration()
     node.applyMetadata(this, name, rawNode, defaultNamespace = recordDeclaration?.name)
@@ -437,6 +437,7 @@ fun MetadataProvider.newNamespaceDeclaration(
     node.applyMetadata(this, name, rawNode)
 
     log(node)
+
     return node
 }
 

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/ExpressionBuilder.kt

@@ -122,15 +122,11 @@ fun MetadataProvider.newUnaryOperator(
 @JvmOverloads
 fun MetadataProvider.newAssignExpression(
     operatorCode: String = "=",
-    lhs: List<Expression> = listOf(),
-    rhs: List<Expression> = listOf(),
     rawNode: Any? = null
 ): AssignExpression {
     val node = AssignExpression()
     node.applyMetadata(this, operatorCode, rawNode, true)
     node.operatorCode = operatorCode
-    node.lhs = lhs
-    node.rhs = rhs
 
     log(node)
 
@@ -183,19 +179,13 @@ fun MetadataProvider.newConstructExpression(
  */
 @JvmOverloads
 fun MetadataProvider.newConditionalExpression(
-    condition: Expression,
-    thenExpression: Expression? = null,
-    elseExpression: Expression? = null,
     type: Type = unknownType(),
     rawNode: Any? = null
 ): ConditionalExpression {
     val node = ConditionalExpression()
     node.applyMetadata(this, EMPTY_NAME, rawNode, true)
 
     node.type = type
-    node.condition = condition
-    node.thenExpression = thenExpression
-    node.elseExpression = elseExpression
 
     log(node)
     return node

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/Extensions.kt

@@ -41,7 +41,6 @@ import de.fraunhofer.aisec.cpg.graph.statements.WhileStatement
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.*
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.Block
 import de.fraunhofer.aisec.cpg.helpers.SubgraphWalker
-import de.fraunhofer.aisec.cpg.passes.astParent
 import kotlin.math.absoluteValue
 
 /**

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/Node.kt

@@ -158,6 +158,8 @@ open class Node :
     var astChildren: List<Node> = listOf()
         get() = SubgraphWalker.getAstChildren(this)
 
+    @Relationship("AST") var astParent: Node? = null
+
     /** Virtual property for accessing [prevEOGEdges] without property edges. */
     @PopulatedByPass(EvaluationOrderGraphPass::class)
     var prevEOG: List<Node> by PropertyEdgeDelegate(Node::prevEOGEdges, false)

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/NodeBuilder.kt

@@ -30,6 +30,8 @@ import de.fraunhofer.aisec.cpg.frontends.*
 import de.fraunhofer.aisec.cpg.graph.Node.Companion.EMPTY_NAME
 import de.fraunhofer.aisec.cpg.graph.NodeBuilder.LOGGER
 import de.fraunhofer.aisec.cpg.graph.NodeBuilder.log
+import de.fraunhofer.aisec.cpg.graph.declarations.Declaration
+import de.fraunhofer.aisec.cpg.graph.declarations.TranslationUnitDeclaration
 import de.fraunhofer.aisec.cpg.graph.scopes.Scope
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.*
 import de.fraunhofer.aisec.cpg.graph.types.*
@@ -39,6 +41,8 @@ import de.fraunhofer.aisec.cpg.passes.inference.IsInferredProvider
 import de.fraunhofer.aisec.cpg.sarif.PhysicalLocation
 import de.fraunhofer.aisec.cpg.sarif.Region
 import java.net.URI
+import java.util.*
+import kotlin.collections.ArrayDeque
 import org.slf4j.LoggerFactory
 
 object NodeBuilder {
@@ -91,6 +95,10 @@ interface NamespaceProvider : MetadataProvider {
     val namespace: Name?
 }
 
+interface AstStackProvider : MetadataProvider {
+    val astStack: ArrayDeque<Node>
+}
+
 /**
  * Applies various metadata on this [Node], based on the kind of provider in [provider]. This can
  * include:
@@ -148,6 +156,10 @@ fun Node.applyMetadata(
         )
     }
 
+    if (provider is AstStackProvider) {
+        provider.astStack.lastOrNull().let { this.astParent = it }
+    }
+
     if (name != null) {
         val namespace =
             if (provider is NamespaceProvider) {
@@ -217,14 +229,11 @@ fun MetadataProvider.newAnnotation(name: CharSequence?, rawNode: Any? = null): A
 @JvmOverloads
 fun MetadataProvider.newAnnotationMember(
     name: CharSequence?,
-    value: Expression?,
     rawNode: Any? = null
 ): AnnotationMember {
     val node = AnnotationMember()
     node.applyMetadata(this, name, rawNode, true)
 
-    node.value = value
-
     log(node)
     return node
 }
@@ -380,3 +389,69 @@ private fun <AstNode> Node.setCodeAndLocation(
     }
     this.location = provider.locationOf(rawNode)
 }
+
+context(AstStackProvider, ContextProvider)
+fun <T : Node> T.withChildren(
+    hasScope: Boolean = false,
+    isGlobalScope: Boolean = false,
+    init: (T) -> Unit
+): T {
+    val scopeManager =
+        [email protected]?.scopeManager
+            ?: throw TranslationException(
+                "Trying to create node children without a ContextProvider. This will fail."
+            )
+
+    (this@AstStackProvider).astStack.addLast(this@withChildren)
+
+    if (isGlobalScope && this is TranslationUnitDeclaration) {
+        scopeManager.resetToGlobal(this)
+        init(this)
+    } else if (hasScope) {
+        scopeManager.enterScope(this)
+        init(this)
+        scopeManager.leaveScope(this)
+    } else {
+        init(this)
+    }
+
+    (this@AstStackProvider).astStack.removeLast()
+
+    return this
+}
+
+/**
+ * This function can be used to set the [Node.astParent] of this node to the current node on the
+ * [AstStackProvider]'s stack. This is particularly useful if the node was created outside of the
+ * [withChildren] lambda. This is a usual pattern if the node is optionally wrapped in something
+ * else.
+ *
+ * Example:
+ * ```kotlin
+ * val expr = newReference("p")
+ *
+ * return if (isDeref) {
+ *   newUnaryOperator("*", prefix = true, postfix = false).withChildren {
+ *     it.input = expr.withParent()
+ *   }
+ * } else {
+ *   expr
+ * }
+ * ```
+ */
+context(AstStackProvider)
+fun <T : Node> T.withParent(): T {
+    this.astParent = (this@AstStackProvider).astStack.lastOrNull()
+    return this
+}
+
+context(ContextProvider)
+fun <T : Declaration> T.declare(): T {
+    val scopeManager =
+        [email protected]?.scopeManager
+            ?: throw TranslationException(
+                "Trying to create node children without a ContextProvider. This will fail."
+            )
+    scopeManager.addDeclaration(this)
+    return this
+}

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/builder/Fluent.kt

@@ -1088,7 +1088,11 @@ operator fun Expression.plus(rhs: Expression): BinaryOperator {
  */
 context(LanguageFrontend<*, *>, StatementHolder)
 operator fun Expression.plusAssign(rhs: Expression) {
-    val node = (this@LanguageFrontend).newAssignExpression("+=", listOf(this), listOf(rhs))
+    val node =
+        (this@LanguageFrontend).newAssignExpression("+=").withChildren {
+            it.rhs = listOf(rhs)
+            it.lhs = listOf(this)
+        }
 
     (this@StatementHolder) += node
 }
@@ -1292,8 +1296,10 @@ fun Expression.conditional(
     thenExpression: Expression,
     elseExpression: Expression
 ): ConditionalExpression {
-    val node =
-        (this@LanguageFrontend).newConditionalExpression(condition, thenExpression, elseExpression)
+    val node = (this@LanguageFrontend).newConditionalExpression()
+    node.condition = condition
+    node.thenExpression = thenExpression
+    node.elseExpression = elseExpression
 
     if (this@Holder is StatementHolder) {
         (this@Holder) += node
@@ -1326,7 +1332,11 @@ infix fun Expression.assign(init: AssignExpression.() -> Expression): AssignExpr
  */
 context(LanguageFrontend<*, *>, Holder<out Node>)
 infix fun Expression.assign(rhs: Expression): AssignExpression {
-    val node = (this@LanguageFrontend).newAssignExpression("=", listOf(this), listOf(rhs))
+    val node =
+        (this@LanguageFrontend).newAssignExpression("=").withChildren {
+            it.rhs = listOf(rhs)
+            it.lhs = listOf(this)
+        }
 
     if (this@Holder is StatementHolder) {
         this@Holder += node
@@ -1341,7 +1351,11 @@ infix fun Expression.assign(rhs: Expression): AssignExpression {
  */
 context(LanguageFrontend<*, *>, Holder<out Node>)
 infix fun Expression.assignPlus(rhs: Expression): AssignExpression {
-    val node = (this@LanguageFrontend).newAssignExpression("+=", listOf(this), listOf(rhs))
+    val node =
+        (this@LanguageFrontend).newAssignExpression("+=").withChildren {
+            it.rhs = listOf(rhs)
+            it.lhs = listOf(this)
+        }
 
     if (this@Holder is StatementHolder) {
         this@Holder += node
@@ -1356,7 +1370,11 @@ infix fun Expression.assignPlus(rhs: Expression): AssignExpression {
  */
 context(LanguageFrontend<*, *>, Holder<out Node>)
 infix fun Expression.assignAsExpr(rhs: Expression): AssignExpression {
-    val node = (this@LanguageFrontend).newAssignExpression("=", listOf(this), listOf(rhs))
+    val node =
+        (this@LanguageFrontend).newAssignExpression("=").withChildren {
+            it.rhs = listOf(rhs)
+            it.lhs = listOf(this)
+        }
 
     node.usedAsExpression = true