@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_throw.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-throw-literal: throw should always pass an Error subclass.
+// noThrowLiteral: throw should always pass an Error subclass.
 // https://eslint.org/docs/latest/rules/no-throw-literal
 type noThrowLiteral struct{}
 

package/linthost/rules_ts.go

@@ -6,20 +6,20 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-explicit-any: ban `: any` annotations. Loud equivalent of
+// noExplicitAny: ban `: any` annotations. Loud equivalent of
 // `@typescript-eslint/no-explicit-any`.
 type noExplicitAny struct{}
 
-func (noExplicitAny) Name() string           { return "no-explicit-any" }
+func (noExplicitAny) Name() string           { return "typescript/no-explicit-any" }
 func (noExplicitAny) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindAnyKeyword} }
 func (noExplicitAny) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Unexpected any. Specify a different type.")
 }
 
-// no-non-null-assertion: ban the postfix `!` non-null assertion.
+// noNonNullAssertion: ban the postfix `!` non-null assertion.
 type noNonNullAssertion struct{}
 
-func (noNonNullAssertion) Name() string { return "no-non-null-assertion" }
+func (noNonNullAssertion) Name() string { return "typescript/no-non-null-assertion" }
 func (noNonNullAssertion) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindNonNullExpression}
 }
@@ -27,11 +27,11 @@ func (noNonNullAssertion) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Forbidden non-null assertion.")
 }
 
-// no-empty-interface: empty `interface { }` declarations are an alias
+// noEmptyInterface: empty `interface { }` declarations are an alias
 // for the supertype with extra ceremony.
 type noEmptyInterface struct{}
 
-func (noEmptyInterface) Name() string { return "no-empty-interface" }
+func (noEmptyInterface) Name() string { return "typescript/no-empty-interface" }
 func (noEmptyInterface) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindInterfaceDeclaration}
 }
@@ -45,11 +45,11 @@ func (noEmptyInterface) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-inferrable-types: `let x: number = 0` — the annotation is what TS
+// noInferrableTypes: `let x: number = 0` — the annotation is what TS
 // would have inferred anyway.
 type noInferrableTypes struct{}
 
-func (noInferrableTypes) Name() string { return "no-inferrable-types" }
+func (noInferrableTypes) Name() string { return "typescript/no-inferrable-types" }
 func (noInferrableTypes) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindVariableDeclaration, shimast.KindParameter, shimast.KindPropertyDeclaration}
 }
@@ -126,11 +126,11 @@ func isUnaryNumeric(node *shimast.Node) bool {
   return false
 }
 
-// no-namespace: TypeScript-only `namespace`/`module` declarations. They
+// noNamespace: TypeScript-only `namespace`/`module` declarations. They
 // exist for legacy reasons; modern TS uses ES modules.
 type noNamespace struct{}
 
-func (noNamespace) Name() string           { return "no-namespace" }
+func (noNamespace) Name() string           { return "typescript/no-namespace" }
 func (noNamespace) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindModuleDeclaration} }
 func (noNamespace) Check(ctx *Context, node *shimast.Node) {
   decl := node.AsModuleDeclaration()
@@ -145,11 +145,11 @@ func (noNamespace) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "ES2015 module syntax is preferred over namespaces.")
 }
 
-// no-this-alias: `const self = this;` reassigns `this` to a local. Use
+// noThisAlias: `const self = this;` reassigns `this` to a local. Use
 // arrow functions or `.bind(this)` instead.
 type noThisAlias struct{}
 
-func (noThisAlias) Name() string           { return "no-this-alias" }
+func (noThisAlias) Name() string           { return "typescript/no-this-alias" }
 func (noThisAlias) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindVariableDeclaration} }
 func (noThisAlias) Check(ctx *Context, node *shimast.Node) {
   decl := node.AsVariableDeclaration()
@@ -161,10 +161,10 @@ func (noThisAlias) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// prefer-as-const: `as 'foo'` / `as 1` should be `as const`.
+// preferAsConst: `as 'foo'` / `as 1` should be `as const`.
 type preferAsConst struct{}
 
-func (preferAsConst) Name() string { return "prefer-as-const" }
+func (preferAsConst) Name() string { return "typescript/prefer-as-const" }
 func (preferAsConst) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindAsExpression, shimast.KindTypeAssertionExpression}
 }
@@ -213,7 +213,7 @@ func (preferAsConst) Check(ctx *Context, node *shimast.Node) {
 }
 
 // literalsMatchSourceText reports whether lhs and rhs are both literal
-// expressions whose source text is identical. Used by prefer-as-const to
+// expressions whose source text is identical. Used by preferAsConst to
 // detect `x as "foo"` where "foo" matches x's literal value.
 func literalsMatchSourceText(file *shimast.SourceFile, lhs, rhs *shimast.Node) bool {
   if lhs == nil || rhs == nil {
@@ -225,11 +225,11 @@ func literalsMatchSourceText(file *shimast.SourceFile, lhs, rhs *shimast.Node) b
   return nodeText(file, lhs) == nodeText(file, rhs)
 }
 
-// no-require-imports: ban `require(...)` calls in TS source. Use
+// noRequireImports: ban `require(...)` calls in TS source. Use
 // ES `import` instead.
 type noRequireImports struct{}
 
-func (noRequireImports) Name() string { return "no-require-imports" }
+func (noRequireImports) Name() string { return "typescript/no-require-imports" }
 func (noRequireImports) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindCallExpression, shimast.KindImportEqualsDeclaration}
 }
@@ -250,11 +250,11 @@ func (noRequireImports) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// ban-ts-comment: `// @ts-ignore` / `// @ts-nocheck` / `// @ts-expect-error`
+// banTsComment: `// @ts-ignore` / `// @ts-nocheck` / `// @ts-expect-error`
 // silence the type checker. Default mode flags every variant.
 type banTsComment struct{}
 
-func (banTsComment) Name() string           { return "ban-ts-comment" }
+func (banTsComment) Name() string           { return "typescript/ban-ts-comment" }
 func (banTsComment) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (banTsComment) Check(ctx *Context, node *shimast.Node) {
   if ctx.File == nil {

package/linthost/rules_ts_async.go

@@ -0,0 +1,399 @@
+// TypeScript async/error-flow rules: type-aware ports of the
+// typescript-eslint recommended-type-checked rules that round out the
+// async story alongside `typescript/await-thenable`,
+// `typescript/no-floating-promises`, and `typescript/return-await`
+// already in rules_promise.go.
+//
+// Implemented here:
+//   - typescript/require-await
+//     (AST-only; async function with no `await` in its body)
+//   - typescript/no-misused-promises
+//     (type-aware; Promise in conditional / logical / forEach position)
+//   - typescript/use-unknown-in-catch-callback-variable
+//     (type-aware; `.catch(err)` / `.then(_, err)` must annotate `unknown`)
+//   - typescript/only-throw-error
+//     (type-aware; `throw` of a primitive value)
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// requireAwait reports `async` function bodies that contain no `await`
+// expression. The function still pays the microtask cost and signals
+// async semantics to callers; the missing `await` is almost always a
+// refactor artifact. typescript-eslint:
+// https://typescript-eslint.io/rules/require-await/
+//
+// AST-only. The walker stops at nested function-like boundaries so an
+// `await` inside an inner non-async closure does not count toward the
+// outer function. Async generators are exempt — they satisfy the
+// async-keyword contract through `yield`.
+type requireAwait struct{}
+
+func (requireAwait) Name() string { return "typescript/require-await" }
+func (requireAwait) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+	}
+}
+func (requireAwait) Check(ctx *Context, node *shimast.Node) {
+	if !hasAsyncModifier(node) {
+		return
+	}
+	if requireAwaitIsAsyncGenerator(node) {
+		return
+	}
+	body := node.Body()
+	if body == nil {
+		return
+	}
+	if requireAwaitBodyHasAwait(body) {
+		return
+	}
+	startPos := keywordStart(ctx.File, node, "async")
+	if startPos < 0 {
+		ctx.Report(node, "Async function has no `await` expression.")
+		return
+	}
+	ctx.ReportRange(startPos, startPos+len("async"), "Async function has no `await` expression.")
+}
+
+// requireAwaitIsAsyncGenerator reports whether node is `async function*`,
+// `async *method`, or the function-expression form thereof. Async
+// generators are exempted by typescript-eslint: the generator's `yield`
+// expressions express the suspend points and the rule would otherwise
+// fire on every `async function*` that does not also `await`.
+func requireAwaitIsAsyncGenerator(node *shimast.Node) bool {
+	switch node.Kind {
+	case shimast.KindFunctionDeclaration:
+		decl := node.AsFunctionDeclaration()
+		return decl != nil && decl.AsteriskToken != nil
+	case shimast.KindFunctionExpression:
+		expr := node.AsFunctionExpression()
+		return expr != nil && expr.AsteriskToken != nil
+	case shimast.KindMethodDeclaration:
+		decl := node.AsMethodDeclaration()
+		return decl != nil && decl.AsteriskToken != nil
+	}
+	return false
+}
+
+// requireAwaitBodyHasAwait reports whether body (or any descendant that
+// is not itself a nested function-like scope) contains an `await`
+// expression. The walker mirrors `walkFunctionBody` in rules_promise.go
+// but bails out early once an `await` is found.
+func requireAwaitBodyHasAwait(body *shimast.Node) bool {
+	found := false
+	var walk func(*shimast.Node)
+	walk = func(n *shimast.Node) {
+		if found || n == nil {
+			return
+		}
+		if n != body && isFunctionLikeKind(n) {
+			return
+		}
+		if n.Kind == shimast.KindAwaitExpression {
+			found = true
+			return
+		}
+		n.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return false
+		})
+	}
+	walk(body)
+	return found
+}
+
+// noMisusedPromises reports Promises supplied where a boolean or a
+// `void`-returning callback is expected. The Promise is truthy as a
+// value, so the conditional silently passes; the discarded Promise then
+// leaks any rejection. typescript-eslint:
+// https://typescript-eslint.io/rules/no-misused-promises/
+//
+// Type-aware. Covers the three highest-signal positions:
+//   - conditional positions: `if (p)`, `while (p)`, `do … while (p)`,
+//     `for (; p; …)`, `p ? a : b`, `!p`;
+//   - short-circuit / nullish operators: `p && x`, `p || x`, `p ?? x`;
+//   - array iteration: `.forEach(async fn)` where the callback returns
+//     a Promise the iteration never observes.
+//
+// JSX event-handler positions and arbitrary user-defined
+// void-callback contracts are deferred — they need a richer expected-
+// type inspection than this baseline.
+type noMisusedPromises struct{}
+
+func (noMisusedPromises) Name() string { return "typescript/no-misused-promises" }
+func (noMisusedPromises) NeedsTypeChecker() bool {
+	return true
+}
+func (noMisusedPromises) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindIfStatement,
+		shimast.KindWhileStatement,
+		shimast.KindDoStatement,
+		shimast.KindForStatement,
+		shimast.KindConditionalExpression,
+		shimast.KindPrefixUnaryExpression,
+		shimast.KindBinaryExpression,
+		shimast.KindCallExpression,
+	}
+}
+func (noMisusedPromises) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindIfStatement:
+		if stmt := node.AsIfStatement(); stmt != nil {
+			noMisusedPromisesReportConditional(ctx, stmt.Expression)
+		}
+	case shimast.KindWhileStatement:
+		if stmt := node.AsWhileStatement(); stmt != nil {
+			noMisusedPromisesReportConditional(ctx, stmt.Expression)
+		}
+	case shimast.KindDoStatement:
+		if stmt := node.AsDoStatement(); stmt != nil {
+			noMisusedPromisesReportConditional(ctx, stmt.Expression)
+		}
+	case shimast.KindForStatement:
+		if stmt := node.AsForStatement(); stmt != nil {
+			noMisusedPromisesReportConditional(ctx, stmt.Condition)
+		}
+	case shimast.KindConditionalExpression:
+		if expr := node.AsConditionalExpression(); expr != nil {
+			noMisusedPromisesReportConditional(ctx, expr.Condition)
+		}
+	case shimast.KindPrefixUnaryExpression:
+		expr := node.AsPrefixUnaryExpression()
+		if expr != nil && expr.Operator == shimast.KindExclamationToken {
+			noMisusedPromisesReportConditional(ctx, expr.Operand)
+		}
+	case shimast.KindBinaryExpression:
+		bin := node.AsBinaryExpression()
+		if bin == nil || bin.OperatorToken == nil {
+			return
+		}
+		switch bin.OperatorToken.Kind {
+		case shimast.KindAmpersandAmpersandToken,
+			shimast.KindBarBarToken,
+			shimast.KindQuestionQuestionToken:
+			noMisusedPromisesReportConditional(ctx, bin.Left)
+		}
+	case shimast.KindCallExpression:
+		if call := node.AsCallExpression(); call != nil {
+			noMisusedPromisesCheckVoidCallback(ctx, call)
+		}
+	}
+}
+
+// noMisusedPromisesReportConditional reports expr if it carries a
+// Promise type. `await x` and `void x` are author-acknowledged opt-outs
+// and pass through. `any` / `unknown` / `never` are intentionally NOT
+// flagged because they propagate from generic helpers and would
+// produce overwhelming false-positive volume in real codebases.
+func noMisusedPromisesReportConditional(ctx *Context, expr *shimast.Node) {
+	target := stripParens(expr)
+	if target == nil {
+		return
+	}
+	switch target.Kind {
+	case shimast.KindAwaitExpression, shimast.KindVoidExpression:
+		return
+	}
+	t := ctx.Checker.GetTypeAtLocation(target)
+	if t == nil || !isPromiseTypedExpression(ctx.Checker, t) {
+		return
+	}
+	ctx.Report(target, "Expected non-Promise value in a boolean conditional position; did you forget `await`?")
+}
+
+// noMisusedPromisesCheckVoidCallback fires when an async callback is
+// passed to a method that expects a void-returning callback. The
+// baseline targets the most common offender — `Array.prototype.forEach`
+// — by name rather than by signature inspection. Restricting to
+// `forEach` keeps the false-positive rate low; richer void-callback
+// detection (e.g., JSX event handlers, user methods with `void` in
+// their signature) is deferred.
+func noMisusedPromisesCheckVoidCallback(ctx *Context, call *shimast.CallExpression) {
+	if call == nil || call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+		return
+	}
+	_, method, ok := promisePropertyAccessParts(call.Expression)
+	if !ok || method != "forEach" {
+		return
+	}
+	callback := stripParens(call.Arguments.Nodes[0])
+	if callback == nil || !isFunctionLikeKind(callback) {
+		return
+	}
+	if !hasAsyncModifier(callback) {
+		return
+	}
+	ctx.Report(callback, "Async callback passed to forEach — the returned Promise will be discarded; use `for ... of` instead.")
+}
+
+// useUnknownInCatchCallbackVariable requires the parameter of `.catch`
+// and the second parameter of `.then` to be explicitly typed `unknown`.
+// TypeScript 4.4+ types `try { } catch (e)` as `unknown` by default;
+// promise chain callbacks still default to implicit `any`, so this rule
+// closes that ergonomic gap. typescript-eslint:
+// https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable/
+//
+// Type-aware: only fires when the receiver of `.catch` / `.then` is
+// actually a Promise (rules out user-defined methods named `catch`).
+// The annotation check is textual on the parameter's type node — the
+// annotation must be exactly the token `unknown`.
+type useUnknownInCatchCallbackVariable struct{}
+
+func (useUnknownInCatchCallbackVariable) Name() string {
+	return "typescript/use-unknown-in-catch-callback-variable"
+}
+func (useUnknownInCatchCallbackVariable) NeedsTypeChecker() bool {
+	return true
+}
+func (useUnknownInCatchCallbackVariable) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (useUnknownInCatchCallbackVariable) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Arguments == nil {
+		return
+	}
+	receiver, method, ok := promisePropertyAccessParts(call.Expression)
+	if !ok || (method != "catch" && method != "then") {
+		return
+	}
+	args := call.Arguments.Nodes
+	var callback *shimast.Node
+	switch method {
+	case "catch":
+		if len(args) < 1 {
+			return
+		}
+		callback = stripParens(args[0])
+	case "then":
+		if len(args) < 2 {
+			return
+		}
+		callback = stripParens(args[1])
+	}
+	if callback == nil || !isFunctionLikeKind(callback) {
+		return
+	}
+	if receiver == nil {
+		return
+	}
+	t := ctx.Checker.GetTypeAtLocation(receiver)
+	if t == nil || !isPromiseTypedExpression(ctx.Checker, t) {
+		return
+	}
+	params := callback.Parameters()
+	if len(params) == 0 {
+		return
+	}
+	param := params[0].AsParameterDeclaration()
+	if param == nil {
+		return
+	}
+	if param.Type == nil {
+		ctx.Report(params[0], "Catch callback parameter should be explicitly typed `unknown`.")
+		return
+	}
+	annotationText := nodeText(ctx.File, param.Type)
+	if annotationText != "unknown" {
+		ctx.Report(param.Type, "Catch callback parameter must be typed `unknown`, not `"+annotationText+"`.")
+	}
+}
+
+// onlyThrowError reports `throw` of a value that is statically known
+// to be a primitive (string / number / boolean / bigint / void /
+// undefined / null). Throwing a non-Error loses the structured stack
+// trace and breaks downstream `instanceof Error` checks.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/only-throw-error/
+//
+// Type-aware. `any` / `unknown` / `never` pass through — they propagate
+// from generic helpers and a strict rejection would explode at every
+// re-throw of a caught `unknown`. Object types are conservatively
+// allowed (a full base-type walk to confirm Error-derivation is
+// deferred); the practical effect is that `throw "string"` and
+// `throw 42` are caught but `throw { code: 1 }` slips through.
+type onlyThrowError struct{}
+
+func (onlyThrowError) Name() string { return "typescript/only-throw-error" }
+func (onlyThrowError) NeedsTypeChecker() bool {
+	return true
+}
+func (onlyThrowError) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindThrowStatement}
+}
+func (onlyThrowError) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	stmt := node.AsThrowStatement()
+	if stmt == nil || stmt.Expression == nil {
+		return
+	}
+	expr := stripParens(stmt.Expression)
+	if expr == nil {
+		return
+	}
+	t := ctx.Checker.GetTypeAtLocation(expr)
+	if t == nil {
+		return
+	}
+	if onlyThrowErrorIsPrimitive(ctx.Checker, t) {
+		ctx.Report(node, "Throw an Error object instead of a non-Error value.")
+	}
+}
+
+// onlyThrowErrorIsPrimitive returns true when t is a primitive type
+// (string / number / boolean / bigint / void / undefined / null).
+// any / unknown / never escape the check on purpose. Union and
+// intersection types recurse — `string | number` is a primitive
+// throw even though it is a composite type.
+func onlyThrowErrorIsPrimitive(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+	if checker == nil || t == nil {
+		return false
+	}
+	flags := t.Flags()
+	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+		return false
+	}
+	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+		for _, part := range t.Types() {
+			if part == nil {
+				continue
+			}
+			if onlyThrowErrorIsPrimitive(checker, part) {
+				return true
+			}
+		}
+		return false
+	}
+	const primitiveMask = shimchecker.TypeFlagsStringLike |
+		shimchecker.TypeFlagsNumberLike |
+		shimchecker.TypeFlagsBigIntLike |
+		shimchecker.TypeFlagsBooleanLike |
+		shimchecker.TypeFlagsVoid |
+		shimchecker.TypeFlagsUndefined |
+		shimchecker.TypeFlagsNull
+	return flags&primitiveMask != 0
+}
+
+func init() {
+	Register(requireAwait{})
+	Register(noMisusedPromises{})
+	Register(useUnknownInCatchCallbackVariable{})
+	Register(onlyThrowError{})
+}

package/linthost/rules_ts_class_literal_property_style.go

@@ -0,0 +1,115 @@
+// AST-only `typescript/class-literal-property-style` rule from
+// typescript-eslint. Implemented here as a standalone file because the
+// rule's literal-shape predicate and getter/setter pairing are
+// self-contained and unrelated to the other class-shape rules already
+// living in rules_ts_simple.go.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// classLiteralPropertyStyle reports `get foo() { return <literal>; }`
+// accessors that have no companion setter — those should be expressed
+// as a `readonly foo = <literal>;` field declaration. The getter form
+// re-runs the body on every read and obscures the fact that the value
+// is fixed; a readonly field is shorter, type-narrows to the literal
+// type, and signals "this is a constant" at the call site.
+// https://typescript-eslint.io/rules/class-literal-property-style/
+//
+// Default upstream config is `"fields"`, matching the wording above.
+// The rule fires when:
+//   - the class member is a `get` accessor,
+//   - its body is a block containing a single `return <literal>;`,
+//   - the literal is a string, number, boolean, `null`, a template
+//     literal with no substitutions, or a unary-minus prefix on a
+//     numeric literal,
+//   - the class has no `set` accessor for the same member name.
+type classLiteralPropertyStyle struct{}
+
+func (classLiteralPropertyStyle) Name() string {
+	return "typescript/class-literal-property-style"
+}
+func (classLiteralPropertyStyle) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindGetAccessor}
+}
+func (classLiteralPropertyStyle) Check(ctx *Context, node *shimast.Node) {
+	parent := node.Parent
+	if parent == nil ||
+		(parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+		return
+	}
+	accessor := node.AsGetAccessorDeclaration()
+	if accessor == nil || accessor.Body == nil || accessor.Body.Kind != shimast.KindBlock {
+		return
+	}
+	statements := accessor.Body.Statements()
+	if len(statements) != 1 {
+		return
+	}
+	ret := statements[0]
+	if ret == nil || ret.Kind != shimast.KindReturnStatement {
+		return
+	}
+	retStmt := ret.AsReturnStatement()
+	if retStmt == nil || retStmt.Expression == nil {
+		return
+	}
+	if !isClassLiteralPropertyValue(retStmt.Expression) {
+		return
+	}
+	name := classMemberName(node)
+	if name == "" {
+		return
+	}
+	if classHasSetterFor(parent, name) {
+		return
+	}
+	ctx.Report(node, "Literal-returning getter `"+name+"` should be a `readonly` field instead.")
+}
+
+// isClassLiteralPropertyValue reports whether the expression is one of
+// the literal shapes the rule accepts: a plain literal, a template
+// literal without substitutions, or a unary-minus prefix on a numeric
+// literal.
+func isClassLiteralPropertyValue(expr *shimast.Node) bool {
+	if expr == nil {
+		return false
+	}
+	switch expr.Kind {
+	case shimast.KindStringLiteral,
+		shimast.KindNumericLiteral,
+		shimast.KindTrueKeyword,
+		shimast.KindFalseKeyword,
+		shimast.KindNullKeyword,
+		shimast.KindNoSubstitutionTemplateLiteral:
+		return true
+	case shimast.KindPrefixUnaryExpression:
+		prefix := expr.AsPrefixUnaryExpression()
+		if prefix == nil || prefix.Operator != shimast.KindMinusToken || prefix.Operand == nil {
+			return false
+		}
+		return prefix.Operand.Kind == shimast.KindNumericLiteral
+	}
+	return false
+}
+
+// classHasSetterFor reports whether the class contains a `set`
+// accessor whose name matches `name`. A getter paired with a setter
+// is left alone because the field form cannot reproduce the setter's
+// side effects.
+func classHasSetterFor(class *shimast.Node, name string) bool {
+	for _, member := range classMembers(class) {
+		if member == nil || member.Kind != shimast.KindSetAccessor {
+			continue
+		}
+		if classMemberName(member) == name {
+			return true
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(classLiteralPropertyStyle{})
+}