Implement a throw or raise statement

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

@@ -356,3 +356,18 @@ fun MetadataProvider.newLookupScopeStatement(
     log(node)
     return node
 }
+
+/**
+ * Creates a new [ThrowStatement]. The [MetadataProvider] receiver will be used to fill different
+ * meta-data using [Node.applyMetadata]. Calling this extension function outside of Kotlin requires
+ * an appropriate [MetadataProvider], such as a [LanguageFrontend] as an additional prepended
+ * argument.
+ */
+@JvmOverloads
+fun MetadataProvider.newThrowStatement(rawNode: Any? = null): ThrowStatement {
+    val node = ThrowStatement()
+    node.applyMetadata(this, EMPTY_NAME, rawNode, true)
+
+    log(node)
+    return node
+}

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

@@ -1400,6 +1400,7 @@ infix fun Expression.assignAsExpr(rhs: Expression): AssignExpression {
 
     return node
 }
+
 /**
  * Creates a new [AssignExpression] with a `=` [AssignExpression.operatorCode] in the Fluent Node
  * DSL and adds it to the nearest enclosing [StatementHolder].
@@ -1414,6 +1415,23 @@ infix fun Expression.assignAsExpr(rhs: AssignExpression.() -> Unit): AssignExpre
     return node
 }
 
+/**
+ * Creates a new [ThrowStatement] in the Fluent Node DSL and adds it to the nearest enclosing
+ * [StatementHolder].
+ */
+context(LanguageFrontend<*, *>, Holder<out Node>)
+infix fun Expression.`throw`(init: (ThrowStatement.() -> Unit)?): ThrowStatement {
+    val node = (this@LanguageFrontend).newThrowStatement()
+    if (init != null) init(node)
+
+    val holder = this@Holder
+    if (holder is StatementHolder) {
+        holder += node
+    }
+
+    return node
+}
+
 /** Creates a new [Type] with the given [name] in the Fluent Node DSL. */
 fun LanguageFrontend<*, *>.t(name: CharSequence, generics: List<Type> = listOf()) =
     objectType(name, generics)

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

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2024, Fraunhofer AISEC. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *                    $$$$$$\  $$$$$$$\   $$$$$$\
+ *                   $$  __$$\ $$  __$$\ $$  __$$\
+ *                   $$ /  \__|$$ |  $$ |$$ /  \__|
+ *                   $$ |      $$$$$$$  |$$ |$$$$\
+ *                   $$ |      $$  ____/ $$ |\_$$ |
+ *                   $$ |  $$\ $$ |      $$ |  $$ |
+ *                   \$$$$$   |$$ |      \$$$$$   |
+ *                    \______/ \__|       \______/
+ *
+ */
+package de.fraunhofer.aisec.cpg.graph.statements
+
+import de.fraunhofer.aisec.cpg.graph.ArgumentHolder
+import de.fraunhofer.aisec.cpg.graph.edges.ast.astOptionalEdgeOf
+import de.fraunhofer.aisec.cpg.graph.edges.unwrapping
+import de.fraunhofer.aisec.cpg.graph.statements.expressions.Expression
+import java.util.Objects
+import org.apache.commons.lang3.builder.ToStringBuilder
+import org.neo4j.ogm.annotation.Relationship
+
+/** Represents a `throw` or `raise` statement. */
+class ThrowStatement : Statement(), ArgumentHolder {
+
+    /** The exception object to be raised. */
+    @Relationship(value = "EXCEPTION") var exceptionEdge = astOptionalEdgeOf<Expression>()
+    var exception by unwrapping(ThrowStatement::exceptionEdge)
+
+    /**
+     * Some languages (Python) can add a parent exception (or `cause`) to indicate that an exception
+     * was raised while handling another exception. This is stored in the graph, but has no further
+     * implications like EOG or DFG connections, as it is only of informational purpose, but it
+     * doesn't change the program behavior.
+     */
+    @Relationship(value = "PARENT_EXCEPTION")
+    var parentExceptionEdge = astOptionalEdgeOf<Expression>()
+    var parentException by unwrapping(ThrowStatement::parentExceptionEdge)
+
+    override fun addArgument(expression: Expression) {
+        when {
+            exception == null -> exception = expression
+            parentException == null -> parentException = expression
+        }
+    }
+
+    override fun replaceArgument(old: Expression, new: Expression): Boolean {
+        return when {
+            exception == old -> {
+                exception = new
+                true
+            }
+            parentException == old -> {
+                parentException = new
+                true
+            }
+            else -> false
+        }
+    }
+
+    override fun hasArgument(expression: Expression): Boolean {
+        return exception == expression || parentException == expression
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is ThrowStatement) return false
+        return super.equals(other) &&
+            exception == other.exception &&
+            parentException == other.parentException
+    }
+
+    override fun hashCode() = Objects.hash(super.hashCode(), exception, parentException)
+
+    override fun toString(): String {
+        return ToStringBuilder(this, TO_STRING_STYLE)
+            .appendSuper(super.toString())
+            .append("exception", exception)
+            .append("parentException", parentException)
+            .toString()
+    }
+}

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/passes/DFGPass.kt

@@ -130,6 +130,7 @@ class DFGPass(ctx: TranslationContext) : ComponentPass(ctx) {
             is ForStatement -> handleForStatement(node)
             is SwitchStatement -> handleSwitchStatement(node)
             is IfStatement -> handleIfStatement(node)
+            is ThrowStatement -> handleThrowStatement(node)
             // Declarations
             is FieldDeclaration -> handleFieldDeclaration(node)
             is FunctionDeclaration -> handleFunctionDeclaration(node, functionSummaries)
@@ -138,6 +139,17 @@ class DFGPass(ctx: TranslationContext) : ComponentPass(ctx) {
         }
     }
 
+    /**
+     * Handle a [ThrowStatement]. Currently, we support two types of [ThrowStatement.exception],
+     * which are then forwarded to the appropriate handlers:
+     * - [CallExpression]
+     * - [Reference]
+     */
+    protected fun handleThrowStatement(node: ThrowStatement) {
+        node.exception?.let { node.prevDFGEdges += it }
+        node.parentException?.let { node.prevDFGEdges += it }
+    }
+
     protected fun handleAssignExpression(node: AssignExpression) {
         // If this is a compound assign, we also need to model a dataflow to the node itself
         if (node.isCompoundAssignment) {

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/passes/EvaluationOrderGraphPass.kt

@@ -160,6 +160,7 @@
         map[LookupScopeStatement::class.java] = {
             handleLookupScopeStatement(it as LookupScopeStatement)
         }
+        map[ThrowStatement::class.java] = { handleThrowStatement(it as ThrowStatement) }
     }
 
     protected fun doNothing() {
@@ -1032,6 +1033,31 @@
         pushToEOG(stmt)
     }
 
+    /**
+     * This is copied & pasted with minimal adjustments from [handleThrowOperator]. TODO: To be
+     * merged in a later PR.
+     */
+    protected fun handleThrowStatement(statement: ThrowStatement) {
+        val input = statement.exception
+        createEOG(input)
+        statement.parentException?.let { createEOG(it) }
+
+        val catchingScope =
+            scopeManager.firstScopeOrNull { scope -> scope is TryScope || scope is FunctionScope }
+
+        val throwType = input?.type
+        if (throwType == null) {
+            TODO("???")
+        }
+        pushToEOG(statement)
+        if (catchingScope is TryScope) {
+            catchingScope.catchesOrRelays[throwType] = currentPredecessors.toMutableList()
+        } else if (catchingScope is FunctionScope) {
+            catchingScope.catchesOrRelays[throwType] = currentPredecessors.toMutableList()
+        }
+        currentPredecessors.clear()
+    }
+
     companion object {
         protected val LOGGER = LoggerFactory.getLogger(EvaluationOrderGraphPass::class.java)
 

cpg-core/src/test/kotlin/de/fraunhofer/aisec/cpg/GraphExamples.kt

@@ -1342,5 +1342,25 @@ class GraphExamples {
                     }
                 }
             }
+
+        fun prepareThrowDFGTest(
+            config: TranslationConfiguration =
+                TranslationConfiguration.builder()
+                    .defaultPasses()
+                    .registerLanguage(TestLanguage("."))
+                    .build()
+        ) =
+            testFrontend(config).build {
+                translationResult {
+                    translationUnit("some.file") {
+                        function("foo", t("void")) {
+                            body {
+                                declare { variable("a", t("short")) { literal(42) } }
+                                `throw` { call("SomeError") { ref("a") } }
+                            }
+                        }
+                    }
+                }
+            }
     }
 }

cpg-core/src/test/kotlin/de/fraunhofer/aisec/cpg/graph/ThrowStatementTest.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2022, Fraunhofer AISEC. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *                    $$$$$$\  $$$$$$$\   $$$$$$\
+ *                   $$  __$$\ $$  __$$\ $$  __$$\
+ *                   $$ /  \__|$$ |  $$ |$$ /  \__|
+ *                   $$ |      $$$$$$$  |$$ |$$$$\
+ *                   $$ |      $$  ____/ $$ |\_$$ |
+ *                   $$ |  $$\ $$ |      $$ |  $$ |
+ *                   \$$$$$   |$$ |      \$$$$$   |
+ *                    \______/ \__|       \______/
+ *
+ */
+package de.fraunhofer.aisec.cpg.graph
+
+import de.fraunhofer.aisec.cpg.frontends.TestLanguageFrontend
+import de.fraunhofer.aisec.cpg.graph.builder.*
+import de.fraunhofer.aisec.cpg.graph.statements.ThrowStatement
+import de.fraunhofer.aisec.cpg.graph.statements.expressions.Block
+import de.fraunhofer.aisec.cpg.graph.statements.expressions.CallExpression
+import kotlin.test.*
+
+class ThrowStatementTest {
+    @Test
+    fun testThrow() {
+        val result =
+            TestLanguageFrontend().build {
+                translationResult {
+                    translationUnit("some.file") {
+                        function("foo", t("void")) {
+                            body {
+                                `throw` {}
+                                `throw` { call("SomeError") }
+                            }
+                        }
+                    }
+                }
+            }
+
+        // Let's assert that we did this correctly
+        val main = result.functions["foo"]
+        assertNotNull(main)
+        val body = main.body
+        assertIs<Block>(body)
+
+        val emptyThrow = body.statements.getOrNull(0)
+        assertIs<ThrowStatement>(emptyThrow)
+        assertNull(emptyThrow.exception)
+
+        val throwWithExc = body.statements.getOrNull(1)
+        assertIs<ThrowStatement>(throwWithExc)
+        val throwCall = throwWithExc.exception
+        assertIs<CallExpression>(throwCall)
+        assertEquals("SomeError", throwCall.name.localName)
+    }
+}

cpg-core/src/test/kotlin/de/fraunhofer/aisec/cpg/graph/edges/flows/DataflowTest.kt

@@ -25,13 +25,18 @@
  */
 package de.fraunhofer.aisec.cpg.graph.edges.flows
 
+import de.fraunhofer.aisec.cpg.GraphExamples.Companion.prepareThrowDFGTest
 import de.fraunhofer.aisec.cpg.frontends.TestLanguageFrontend
-import de.fraunhofer.aisec.cpg.graph.newLiteral
-import de.fraunhofer.aisec.cpg.graph.newReference
+import de.fraunhofer.aisec.cpg.graph.*
+import de.fraunhofer.aisec.cpg.graph.statements.ThrowStatement
+import de.fraunhofer.aisec.cpg.graph.statements.expressions.Block
+import de.fraunhofer.aisec.cpg.graph.statements.expressions.CallExpression
 import kotlin.collections.firstOrNull
 import kotlin.test.Test
 import kotlin.test.assertContains
 import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertNotNull
 import kotlin.test.assertSame
 
 class DataflowTest {
@@ -101,4 +106,25 @@ class DataflowTest {
             assertEquals(0, node2.prevDFGEdges.size)
         }
     }
+
+    @Test
+    fun testThrow() {
+        val result = prepareThrowDFGTest()
+
+        // Let's assert that we did this correctly
+        val main = result.functions[0]
+        assertNotNull(main)
+        val body = main.body
+        assertIs<Block>(body)
+
+        val throwStmt = body.statements.getOrNull(1)
+        assertIs<ThrowStatement>(throwStmt)
+        assertNotNull(throwStmt.exception)
+        val throwCall = throwStmt.exception
+        assertIs<CallExpression>(throwCall)
+
+        val someError = result.calls["SomeError"]
+        assertIs<CallExpression>(someError)
+        assertContains(throwStmt.prevDFG, someError)
+    }
 }