Add support for property-based testing

.github/actions/run-effekt-tests/action.yml

@@ -34,12 +34,12 @@ runs:
         timeout_minutes: ${{ inputs.retry-timeout }}
         max_attempts: ${{ inputs.retry-max-attempts }}
         retry_on: error
-        command: EFFEKT_VALGRIND=1 EFFEKT_DEBUG=1 sbt -J-Xss1G clean test
+        command: EFFEKT_VALGRIND=1 EFFEKT_DEBUG=1 sbt clean test
         new_command_on_retry: sbt testQuick
 
     - name: Run full test suite without retry
       if: ${{ inputs.full-test == 'true' && runner.os != 'Windows' && inputs.use-retry != 'true' }}
-      run: EFFEKT_VALGRIND=1 EFFEKT_DEBUG=1 sbt -J-Xss1G clean test
+      run: EFFEKT_VALGRIND=1 EFFEKT_DEBUG=1 sbt clean test
       shell: bash
 
     - name: Assemble fully optimized js file

.github/actions/setup-effekt/action.yml

@@ -13,7 +13,7 @@ inputs:
   llvm-version:
     description: 'LLVM version to install'
     required: false
-    default: '15'
+    default: '18'
   install-dependencies:
     description: 'Whether to install system dependencies (Linux only)'
     required: false

.github/workflows/deploy.yml

@@ -1,5 +1,8 @@
 name: Release Artifacts
 
+permissions:
+  id-token: write
+
 on:
   push:
     tags:

.github/workflows/manual-npm-publish.yml

@@ -0,0 +1,69 @@
+# Do not use this, please. This is just for manual NPM publishing in a time of great need.
+name: Publish to NPM manually
+
+permissions:
+  id-token: write
+
+on:
+  workflow_dispatch: # For manual triggering
+
+jobs:
+  build-jar:
+    name: Build and assemble the Effekt compiler
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.get_version.outputs.VERSION }}
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        submodules: 'true'
+
+    - uses: ./.github/actions/setup-effekt
+
+    - name: Get the version
+      id: get_version
+      run: |
+          git fetch --tags
+          LATEST_TAG=$(git describe --tags --abbrev=0)
+          echo "VERSION=${LATEST_TAG#v}" >> $GITHUB_OUTPUT
+
+    - name: Assemble jar file
+      run: sbt clean deploy
+
+    - name: Generate npm package
+      run: mv $(npm pack) effekt.tgz
+
+    - name: Upload Effekt binary
+      uses: actions/upload-artifact@v4
+      with:
+        name: effekt
+        path: bin/effekt
+
+    - name: Upload the npm package
+      uses: actions/upload-artifact@v4
+      with:
+        name: effekt-npm-package
+        path: effekt.tgz
+
+  publish-npm:
+    name: Publish NPM Package
+    runs-on: ubuntu-latest
+    needs: [build-jar]
+    steps:
+      - name: Download npm package
+        uses: actions/download-artifact@v4
+        with:
+          name: effekt-npm-package
+
+      - name: Set up NodeJS ${{ env.NODE_VERSION }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Publish to NPM as @effekt-lang/effekt
+        run: npm publish effekt.tgz --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

effekt/js/src/main/scala/effekt/LanguageServer.scala

@@ -98,18 +98,12 @@ class LanguageServer extends Intelligence {
     file(path).lastModified
 
   @JSExport
-  def compileFile(path: String): String = {
-    val mainOutputPath = compileCached(VirtualFileSource(path)).getOrElseAborting {
-      throw js.JavaScriptException(s"Cannot compile ${path}")
+  def compileFile(path: String): String =
+    compileCached(VirtualFileSource(path)).getOrElseAborting {
+      // report all collected error messages
+      val formattedErrors = context.messaging.formatMessages(context.messaging.get)
+      throw js.JavaScriptException(formattedErrors)
     }
-    try {
-      mainOutputPath
-    } catch {
-      case FatalPhaseError(msg) =>
-        val formattedError = context.messaging.formatMessage(msg)
-        throw js.JavaScriptException(formattedError)
-    }
-  }
 
   @JSExport
   def showCore(path: String): String = {

effekt/jvm/src/main/scala/effekt/EffektConfig.scala

@@ -68,8 +68,8 @@ class EffektConfig(args: Seq[String]) extends REPLConfig(args.takeWhile(_ != "--
 
   val llvmVersion: ScallopOption[String] = opt[String](
     "llvm-version",
-    descr = "the llvm version that should be used to compile the generated programs (only necessary if backend is llvm, defaults to 15)",
-    default = Some(sys.env.getOrElse("EFFEKT_LLVM_VERSION", "15")),
+    descr = "the llvm version that should be used to compile the generated programs (only necessary if backend is llvm, defaults to 18)",
+    default = Some(sys.env.getOrElse("EFFEKT_LLVM_VERSION", "18")),
     noshort = true,
     group = advanced
   )

effekt/jvm/src/main/scala/effekt/Main.scala

@@ -17,14 +17,19 @@ object Main {
       parseArgs(args)
     } catch {
       case e: ScallopException =>
-        System.err.println(e.getMessage())
+        System.err.println(e.getMessage)
         return
     }
 
     if (config.server()) {
-      Server.launch(config)
+      val serverConfig = ServerConfig(
+        debug = config.debug(),
+        debugPort = config.debugPort()
+      )
+      val server = new Server(config)
+      server.launch(serverConfig)
     } else if (config.repl()) {
-      new Repl(Server).run(config)
+      new Repl(new Driver {}).run(config)
     } else {
       compileFiles(config)
     }
@@ -43,8 +48,9 @@ object Main {
    * Compile files specified in the configuration.
    */
   private def compileFiles(config: EffektConfig): Unit = {
+    val driver = new Driver {}
     for (filename <- config.filenames()) {
-      Server.compileFile(filename, config)
+      driver.compileFile(filename, config)
     }
   }
 }

effekt/jvm/src/main/scala/effekt/Runner.scala

@@ -267,8 +267,8 @@ object LLVMRunner extends Runner[String] {
   override def includes(path: File): List[File] = List(path / ".." / "llvm")
 
   lazy val gccCmd = discoverExecutable(List("cc", "clang", "gcc"), List("--version"))
-  lazy val llcCmd = discoverExecutable(List("llc", "llc-15", "llc-16"), List("--version"))
-  lazy val optCmd = discoverExecutable(List("opt", "opt-15", "opt-16"), List("--version"))
+  lazy val llcCmd = discoverExecutable(List("llc", "llc-18"), List("--version"))
+  lazy val optCmd = discoverExecutable(List("opt", "opt-18"), List("--version"))
 
   def checkSetup(): Either[String, Unit] =
     gccCmd.getOrElseAborting { return Left("Cannot find gcc. This is required to use the LLVM backend.") }