@ttsc/lint 0.25.0 → 0.26.0

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.25.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.25.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

package/src/structures/rules/ITtscLintFunctionalRuleOptions.ts

@@ -80,24 +80,45 @@ export interface ITtscLintFunctionalNoThrowStatementsRuleOptions {
 
 /** `functional/no-mixed-types` rule options. */
 export interface ITtscLintFunctionalNoMixedTypesRuleOptions {
-  /** Check interface member kinds. */
+  /**
+   * Check interface member kinds.
+   *
+   * @default true
+   */
   checkInterfaces?: boolean;
 
-  /** Check type-literal member kinds. */
+  /**
+   * Check type-literal member kinds.
+   *
+   * @default true
+   */
   checkTypeLiterals?: boolean;
 }
 
 /** `functional/no-return-void` rule options. */
 export interface ITtscLintFunctionalNoReturnVoidRuleOptions {
-  /** Permit a function that returns `null` to satisfy the rule. */
+  /**
+   * Permit a function whose declared return type is `null`. Set `false` to
+   * reject it the way a declared `void` is rejected.
+   *
+   * @default true
+   */
   allowNull?: boolean;
 
-  /** Permit a function that returns `undefined` to satisfy the rule. */
+  /**
+   * Permit a function whose declared return type is `undefined`. Set `false` to
+   * reject it the way a declared `void` is rejected.
+   *
+   * @default true
+   */
   allowUndefined?: boolean;
 
   /**
-   * Skip functions whose return type is inferred to be `void` rather than
-   * declared explicitly.
+   * Skip a bare `return;` inside a function that declares no return type. That
+   * statement is the one place the rule rejects a void-ness it inferred rather
+   * than read from an annotation.
+   *
+   * @default false
    */
   ignoreInferredTypes?: boolean;
 }
@@ -105,7 +126,8 @@ export interface ITtscLintFunctionalNoReturnVoidRuleOptions {
 /** `functional/prefer-immutable-types` rule options. */
 export interface ITtscLintFunctionalPreferImmutableTypesRuleOptions extends ITtscLintFunctionalPatternOptions {
   /**
-   * Minimum accepted immutability. The native subset treats any configured
+   * Minimum accepted immutability. Reserved for upstream-compatible configs;
+   * the native subset computes no immutability level and treats any configured
    * value as readonly-required.
    */
   enforcement?:
@@ -118,31 +140,62 @@ export interface ITtscLintFunctionalPreferImmutableTypesRuleOptions extends ITts
 
 /** `functional/prefer-readonly-type` rule options. */
 export interface ITtscLintFunctionalPreferReadonlyTypeRuleOptions extends ITtscLintFunctionalPatternOptions {
-  /** Permit mutation of locals while still policing exported types. */
+  /**
+   * Permit mutation of locals while still policing exported types. Reserved for
+   * upstream-compatible configs; the native subset reads type annotations and
+   * models no local-versus-exported distinction.
+   */
   allowLocalMutation?: boolean;
 
-  /** Permit a mutable return type even when parameters must be readonly. */
+  /**
+   * Permit a mutable return type even when parameters must be readonly. Covers
+   * every signature that can declare one, including call and construct
+   * signatures, constructor types, and a get accessor.
+   *
+   * @default false
+   */
   allowMutableReturnType?: boolean;
 
-  /** Also check property positions that have no explicit type annotation. */
+  /**
+   * Also check property positions that have no explicit type annotation.
+   * Reserved for upstream-compatible configs; judging an unannotated position
+   * needs the type checker, which this rule does not use.
+   */
   checkImplicit?: boolean;
 
-  /** Skip array / tuple / `Map` / `Set` types. */
+  /**
+   * Skip array / tuple / `Map` / `Set` types.
+   *
+   * @default false
+   */
   ignoreCollections?: boolean;
 
   /**
-   * Skip class fields. `"fieldsOnly"` keeps the rule active for non-field class
-   * members.
+   * Skip class members. `true` skips anything under a class, its heritage
+   * clause and type parameters included; `"fieldsOnly"` narrows that to field
+   * declarations and keeps methods, accessors, and constructor parameters
+   * checked.
+   *
+   * @default false
    */
   ignoreClass?: boolean | "fieldsOnly";
 
-  /** Skip interface members entirely. */
+  /**
+   * Skip interface members entirely.
+   *
+   * @default false
+   */
   ignoreInterface?: boolean;
 }
 
 /** `functional/prefer-tacit` rule options. */
 export interface ITtscLintFunctionalPreferTacitRuleOptions {
-  /** Check member expressions such as `x => service.map(x)`. */
+  /**
+   * Check member expressions such as `x => service.map(x)`. Set `false` to keep
+   * the rule on bare-identifier callees only.
+   *
+   * @default true
+   */
   checkMemberExpressions?: boolean;
 }
 
@@ -167,7 +220,11 @@ export interface ITtscLintFunctionalTypeDeclarationImmutabilityRule {
    */
   immutability?: "ReadonlyShallow" | "ReadonlyDeep" | "Immutable" | "Mutable";
 
-  /** Comparator applied to the immutability level above. */
+  /**
+   * Comparator applied to the immutability level above. Reserved for
+   * upstream-compatible configs alongside `immutability`: the native subset
+   * computes no immutability level, so there is nothing to compare.
+   */
   comparator?:
     | "Less"
     | "AtMost"