@ttsc/lint 0.28.4 → 0.28.6

package/linthost/check_serve.go

@@ -220,12 +220,13 @@ func (s *residentCheckState) run(
       opts.cwd,
       opts.tsconfig,
       loadProgramOptions{
-        forceNoEmit:      true,
-        needsRuleChecker: engine.NeedsTypeChecker(),
-        singleThreaded:   opts.singleThreaded,
-        checkers:         opts.checkers,
-        tsgoArgs:         opts.tsgoArgs,
-        projectIdentity:  opts.projectIdentity,
+        forceNoEmit:        true,
+        semanticConfigPath: opts.semanticConfigPath,
+        needsRuleChecker:   engine.NeedsTypeChecker(),
+        singleThreaded:     opts.singleThreaded,
+        checkers:           opts.checkers,
+        tsgoArgs:           opts.tsgoArgs,
+        projectIdentity:    opts.projectIdentity,
       },
     )
     if err != nil {

package/linthost/compile.go

@@ -74,6 +74,7 @@ func RunTransform(args []string) int {
 
 // RunTransformWithIO runs transform with invocation-owned output streams.
 func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
+  semanticConfigPath := os.Getenv(semanticConfigPathEnv)
   fs := flag.NewFlagSet("transform", flag.ContinueOnError)
   fs.SetOutput(stderr)
   file := fs.String("file", "", "absolute or cwd-relative path of the .ts file to transform")
@@ -122,12 +123,13 @@ func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
   engine.SetSerial(*singleThreaded)
 
   prog, parseDiags, err := loadProgram(resolvedCwd, *tsconfig, loadProgramOptions{
-    forceEmit:        true,
-    needsRuleChecker: engine.NeedsTypeChecker(),
-    singleThreaded:   *singleThreaded,
-    checkers:         *checkers,
-    tsgoArgs:         tsgoArgs,
-    projectIdentity:  projectIdentity,
+    forceEmit:          true,
+    semanticConfigPath: semanticConfigPath,
+    needsRuleChecker:   engine.NeedsTypeChecker(),
+    singleThreaded:     *singleThreaded,
+    checkers:           *checkers,
+    tsgoArgs:           tsgoArgs,
+    projectIdentity:    projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(stderr, "@ttsc/lint: %v\n", err)
@@ -201,21 +203,22 @@ func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
 }
 
 type subcommandOpts struct {
-  cwd             string
-  tsconfig        string
-  pluginsJSON     string
-  emit            bool
-  noEmit          bool
-  quiet           bool
-  verbose         bool
-  diagnostics     bool
-  outDir          string
-  singleThreaded  bool
-  checkers        int
-  tsgoArgs        []string
-  projectIdentity publicrule.ProjectIdentity
-  stdout          io.Writer
-  stderr          io.Writer
+  cwd                string
+  tsconfig           string
+  pluginsJSON        string
+  emit               bool
+  noEmit             bool
+  quiet              bool
+  verbose            bool
+  diagnostics        bool
+  outDir             string
+  semanticConfigPath string
+  singleThreaded     bool
+  checkers           int
+  tsgoArgs           []string
+  projectIdentity    publicrule.ProjectIdentity
+  stdout             io.Writer
+  stderr             io.Writer
 }
 
 // parseSubcommandFlags parses the shared flag set used by the `check`,
@@ -226,6 +229,7 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
 }
 
 func parseSubcommandFlagsWithIO(name string, args []string, stdout, stderr io.Writer) (*subcommandOpts, error) {
+  semanticConfigPath := os.Getenv(semanticConfigPathEnv)
   if stdout == nil {
     stdout = io.Discard
   }
@@ -267,21 +271,22 @@ func parseSubcommandFlagsWithIO(name string, args []string, stdout, stderr io.Wr
     return nil, err
   }
   return &subcommandOpts{
-    cwd:             resolvedCwd,
-    tsconfig:        *tsconfig,
-    pluginsJSON:     *pluginsJSON,
-    emit:            *emit,
-    noEmit:          *noEmit,
-    quiet:           *quiet,
-    verbose:         *verbose,
-    diagnostics:     *diagnostics || *extendedDiagnostics,
-    outDir:          *outDir,
-    singleThreaded:  *singleThreaded,
-    checkers:        *checkers,
-    tsgoArgs:        tsgoArgs,
-    projectIdentity: projectIdentity,
-    stdout:          stdout,
-    stderr:          stderr,
+    cwd:                resolvedCwd,
+    tsconfig:           *tsconfig,
+    pluginsJSON:        *pluginsJSON,
+    emit:               *emit,
+    noEmit:             *noEmit,
+    quiet:              *quiet,
+    verbose:            *verbose,
+    diagnostics:        *diagnostics || *extendedDiagnostics,
+    outDir:             *outDir,
+    semanticConfigPath: semanticConfigPath,
+    singleThreaded:     *singleThreaded,
+    checkers:           *checkers,
+    tsgoArgs:           tsgoArgs,
+    projectIdentity:    projectIdentity,
+    stdout:             stdout,
+    stderr:             stderr,
   }, nil
 }
 
@@ -332,14 +337,15 @@ func runProject(opts *subcommandOpts) int {
   engine.SetSerial(opts.singleThreaded)
 
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceEmit:        opts.emit,
-    forceNoEmit:      opts.noEmit,
-    outDir:           opts.outDir,
-    needsRuleChecker: engine.NeedsTypeChecker(),
-    singleThreaded:   opts.singleThreaded,
-    checkers:         opts.checkers,
-    tsgoArgs:         opts.tsgoArgs,
-    projectIdentity:  opts.projectIdentity,
+    forceEmit:          opts.emit,
+    forceNoEmit:        opts.noEmit,
+    outDir:             opts.outDir,
+    semanticConfigPath: opts.semanticConfigPath,
+    needsRuleChecker:   engine.NeedsTypeChecker(),
+    singleThreaded:     opts.singleThreaded,
+    checkers:           opts.checkers,
+    tsgoArgs:           opts.tsgoArgs,
+    projectIdentity:    opts.projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(opts.stderr, "@ttsc/lint: %v\n", err)

package/linthost/fix.go

@@ -143,13 +143,14 @@ func runFix(opts *subcommandOpts) int {
 // NoEmit forced on. Returns (nil, 2) when loading or config parsing fails.
 func loadFixProgram(opts *subcommandOpts, needsRuleChecker bool) (*program, int) {
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceNoEmit:      true,
-    outDir:           opts.outDir,
-    needsRuleChecker: needsRuleChecker,
-    singleThreaded:   opts.singleThreaded,
-    checkers:         opts.checkers,
-    tsgoArgs:         opts.tsgoArgs,
-    projectIdentity:  opts.projectIdentity,
+    forceNoEmit:        true,
+    outDir:             opts.outDir,
+    semanticConfigPath: opts.semanticConfigPath,
+    needsRuleChecker:   needsRuleChecker,
+    singleThreaded:     opts.singleThreaded,
+    checkers:           opts.checkers,
+    tsgoArgs:           opts.tsgoArgs,
+    projectIdentity:    opts.projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)

package/linthost/host.go

@@ -33,6 +33,11 @@ import (
 
 var programLifecycleSequence atomic.Uint64
 
+// semanticConfigPathEnv mirrors `driver.SemanticConfigPathEnv`: the internal
+// channel that identifies the user-authored config behind a generated wrapper.
+// This module cannot import the ttsc driver; see the package boundary above.
+const semanticConfigPathEnv = "TTSC_SEMANTIC_CONFIG_PATH"
+
 // program bundles the tsgo Program with the parsed config and the standalone
 // checker used only by type-aware lint rules.
 type program struct {
@@ -54,9 +59,10 @@ type program struct {
 }
 
 type loadProgramOptions struct {
-  forceEmit   bool
-  forceNoEmit bool
-  outDir      string
+  forceEmit          bool
+  forceNoEmit        bool
+  outDir             string
+  semanticConfigPath string
   // needsRuleChecker asks loadProgram to create the standalone checker that
   // type-aware lint rules receive through Context.Checker.
   needsRuleChecker bool
@@ -118,6 +124,9 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
   if len(parsed.Errors) > 0 {
     return nil, parsed.Errors, nil
   }
+  if err := applySemanticConfigPath(parsed, options.semanticConfigPath); err != nil {
+    return nil, nil, err
+  }
   if options.forceNoEmit {
     forceNoEmit(parsed)
   }
@@ -158,6 +167,18 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
   }, nil, nil
 }
 
+func applySemanticConfigPath(parsed *tsoptions.ParsedCommandLine, semanticConfigPath string) error {
+  configured := strings.TrimSpace(semanticConfigPath)
+  if configured == "" {
+    return nil
+  }
+  if !filepath.IsAbs(configured) {
+    return fmt.Errorf("linthost: semantic config path must be absolute: %s", configured)
+  }
+  parsed.ParsedConfig.CompilerOptions.ConfigFilePath = shimtspath.ResolvePath(configured)
+  return nil
+}
+
 func normalizeProjectIdentity(
   identity publicrule.ProjectIdentity,
   cwd string,

package/linthost/lsp.go

@@ -145,10 +145,11 @@ type lspCommandOptions struct {
   pluginsJSON  string
   // rangeJSON carries the editor selection used to limit quickfix.ttsc
   // actions. Source fix-all and format actions remain document-wide.
-  rangeJSON       string
-  tsconfig        string
-  uri             string
-  projectIdentity publicrule.ProjectIdentity
+  rangeJSON          string
+  semanticConfigPath string
+  tsconfig           string
+  uri                string
+  projectIdentity    publicrule.ProjectIdentity
 }
 
 // lspCommandIDs is the workspace/executeCommand ids owned by @ttsc/lint, shared
@@ -424,16 +425,17 @@ func parseLSPCommandOptions(name string, args []string) (*lspCommandOptions, boo
     return nil, false
   }
   return &lspCommandOptions{
-    argumentsJSON:   *argumentsJSON,
-    command:         *command,
-    contextJSON:     *contextJSON,
-    contentStdin:    *contentStdin,
-    cwd:             resolvedCwd,
-    pluginsJSON:     *pluginsJSON,
-    rangeJSON:       *rangeJSON,
-    tsconfig:        *tsconfig,
-    uri:             *uri,
-    projectIdentity: projectIdentity,
+    argumentsJSON:      *argumentsJSON,
+    command:            *command,
+    contextJSON:        *contextJSON,
+    contentStdin:       *contentStdin,
+    cwd:                resolvedCwd,
+    pluginsJSON:        *pluginsJSON,
+    rangeJSON:          *rangeJSON,
+    semanticConfigPath: os.Getenv(semanticConfigPathEnv),
+    tsconfig:           *tsconfig,
+    uri:                *uri,
+    projectIdentity:    projectIdentity,
   }, true
 }
 

package/linthost/rules_format_print_width.go

@@ -187,6 +187,19 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
     return
   }
 
+  // Abstain on any uncontrolled reflow target nested below a binary
+  // expression. The structured printer does not own BinaryExpression, so
+  // independently flattening or breaking its child calls and value literals
+  // can change whether the complete binary line fits. The next cascade pass
+  // then reverses those child decisions and `ttsc format` oscillates to the
+  // 10-pass cap. A destructuring assignment target may skip only its directly
+  // owning `=` because the literal printer owns the complete left-hand list and
+  // charges the `= value` suffix. Any binary ancestor above that assignment
+  // remains uncontrolled.
+  if hasUncontrolledBinaryExpressionAncestor(node) {
+    return
+  }
+
   // Abstain on any node nested inside a template-literal substitution.
   // Prettier renders `${…}` expressions at printWidth:Infinity, it
   // never breaks an interpolation the source wrote on one line, so
@@ -505,6 +518,31 @@ func hasReflowAncestor(node *shimast.Node) bool {
   return false
 }
 
+// hasUncontrolledBinaryExpressionAncestor reports whether `node` is a fragment
+// of a binary expression whose layout it cannot own. A destructuring assignment
+// target may skip its owning `=` because the literal printer owns that complete
+// left-hand list, but an enclosing binary expression remains uncontrolled.
+func hasUncontrolledBinaryExpressionAncestor(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  skipOwningAssignment := isDestructuringAssignmentTarget(node)
+  child := node
+  for parent := node.Parent; parent != nil; parent = parent.Parent {
+    if parent.Kind == shimast.KindBinaryExpression {
+      expression := parent.AsBinaryExpression()
+      if skipOwningAssignment && expression != nil && expression.OperatorToken != nil &&
+        expression.OperatorToken.Kind == shimast.KindEqualsToken && expression.Left == child {
+        skipOwningAssignment = false
+      } else {
+        return true
+      }
+    }
+    child = parent
+  }
+  return false
+}
+
 // hasTemplateSubstitutionAncestor reports whether `node` sits inside a
 // template-literal substitution (`${…}`). formatPrintWidth abstains
 // on such nodes: Prettier prints template interpolations at infinite

package/linthost/serve.go

@@ -80,9 +80,10 @@ func (c *residentProgramCache) acquire(
     }
   }
   prog, diags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceNoEmit:      true,
-    needsRuleChecker: needsChecker,
-    projectIdentity:  opts.projectIdentity,
+    forceNoEmit:        true,
+    needsRuleChecker:   needsChecker,
+    projectIdentity:    opts.projectIdentity,
+    semanticConfigPath: opts.semanticConfigPath,
   })
   if err != nil {
     return nil, nil, noopClose, err
@@ -172,9 +173,10 @@ func acquireProgram(
     return residentPrograms.acquire(opts, needsChecker)
   }
   prog, diags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceNoEmit:      true,
-    needsRuleChecker: needsChecker,
-    projectIdentity:  opts.projectIdentity,
+    forceNoEmit:        true,
+    needsRuleChecker:   needsChecker,
+    projectIdentity:    opts.projectIdentity,
+    semanticConfigPath: opts.semanticConfigPath,
   })
   if prog == nil {
     return prog, diags, noopClose, err

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.28.4",
+  "version": "0.28.6",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -37,7 +37,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.28.4"
+    "ttsc": "0.28.6"
   },
   "repository": {
     "type": "git",