Add Rust language frontend leveraging Rust Analyzer internals for parsing and inference

build.gradle.kts

@@ -99,6 +99,12 @@ val enablePythonFrontend: Boolean by extra {
 }
 project.logger.lifecycle("Python frontend is ${if (enablePythonFrontend) "enabled" else "disabled"}")
 
+val enableRustFrontend: Boolean by extra {
+    val enableRustFrontend: String? by project
+    enableRustFrontend.toBoolean()
+}
+project.logger.lifecycle("Rust frontend is ${if (enableRustFrontend) "enabled" else "disabled"}")
+
 val enableLLVMFrontend: Boolean by extra {
     val enableLLVMFrontend: String? by project
     enableLLVMFrontend.toBoolean()

buildSrc/src/main/kotlin/cpg.frontend-dependency-conventions.gradle.kts

@@ -10,6 +10,7 @@ val enablePythonFrontend: Boolean by rootProject.extra
 val enableLLVMFrontend: Boolean by rootProject.extra
 val enableTypeScriptFrontend: Boolean by rootProject.extra
 val enableRubyFrontend: Boolean by rootProject.extra
+val enableRustFrontend: Boolean by rootProject.extra
 val enableJVMFrontend: Boolean by rootProject.extra
 val enableINIFrontend: Boolean by rootProject.extra
 
@@ -38,6 +39,9 @@ dependencies {
     if (enableRubyFrontend) {
         implementation(project(":cpg-language-ruby"))
     }
+    if (enableRustFrontend) {
+        implementation(project(":cpg-language-rust"))
+    }
     if (enableINIFrontend) {
         implementation(project(":cpg-language-ini"))
     }

configure_frontends.sh

@@ -52,6 +52,8 @@ answerGo=$(ask "Do you want to enable the Go frontend? (currently $(getProperty
 setProperty "enableGoFrontend" $answerGo
 answerPython=$(ask "Do you want to enable the Python frontend? (currently $(getProperty "enablePythonFrontend"))")
 setProperty "enablePythonFrontend" $answerPython
+answerRust=$(ask "Do you want to enable the Rust frontend? (currently $(getProperty "enableRustFrontend"))")
+setProperty "enableRustFrontend" $answerRust
 answerLLVM=$(ask "Do you want to enable the LLVM frontend? (currently $(getProperty "enableLLVMFrontend"))")
 setProperty "enableLLVMFrontend" $answerLLVM
 answerTypescript=$(ask "Do you want to enable the TypeScript frontend? (currently $(getProperty "enableTypeScriptFrontend"))")

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

@@ -610,6 +610,51 @@ fun MetadataProvider.newThrow(rawNode: Any? = null): Throw {
     return node
 }
 
+/**
+ * Creates a new [ObjectDeconstruction]. 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.newObjectDeconstruction(rawNode: Any? = null): ObjectDeconstruction {
+    val node = ObjectDeconstruction()
+    node.applyMetadata(this, EMPTY_NAME, rawNode, true)
+
+    log(node)
+    return node
+}
+
+/**
+ * Creates a new [NamedDeconstruction]. 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.newNamedDeconstruction(rawNode: Any? = null): NamedDeconstruction {
+    val node = NamedDeconstruction()
+    node.applyMetadata(this, EMPTY_NAME, rawNode, true)
+
+    log(node)
+    return node
+}
+
+/**
+ * Creates a new [AlternativeDeconstruction]. 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.newAlternativeDeconstruction(rawNode: Any? = null): AlternativeDeconstruction {
+    val node = AlternativeDeconstruction()
+    node.applyMetadata(this, EMPTY_NAME, rawNode, true)
+
+    log(node)
+    return node
+}
+
 /**
  * Creates a new [ProblemExpression]. The [MetadataProvider] receiver will be used to fill different
  * meta-data using [Node.applyMetadata]. Calling this extension function outside of Kotlin requires

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, 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.declarations
+
+import de.fraunhofer.aisec.cpg.graph.DeclarationHolder
+import de.fraunhofer.aisec.cpg.graph.Node
+import de.fraunhofer.aisec.cpg.graph.edges.ast.astEdgesOf
+import de.fraunhofer.aisec.cpg.graph.edges.unwrapping
+import java.util.Objects
+
+/**
+ * Children in this declaration are added to an existing node with namespace. This can be a Record,
+ * or another similar construct that contains declarations. The children are therefore in this ast
+ * construct but are added to the symbol table of the construct it is extending.
+ *
+ * The name that this extension has needs to identify the construct, it is extending
+ */
+class ExtensionDeclaration : Declaration(), DeclarationHolder {
+    /**
+     * Edges to nested namespaces, records, functions, fields etc. contained in the current
+     * namespace.
+     */
+    val declarationEdges = astEdgesOf<Declaration>()
+    override val declarations by unwrapping(ExtensionDeclaration::declarationEdges)
+
+    /**
+     * In some languages, there is a relationship between paths / directories and the package
+     * structure. Therefore, we need to be aware of the path this namespace / package is in.
+     */
+    var path: String? = null
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is ExtensionDeclaration) return false
+        return super.equals(other) && declarations == other.declarations
+    }
+
+    override fun hashCode() = Objects.hash(super.hashCode(), declarations)
+
+    override fun addDeclaration(declaration: Declaration) {
+        addIfNotContains(declarations, declaration)
+    }
+
+    override fun getStartingPrevEOG(): Collection<Node> {
+        return setOf()
+    }
+
+    override fun getExitNextEOG(): Collection<Node> {
+        return setOf()
+    }
+}

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2026, 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.expressions
+
+import de.fraunhofer.aisec.cpg.graph.ArgumentHolder
+import de.fraunhofer.aisec.cpg.graph.edges.ast.astEdgesOf
+import de.fraunhofer.aisec.cpg.graph.edges.unwrapping
+import de.fraunhofer.aisec.cpg.graph.types.HasType
+import de.fraunhofer.aisec.cpg.graph.types.Type
+import de.fraunhofer.aisec.cpg.persistence.Relationship
+import java.util.Objects
+import kotlin.collections.plusAssign
+
+class AlternativeDeconstruction : Deconstruction(), ArgumentHolder, HasType.TypeObserver {
+
+    @Relationship("ALTERNATIVES") var alternativeEdges = astEdgesOf<Expression>()
+    var alternatives by unwrapping(AlternativeDeconstruction::alternativeEdges)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is AlternativeDeconstruction) return false
+        return super.equals(other) && alternatives == other.alternatives
+    }
+
+    override fun hashCode() = Objects.hash(super.hashCode(), alternatives)
+
+    override fun addArgument(expression: Expression) {
+        this.alternatives += expression
+        expression.access = this.access
+    }
+
+    override fun replaceArgument(old: Expression, new: Expression): Boolean {
+        val idx = alternativeEdges.indexOfFirst { it.end == old }
+        if (idx != -1) {
+            old.unregisterTypeObserver(this)
+            alternativeEdges[idx].end = new
+            new.registerTypeObserver(this)
+            new.access = this.access
+            return true
+        }
+
+        return false
+    }
+
+    override fun hasArgument(expression: Expression): Boolean {
+        return expression in this.alternatives
+    }
+
+    override fun typeChanged(newType: Type, src: HasType) {
+        val type = type
+        typeObservers.forEach { it.typeChanged(type, this) }
+    }
+
+    override fun assignedTypeChanged(assignedTypes: Set<Type>, src: HasType) {
+        addAssignedTypes(assignedTypes)
+        typeObservers.forEach { it.assignedTypeChanged(assignedTypes, this) }
+    }
+}

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

@@ -26,27 +26,58 @@
 package de.fraunhofer.aisec.cpg.graph.expressions
 
 import de.fraunhofer.aisec.cpg.graph.Node
+import de.fraunhofer.aisec.cpg.graph.edges.ast.astOptionalEdgeOf
+import de.fraunhofer.aisec.cpg.graph.edges.unwrapping
+import de.fraunhofer.aisec.cpg.graph.types.HasType
+import de.fraunhofer.aisec.cpg.graph.types.Type
+import de.fraunhofer.aisec.cpg.persistence.Relationship
 import java.util.Objects
 
 /**
  * Expression used to interrupt further execution of a loop body and exit the respective loop
  * context. Can have a loop label, e.g. in Java, to specify which of the nested loops should be
  * broken out of.
  */
-class Break : Expression(false) {
+class Break : Expression(false), HasType.TypeObserver {
 
     /** Specifies the label of the loop in a nested structure that this statement will 'break' */
     var label: String? = null
 
+    @Relationship("EXPR")
+    var exprEdge =
+        astOptionalEdgeOf<Expression>(
+            onChanged = { old, new -> exchangeTypeObserverWithAccessPropagation(old, new) }
+        )
+    /** The expression on which the operation is applied. */
+    var expr by unwrapping(Break::exprEdge)
+
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (other !is Break) return false
-        return super.equals(other) && label == other.label
+        return super.equals(other) && label == other.label && expr == other.expr
     }
 
-    override fun hashCode() = Objects.hash(super.hashCode(), label)
+    override fun hashCode() = Objects.hash(super.hashCode(), label, expr)
 
     override fun getStartingPrevEOG(): Collection<Node> {
         return this.prevEOG
     }
+
+    override fun typeChanged(newType: Type, src: HasType) {
+        if (src != expr) {
+            return
+        }
+
+        this.type = newType
+    }
+
+    override fun assignedTypeChanged(assignedTypes: Set<Type>, src: HasType) {
+        // Only accept type changes from out input
+        if (src != expr) {
+            return
+        }
+
+        // Apply our operator to all assigned types and forward them to us
+        this.addAssignedTypes(assignedTypes)
+    }
 }

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, 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.expressions
+
+abstract class Deconstruction : Expression()