Svelte support in TS module

cpg-language-typescript/__specs/svelte-language-support.md

@@ -0,0 +1,32 @@
+# Svelte Language Support Integration Plan
+
+This document tracks the progress of integrating Svelte language support into the `cpg-language-typescript` module.
+
+## Plan (Systematic Approach)
+
+1.  **Revert & Branch:** Revert `cpg-language-typescript` to baseline (main branch state). Create new branch `feature/svelte-support`. (DONE)
+2.  **Verify Baseline:** Confirm the original module builds correctly (ignoring test setup issues like Kover). (DONE - `./gradlew :cpg-language-typescript:clean :cpg-language-typescript:assemble` succeeded).
+3.  **Add Svelte Kotlin Stubs:** Create minimal `SvelteLanguage.kt`, `SvelteAST.kt`, `SvelteLanguageFrontend.kt`. (DONE)
+4.  **Build Step 1:** Run `compileKotlin` to ensure stubs are syntactically correct. Commit. (Current Step)
+    *   Purpose: Quickly check basic Kotlin syntax, class structure, inheritance, and imports for the new stub files before adding complex logic. Confirms the stubs themselves don't break compilation.
+5.  **Add Svelte Parser Script & Build Logic:** Decide between Deno or Node.js for the `svelte.parse` script. Add parser script and necessary build tasks (`build.gradle.kts`). Run `assemble`. Commit.
+6.  **Integrate Parser Execution:** Add logic to `SvelteLanguageFrontend.kt` to run the parser and read JSON output.
+7.  **Build Step 2:** Run `compileKotlin`. Fix process/IO/JSON errors. Commit.
+8.  **Integrate Basic CPG Nodes:** Add code to create `TranslationUnitDeclaration` and placeholder `RecordDeclaration` from AST.
+9.  **Build Step 3:** Run `compileKotlin`. Analyze and fix core CPG integration errors carefully. Commit.
+10. **Add Dispatch Logic:** Re-introduce Svelte dispatch logic in `TypeScriptLanguageFrontend.kt`.
+11. **Build Step 4:** Run `compileKotlin`. Fix. Commit.
+12. **Add Tests & Refine:** Implement tests and detailed CPG node handling.
+
+## Progress Notes
+
+*   **Strategy Shift:** Decided to integrate Svelte support directly into `cpg-language-typescript` instead of a separate module, based on maintainer feedback.
+*   **Kotlin Stubs:** Created initial Kotlin classes within `cpg-language-typescript`:
+    *   `SvelteLanguage.kt`: Defines the language properties.
+    *   `SvelteAST.kt`: Placeholder interface for AST nodes.
+    *   `SvelteLanguageFrontend.kt`: Stub implementation for the frontend, including basic `parse` method structure.
+*   **Parser Setup:**
+    *   Modified the existing Deno-based parser script (`src/main/typescript/parser.ts`) to include `svelte.parse()` for handling `.svelte` files.
+    *   The build process in `cpg-language-typescript/build.gradle.kts` will need to be adjusted to handle Deno execution for the combined parser (specific tasks to be defined).
+*   **Frontend Integration:** Modified `TypeScriptLanguageFrontend.kt`'s `parse` method to detect `.svelte` files and delegate to `SvelteLanguageFrontend` (when instantiated).
+*   **Build Status (Current):** Successfully added Kotlin stubs. Next step is to resolve Kotlin compilation errors in the new Svelte files and attempt a build (`./gradlew :cpg-language-typescript:build`).

cpg-language-typescript/build.gradle.kts

@@ -1,4 +1,6 @@
 /*
+ * cpg-language-typescript module gradle build config
+ *
  * Copyright (c) 2022, Fraunhofer AISEC. All rights reserved.
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");

cpg-language-typescript/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/typescript/SvelteAST.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2025, 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.frontends.typescript
+
+/**
+ * Base interface for Svelte AST nodes parsed from the svelte parser. We will define concrete data
+ * classes inheriting from this later.
+ */
+interface SvelteNode {
+    // Common properties expected from the svelte parser output
+    // For now, let's assume they will be added later.
+    // val type: String
+    // val start: Int
+    // val end: Int
+}

cpg-language-typescript/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/typescript/SvelteLanguage.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2025, 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.frontends.typescript
+
+import de.fraunhofer.aisec.cpg.frontends.Language
+import de.fraunhofer.aisec.cpg.graph.types.*
+import kotlin.reflect.KClass
+import org.neo4j.ogm.annotation.Transient
+
+/** The Svelte language. */
+class SvelteLanguage : Language<SvelteLanguageFrontend>() {
+
+    override val fileExtensions = listOf("svelte")
+    override val namespaceDelimiter = "." // Using JS/TS convention for now
+
+    @Transient
+    override val frontend: KClass<out SvelteLanguageFrontend> = SvelteLanguageFrontend::class
+
+    // TODO: Define built-in types relevant for Svelte if any, beyond JS/TS
+    @Transient override val builtInTypes: Map<String, Type> = mapOf()
+
+    // TODO: Define compound assignment operators if Svelte has specific ones
+    @Transient override val compoundAssignmentOperators = setOf<String>() // Inherit from JS/TS?
+}

cpg-language-typescript/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/typescript/SvelteLanguageFrontend.kt

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2025, 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.frontends.typescript
+
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import de.fraunhofer.aisec.cpg.TranslationContext
+import de.fraunhofer.aisec.cpg.frontends.LanguageFrontend
+import de.fraunhofer.aisec.cpg.frontends.TranslationException as CpgTranslationException
+import de.fraunhofer.aisec.cpg.graph.Node
+import de.fraunhofer.aisec.cpg.graph.declarations.TranslationUnitDeclaration
+import de.fraunhofer.aisec.cpg.graph.newTranslationUnitDeclaration
+import de.fraunhofer.aisec.cpg.graph.types.Type
+import de.fraunhofer.aisec.cpg.graph.unknownType
+import de.fraunhofer.aisec.cpg.sarif.PhysicalLocation
+import java.io.File
+import java.io.InputStreamReader
+
+/**
+ * Language Frontend for analyzing Svelte files.
+ *
+ * Responsible for converting a Svelte AST (obtained by running the Deno parser script) into CPG
+ * nodes.
+ */
+class SvelteLanguageFrontend(ctx: TranslationContext, language: SvelteLanguage = SvelteLanguage()) :
+    LanguageFrontend<SvelteNode, SvelteNode>(ctx, language) {
+
+    private val mapper = jacksonObjectMapper()
+    private var currentFileContent: String? = null
+
+    // Companion object to manage the parser binary extraction (similar to TS frontend)
+    companion object {
+        // Use the *same* parser binary as TypeScriptLanguageFrontend
+        private val parserFile: File = TypeScriptLanguageFrontend.parserFile
+    }
+
+    @Throws(CpgTranslationException::class)
+    override fun parse(file: File): TranslationUnitDeclaration {
+        currentFileContent = file.readText() // Store content for code/location mapping
+
+        if (!parserFile.exists()) {
+            // If the TS frontend didn't extract it, something is wrong
+            throw CpgTranslationException(
+                "Unified parser binary not found at ${parserFile.absolutePath} (expected TS frontend to extract)"
+            )
+        }
+
+        // This frontend *only* handles Svelte
+        val languageFlag = "--language=svelte"
+
+        log.info(
+            "Executing unified parser for Svelte file {} with flag: {}",
+            file.absolutePath,
+            languageFlag,
+        )
+        val process =
+            try {
+                Runtime.getRuntime()
+                    .exec(arrayOf(parserFile.absolutePath, languageFlag, file.absolutePath))
+            } catch (e: Exception) {
+                throw CpgTranslationException(
+                    "Error executing unified parser for Svelte: ${e.message}",
+                    e,
+                )
+            }
+
+        val stdInput = InputStreamReader(process.inputStream)
+        val stdError = InputStreamReader(process.errorStream)
+        val jsonResult = stdInput.readText()
+        val errors = stdError.readText()
+        stdInput.close()
+        stdError.close()
+
+        val exitCode = process.waitFor()
+
+        if (exitCode != 0) {
+            log.error("Unified parser (Svelte) exited with code {}: {}", exitCode, errors)
+            throw CpgTranslationException("Unified parser (Svelte) failed: $errors")
+        }
+        if (errors.isNotEmpty()) {
+            log.warn("Unified parser (Svelte) reported errors/warnings: {}", errors)
+        }
+
+        // --- Start AST Deserialization and CPG Creation ---
+        log.info("Handling Svelte AST JSON for {}", file.name)
+
+        // TODO: Define SvelteNode data classes in SvelteAST.kt matching svelte.parse output
+        // For now, we deserialize into a generic map or a placeholder root node
+        // data class SvelteProgramNode(val type: String?, val children: List<Any>?) : SvelteNode //
+        // Placeholder - move to SvelteAST.kt
+        // val svelteAstRoot: SvelteProgramNode = try { ... } catch ...
+
+        // Placeholder implementation:
+        log.debug("Svelte parser JSON output: {}", jsonResult)
+        // val svelteAstRoot: Map<String, Any> = mapper.readValue(jsonString) // Example
+        // deserialization
+
+        // Create the TranslationUnitDeclaration using the builder function
+        val tud = newTranslationUnitDeclaration(file.name, currentFileContent ?: "")
+
+        // TODO: Implement the actual CPG node creation logic here.
+        // Iterate through svelteAstRoot (html, css, instance, module sections)
+        // and create corresponding CPG nodes (RecordDeclaration, FunctionDeclaration, etc.)
+
+        // TODO: Implement comment handling if needed and possible from Svelte AST
+
+        log.info("Svelte CPG construction finished for {}", file.name)
+        return tud
+    }
+
+    override fun typeOf(typeNode: SvelteNode): Type {
+        // TODO: Implement type mapping based on Svelte AST node types
+        return unknownType()
+    }
+
+    override fun codeOf(astNode: SvelteNode): String? {
+        // TODO: Extract code snippet corresponding to the SvelteNode
+        // Requires SvelteNode to have start/end properties from parser
+        // Use currentFileContent?.substring(astNode.start, astNode.end)
+        return null // Placeholder
+    }
+
+    override fun locationOf(astNode: SvelteNode): PhysicalLocation? {
+        // TODO: Create PhysicalLocation based on SvelteNode start/end properties
+        // Requires SvelteNode to have start/end and file info
+        // Use FrontendUtils.parseLocation or similar
+        return null // Placeholder
+    }
+
+    override fun setComment(node: Node, astNode: SvelteNode) {
+        // TODO: Implement comment association if Svelte AST provides comment info
+    }
+}