@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_unicorn_prefer_regexp_test_rule.go

@@ -0,0 +1,80 @@
+// unicorn/prefer-regexp-test: `if ("abc".match(/a/))` and
+// `if (/a/.exec("abc"))` use match-array / null returns to encode a
+// boolean question. `RegExp#test()` returns a boolean directly, avoids
+// allocating the match result, and reads exactly like the question
+// being asked.
+//
+// AST-only and parent-driven: visit each `CallExpression` whose callee
+// is `PropertyAccess(_, match|exec)`, then confirm the call sits in a
+// boolean position — the condition slot of `if`/`?:`, the operand of a
+// unary `!`, or one of the short-circuit binary operators `&&`, `||`,
+// `??`. Matches that aren't in a boolean position may still use the
+// returned array, so they're out of scope.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-regexp-test.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferRegexpTest struct{}
+
+func (unicornPreferRegexpTest) Name() string { return "unicorn/prefer-regexp-test" }
+func (unicornPreferRegexpTest) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferRegexpTest) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	switch identifierText(access.Name()) {
+	case "match", "exec":
+	default:
+		return
+	}
+	if !unicornPreferRegexpTestInBooleanPosition(node) {
+		return
+	}
+	ctx.Report(node, "Prefer `RegExp#test()` over `String#match()` / `RegExp#exec()` in a boolean context.")
+}
+
+// unicornPreferRegexpTestInBooleanPosition reports whether `node` sits in
+// a position that consumes only its truthiness: the condition of an
+// `if` / ternary, the operand of `!`, or one side of `&&` / `||` / `??`.
+func unicornPreferRegexpTestInBooleanPosition(node *shimast.Node) bool {
+	parent := node.Parent
+	if parent == nil {
+		return false
+	}
+	switch parent.Kind {
+	case shimast.KindIfStatement:
+		ifStmt := parent.AsIfStatement()
+		return ifStmt != nil && ifStmt.Expression == node
+	case shimast.KindConditionalExpression:
+		cond := parent.AsConditionalExpression()
+		return cond != nil && cond.Condition == node
+	case shimast.KindPrefixUnaryExpression:
+		pre := parent.AsPrefixUnaryExpression()
+		return pre != nil && pre.Operator == shimast.KindExclamationToken
+	case shimast.KindBinaryExpression:
+		bin := parent.AsBinaryExpression()
+		if bin == nil || bin.OperatorToken == nil {
+			return false
+		}
+		switch bin.OperatorToken.Kind {
+		case shimast.KindAmpersandAmpersandToken,
+			shimast.KindBarBarToken,
+			shimast.KindQuestionQuestionToken:
+			return true
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(unicornPreferRegexpTest{})
+}

package/linthost/rules_unicorn_prefer_response_static_json.go

@@ -0,0 +1,53 @@
+// unicorn/prefer-response-static-json: `new Response(JSON.stringify(value), …)`
+// is the manual two-step recipe — stringify then construct — that the
+// platform's `Response.json(value, …)` static factory now performs in
+// one call. The static factory also sets `Content-Type: application/json`
+// automatically; the manual form leaves the header to the author.
+//
+// AST-only: visit each `NewExpression`. Match when the callee identifier
+// is `Response` AND the first argument is a `CallExpression` whose
+// callee is the property chain `JSON.stringify`. Other arguments (init
+// options) are intentionally not inspected — the rule fires regardless
+// of headers/status because the simpler factory handles both shapes.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-response-static-json.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferResponseStaticJson struct{}
+
+func (unicornPreferResponseStaticJson) Name() string {
+	return "unicorn/prefer-response-static-json"
+}
+func (unicornPreferResponseStaticJson) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornPreferResponseStaticJson) Check(ctx *Context, node *shimast.Node) {
+	ne := node.AsNewExpression()
+	if ne == nil || identifierText(ne.Expression) != "Response" {
+		return
+	}
+	if ne.Arguments == nil || len(ne.Arguments.Nodes) == 0 {
+		return
+	}
+	first := stripParens(ne.Arguments.Nodes[0])
+	if first == nil || first.Kind != shimast.KindCallExpression {
+		return
+	}
+	call := first.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil ||
+		identifierText(access.Expression) != "JSON" ||
+		identifierText(access.Name()) != "stringify" {
+		return
+	}
+	ctx.Report(node, "Prefer `Response.json(value)` over `new Response(JSON.stringify(value), ...)`.")
+}
+
+func init() {
+	Register(unicornPreferResponseStaticJson{})
+}

package/linthost/rules_unicorn_prefer_set_has.go

@@ -0,0 +1,42 @@
+// unicorn/prefer-set-has: `[a, b, c].includes(x)` is `O(n)` per lookup,
+// while `new Set([a, b, c]).has(x)` is `O(1)` after a single `O(n)`
+// construction. For repeated membership lookups against a fixed
+// collection the `Set` form is meaningfully faster and clearer about
+// intent.
+//
+// AST-only minimum-viable port: only the literal-array-receiver shape
+// (`[…].includes(x)`) is reported. The upstream rule also reasons
+// about typed variable receivers, which requires type-flow analysis
+// out of scope for this slice; expanding to typed receivers is a
+// follow-up.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-set-has.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSetHas struct{}
+
+func (unicornPreferSetHas) Name() string { return "unicorn/prefer-set-has" }
+func (unicornPreferSetHas) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferSetHas) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "includes" {
+		return
+	}
+	receiver := stripParens(access.Expression)
+	if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+		return
+	}
+	ctx.Report(node, "Prefer `Set#has()` over `Array#includes()` for repeated membership lookups against a constant collection.")
+}
+
+func init() {
+	Register(unicornPreferSetHas{})
+}

package/linthost/rules_unicorn_prefer_set_size.go

@@ -0,0 +1,48 @@
+// unicorn/prefer-set-size: `[...set].length` materializes the entire Set
+// into a throwaway array just to read its element count. `Set#size` is a
+// constant-time property that returns the same value without the
+// allocation, and reads more naturally for the intent the code expresses.
+//
+// AST-only: visit each `PropertyAccessExpression`, match when the
+// accessed property is named `length` AND the receiver is an
+// array-literal expression whose only element is a SpreadElement (i.e.
+// `[...x]`). The contents of the spread are not inspected — the
+// syntactic shape `[...x].length` is the signal regardless of whether
+// the spread source is statically a Set.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-set-size.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSetSize struct{}
+
+func (unicornPreferSetSize) Name() string { return "unicorn/prefer-set-size" }
+func (unicornPreferSetSize) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
+func (unicornPreferSetSize) Check(ctx *Context, node *shimast.Node) {
+	access := node.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "length" {
+		return
+	}
+	receiver := stripParens(access.Expression)
+	if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+		return
+	}
+	arr := receiver.AsArrayLiteralExpression()
+	if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 1 {
+		return
+	}
+	only := arr.Elements.Nodes[0]
+	if only == nil || only.Kind != shimast.KindSpreadElement {
+		return
+	}
+	ctx.Report(node, "Prefer `Set#size` over `[...set].length`.")
+}
+
+func init() {
+	Register(unicornPreferSetSize{})
+}

package/linthost/rules_unicorn_prefer_simple_condition_first.go

@@ -0,0 +1,34 @@
+// unicorn/prefer-simple-condition-first: when a `&&`/`||` chain mixes
+// a "simple" operand (a bare identifier, a small literal comparison)
+// with a "complex" one (a function call, a property chain), short-
+// circuit evaluation reads more naturally if the simple operand sits
+// to the left — the cheap test is the gate, the expensive test runs
+// only if the gate passes.
+//
+// Escape-hatch / no-op port: ranking arbitrary expressions by
+// "simpleness" requires a stable complexity heuristic the upstream rule
+// embeds across hundreds of lines (literal counts, identifier depth,
+// call-chain weight, parenthesization). Without a faithful port of that
+// heuristic the rule would either over-fire on equally-weighted operands
+// or under-fire on the cases it is meant to catch; either way users get
+// confusing diagnostics. Registered so the typed-key/Go-registry parity
+// check passes and so users can configure the rule, but it intentionally
+// reports nothing until the heuristic lands in a follow-up.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-simple-condition-first.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSimpleConditionFirst struct{}
+
+func (unicornPreferSimpleConditionFirst) Name() string {
+	return "unicorn/prefer-simple-condition-first"
+}
+func (unicornPreferSimpleConditionFirst) Visits() []shimast.Kind { return nil }
+func (unicornPreferSimpleConditionFirst) Check(_ *Context, _ *shimast.Node) {
+	// Intentionally empty — see file header for the escape-hatch rationale.
+}
+
+func init() {
+	Register(unicornPreferSimpleConditionFirst{})
+}

package/linthost/rules_unicorn_prefer_single_call.go

@@ -0,0 +1,96 @@
+// unicorn/prefer-single-call: `xs.push(1); xs.push(2);` repeats the
+// `xs.push` lookup and the call dispatch for what is conceptually one
+// "append these values" operation. Variadic methods like `push`,
+// `unshift`, `addEventListener`, and `removeEventListener` accept
+// multiple arguments specifically so authors can collapse the back-to-
+// back form into a single call.
+//
+// AST-only: visit each `Block` AND `SourceFile`, scan the statement
+// list for any pair of consecutive `ExpressionStatement`s whose
+// expressions are `CallExpression`s targeting
+// `PropertyAccess(<sameReceiverText>, <sameMethod>)` where the method
+// is one of the variadic appenders. Receiver equivalence is decided
+// by source-text comparison so chained receivers (e.g. `obj.list.push`)
+// line up exactly. Report on the second statement so the diagnostic
+// anchors to the redundant call.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-single-call.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSingleCall struct{}
+
+func (unicornPreferSingleCall) Name() string { return "unicorn/prefer-single-call" }
+func (unicornPreferSingleCall) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBlock, shimast.KindSourceFile}
+}
+func (unicornPreferSingleCall) Check(ctx *Context, node *shimast.Node) {
+	var stmts []*shimast.Node
+	switch node.Kind {
+	case shimast.KindBlock:
+		block := node.AsBlock()
+		if block == nil || block.Statements == nil {
+			return
+		}
+		stmts = block.Statements.Nodes
+	case shimast.KindSourceFile:
+		file := node.AsSourceFile()
+		if file == nil || file.Statements == nil {
+			return
+		}
+		stmts = file.Statements.Nodes
+	default:
+		return
+	}
+	for i := 1; i < len(stmts); i++ {
+		prevReceiver, prevMethod := unicornPreferSingleCallExtract(ctx, stmts[i-1])
+		if prevReceiver == "" {
+			continue
+		}
+		currReceiver, currMethod := unicornPreferSingleCallExtract(ctx, stmts[i])
+		if currReceiver == "" {
+			continue
+		}
+		if prevReceiver != currReceiver || prevMethod != currMethod {
+			continue
+		}
+		ctx.Report(stmts[i], "Combine consecutive `"+currMethod+"` calls with multiple arguments into a single call.")
+	}
+}
+
+// unicornPreferSingleCallExtract returns (receiverText, methodName) for a
+// statement of the shape `<receiver>.<method>(…);` where `method` is one
+// of the variadic appenders the rule targets. Returns ("", "") for any
+// other shape.
+func unicornPreferSingleCallExtract(ctx *Context, stmt *shimast.Node) (string, string) {
+	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+		return "", ""
+	}
+	exprStmt := stmt.AsExpressionStatement()
+	if exprStmt == nil || exprStmt.Expression == nil {
+		return "", ""
+	}
+	call := stripParens(exprStmt.Expression)
+	if call == nil || call.Kind != shimast.KindCallExpression {
+		return "", ""
+	}
+	c := call.AsCallExpression()
+	if c == nil || c.Expression == nil || c.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return "", ""
+	}
+	access := c.Expression.AsPropertyAccessExpression()
+	if access == nil || access.Expression == nil {
+		return "", ""
+	}
+	method := identifierText(access.Name())
+	switch method {
+	case "push", "unshift", "addEventListener", "removeEventListener":
+	default:
+		return "", ""
+	}
+	return nodeText(ctx.File, access.Expression), method
+}
+
+func init() {
+	Register(unicornPreferSingleCall{})
+}

package/linthost/rules_unicorn_prefer_spread.go

@@ -0,0 +1,51 @@
+// unicorn/prefer-spread: `Array.from(x)` with a single iterable argument
+// is equivalent to a spread copy `[...x]`. The spread form is shorter,
+// reads as a value-level operation rather than a constructor call, and
+// removes the `Array` global from the read path entirely.
+//
+// AST-only: visit each `CallExpression`, match `Array.from(x)` — a
+// callee that is a property access reading `from` on a bare identifier
+// `Array`, with exactly one argument. The single-argument restriction
+// is load-bearing: `Array.from(x, mapFn)` and `Array.from(x, mapFn,
+// thisArg)` have observable behavior the spread does not (the mapper
+// receives the index, and `thisArg` is bound on a non-arrow mapper), so
+// the rule deliberately stays away from them.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-spread.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSpread struct{}
+
+func (unicornPreferSpread) Name() string { return "unicorn/prefer-spread" }
+func (unicornPreferSpread) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferSpread) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Name()) != "from" {
+		return
+	}
+	receiver := stripParens(access.Expression)
+	if identifierText(receiver) != "Array" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	ctx.Report(node, "Prefer spread `[...x]` over `Array.from(x)` for single-arg shallow copies.")
+}
+
+func init() {
+	Register(unicornPreferSpread{})
+}

package/linthost/rules_unicorn_prefer_string_raw.go

@@ -0,0 +1,43 @@
+// unicorn/prefer-string-raw: a string literal whose source contains
+// `\\` (an escaped backslash) is using the escape syntax to represent a
+// literal backslash. The same value, written through `String.raw` as
+// a template literal, drops every backslash escape and reads as the
+// literal text the author meant — particularly noticeable for Windows
+// paths, regex source strings, and TeX-shaped snippets.
+//
+// AST-only: visit `KindStringLiteral` and
+// `KindNoSubstitutionTemplateLiteral`. The match keys on the raw source
+// bytes of the literal node — `nodeText` returns the as-written source
+// — and fires when those bytes contain the two-character sequence `\\`,
+// i.e. an escaped backslash that `String.raw` would render literally.
+// Untagged template literals with substitutions are out of scope; this
+// rule only addresses the "single literal of fixed text" case.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-raw.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornPreferStringRaw struct{}
+
+func (unicornPreferStringRaw) Name() string { return "unicorn/prefer-string-raw" }
+func (unicornPreferStringRaw) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
+func (unicornPreferStringRaw) Check(ctx *Context, node *shimast.Node) {
+	raw := nodeText(ctx.File, node)
+	if raw == "" {
+		return
+	}
+	if !strings.Contains(raw, `\\`) {
+		return
+	}
+	ctx.Report(node, "Prefer `String.raw` for strings with backslash escapes.")
+}
+
+func init() {
+	Register(unicornPreferStringRaw{})
+}

package/linthost/rules_unicorn_prefer_string_replace_all.go

@@ -0,0 +1,95 @@
+// unicorn/prefer-string-replace-all: `"abc".replace(/a/g, "x")` is the
+// pre-ES2021 idiom for "replace every occurrence". ES2021's
+// `String#replaceAll` does the same thing without the regex flag
+// detour. The rule fires on `.replace(/<pattern>/g, replacement)` so
+// authors switch to the explicit method.
+//
+// AST-only: a `CallExpression` whose callee is `.replace` AND whose
+// first argument is a `RegularExpressionLiteral` carrying the `g` flag
+// in its trailing flag block matches. The flag is read from the raw
+// source text — the AST does not split pattern from flags — using the
+// shared `nodeText` accessor.
+//
+// To preserve semantics, the pattern body must also be literal — any
+// regex metacharacter (`\`, `.`, `*`, `+`, `?`, `[`, `]`, `(`, `)`,
+// `{`, `}`, `|`, `^`, `$`) disqualifies the rewrite, because
+// `/<pat>/g` and `.replaceAll(<pat>, ...)` mean different things when
+// the pattern is anything but a fixed string.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-replace-all.md
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornPreferStringReplaceAll struct{}
+
+func (unicornPreferStringReplaceAll) Name() string { return "unicorn/prefer-string-replace-all" }
+func (unicornPreferStringReplaceAll) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStringReplaceAll) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "replace" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) < 1 {
+		return
+	}
+	first := stripParens(call.Arguments.Nodes[0])
+	if first == nil || first.Kind != shimast.KindRegularExpressionLiteral {
+		return
+	}
+	raw := nodeText(ctx.File, first)
+	if !unicornPreferStringReplaceAllHasGlobalFlag(raw) {
+		return
+	}
+	if !unicornPreferStringReplaceAllIsLiteralPattern(raw) {
+		return
+	}
+	ctx.Report(node, "Prefer `String#replaceAll(literal, replacement)` over `replace(/literal/g, replacement)`.")
+}
+
+// unicornPreferStringReplaceAllHasGlobalFlag returns true when `raw` (the
+// source text of a RegularExpressionLiteral, including the surrounding
+// `/` delimiters and trailing flag block) carries the `g` flag.
+func unicornPreferStringReplaceAllHasGlobalFlag(raw string) bool {
+	if len(raw) < 3 || raw[0] != '/' {
+		return false
+	}
+	closing := strings.LastIndexByte(raw, '/')
+	if closing <= 0 {
+		return false
+	}
+	flags := raw[closing+1:]
+	return strings.ContainsRune(flags, 'g')
+}
+
+// unicornPreferStringReplaceAllIsLiteralPattern returns true when the
+// pattern body of `raw` (the source text of a RegularExpressionLiteral)
+// contains no regex metacharacters. Conservative: any metachar — even
+// an escaped one like `\.` — disqualifies the rewrite, because
+// recovering the original character cleanly from raw source requires
+// regex-aware parsing we don't do here.
+func unicornPreferStringReplaceAllIsLiteralPattern(raw string) bool {
+	if len(raw) < 3 || raw[0] != '/' {
+		return false
+	}
+	closing := strings.LastIndexByte(raw, '/')
+	if closing <= 0 {
+		return false
+	}
+	body := raw[1:closing]
+	return !strings.ContainsAny(body, `\.*+?[](){}|^$`)
+}
+
+func init() {
+	Register(unicornPreferStringReplaceAll{})
+}

package/linthost/rules_unicorn_prefer_string_slice.go

@@ -0,0 +1,43 @@
+// unicorn/prefer-string-slice: `String#substr` is deprecated and
+// `String#substring` has surprising "swap arguments when end < start"
+// semantics. `String#slice` is the single modern alternative whose
+// behavior matches author intent. The rule fires on any `.substr(…)`
+// or `.substring(…)` callsite so the codebase converges on `.slice`.
+//
+// AST-only: a `CallExpression` whose callee is a
+// `PropertyAccessExpression` ending in `substr` or `substring`
+// matches. Receiver typing is intentionally not checked — both names
+// exist almost exclusively on strings in real code, and the
+// upstream rule treats them as banned regardless.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-slice.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferStringSlice struct{}
+
+func (unicornPreferStringSlice) Name() string { return "unicorn/prefer-string-slice" }
+func (unicornPreferStringSlice) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferStringSlice) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	switch identifierText(access.Name()) {
+	case "substr", "substring":
+	default:
+		return
+	}
+	ctx.Report(node, "Prefer `String#slice()` over `substr` / `substring`.")
+}
+
+func init() {
+	Register(unicornPreferStringSlice{})
+}