@ttsc/lint 0.24.0 → 0.26.0

package/linthost/rules_format_parameter_properties.go

@@ -10,9 +10,8 @@ import (
 // formatParameterProperties breaks a constructor's parameter list onto
 // one-parameter-per-line when it declares parameter properties, matching
 // Prettier 3. Prettier forces the break whenever a constructor has more
-// than one parameter and at least one carries an accessibility or
-// `readonly` modifier (a parameter property), regardless of whether the
-// flat form fits printWidth:
+// than one parameter and at least one carries a parameter-property
+// modifier, regardless of whether the flat form fits printWidth:
 //
 //  constructor(
 //    private readonly repo: Repository,
@@ -155,26 +154,15 @@ func (formatParameterProperties) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// anyParameterProperty reports whether any parameter carries an
-// accessibility (`public`/`private`/`protected`) or `readonly` modifier,
-// which makes it a parameter property.
+// anyParameterProperty reports whether any parameter is a parameter property.
+// It defers to the package's shared `isParameterProperty` so one definition
+// answers the question for every rule that asks it; restating the modifier set
+// here is what left `override` out and made this rule abstain on a legal
+// parameter property Prettier breaks.
 func anyParameterProperty(params []*shimast.Node) bool {
   for _, p := range params {
-    if p == nil {
-      continue
-    }
-    mods := p.Modifiers()
-    if mods == nil {
-      continue
-    }
-    for _, m := range mods.Nodes {
-      switch m.Kind {
-      case shimast.KindPublicKeyword,
-        shimast.KindPrivateKeyword,
-        shimast.KindProtectedKeyword,
-        shimast.KindReadonlyKeyword:
-        return true
-      }
+    if isParameterProperty(p) {
+      return true
     }
   }
   return false

package/linthost/rules_format_whitespace.go

@@ -311,7 +311,11 @@ func collectTemplateRanges(file *shimast.SourceFile, src string) []byteRange {
       return
     }
     switch node.Kind {
-    case shimast.KindNoSubstitutionTemplateLiteral, shimast.KindTemplateExpression:
+    case shimast.KindNoSubstitutionTemplateLiteral,
+      shimast.KindTemplateExpression,
+      // A template literal TYPE spans head plus spans like the expression form
+      // and its newlines are equally part of the declared type's text.
+      shimast.KindTemplateLiteralType:
       pos := shimscanner.SkipTrivia(src, node.Pos())
       end := node.End()
       if pos >= 0 && end <= len(src) && end > pos {

package/linthost/rules_functional.go

@@ -143,6 +143,34 @@ type functionalNoTryOptions struct {
   AllowFinally bool `json:"allowFinally"`
 }
 
+// functionalNoMixedTypesOptions gates the two container kinds the rule visits.
+// Both default to true (an absent key leaves the container checked), so the
+// pointers distinguish "not configured" from an explicit false.
+type functionalNoMixedTypesOptions struct {
+  CheckInterfaces   *bool `json:"checkInterfaces"`
+  CheckTypeLiterals *bool `json:"checkTypeLiterals"`
+}
+
+// functionalNoReturnVoidOptions narrows what counts as a rejected return.
+//
+// `allowNull` and `allowUndefined` default to true, matching the rule's
+// existing behavior: only a declared `void` return type is rejected. Setting
+// either to false extends the rejection to that declared return type.
+// `ignoreInferredTypes` defaults to false and, when true, spares a bare
+// `return;` whose enclosing function declares no return type, which is the one
+// place the rule reports a void-ness it inferred rather than read.
+type functionalNoReturnVoidOptions struct {
+  AllowNull           *bool `json:"allowNull"`
+  AllowUndefined      *bool `json:"allowUndefined"`
+  IgnoreInferredTypes bool  `json:"ignoreInferredTypes"`
+}
+
+// functionalPreferTacitOptions gates the member-expression callee shape.
+// Defaults to true, keeping `x => service.handler(x)` reported as before.
+type functionalPreferTacitOptions struct {
+  CheckMemberExpressions *bool `json:"checkMemberExpressions"`
+}
+
 type functionalImmutableDataOptions struct {
   functionalPatternOptions
   IgnoreMapsAndSets bool `json:"ignoreMapsAndSets"`
@@ -159,8 +187,15 @@ type functionalPreferImmutableTypesOptions struct {
   functionalPatternOptions
 }
 
+// functionalPreferReadonlyTypeOptions narrows which positions the rule polices.
+// Both gates default to off, so an absent key leaves every visited position
+// checked exactly as before.
 type functionalPreferReadonlyTypeOptions struct {
   functionalPatternOptions
+  AllowMutableReturnType bool        `json:"allowMutableReturnType"`
+  IgnoreClass            interface{} `json:"ignoreClass"`
+  IgnoreCollections      bool        `json:"ignoreCollections"`
+  IgnoreInterface        bool        `json:"ignoreInterface"`
 }
 
 type functionalReadonlyTypeOptions struct {
@@ -332,6 +367,18 @@ func (functionalNoLoopStatements) Check(ctx *Context, node *shimast.Node) {
 }
 
 func (functionalNoMixedTypes) Check(ctx *Context, node *shimast.Node) {
+  var opts functionalNoMixedTypesOptions
+  _ = ctx.DecodeOptions(&opts)
+  switch node.Kind {
+  case shimast.KindInterfaceDeclaration:
+    if opts.CheckInterfaces != nil && !*opts.CheckInterfaces {
+      return
+    }
+  case shimast.KindTypeLiteral:
+    if opts.CheckTypeLiterals != nil && !*opts.CheckTypeLiterals {
+      return
+    }
+  }
   members := containerMembers(node)
   if len(members) < 2 {
     return
@@ -361,16 +408,51 @@ func (functionalNoPromiseReject) Check(ctx *Context, node *shimast.Node) {
 }
 
 func (functionalNoReturnVoid) Check(ctx *Context, node *shimast.Node) {
+  var opts functionalNoReturnVoidOptions
+  _ = ctx.DecodeOptions(&opts)
   if node.Kind == shimast.KindReturnStatement {
     ret := node.AsReturnStatement()
-    if ret != nil && ret.Expression == nil {
-      ctx.Report(node, "Function must return a value.")
+    if ret == nil || ret.Expression != nil {
+      return
+    }
+    if opts.IgnoreInferredTypes && functionalEnclosingReturnTypeText(ctx, node) == "" {
+      return
     }
+    ctx.Report(node, "Function must return a value.")
     return
   }
-  if functionalReturnTypeText(ctx, node) == "void" {
+  switch functionalReturnTypeText(ctx, node) {
+  case "void":
     ctx.Report(node, "Function must return a value.")
+  case "null":
+    if opts.AllowNull != nil && !*opts.AllowNull {
+      ctx.Report(node, "Function must return a value.")
+    }
+  case "undefined":
+    if opts.AllowUndefined != nil && !*opts.AllowUndefined {
+      ctx.Report(node, "Function must return a value.")
+    }
+  }
+}
+
+// functionalEnclosingReturnTypeText returns the declared return type text of the
+// nearest function-like ancestor of `node`, or "" when that function declares
+// none. A bare `return;` there is the only place the rule reports a void-ness it
+// inferred instead of reading, which is what `ignoreInferredTypes` spares.
+//
+// The walk stops at the nearest function-like of ANY kind. Skipping a
+// constructor or a set accessor, neither of which may annotate a return type,
+// would attribute an enclosing function's annotation to a `return;` that has
+// nothing to do with it. A get accessor may annotate one, and
+// functionalReturnTypeText reads it.
+func functionalEnclosingReturnTypeText(ctx *Context, node *shimast.Node) string {
+  for parent := node.Parent; parent != nil; parent = parent.Parent {
+    if !isFunctionLikeKind(parent) {
+      continue
+    }
+    return functionalReturnTypeText(ctx, parent)
   }
+  return ""
 }
 
 func (functionalNoThisExpressions) Check(ctx *Context, node *shimast.Node) {
@@ -418,6 +500,20 @@ func (functionalPreferPropertySignatures) Check(ctx *Context, node *shimast.Node
 func (functionalPreferReadonlyType) Check(ctx *Context, node *shimast.Node) {
   var opts functionalPreferReadonlyTypeOptions
   _ = ctx.DecodeOptions(&opts)
+  if opts.IgnoreInterface && hasAncestor(node, func(ancestor *shimast.Node) bool {
+    return ancestor.Kind == shimast.KindInterfaceDeclaration
+  }) {
+    return
+  }
+  if functionalIgnoreClassSkips(opts.IgnoreClass, node) {
+    return
+  }
+  if opts.AllowMutableReturnType && isFunctionLikeReturnTypePosition(node) {
+    return
+  }
+  if opts.IgnoreCollections && isFunctionalCollectionTypeNode(node) {
+    return
+  }
   switch node.Kind {
   case shimast.KindArrayType:
     if !isReadonlyTypeNode(node) {
@@ -451,10 +547,33 @@ func (functionalPreferReadonlyType) Check(ctx *Context, node *shimast.Node) {
 }
 
 func (functionalPreferTacit) Check(ctx *Context, node *shimast.Node) {
+  var opts functionalPreferTacitOptions
+  _ = ctx.DecodeOptions(&opts)
   text := compactFunctionalWhitespace(nodeText(ctx.File, node))
-  if isTacitWrapperText(text) {
-    ctx.Report(node, "Potentially unnecessary function wrapper.")
+  if !isTacitWrapperText(text) {
+    return
+  }
+  if opts.CheckMemberExpressions != nil && !*opts.CheckMemberExpressions &&
+    isTacitWrapperMemberCallee(text) {
+    return
   }
+  ctx.Report(node, "Potentially unnecessary function wrapper.")
+}
+
+// isTacitWrapperMemberCallee reports whether the wrapper's callee is a member
+// expression (`service.handler`) rather than a bare identifier. `text` has
+// already satisfied isTacitWrapperText, so the split and the `(` are present.
+func isTacitWrapperMemberCallee(text string) bool {
+  parts := strings.Split(text, "=>")
+  if len(parts) != 2 {
+    return false
+  }
+  call := parts[1]
+  open := strings.LastIndex(call, "(")
+  if open <= 0 {
+    return false
+  }
+  return strings.Contains(call[:open], ".")
 }
 
 func (functionalReadonlyType) Check(ctx *Context, node *shimast.Node) {
@@ -595,27 +714,12 @@ func isDeclarationName(node *shimast.Node) bool {
   }
 }
 
+// functionalReturnTypeText returns the declared return-type text of a
+// signature-bearing node, or "" when it declares none. It reads the same
+// signature table isFunctionLikeReturnTypePosition uses, so a get accessor is
+// not mistaken for a declaration that cannot annotate its return type.
 func functionalReturnTypeText(ctx *Context, node *shimast.Node) string {
-  var typeNode *shimast.Node
-  switch node.Kind {
-  case shimast.KindFunctionDeclaration:
-    if decl := node.AsFunctionDeclaration(); decl != nil {
-      typeNode = decl.Type
-    }
-  case shimast.KindFunctionExpression:
-    if decl := node.AsFunctionExpression(); decl != nil {
-      typeNode = decl.Type
-    }
-  case shimast.KindArrowFunction:
-    if decl := node.AsArrowFunction(); decl != nil {
-      typeNode = decl.Type
-    }
-  case shimast.KindMethodDeclaration:
-    if decl := node.AsMethodDeclaration(); decl != nil {
-      typeNode = decl.Type
-    }
-  }
-  return strings.TrimSpace(nodeText(ctx.File, typeNode))
+  return strings.TrimSpace(nodeText(ctx.File, signatureReturnTypeNode(node)))
 }
 
 func functionalFunctionLikeName(node *shimast.Node) string {
@@ -757,6 +861,125 @@ func nilSafeFile(node *shimast.Node) *shimast.SourceFile {
   return nil
 }
 
+// isFunctionLikeReturnTypePosition reports whether `node` is the return-type
+// annotation of any signature-bearing declaration, or sits inside one. The rule
+// visits type nodes, so a mutable array nested in the return type is the same
+// position as the return type itself.
+//
+// Every kind that can carry a return-type annotation is listed: leaving call
+// signatures, construct signatures, constructor types, or a get accessor out
+// would let the same option answer differently for the same position depending
+// on how the signature was spelled.
+func isFunctionLikeReturnTypePosition(node *shimast.Node) bool {
+  for current := node; current != nil && current.Parent != nil; current = current.Parent {
+    typeNode := signatureReturnTypeNode(current.Parent)
+    if typeNode != nil && typeNode == current {
+      return true
+    }
+  }
+  return false
+}
+
+// signatureReturnTypeNode returns the declared return-type node of `node`, or
+// nil when `node` carries no signature or declares no return type.
+//
+// Do not replace this table with typescript-go's own FunctionLikeData().Type:
+// an index signature embeds the same base, so that accessor also returns the
+// value type of `{ [k: string]: string[] }`, which is not a return type. The
+// three kinds this table omits, a constructor, a set accessor, and an index
+// signature, are exactly the ones whose Type field means something else.
+func signatureReturnTypeNode(node *shimast.Node) *shimast.Node {
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    if decl := node.AsFunctionDeclaration(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindFunctionExpression:
+    if decl := node.AsFunctionExpression(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindArrowFunction:
+    if decl := node.AsArrowFunction(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindMethodDeclaration:
+    if decl := node.AsMethodDeclaration(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindMethodSignature:
+    if decl := node.AsMethodSignatureDeclaration(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindGetAccessor:
+    if decl := node.AsGetAccessorDeclaration(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindFunctionType:
+    if decl := node.AsFunctionTypeNode(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindConstructorType:
+    if decl := node.AsConstructorTypeNode(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindCallSignature:
+    if decl := node.AsCallSignatureDeclaration(); decl != nil {
+      return decl.Type
+    }
+  case shimast.KindConstructSignature:
+    if decl := node.AsConstructSignatureDeclaration(); decl != nil {
+      return decl.Type
+    }
+  }
+  return nil
+}
+
+// isFunctionalClassMemberPosition reports whether `node` sits inside a class,
+// and whether that position is a field. `ignoreClass: true` skips anything
+// under a class, its heritage clause and type parameters included, the same
+// ancestor test `ignoreInterface` applies. `"fieldsOnly"` narrows that to field
+// declarations, leaving methods, accessors, and constructor parameters checked.
+func isFunctionalClassMemberPosition(node *shimast.Node) (inClass bool, inField bool) {
+  for parent := node.Parent; parent != nil; parent = parent.Parent {
+    switch parent.Kind {
+    case shimast.KindPropertyDeclaration:
+      inField = true
+    case shimast.KindClassDeclaration, shimast.KindClassExpression:
+      return true, inField
+    }
+  }
+  return false, false
+}
+
+// functionalIgnoreClassSkips resolves the `boolean | "fieldsOnly"` option
+// against a visited node's class position.
+func functionalIgnoreClassSkips(option interface{}, node *shimast.Node) bool {
+  if option == nil || option == false {
+    return false
+  }
+  inClass, inField := isFunctionalClassMemberPosition(node)
+  if !inClass {
+    return false
+  }
+  if option == "fieldsOnly" {
+    return inField
+  }
+  return option == true
+}
+
+// isFunctionalCollectionTypeNode reports whether `node` is an array, tuple, or
+// mutable built-in collection reference, the set `ignoreCollections` spares.
+func isFunctionalCollectionTypeNode(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindArrayType, shimast.KindTupleType:
+    return true
+  case shimast.KindTypeReference:
+    return isMutableTypeReference(node)
+  default:
+    return false
+  }
+}
+
 func isMutableTypeReference(node *shimast.Node) bool {
   ref := node.AsTypeReferenceNode()
   if ref == nil || ref.TypeName == nil {

package/linthost/rules_ts_extra.go

@@ -317,12 +317,14 @@ func parameterPropertyName(param *shimast.Node) (string, bool) {
   return name, name != ""
 }
 
+// isParameterProperty is the package's shared parameter-property predicate.
+// The compiler's own mask is the source: a restated keyword list is what left
+// `override` out of format/parameter-properties (#1131), and this predicate
+// feeds six rules, so a restatement here would be five more chances at the same
+// drift.
 func isParameterProperty(param *shimast.Node) bool {
-  return hasModifier(param, shimast.KindPublicKeyword) ||
-    hasModifier(param, shimast.KindPrivateKeyword) ||
-    hasModifier(param, shimast.KindProtectedKeyword) ||
-    hasModifier(param, shimast.KindReadonlyKeyword) ||
-    hasModifier(param, shimast.KindOverrideKeyword)
+  return param != nil &&
+    param.ModifierFlags()&shimast.ModifierFlagsParameterPropertyModifier != 0
 }
 
 func thisPropertyAssignment(stmt *shimast.Node) (property string, value string, ok bool) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "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.24.0"
+    "ttsc": "0.26.0"
   },
   "repository": {
     "type": "git",

package/rule/rule.go

@@ -262,15 +262,27 @@ type RelatedInformation struct {
 // be replaced as a whole.
 //
 // Application policy: a rule may emit several `TextEdit`s in one
-// `ReportFix` / `ReportRangeFix` call, in any order. The host treats the
-// per-pass edit set as a candidate list. Within a single fix pass, edits
-// must not overlap each other; when two edits cover overlapping ranges
-// (either from one rule emitting multiple edits in one call, or from two
-// different rules in the same pass), the host applies the earliest-starting
-// / shortest edit and silently drops the rest. There is no diagnostic for
-// dropped edits, and the host does not currently report when a comment
-// falls inside a deletion range. Design fixes so each finding emits one
-// contiguous TextEdit covering the entire replacement region.
+// `ReportFix` / `ReportRangeFix` call, in any order. The unit the host
+// resolves conflicts on is the FINDING, not the individual edit. Within one
+// fix pass the host considers each finding's edits as one group, earliest
+// group first, and accepts a group only when every member coexists with the
+// edits already accepted. If any member would be dropped, the whole group is
+// skipped, so a multi-edit fix never half-applies. The skipped finding is not
+// lost: the next cascade pass re-runs the rule against the rewritten source
+// and the fix applies then, or the cascade converges without it.
+//
+// A finding's own edits must therefore not overlap each other either, or the
+// finding can never apply. Exact duplicates within one finding are collapsed
+// rather than treated as a conflict, so repeating an identical edit is
+// harmless. Nothing diagnoses a skipped group, and the host does not report
+// when a comment falls inside a deletion range.
+//
+// Emit the narrowest edits that express the rewrite. Several small
+// non-overlapping edits contend for less source than one wide replacement and
+// are the shape the atomic applier exists to support. Built-ins that ship
+// multi-edit fixes include `typescript/no-import-type-side-effects`,
+// `format/whitespace`, `format/indent`, `unicorn/prevent-abbreviations`, and
+// `unicorn/template-indent`.
 type TextEdit struct {
   Pos  int
   End  int