Codegen passing

.gitignore

@@ -28,3 +28,13 @@ Thumbs.db
 /editors/code/out
 /editors/code/.vscode-test
 /editors/code/package-lock.json
+/editors/code/pfc-lsp-*
+
+# purs
+/output
+
+# test artifacts
+tests/fixtures/original-compiler/passing/*.output.js
+tests/fixtures/original-compiler/passing/*/*.output.js
+tests/fixtures/original-compiler/passing/*.error.txt
+tests/fixtures/original-compiler/passing/*/*.error.txt

Cargo.toml

@@ -22,11 +22,13 @@ miette = { version = "7.6", features = ["fancy"] }
 thiserror = "2.0"
 lalrpop-util = "0.22"
 glob = "0.3"
-swc_ecma_parser = "34.0.0"
-swc_ecma_ast = "20.0.1"
-swc_common = "18.0.1"
+swc_ecma_parser = "35.0.0"
+swc_ecma_ast = "21.0.0"
+swc_common = "19.0.0"
+swc_ecma_codegen = "24.0.0"
 ntest_timeout = "0.9.5"
 rayon = "1.10"
+stacker = "0.1"
 mimalloc = { version = "0.1", default-features = false }
 tower-lsp = "0.20"
 tokio = { version = "1", features = ["full"] }
@@ -43,3 +45,5 @@ insta = "1.34"
 criterion = "0.5"
 proptest = "1.4"
 regex = "1"
+tempfile = "3.27.0"
+wait-timeout = "0.2.1"

editors/code/package.json

@@ -1,9 +1,10 @@
 {
   "name": "pfc-lsp",
-  "displayName": "PureScript Fast Compiler",
+  "displayName": "PureScript Fast Compiler LSP Client",
   "description": "VS Code client for the pfc language server",
   "version": "0.0.1",
-  "publisher": "pfc",
+  "publisher": "OxfordAbstracts",
+  "repository": "https://github.com/OxfordAbstracts/purescript-fast-compiler",
   "engines": {
     "vscode": "^1.75.0"
   },
@@ -49,6 +50,16 @@
           "type": "string",
           "default": "ragu sources",
           "description": "Shell command that outputs PureScript source file paths (one per line). Example: find src .spago/p -name '*.purs'"
+        },
+        "pfc.outputDir": {
+          "type": "string",
+          "default": "",
+          "description": "Output directory for generated JavaScript. When set, the LSP will generate JS code on save. Example: output"
+        },
+        "pfc.outputDirCommand": {
+          "type": "string",
+          "default": "ragu output-dir",
+          "description": "Shell command that outputs the JS output directory path. When set, overrides pfc.outputDir. Example: spago path output"
         }
       }
     }
@@ -61,6 +72,7 @@
     "vscode-languageclient": "^9.0.1"
   },
   "devDependencies": {
+    "@types/node": "^20.0.0",
     "@types/vscode": "^1.75.0",
     "typescript": "^5.0.0"
   }

editors/code/src/extension.ts

@@ -11,11 +11,15 @@ export function activate(context: vscode.ExtensionContext) {
   const config = vscode.workspace.getConfiguration("pfc");
   const serverPath = config.get<string>("serverPath", "pfc");
   const sourcesCommand = config.get<string>("sourcesCommand", "");
+  const outputDir = config.get<string>("outputDir", "");
 
   const args = ["lsp"];
   if (sourcesCommand) {
     args.push("--sources-cmd", sourcesCommand);
   }
+  if (outputDir) {
+    args.push("--output-dir", outputDir);
+  }
 
   const serverOptions: ServerOptions = {
     command: serverPath,

src/ast.rs

@@ -291,6 +291,9 @@ pub enum Expr {
     /// Typed hole: ?hole
     Hole { span: Span, name: Ident },
 
+    /// Wildcard: _ (anonymous argument, NOT a typed hole)
+    Wildcard { span: Span },
+
     /// Array literal: [1, 2, 3]
     Array { span: Span, elements: Vec<Expr> },
 
@@ -580,6 +583,7 @@ impl Expr {
             | Expr::RecordUpdate { span, .. }
             | Expr::TypeAnnotation { span, .. }
             | Expr::Hole { span, .. }
+            | Expr::Wildcard { span, .. }
             | Expr::Array { span, .. }
             | Expr::Negate { span, .. }
             | Expr::AsPattern { span, .. }
@@ -1697,6 +1701,10 @@ impl Converter {
     // --- Expression conversion ---
 
     fn convert_expr(&mut self, expr: &cst::Expr) -> Expr {
+        stacker::maybe_grow(32 * 1024, 2 * 1024 * 1024, || self.convert_expr_impl(expr))
+    }
+
+    fn convert_expr_impl(&mut self, expr: &cst::Expr) -> Expr {
         match expr {
             cst::Expr::Var { span, name } => Expr::Var {
                 span: *span,
@@ -1931,10 +1939,87 @@ impl Converter {
                     .map(|f| self.convert_record_field(f))
                     .collect(),
             },
-            cst::Expr::RecordAccess { span, expr, field } => Expr::RecordAccess {
-                span: *span,
-                expr: Box::new(self.convert_expr(expr)),
-                field: field.clone(),
+            cst::Expr::RecordAccess { span, expr, field } => {
+                // _.x (record accessor section) → \$_arg -> $_arg.x
+                if Self::is_wildcard(expr) {
+                    let param_name = intern("$_arg");
+                    let mut scope = HashMap::new();
+                    scope.insert(param_name, *span);
+                    self.local_scopes.push(scope);
+                    let param_expr = Expr::Var {
+                        span: expr.span(),
+                        name: QualifiedIdent {
+                            module: None,
+                            name: param_name,
+                        },
+                        definition_site: DefinitionSite::Local(*span),
+                    };
+                    let body = Expr::RecordAccess {
+                        span: *span,
+                        expr: Box::new(param_expr),
+                        field: field.clone(),
+                    };
+                    self.local_scopes.pop();
+                    Expr::Lambda {
+                        span: *span,
+                        binders: vec![Binder::Var {
+                            span: *span,
+                            name: cst::Spanned {
+                                span: *span,
+                                value: param_name,
+                            },
+                        }],
+                        body: Box::new(body),
+                    }
+                } else {
+                    // Handle chained accessor on wildcard: _.x.y → \$_arg -> $_arg.x.y
+                    let mut chain = vec![field.clone()];
+                    let mut inner = expr.as_ref();
+                    while let cst::Expr::RecordAccess { expr: e, field: f, .. } = inner {
+                        chain.push(f.clone());
+                        inner = e.as_ref();
+                    }
+                    if Self::is_wildcard(inner) {
+                        let param_name = intern("$_arg");
+                        let mut scope = HashMap::new();
+                        scope.insert(param_name, *span);
+                        self.local_scopes.push(scope);
+                        let mut body = Expr::Var {
+                            span: inner.span(),
+                            name: QualifiedIdent {
+                                module: None,
+                                name: param_name,
+                            },
+                            definition_site: DefinitionSite::Local(*span),
+                        };
+                        // Apply fields in reverse (innermost first): _.x.y → ($__arg).x.y
+                        for f in chain.iter().rev() {
+                            body = Expr::RecordAccess {
+                                span: *span,
+                                expr: Box::new(body),
+                                field: f.clone(),
+                            };
+                        }
+                        self.local_scopes.pop();
+                        Expr::Lambda {
+                            span: *span,
+                            binders: vec![Binder::Var {
+                                span: *span,
+                                name: cst::Spanned {
+                                    span: *span,
+                                    value: param_name,
+                                },
+                            }],
+                            body: Box::new(body),
+                        }
+                    } else {
+                        Expr::RecordAccess {
+                            span: *span,
+                            expr: Box::new(self.convert_expr(expr)),
+                            field: field.clone(),
+                        }
+                    }
+                }
             },
             cst::Expr::RecordUpdate {
                 span,
@@ -1975,9 +2060,8 @@ impl Converter {
                 span: *span,
                 name: *name,
             },
-            cst::Expr::Wildcard { span } => Expr::Hole {
+            cst::Expr::Wildcard { span } => Expr::Wildcard {
                 span: *span,
-                name: intern("_"),
             },
             cst::Expr::Array { span, elements } => Expr::Array {
                 span: *span,
@@ -2204,8 +2288,7 @@ impl Converter {
             return result;
         }
 
-        let wildcard_sym = interner::intern("_");
-        // Destructure App(App(op, left), right) to check for holes
+        // Destructure App(App(op, left), right) to check for wildcard sections
         if let Expr::App {
             span: outer_span,
             func: outer_func,
@@ -2218,10 +2301,8 @@ impl Converter {
                 arg: left_arg,
             } = *outer_func
             {
-                let left_is_hole =
-                    matches!(&*left_arg, Expr::Hole { name, .. } if *name == wildcard_sym);
-                let right_is_hole =
-                    matches!(&*right_arg, Expr::Hole { name, .. } if *name == wildcard_sym);
+                let left_is_hole = matches!(&*left_arg, Expr::Wildcard { .. });
+                let right_is_hole = matches!(&*right_arg, Expr::Wildcard { .. });
                 if left_is_hole || right_is_hole {
                     // Valid section after rebalancing — desugar to lambda
                     let param_name = interner::intern("$_arg");
@@ -2278,10 +2359,7 @@ impl Converter {
         // but emit error for safety
         self.errors
             .push(TypeError::IncorrectAnonymousArgument { span });
-        output.pop().unwrap_or(Expr::Hole {
-            span,
-            name: wildcard_sym,
-        })
+        output.pop().unwrap_or(Expr::Wildcard { span })
     }
 
     fn build_op_app(
@@ -2363,6 +2441,10 @@ impl Converter {
     // --- Type expression conversion ---
 
     fn convert_type_expr(&mut self, ty: &cst::TypeExpr) -> TypeExpr {
+        stacker::maybe_grow(32 * 1024, 2 * 1024 * 1024, || self.convert_type_expr_impl(ty))
+    }
+
+    fn convert_type_expr_impl(&mut self, ty: &cst::TypeExpr) -> TypeExpr {
         match ty {
             cst::TypeExpr::Var { span, name } => TypeExpr::Var {
                 span: *span,
@@ -2610,6 +2692,10 @@ impl Converter {
     // --- Binder conversion ---
 
     fn convert_binder(&mut self, binder: &cst::Binder) -> Binder {
+        stacker::maybe_grow(32 * 1024, 2 * 1024 * 1024, || self.convert_binder_impl(binder))
+    }
+
+    fn convert_binder_impl(&mut self, binder: &cst::Binder) -> Binder {
         match binder {
             cst::Binder::Wildcard { span } => Binder::Wildcard { span: *span },
             cst::Binder::Var { span, name } => Binder::Var {

src/build/cache.rs

@@ -663,6 +663,11 @@ impl ModuleCache {
         self.entries.get(module_name).map(|c| c.imports())
     }
 
+    /// Get the cache directory path, if configured.
+    pub fn cache_dir(&self) -> Option<&Path> {
+        self.cache_dir.as_deref()
+    }
+
     /// Get cached exports for a module, loading from disk if needed.
     pub fn get_exports(&mut self, module_name: &str) -> Option<&ModuleExports> {
         // Check if we need to load from disk first
@@ -863,7 +868,7 @@ impl ModuleCache {
 
 // ===== File helpers =====
 
-fn module_file_path(cache_dir: &Path, module_name: &str) -> PathBuf {
+pub fn module_file_path(cache_dir: &Path, module_name: &str) -> PathBuf {
     cache_dir.join("modules").join(format!("{}.bin", module_name))
 }
 
@@ -884,7 +889,7 @@ fn save_module_file(path: &Path, exports: &ModuleExports) -> io::Result<()> {
     Ok(())
 }
 
-fn load_module_file(path: &Path) -> io::Result<ModuleExports> {
+pub fn load_module_file(path: &Path) -> io::Result<ModuleExports> {
     let file = std::fs::File::open(path)?;
     let decoder = io::BufReader::new(zstd::Decoder::new(file)
         .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("zstd: {e}")))?);