Ts native parser

.github/workflows/ci.yml

@@ -110,7 +110,29 @@ jobs:
           # Builds on other branches will only read existing entries from the cache.
           cache-read-only: ${{ github.ref != 'refs/heads/develop' && github.ref != 'ref/heads/neo' }}
 
-      - name: Set up ArkAnalyzer
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: jacodb-ets/ts-frontend/package-lock.json
+
+      - name: Build and test ts-frontend
+        working-directory: jacodb-ets/ts-frontend
+        run: |
+          npm ci
+          npm run build
+          npm test
+
+      # The legacy ArkAnalyzer provider stays supported (selectable via
+      # ETS_IR_PROVIDER=arkanalyzer); setting ARKANALYZER_DIR here enables
+      # the provider-parity test in EtsTsFrontendTest.
+      #
+      # Best-effort: the default provider is the bundled ts-frontend, so a
+      # broken upstream ArkAnalyzer must not fail the job — without
+      # ARKANALYZER_DIR the parity test skips itself.
+      - name: Set up ArkAnalyzer (legacy provider, best-effort)
+        continue-on-error: true
         run: |
           REPO_URL="https://gitcode.com/Lipen/arkanalyzer"
           DEST_DIR="arkanalyzer"
@@ -131,7 +153,6 @@ jobs:
               echo "Repository cloned successfully."
           fi
 
-          echo "ARKANALYZER_DIR=$(realpath $DEST_DIR)" >> $GITHUB_ENV
           cd $DEST_DIR
 
           # ArkAnalyzer's bundled TypeScript (ohos-typescript 4.9.5) cannot parse
@@ -145,6 +166,9 @@ jobs:
           npm install
           npm run build
 
+          # Export only after a successful build so a broken checkout is never used.
+          echo "ARKANALYZER_DIR=$(realpath .)" >> $GITHUB_ENV
+
       - name: Run ETS tests
         run: ./gradlew --scan :jacodb-ets:generateTestResources :jacodb-ets:test
 

jacodb-ets/ARKANALYZER.md

@@ -1,5 +1,11 @@
 # ArkAnalyzer
 
+> **Note:** ArkAnalyzer is now the LEGACY EtsIR provider. The default provider
+> is the native TypeScript frontend in [`ts-frontend`](ts-frontend/README.md),
+> which requires no external checkout. ArkAnalyzer remains fully supported:
+> select it with `ETS_IR_PROVIDER=arkanalyzer` (plus `ARKANALYZER_DIR`) or by
+> passing `EtsIrProvider.ARKANALYZER` to the `loadEts*AutoConvert` functions.
+
 ## Installation
 
 Clone and install the ArkAnalyzer via NPM:

jacodb-ets/build.gradle.kts

@@ -1,3 +1,4 @@
+import org.apache.tools.ant.taskdefs.condition.Os
 import java.io.FileNotFoundException
 
 plugins {
@@ -21,44 +22,117 @@ dependencies {
     testFixturesImplementation(Libs.junit_jupiter_api)
 }
 
+// ----------------------------------------------------------------------------
+// Native TypeScript frontend (ts-frontend)
+// ----------------------------------------------------------------------------
+
+val tsFrontendDir: File = projectDir.resolve("ts-frontend")
+val npmExecutable: String = if (Os.isFamily(Os.FAMILY_WINDOWS)) "npm.cmd" else "npm"
+
+fun isNpmAvailable(): Boolean = try {
+    ProcessBuilder(npmExecutable, "--version").start().waitFor() == 0
+} catch (_: Exception) {
+    false
+}
+
+val installTsFrontend = tasks.register<Exec>("installTsFrontend") {
+    group = "build"
+    description = "Installs npm dependencies of the ts-frontend."
+    workingDir = tsFrontendDir
+    commandLine(npmExecutable, "ci")
+    inputs.files(tsFrontendDir.resolve("package.json"), tsFrontendDir.resolve("package-lock.json"))
+    outputs.dir(tsFrontendDir.resolve("node_modules"))
+    onlyIf {
+        isNpmAvailable().also { available ->
+            if (!available) logger.warn("npm is not available; skipping ts-frontend install")
+        }
+    }
+}
+
+val buildTsFrontend = tasks.register<Exec>("buildTsFrontend") {
+    group = "build"
+    description = "Compiles the ts-frontend (TypeScript -> dist)."
+    dependsOn(installTsFrontend)
+    workingDir = tsFrontendDir
+    commandLine(npmExecutable, "run", "build")
+    inputs.dir(tsFrontendDir.resolve("src"))
+    inputs.files(tsFrontendDir.resolve("package.json"), tsFrontendDir.resolve("tsconfig.json"))
+    outputs.dir(tsFrontendDir.resolve("dist"))
+    onlyIf {
+        isNpmAvailable().also { available ->
+            if (!available) logger.warn("npm is not available; skipping ts-frontend build")
+        }
+    }
+}
+
+tasks.register<Exec>("testTsFrontend") {
+    group = "verification"
+    description = "Runs the ts-frontend unit tests (vitest)."
+    dependsOn(installTsFrontend)
+    workingDir = tsFrontendDir
+    commandLine(npmExecutable, "test")
+    onlyIf {
+        isNpmAvailable().also { available ->
+            if (!available) logger.warn("npm is not available; skipping ts-frontend tests")
+        }
+    }
+}
+
+tasks.test {
+    dependsOn(buildTsFrontend)
+    systemProperty("ets.frontend.dir", tsFrontendDir.absolutePath)
+}
+
+// ----------------------------------------------------------------------------
+// Test resource generation
+// ----------------------------------------------------------------------------
+
 // Example usage:
 // ```
-// export ARKANALYZER_DIR=~/dev/arkanalyzer
 // ./gradlew generateTestResources
+// # or with the legacy ArkAnalyzer provider:
+// export ARKANALYZER_DIR=~/dev/arkanalyzer
+// ETS_IR_PROVIDER=arkanalyzer ./gradlew generateTestResources
 // ```
 tasks.register("generateTestResources") {
     group = "build"
-    description = "Generates test resources from TypeScript files using ArkAnalyzer."
+    description = "Generates test resources (EtsIR JSON) from TypeScript sample files."
+    dependsOn(buildTsFrontend)
     doLast {
-        println("Generating test resources using ArkAnalyzer...")
+        val provider = (System.getenv("ETS_IR_PROVIDER") ?: "ts-frontend").lowercase()
+        println("Generating test resources using provider: $provider")
         val startTime = System.currentTimeMillis()
 
-        val envVarName = "ARKANALYZER_DIR"
-        val defaultArkAnalyzerDir = "arkanalyzer"
-
-        val arkAnalyzerDir = rootDir.resolve(System.getenv(envVarName) ?: run {
-            println("Please, set $envVarName environment variable. Using default value: '$defaultArkAnalyzerDir'")
-            defaultArkAnalyzerDir
-        })
-        if (!arkAnalyzerDir.exists()) {
-            throw FileNotFoundException(
-                "ArkAnalyzer directory does not exist: '${arkAnalyzerDir.absolutePath}'. " +
-                    "Did you forget to set the '$envVarName' environment variable? " +
-                    "Current value is '${System.getenv(envVarName)}', " +
-                    "current dir is '${File("").absolutePath}'."
-            )
-        }
-        println("Using ArkAnalyzer directory: '${arkAnalyzerDir.relativeTo(rootDir)}'")
-
-        val scriptSubPath = "src/save/serializeArkIR"
-        val script = arkAnalyzerDir.resolve("out").resolve("$scriptSubPath.js")
-        if (!script.exists()) {
-            throw FileNotFoundException(
-                "Script file not found: '$script'. " +
-                    "Did you forget to execute 'npm run build' in the arkanalyzer project?"
-            )
+        val script: File = when (provider) {
+            "arkanalyzer" -> {
+                val envVarName = "ARKANALYZER_DIR"
+                val arkAnalyzerDir = rootDir.resolve(System.getenv(envVarName) ?: "arkanalyzer")
+                if (!arkAnalyzerDir.exists()) {
+                    throw FileNotFoundException(
+                        "ArkAnalyzer directory does not exist: '${arkAnalyzerDir.absolutePath}'. " +
+                            "Did you forget to set the '$envVarName' environment variable?"
+                    )
+                }
+                arkAnalyzerDir.resolve("out/src/save/serializeArkIR.js").also {
+                    if (!it.exists()) {
+                        throw FileNotFoundException(
+                            "Script file not found: '$it'. " +
+                                "Did you forget to execute 'npm run build' in the arkanalyzer project?"
+                        )
+                    }
+                }
+            }
+
+            else -> tsFrontendDir.resolve("dist/index.js").also {
+                if (!it.exists()) {
+                    throw FileNotFoundException(
+                        "Script file not found: '$it'. " +
+                            "Did you forget to execute 'npm run build' in ts-frontend?"
+                    )
+                }
+            }
         }
-        println("Using script: '${script.relativeTo(arkAnalyzerDir)}'")
+        println("Using script: '$script'")
 
         val resources = projectDir.resolve("src/test/resources")
         val inputDir = resources.resolve("samples/source")
@@ -87,8 +161,11 @@ tasks.register("generateTestResources") {
         }
 
         if (!ok) {
-            println("Timeout!")
             process.destroy()
+            throw GradleException("Test resource generation timed out")
+        }
+        if (process.exitValue() != 0) {
+            throw GradleException("Test resource generation failed with exit code ${process.exitValue()}")
         }
 
         println("Done generating test resources in %.1fs".format((System.currentTimeMillis() - startTime) / 1000.0))