Replace UnaryOperator("throw") with ThrowStatement for CXX

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

@@ -572,8 +572,8 @@ val Node?.forLoops: List<ForStatement>
 val Node?.trys: List<TryStatement>
     get() = this.allChildren()
 
-/** Returns all [ThrowStatement] child edges in this graph, starting with this [Node]. */
-val Node?.throws: List<ThrowStatement>
+/** Returns all [ThrowExpression] child edges in this graph, starting with this [Node]. */
+val Node?.throws: List<ThrowExpression>
     get() = this.allChildren()
 
 /** Returns all [ForEachStatement] child edges in this graph, starting with this [Node]. */

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

@@ -358,14 +358,14 @@ fun MetadataProvider.newLookupScopeStatement(
 }
 
 /**
- * Creates a new [ThrowStatement]. The [MetadataProvider] receiver will be used to fill different
+ * Creates a new [ThrowExpression]. 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()
+fun MetadataProvider.newThrowStatement(rawNode: Any? = null): ThrowExpression {
+    val node = ThrowExpression()
     node.applyMetadata(this, EMPTY_NAME, rawNode, true)
 
     log(node)

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

@@ -1457,11 +1457,11 @@ infix fun Expression.assignAsExpr(rhs: AssignExpression.() -> Unit): AssignExpre
 }
 
 /**
- * Creates a new [ThrowStatement] in the Fluent Node DSL and adds it to the nearest enclosing
+ * Creates a new [ThrowExpression] 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 {
+infix fun Expression.`throw`(init: (ThrowExpression.() -> Unit)?): ThrowExpression {
     val node = (this@LanguageFrontend).newThrowStatement()
     if (init != null) init(node)
 

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

@@ -33,20 +33,20 @@ 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 {
+/** Represents a `throw` or `raise` statement/expression. */
+class ThrowExpression : Expression(), ArgumentHolder {
 
     /** The exception object to be raised. */
     @Relationship(value = "EXCEPTION") var exceptionEdge = astOptionalEdgeOf<Expression>()
-    var exception by unwrapping(ThrowStatement::exceptionEdge)
+    var exception by unwrapping(ThrowExpression::exceptionEdge)
 
     /**
      * Some languages (Python) can add a parent exception (or `cause`) to indicate that an exception
      * was raised while handling another exception.
      */
     @Relationship(value = "PARENT_EXCEPTION")
     var parentExceptionEdge = astOptionalEdgeOf<Expression>()
-    var parentException by unwrapping(ThrowStatement::parentExceptionEdge)
+    var parentException by unwrapping(ThrowExpression::parentExceptionEdge)
 
     override fun addArgument(expression: Expression) {
         when {
@@ -75,7 +75,7 @@ class ThrowStatement : Statement(), ArgumentHolder {
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
-        if (other !is ThrowStatement) return false
+        if (other !is ThrowExpression) return false
         return super.equals(other) &&
             exception == other.exception &&
             parentException == other.parentException

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

@@ -132,7 +132,7 @@ class DFGPass(ctx: TranslationContext) : ComponentPass(ctx) {
             is ForStatement -> handleForStatement(node)
             is SwitchStatement -> handleSwitchStatement(node)
             is IfStatement -> handleIfStatement(node)
-            is ThrowStatement -> handleThrowStatement(node)
+            is ThrowExpression -> handleThrowStatement(node)
             // Declarations
             is FieldDeclaration -> handleFieldDeclaration(node)
             is FunctionDeclaration -> handleFunctionDeclaration(node, functionSummaries)
@@ -169,8 +169,8 @@ class DFGPass(ctx: TranslationContext) : ComponentPass(ctx) {
         comprehension.predicate?.let { comprehension.prevDFG += it }
     }
 
-    /** Handle a [ThrowStatement]. The exception and parent exception flow into the node. */
-    protected fun handleThrowStatement(node: ThrowStatement) {
+    /** Handle a [ThrowExpression]. The exception and parent exception flow into the node. */
+    protected fun handleThrowStatement(node: ThrowExpression) {
         node.exception?.let { node.prevDFGEdges += it }
         node.parentException?.let { node.prevDFGEdges += it }
     }

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

@@ -194,7 +194,7 @@ open class EvaluationOrderGraphPass(ctx: TranslationContext) : TranslationUnitPa
         map[LookupScopeStatement::class.java] = {
             handleLookupScopeStatement(it as LookupScopeStatement)
         }
-        map[ThrowStatement::class.java] = { handleThrowStatement(it as ThrowStatement) }
+        map[ThrowExpression::class.java] = { handleThrowStatement(it as ThrowExpression) }
     }
 
     protected fun doNothing() {
@@ -1124,7 +1124,7 @@ open class EvaluationOrderGraphPass(ctx: TranslationContext) : TranslationUnitPa
     }
 
     /** Calls [handleThrowOperator]. */
-    protected fun handleThrowStatement(statement: ThrowStatement) {
+    protected fun handleThrowStatement(statement: ThrowExpression) {
         handleThrowOperator(
             statement,
             statement.exception?.type,

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

@@ -29,7 +29,7 @@ import de.fraunhofer.aisec.cpg.GraphExamples.Companion.testFrontend
 import de.fraunhofer.aisec.cpg.TranslationConfiguration
 import de.fraunhofer.aisec.cpg.frontends.TestLanguage
 import de.fraunhofer.aisec.cpg.graph.builder.*
-import de.fraunhofer.aisec.cpg.graph.statements.ThrowStatement
+import de.fraunhofer.aisec.cpg.graph.statements.ThrowExpression
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.Block
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.CallExpression
 import de.fraunhofer.aisec.cpg.test.assertLocalName
@@ -69,21 +69,21 @@ class ThrowStatementTest {
         assertIs<Block>(body)
 
         val emptyThrow = body.statements.getOrNull(0)
-        assertIs<ThrowStatement>(emptyThrow)
+        assertIs<ThrowExpression>(emptyThrow)
         println(emptyThrow.toString()) // This is only here to simulate a higher test coverage
         assertNull(emptyThrow.exception)
         assertTrue(emptyThrow.prevDFG.isEmpty())
 
         val throwWithExc = body.statements.getOrNull(1)
-        assertIs<ThrowStatement>(throwWithExc)
+        assertIs<ThrowExpression>(throwWithExc)
         println(throwWithExc.toString()) // This is only here to simulate a higher test coverage
         val throwCall = throwWithExc.exception
         assertIs<CallExpression>(throwCall)
         assertLocalName("SomeError", throwCall)
         assertEquals(setOf<Node>(throwCall), throwWithExc.prevDFG.toSet())
 
         val throwWithExcAndParent = body.statements.getOrNull(2)
-        assertIs<ThrowStatement>(throwWithExcAndParent)
+        assertIs<ThrowExpression>(throwWithExcAndParent)
         println(
             throwWithExcAndParent.toString()
         ) // This is only here to simulate a higher test coverage

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

@@ -28,7 +28,7 @@ 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.*
-import de.fraunhofer.aisec.cpg.graph.statements.ThrowStatement
+import de.fraunhofer.aisec.cpg.graph.statements.ThrowExpression
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.Block
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.CallExpression
 import kotlin.collections.firstOrNull
@@ -118,7 +118,7 @@ class DataflowTest {
         assertIs<Block>(body)
 
         val throwStmt = body.statements.getOrNull(1)
-        assertIs<ThrowStatement>(throwStmt)
+        assertIs<ThrowExpression>(throwStmt)
         assertNotNull(throwStmt.exception)
         val throwCall = throwStmt.exception
         assertIs<CallExpression>(throwCall)

cpg-language-cxx/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/cxx/ExpressionHandler.kt

@@ -400,7 +400,8 @@ class ExpressionHandler(lang: CXXLanguageFrontend) :
                 // need to information about the parenthesis.
                 return input as Expression
             }
-            IASTUnaryExpression.op_throw -> operatorCode = "throw"
+            IASTUnaryExpression.op_throw ->
+                return newThrowStatement(rawNode = ctx).apply { this.exception = input }
             IASTUnaryExpression.op_typeid -> operatorCode = "typeid"
             IASTUnaryExpression.op_alignOf -> operatorCode = "alignof"
             IASTUnaryExpression.op_sizeofParameterPack -> operatorCode = "sizeof..."

cpg-language-python/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/python/StatementHandler.kt

@@ -88,9 +88,9 @@ class StatementHandler(frontend: PythonLanguageFrontend) :
 
     /**
      * Translates a Python [`Raise`](https://docs.python.org/3/library/ast.html#ast.Raise) into a
-     * [ThrowStatement].
+     * [ThrowExpression].
      */
-    private fun handleRaise(node: Python.AST.Raise): ThrowStatement {
+    private fun handleRaise(node: Python.AST.Raise): ThrowExpression {
         val ret = newThrowStatement(rawNode = node)
         node.exc?.let { ret.exception = frontend.expressionHandler.handle(it) }
         node.cause?.let { ret.parentException = frontend.expressionHandler.handle(it) }