ttsc 0.30.0 → 0.30.1

package/cmd/ttsc/build.go

@@ -114,10 +114,9 @@ func runBuild(args []string) int {
       fmt.Fprintf(stderr, "ttsc: emit failed: %v\n", err)
       return 3
     }
-    for _, d := range eDiags {
-      fmt.Fprintln(stderr, "  -", d.String())
-    }
+    driver.WritePrettyDiagnostics(stderr, eDiags, cwd)
     if driver.CountErrors(eDiags) > 0 {
+      fmt.Fprintln(stderr, "ttsc: emit failed; build output is incomplete")
       return 2
     }
     if !*quiet {

package/driver/emit_plugin.go

@@ -1,7 +1,9 @@
 package driver
 
 import (
+  "context"
   "errors"
+  "fmt"
   "strings"
   "sync"
 
@@ -37,26 +39,35 @@ func (h *pluginEmitHost) GetEmitModuleFormatOfFile(file shimast.HasFileName) shi
   return h.program.GetEmitModuleFormatOfFile(file)
 }
 func (h *pluginEmitHost) GetEmitResolver() shimprinter.EmitResolver {
-  return guardedEmitResolver{h.emitResolver}
+  return h.emitResolver
 }
 
-// guardedEmitResolver makes tsgo's const-enum inliner safe against plugin-built
-// nodes. The inliner calls GetConstantValue on every property/element access it
-// visits — including synthetic ones a plugin injects — and tsgo's checker can
-// nil-panic while computing a contextual type for such a node. A failure there
-// only means "not a const enum", so recover to nil and leave the node as-is.
+// guardedEmitResolver only resolves member accesses from the program's input
+// trees. ParseNode follows original links but trusts the synthesized flag:
+// standalone factories leave it clear, even on generated nodes with copied
+// source positions. Recovering a checker panic is too late to prevent that
+// lookup from recording diagnostics on a parameter the binder never saw.
 type guardedEmitResolver struct {
   shimprinter.EmitResolver
+  originalMembers map[*shimast.Node]struct{}
 }
 
-func (g guardedEmitResolver) GetConstantValue(node *shimast.Node) (result any) {
-  defer func() {
-    if recover() != nil {
-      result = nil
-    }
-  }()
+func (g guardedEmitResolver) GetConstantValue(node *shimast.Node) any {
+  if _, original := g.originalMembers[node]; !original {
+    return nil
+  }
   return g.EmitResolver.GetConstantValue(node)
 }
+
+func collectOriginalMembers(node *shimast.Node, members map[*shimast.Node]struct{}) {
+  if node.Kind == shimast.KindPropertyAccessExpression || node.Kind == shimast.KindElementAccessExpression {
+    members[node] = struct{}{}
+  }
+  node.ForEachChild(func(child *shimast.Node) bool {
+    collectOriginalMembers(child, members)
+    return false
+  })
+}
 func (h *pluginEmitHost) GetProjectReferenceFromSource(path shimtspath.Path) *shimtsoptions.SourceOutputAndProjectReference {
   return h.program.GetProjectReferenceFromSource(path)
 }
@@ -180,8 +191,31 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
   if len(linked) != 0 {
     transforms = append(append([]PluginTransform{}, transforms...), linked...)
   }
-  host := &pluginEmitHost{program: p.TSProgram, emitResolver: p.Checker.GetEmitResolver()}
   options := p.TSProgram.Options()
+  if options.NoEmit.IsTrue() {
+    // Analysis-only incremental projects may still write build information.
+    // Delegate that policy to the ordinary emitter without running JS hooks.
+    result, diagnostics, err := p.EmitAllRaw(writeFile)
+    if err != nil {
+      return diagnostics, err
+    }
+    return p.pluginEmitDiagnostics("analysis-only emit", result.Diagnostics)
+  }
+  if result := shimcompiler.HandleNoEmitOnError(context.Background(), p.TSProgram, nil); result != nil {
+    return p.pluginEmitDiagnostics("pre-emit checking", result.Diagnostics)
+  }
+  // Snapshot ownership before any transformer runs, including transforms that
+  // mutate their input in place or reuse a member from another source file.
+  members := make(map[*shimast.Node]struct{})
+  for _, sf := range p.TSProgram.SourceFiles() {
+    collectOriginalMembers(sf.AsNode(), members)
+  }
+  host := &pluginEmitHost{program: p.TSProgram, emitResolver: guardedEmitResolver{p.Checker.GetEmitResolver(), members}}
+
+  // noEmitOnError applies to the whole build. The JS lane runs before the
+  // declaration lane, so defer callbacks until both have succeeded. Outside
+  // that option keep upstream's emit-despite-errors behavior.
+  output := newPluginEmitOutput(writeFile, options.NoEmitOnError.IsTrue())
   for _, sf := range shimcompiler.GetSourceFilesToEmit(host, nil, false) {
     paths := shimcompiler.GetOutputPathsFor(sf, options, host, false)
     if paths.JsFilePath() != "" && !p.outputEscapesOutDir(paths.JsFilePath()) {
@@ -262,11 +296,11 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       // why the remaining fields stay zero.
       if err := p.writePluginEmitOutput(paths.JsFilePath(), printed.JS, &shimcompiler.WriteFileData{
         SourceMapUrlPos: printed.SourceMapUrlPos,
-      }, writeFile); err != nil {
-        return nil, err
+      }, output.write); err != nil {
+        return nil, fmt.Errorf("driver: native plugin JavaScript emit failed: %w", err)
       }
-      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, nil, writeFile); err != nil {
-        return nil, err
+      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, nil, output.write); err != nil {
+        return nil, fmt.Errorf("driver: native plugin source map emit failed: %w", err)
       }
     }
   }
@@ -274,7 +308,10 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
   // so it also runs for a JavaScript-only `incremental` / `composite` project
   // that has no declarations to write at all.
   if !options.GetEmitDeclarations() && !p.emitsBuildInfo() {
-    return nil, nil
+    if result := shimcompiler.HandleNoEmitOnError(context.Background(), p.TSProgram, nil); result != nil {
+      return p.pluginEmitDiagnostics("JavaScript emit", result.Diagnostics)
+    }
+    return nil, output.flush()
   }
 
   // What the build information this pass writes does and does not claim.
@@ -304,16 +341,18 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
         }
         return nil
       }
-      if writeFile != nil {
-        return writeFile(fileName, text, data)
-      }
-      return DefaultWriteFile(fileName, text)
+      return output.write(fileName, text, data)
     },
   })
+  var diagnostics []Diagnostic
   if result != nil && len(result.Diagnostics) != 0 {
-    return p.convertProgramDiagnostics(result.Diagnostics), nil
+    var err error
+    diagnostics, err = p.pluginEmitDiagnostics("declaration emit", result.Diagnostics)
+    if err != nil {
+      return diagnostics, err
+    }
   }
-  return nil, nil
+  return diagnostics, output.flush()
 }
 
 // writePluginEmitOutput writes one artifact of the hand-assembled emit, passing

package/driver/emit_plugin_output.go

@@ -0,0 +1,83 @@
+package driver
+
+import (
+  "fmt"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+)
+
+// PluginEmitError reports compiler errors from a native plugin emit. The same
+// diagnostics remain in the returned slice for structured consumers. Hosts
+// that only check the Go error still reject an incomplete build and display
+// the compiler's code, severity and available source context.
+type PluginEmitError struct {
+  Diagnostics  []Diagnostic
+  Phase        string
+  Declarations bool
+  cwd          string
+}
+
+func (e *PluginEmitError) Error() string {
+  var out strings.Builder
+  fmt.Fprintf(&out, "driver: native plugin %s failed; build output is incomplete", e.Phase)
+  if e.Declarations {
+    out.WriteString("; declaration output is incomplete or skipped")
+  }
+  out.WriteByte('\n')
+  WritePrettyDiagnostics(&out, e.Diagnostics, e.cwd)
+  return strings.TrimSpace(out.String())
+}
+
+func (p *Program) pluginEmitDiagnostics(phase string, raw []*shimast.Diagnostic) ([]Diagnostic, error) {
+  diagnostics := p.convertProgramDiagnostics(raw)
+  if CountErrors(diagnostics) == 0 {
+    return diagnostics, nil
+  }
+  return diagnostics, &PluginEmitError{
+    Diagnostics:  diagnostics,
+    Phase:        phase,
+    Declarations: p.TSProgram.Options().GetEmitDeclarations(),
+    cwd:          p.TSProgram.GetCurrentDirectory(),
+  }
+}
+
+type pluginEmitOutput struct {
+  writeFile shimcompiler.WriteFile
+  buffered  bool
+  pending   []pluginEmitFile
+}
+
+type pluginEmitFile struct {
+  name string
+  text string
+  data *shimcompiler.WriteFileData
+}
+
+func newPluginEmitOutput(writeFile shimcompiler.WriteFile, buffered bool) *pluginEmitOutput {
+  if writeFile == nil {
+    writeFile = func(name, text string, _ *shimcompiler.WriteFileData) error {
+      return DefaultWriteFile(name, text)
+    }
+  }
+  return &pluginEmitOutput{writeFile: writeFile, buffered: buffered}
+}
+
+// The caller serializes declaration writes; JavaScript and flush are serial.
+func (o *pluginEmitOutput) write(name, text string, data *shimcompiler.WriteFileData) error {
+  if !o.buffered {
+    return o.writeFile(name, text, data)
+  }
+  o.pending = append(o.pending, pluginEmitFile{name, text, data})
+  return nil
+}
+
+func (o *pluginEmitOutput) flush() error {
+  for _, file := range o.pending {
+    if err := o.writeFile(file.name, file.text, file.data); err != nil {
+      return fmt.Errorf("driver: native plugin output write failed for %s; build output is incomplete: %w", file.name, err)
+    }
+  }
+  return nil
+}

package/driver/program.go

@@ -142,7 +142,9 @@ func WritePrettyDiagnostics(w io.Writer, diagnostics []Diagnostic, cwd string) {
   rich := make([]Diagnostic, 0, len(diagnostics))
   plain := make([]Diagnostic, 0)
   for _, d := range diagnostics {
-    if d.raw != nil || d.lint != nil {
+    if d.raw != nil && d.raw.File() != nil && d.raw.Pos() < 0 {
+      plain = append(plain, d)
+    } else if d.raw != nil || d.lint != nil {
       rich = append(rich, d)
     } else {
       plain = append(plain, d)
@@ -162,7 +164,18 @@ func WritePrettyDiagnostics(w io.Writer, diagnostics []Diagnostic, cwd string) {
     shimdiagnosticwriter.FormatMixedDiagnostics(w, astDiags, lintDiags, cwd)
   }
   for _, d := range plain {
-    fmt.Fprintln(w, "  -", d.String())
+    severity := "error"
+    if d.Severity == SeverityWarning {
+      severity = "warning"
+    }
+    code := ""
+    if d.Code != 0 {
+      code = fmt.Sprintf(" TS%d", d.Code)
+    }
+    fmt.Fprintf(w, "  - %s%s: %s\n", severity, code, d.String())
+    if d.raw != nil && d.raw.File() != nil && d.raw.Pos() < 0 {
+      fmt.Fprintln(w, "    Diagnostic refers to generated code; no authored source location is available.")
+    }
   }
 }
 
@@ -187,9 +200,10 @@ func CountErrors(diagnostics []Diagnostic) int {
       }
       continue
     }
-    // Plain text diagnostics (manually assembled): treat as errors so
-    // "ttsc: tsconfig not found"-style failures still flip the exit code.
-    n++
+    // Plain diagnostics default to error but may explicitly declare warning.
+    if d.Severity != SeverityWarning {
+      n++
+    }
   }
   return n
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -47,13 +47,13 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "@ttsc/linux-x64": "0.30.0",
-    "@ttsc/linux-arm64": "0.30.0",
-    "@ttsc/linux-arm": "0.30.0",
-    "@ttsc/darwin-arm64": "0.30.0",
-    "@ttsc/win32-x64": "0.30.0",
-    "@ttsc/darwin-x64": "0.30.0",
-    "@ttsc/win32-arm64": "0.30.0"
+    "@ttsc/linux-x64": "0.30.1",
+    "@ttsc/linux-arm": "0.30.1",
+    "@ttsc/darwin-arm64": "0.30.1",
+    "@ttsc/darwin-x64": "0.30.1",
+    "@ttsc/linux-arm64": "0.30.1",
+    "@ttsc/win32-arm64": "0.30.1",
+    "@ttsc/win32-x64": "0.30.1"
   },
   "sideEffects": [
     "./lib/register.js",

package/utility/host.go

@@ -115,10 +115,9 @@ func RunBuildWithIO(args []string, stdout, stderr io.Writer) int {
     fmt.Fprintf(opts.stderr, "ttsc utility: emit failed: %v\n", err)
     return 3
   }
-  for _, d := range eDiags {
-    fmt.Fprintln(opts.stderr, "  -", d.String())
-  }
+  driver.WritePrettyDiagnostics(opts.stderr, eDiags, opts.cwd)
   if driver.CountErrors(eDiags) > 0 {
+    fmt.Fprintln(opts.stderr, "ttsc utility: emit failed; build output is incomplete")
     return 2
   }
   if res != nil && !opts.quiet {