@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_strings.go

@@ -6,7 +6,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// no-template-curly-in-string: a regular string contains `${...}`. The
+// noTemplateCurlyInString: a regular string contains `${...}`. The
 // developer probably meant a template literal.
 // https://eslint.org/docs/latest/rules/no-template-curly-in-string
 type noTemplateCurlyInString struct{}
@@ -45,7 +45,7 @@ func hasTemplatePlaceholder(text string) bool {
   return false
 }
 
-// no-multi-str: `"line one \\n line two"` style backslash continuations.
+// noMultiStr: `"line one \\n line two"` style backslash continuations.
 // TS strips them silently and the result is rarely what the author meant.
 // https://eslint.org/docs/latest/rules/no-multi-str
 type noMultiStr struct{}
@@ -75,7 +75,7 @@ func hasBackslashLineContinuation(src string) bool {
   return false
 }
 
-// no-useless-concat: `"a" + "b"` of two literals. The compiler can't
+// noUselessConcat: `"a" + "b"` of two literals. The compiler can't
 // constant-fold every case, but this catches the obvious shapes.
 // https://eslint.org/docs/latest/rules/no-useless-concat
 type noUselessConcat struct{}
@@ -109,7 +109,7 @@ func isStringLikeLiteral(node *shimast.Node) bool {
   return false
 }
 
-// no-octal: `010` octal literal. Has to be opt-in via `0o10` in
+// noOctal: `010` octal literal. Has to be opt-in via `0o10` in
 // modern code; the legacy form is silently confusing.
 // https://eslint.org/docs/latest/rules/no-octal
 type noOctal struct{}

package/linthost/rules_suggestions.go

@@ -10,7 +10,7 @@ import (
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// no-alert: `alert()` / `confirm()` / `prompt()`. Rarely the right
+// noAlert: `alert()` / `confirm()` / `prompt()`. Rarely the right
 // answer in production code.
 type noAlert struct{}
 
@@ -27,7 +27,7 @@ func (noAlert) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-bitwise: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>` — almost always a
+// noBitwise: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>` — almost always a
 // typo for the boolean-logic operators.
 type noBitwise struct{}
 
@@ -67,7 +67,7 @@ func (noBitwise) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-caller: `arguments.caller` / `arguments.callee` — strict-mode
+// noCaller: `arguments.caller` / `arguments.callee` — strict-mode
 // errors elsewhere; lint catches them earlier.
 type noCaller struct{}
 
@@ -87,7 +87,7 @@ func (noCaller) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-case-declarations: `switch (x) { case 1: let y = 2; break; }` —
+// noCaseDeclarations: `switch (x) { case 1: let y = 2; break; }` —
 // block-scoped declarations leak across case labels.
 type noCaseDeclarations struct{}
 
@@ -118,7 +118,7 @@ func (noCaseDeclarations) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-continue: `continue` keyword. ESLint flags it as a code-smell
+// noContinue: `continue` keyword. ESLint flags it as a code-smell
 // (loop body should usually be reorganized).
 type noContinue struct{}
 
@@ -128,7 +128,7 @@ func (noContinue) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Unexpected use of continue statement.")
 }
 
-// no-delete-var: `delete x` where `x` is a variable. Strict-mode error.
+// noDeleteVar: `delete x` where `x` is a variable. Strict-mode error.
 type noDeleteVar struct{}
 
 func (noDeleteVar) Name() string           { return "no-delete-var" }
@@ -143,7 +143,7 @@ func (noDeleteVar) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-eq-null: `x == null` — ambiguous with eqeqeq's `null` exception
+// noEqNull: `x == null` — ambiguous with eqeqeq's `null` exception
 // when developers want to also catch `undefined`.
 type noEqNull struct{}
 
@@ -166,7 +166,7 @@ func isNullLiteral(node *shimast.Node) bool {
   return node != nil && node.Kind == shimast.KindNullKeyword
 }
 
-// no-extra-bind: `(function () {}).bind(this)` where `this` isn't used
+// noExtraBind: `(function () {}).bind(this)` where `this` isn't used
 // — only flag the case where the bind target is empty/parameterless,
 // keeping false-positives down.
 type noExtraBind struct{}
@@ -230,7 +230,7 @@ func bodyReferencesThis(node *shimast.Node) bool {
   return found
 }
 
-// no-labels: labels (`outer: for (...) { break outer; }`) are
+// noLabels: labels (`outer: for (...) { break outer; }`) are
 // confusing and rarely needed.
 type noLabels struct{}
 
@@ -240,7 +240,7 @@ func (noLabels) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Unexpected labeled statement.")
 }
 
-// no-lone-blocks: `{ doStuff(); }` outside a control flow context —
+// noLoneBlocks: `{ doStuff(); }` outside a control flow context —
 // the braces add no scope (in non-strict mode) and obscure intent.
 type noLoneBlocks struct{}
 
@@ -293,7 +293,7 @@ func (noLoneBlocks) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Block is redundant.")
 }
 
-// no-lonely-if: `else { if (...) {...} }` should be `else if (...)`.
+// noLonelyIf: `else { if (...) {...} }` should be `else if (...)`.
 type noLonelyIf struct{}
 
 func (noLonelyIf) Name() string           { return "no-lonely-if" }
@@ -321,7 +321,7 @@ func (noLonelyIf) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Unexpected if as the only statement in an else block.")
 }
 
-// no-multi-assign: `a = b = 1`. Confusing right-to-left chains.
+// noMultiAssign: `a = b = 1`. Confusing right-to-left chains.
 type noMultiAssign struct{}
 
 func (noMultiAssign) Name() string           { return "no-multi-assign" }
@@ -342,7 +342,7 @@ func (noMultiAssign) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-negated-condition: `if (!x) {} else {}`. Easier to read with the
+// noNegatedCondition: `if (!x) {} else {}`. Easier to read with the
 // branches swapped.
 type noNegatedCondition struct{}
 
@@ -397,7 +397,7 @@ func isNegatedExpression(node *shimast.Node) bool {
   return false
 }
 
-// no-nested-ternary: `a ? b : c ? d : e`.
+// noNestedTernary: `a ? b : c ? d : e`.
 type noNestedTernary struct{}
 
 func (noNestedTernary) Name() string { return "no-nested-ternary" }
@@ -419,7 +419,7 @@ func hasConditional(node *shimast.Node) bool {
   return expr != nil && expr.Kind == shimast.KindConditionalExpression
 }
 
-// no-new: `new Foo()` whose result is discarded. Either store it or
+// noNew: `new Foo()` whose result is discarded. Either store it or
 // avoid the constructor.
 type noNew struct{}
 
@@ -435,7 +435,7 @@ func (noNew) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-new-func: `new Function("...")` — a third form of dynamic eval.
+// noNewFunc: `new Function("...")` — a third form of dynamic eval.
 type noNewFunc struct{}
 
 func (noNewFunc) Name() string { return "no-new-func" }
@@ -454,8 +454,8 @@ func (noNewFunc) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-object-constructor: `new Object()` / `Object()` — same shape as
-// no-array-constructor but for objects.
+// noObjectConstructor: `new Object()` / `Object()` — same shape as
+// noArrayConstructor but for objects.
 type noObjectConstructor struct{}
 
 func (noObjectConstructor) Name() string { return "no-object-constructor" }
@@ -486,7 +486,7 @@ func (noObjectConstructor) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-octal-escape: `"\251"` — octal escapes in string literals are
+// noOctalEscape: `"\251"` — octal escapes in string literals are
 // deprecated and forbidden in template literals.
 type noOctalEscape struct{}
 
@@ -524,7 +524,7 @@ func hasOctalEscape(src string) bool {
   return false
 }
 
-// no-plusplus: `++x` / `x++`. Equivalent to `x += 1`, considered less
+// noPlusplus: `++x` / `x++`. Equivalent to `x += 1`, considered less
 // clear in some style guides.
 type noPlusPlus struct{}
 
@@ -545,7 +545,7 @@ func (noPlusPlus) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-regex-spaces: multiple spaces in a regex literal — confusing
+// noRegexSpaces: multiple spaces in a regex literal — confusing
 // because the count is invisible.
 type noRegexSpaces struct{}
 
@@ -597,7 +597,7 @@ func regexHasMultipleSpaces(src string) bool {
   return false
 }
 
-// no-return-assign: `return a = b` mixes assignment with return.
+// noReturnAssign: `return a = b` mixes assignment with return.
 type noReturnAssign struct{}
 
 func (noReturnAssign) Name() string { return "no-return-assign" }
@@ -625,7 +625,7 @@ func (noReturnAssign) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-sequences: `(a, b)` — comma operator. Almost always a confusing
+// noSequences: `(a, b)` — comma operator. Almost always a confusing
 // pattern outside of `for` headers.
 type noSequences struct{}
 
@@ -653,7 +653,7 @@ func (noSequences) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Unexpected use of comma operator.")
 }
 
-// no-shadow-restricted-names: redeclaring `undefined`, `NaN`, `Infinity`,
+// noShadowRestrictedNames: redeclaring `undefined`, `NaN`, `Infinity`,
 // `arguments`, or `eval`.
 type noShadowRestrictedNames struct{}
 
@@ -681,7 +681,7 @@ func (noShadowRestrictedNames) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-undefined: literal `undefined` (vs `void 0`). Easier to misuse
+// noUndefined: literal `undefined` (vs `void 0`). Easier to misuse
 // because it's writable in older environments.
 type noUndefined struct{}
 
@@ -695,7 +695,7 @@ func (noUndefined) Check(ctx *Context, node *shimast.Node) {
   if parent == nil {
     return
   }
-  // Don't flag a declaration *named* `undefined` (no-shadow-restricted-names
+  // Don't flag a declaration *named* `undefined` (noShadowRestrictedNames
   // covers that), or a member-access / object-key position
   // (`x.undefined`, `{ undefined: 1 }`).
   switch parent.Kind {
@@ -734,7 +734,7 @@ func nodesShareLoc(a, b *shimast.Node) bool {
   return a == b || (a.Pos() == b.Pos() && a.End() == b.End())
 }
 
-// no-unneeded-ternary: `x ? true : false` → `Boolean(x)` / `!!x`.
+// noUnneededTernary: `x ? true : false` → `Boolean(x)` / `!!x`.
 type noUnneededTernary struct{}
 
 func (noUnneededTernary) Name() string { return "no-unneeded-ternary" }
@@ -811,7 +811,7 @@ func needsParensForUnaryNegation(node *shimast.Node) bool {
   return false
 }
 
-// no-unused-expressions: an expression statement whose value isn't used.
+// noUnusedExpressions: an expression statement whose value isn't used.
 // Filtered down to common patterns ESLint flags by default.
 type noUnusedExpressions struct{}
 
@@ -879,7 +879,7 @@ func isProductiveExpression(node *shimast.Node) bool {
   return false
 }
 
-// no-useless-call: `func.call(undefined, ...args)` / `func.apply(undefined, args)`
+// noUselessCall: `func.call(undefined, ...args)` / `func.apply(undefined, args)`
 // — call/apply with no this binding is just a regular call.
 type noUselessCall struct{}
 
@@ -908,7 +908,7 @@ func (noUselessCall) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-useless-computed-key: `{ ["foo"]: 1 }` could be `{ foo: 1 }`.
+// noUselessComputedKey: `{ ["foo"]: 1 }` could be `{ foo: 1 }`.
 type noUselessComputedKey struct{}
 
 func (noUselessComputedKey) Name() string { return "no-useless-computed-key" }
@@ -943,7 +943,7 @@ func (noUselessComputedKey) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-useless-rename: `import { x as x } from ...` / `const { x: x } = obj`
+// noUselessRename: `import { x as x } from ...` / `const { x: x } = obj`
 // — the rename is a no-op.
 type noUselessRename struct{}
 
@@ -1013,7 +1013,7 @@ func reportUselessRenameFix(ctx *Context, node, propertyName, name *shimast.Node
   )
 }
 
-// object-shorthand: `{ x: x }` → `{ x }`.
+// objectShorthand: `{ x: x }` → `{ x }`.
 type objectShorthand struct{}
 
 func (objectShorthand) Name() string           { return "object-shorthand" }
@@ -1042,7 +1042,7 @@ func (objectShorthand) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// operator-assignment: `x = x + 1` → `x += 1`.
+// operatorAssignment: `x = x + 1` → `x += 1`.
 type operatorAssignment struct{}
 
 func (operatorAssignment) Name() string { return "operator-assignment" }
@@ -1082,7 +1082,7 @@ func isCompoundEligibleOperator(kind shimast.Kind) bool {
   return false
 }
 
-// prefer-exponentiation-operator: `Math.pow(a, b)` → `a ** b`.
+// preferExponentiationOperator: `Math.pow(a, b)` → `a ** b`.
 type preferExponentiationOperator struct{}
 
 func (preferExponentiationOperator) Name() string { return "prefer-exponentiation-operator" }
@@ -1100,7 +1100,7 @@ func (preferExponentiationOperator) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Use the '**' operator instead of 'Math.pow'.")
 }
 
-// prefer-spread: `fn.apply(null, args)` → `fn(...args)`.
+// preferSpread: `fn.apply(null, args)` → `fn(...args)`.
 type preferSpread struct{}
 
 func (preferSpread) Name() string           { return "prefer-spread" }
@@ -1131,7 +1131,7 @@ func (preferSpread) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// prefer-template: string concatenation that would read better as a
+// preferTemplate: string concatenation that would read better as a
 // template literal — heuristic: any `+` involving a string literal AND
 // a non-literal.
 type preferTemplate struct{}
@@ -1277,7 +1277,7 @@ func escapeTemplateLiteralBody(text string) string {
   return sb.String()
 }
 
-// require-yield: `function* gen() { return 1; }` — generators that
+// requireYield: `function* gen() { return 1; }` — generators that
 // never yield are usually unintended.
 type requireYield struct{}
 
@@ -1337,7 +1337,7 @@ func subtreeContainsYield(node *shimast.Node) bool {
   return found
 }
 
-// vars-on-top: `var` declarations should appear at the top of their
+// varsOnTop: `var` declarations should appear at the top of their
 // function/script scope.
 type varsOnTop struct{}