@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_prefer_switch.go

@@ -0,0 +1,103 @@
+// unicorn/prefer-switch: a long `if (x === "a") {…} else if (x === "b")
+// {…} else if (x === "c") {…}` ladder repeats both the discriminant and
+// the equality check on every branch; `switch (x)` collapses the cascade
+// into one labelled lookup and signals intent ("dispatch on the value of
+// x") more directly. The cliff for the rewrite is at three branches —
+// fewer than that, the if-cascade and the switch are about equally
+// readable.
+//
+// AST-only minimum-viable port: visit `IfStatement` and only fire on
+// the outermost `if` of a chain. Walk the else-chain and require it to
+// contain THREE OR MORE `else if` clauses whose condition is a
+// `BinaryExpression` with `===` (or `==`) AND whose left operand is
+// textually identical to the outermost if's left operand AND whose
+// right operand is a string-or-numeric literal. The outermost `if`
+// itself must satisfy the same shape. The shape constraint is
+// intentionally conservative — switch can only dispatch on equality
+// against literal labels.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-switch.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferSwitch struct{}
+
+func (unicornPreferSwitch) Name() string { return "unicorn/prefer-switch" }
+func (unicornPreferSwitch) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIfStatement}
+}
+func (unicornPreferSwitch) Check(ctx *Context, node *shimast.Node) {
+  // Only fire on the outermost if — if our parent is also an
+  // `IfStatement` whose else-branch is `node`, this is a middle of the
+  // chain and a higher-up visit will report it once.
+  if node.Parent != nil && node.Parent.Kind == shimast.KindIfStatement {
+    parent := node.Parent.AsIfStatement()
+    if parent != nil && parent.ElseStatement == node {
+      return
+    }
+  }
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return
+  }
+  discriminant, ok := unicornPreferSwitchDiscriminant(ctx, stmt.Expression)
+  if !ok {
+    return
+  }
+  // Count the outermost `if` plus every well-shaped `else if` that
+  // compares against the same discriminant.
+  branches := 1
+  cur := stmt.ElseStatement
+  for cur != nil && cur.Kind == shimast.KindIfStatement {
+    inner := cur.AsIfStatement()
+    if inner == nil || inner.Expression == nil {
+      return
+    }
+    next, ok := unicornPreferSwitchDiscriminant(ctx, inner.Expression)
+    if !ok || next != discriminant {
+      return
+    }
+    branches++
+    cur = inner.ElseStatement
+  }
+  if branches >= 3 {
+    ctx.Report(node, "Three or more `else if` clauses comparing the same value should be a `switch`.")
+  }
+}
+
+// unicornPreferSwitchDiscriminant returns the textual form of the left
+// operand of an `===`/`==` comparison against a string-or-numeric
+// literal. Returns ok=false for any other shape.
+func unicornPreferSwitchDiscriminant(ctx *Context, expr *shimast.Node) (string, bool) {
+  expr = stripParens(expr)
+  if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+    return "", false
+  }
+  bin := expr.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return "", false
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken, shimast.KindEqualsEqualsToken:
+  default:
+    return "", false
+  }
+  right := stripParens(bin.Right)
+  if right == nil {
+    return "", false
+  }
+  switch right.Kind {
+  case shimast.KindStringLiteral, shimast.KindNumericLiteral:
+  default:
+    return "", false
+  }
+  left := stripParens(bin.Left)
+  if left == nil {
+    return "", false
+  }
+  return nodeText(ctx.File, left), true
+}
+
+func init() {
+  Register(unicornPreferSwitch{})
+}

package/linthost/rules_unicorn_prefer_ternary.go

@@ -0,0 +1,71 @@
+// unicorn/prefer-ternary: when an `if`/`else` pair only differs in the
+// value being returned (or, in the upstream rule, assigned), the
+// equivalent `return cond ? a : b` is one line, removes the
+// duplicated `return` keyword, and matches the shape of every other
+// "pick one of two values" expression in the language.
+//
+// AST-only minimum-viable port: visit `IfStatement` and match only the
+// return-statement case. Both then- and else-branches must each be a
+// single `ReturnStatement` with a non-nil expression — either a bare
+// `return …;` directly under the if, or a block wrapping exactly one
+// such return. The assignment shape (`if (cond) x = a; else x = b;`)
+// from the upstream rule is out of scope for this MVP; both call sites
+// look syntactically symmetric, so adding the assignment branch later
+// is a straightforward extension.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-ternary.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferTernary struct{}
+
+func (unicornPreferTernary) Name() string { return "unicorn/prefer-ternary" }
+func (unicornPreferTernary) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIfStatement}
+}
+func (unicornPreferTernary) Check(ctx *Context, node *shimast.Node) {
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.ThenStatement == nil || stmt.ElseStatement == nil {
+    return
+  }
+  // Reject `else if` — an `if`/`else if`/`else` ladder is a different
+  // rewrite target (it becomes nested ternaries, which the upstream
+  // rule explicitly does not require).
+  if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+    return
+  }
+  if !unicornPreferTernaryIsSingleReturn(stmt.ThenStatement) {
+    return
+  }
+  if !unicornPreferTernaryIsSingleReturn(stmt.ElseStatement) {
+    return
+  }
+  ctx.Report(node, "Use a ternary instead of `if`/`else` whose branches differ only in the returned value.")
+}
+
+// unicornPreferTernaryIsSingleReturn reports whether `branch` is a
+// single `return expr;` — either directly or wrapped in a one-statement
+// block. Returns false for empty returns (`return;`); ternary cannot
+// fold those because both arms have to produce a value.
+func unicornPreferTernaryIsSingleReturn(branch *shimast.Node) bool {
+  if branch == nil {
+    return false
+  }
+  stmt := branch
+  if branch.Kind == shimast.KindBlock {
+    block := branch.AsBlock()
+    if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+      return false
+    }
+    stmt = block.Statements.Nodes[0]
+  }
+  if stmt == nil || stmt.Kind != shimast.KindReturnStatement {
+    return false
+  }
+  ret := stmt.AsReturnStatement()
+  return ret != nil && ret.Expression != nil
+}
+
+func init() {
+  Register(unicornPreferTernary{})
+}

package/linthost/rules_unicorn_prefer_top_level_await.go

@@ -0,0 +1,72 @@
+// unicorn/prefer-top-level-await: ES modules support top-level `await`,
+// which produces a flat synchronous-looking sequence and surfaces
+// rejections through the host. A `.then(cb)` continuation at the module
+// scope re-introduces the callback shape the host could have flattened
+// for free, and silently swallows rejections unless the author wires up
+// an explicit `.catch`.
+//
+// AST-only minimum-viable port: visit `CallExpression` and fire when the
+// callee is `PropertyAccess(_, then)` AND the call sits at the top
+// level of the source file — i.e., walking parents from the call's
+// enclosing statement, the first statement-ancestor's parent is a
+// `SourceFile`. Calls inside a function, class, namespace body, or
+// inside any nested block are excluded; top-level `await` only applies
+// to the module body.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-top-level-await.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferTopLevelAwait struct{}
+
+func (unicornPreferTopLevelAwait) Name() string { return "unicorn/prefer-top-level-await" }
+func (unicornPreferTopLevelAwait) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornPreferTopLevelAwait) 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()) != "then" {
+    return
+  }
+  if !unicornPreferTopLevelAwaitIsTopLevel(node) {
+    return
+  }
+  ctx.Report(node, "Prefer top-level `await` over `.then` chains in ES modules.")
+}
+
+// unicornPreferTopLevelAwaitIsTopLevel walks ancestors and reports
+// whether `node` is positioned in the top-level statement list of a
+// `SourceFile`. The walk crosses parenthesized expressions and
+// expression statements; it stops the moment it sees any function-like,
+// class-body, block, or module-block boundary, which would push the call
+// out of module scope.
+func unicornPreferTopLevelAwaitIsTopLevel(node *shimast.Node) bool {
+  for cur := node.Parent; cur != nil; cur = cur.Parent {
+    switch cur.Kind {
+    case shimast.KindSourceFile:
+      return true
+    case shimast.KindFunctionDeclaration,
+      shimast.KindFunctionExpression,
+      shimast.KindArrowFunction,
+      shimast.KindMethodDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor,
+      shimast.KindConstructor,
+      shimast.KindClassDeclaration,
+      shimast.KindClassExpression,
+      shimast.KindModuleBlock,
+      shimast.KindBlock:
+      return false
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(unicornPreferTopLevelAwait{})
+}

package/linthost/rules_unicorn_prefer_type_error.go

@@ -0,0 +1,127 @@
+// unicorn/prefer-type-error: a guard whose condition is a runtime
+// `typeof` / `instanceof` check throws to signal "wrong type", not
+// "wrong value". JavaScript's `TypeError` exists precisely for that
+// distinction, and tooling (e.g. assertion libraries) treats the two
+// error classes differently. The rule asks throwers to switch from
+// `Error` to `TypeError` whenever the surrounding check is a type
+// check.
+//
+// AST-only: visit every `IfStatement`, require its condition (after
+// `stripParens`, optionally unwrapping a `!` prefix) to be a runtime
+// type check — either a `KindTypeOfExpression`, a `KindBinaryExpression`
+// with the `instanceof` operator, or a `==` / `===` / `!=` / `!==`
+// comparison where one side is a `typeof` expression. The then-branch
+// must be a single `KindThrowStatement` of `new Error(...)`. Fire on
+// the throw.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-type-error.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornPreferTypeError struct{}
+
+func (unicornPreferTypeError) Name() string { return "unicorn/prefer-type-error" }
+func (unicornPreferTypeError) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIfStatement}
+}
+func (unicornPreferTypeError) Check(ctx *Context, node *shimast.Node) {
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.Expression == nil || stmt.ThenStatement == nil {
+    return
+  }
+  cond := stripParens(stmt.Expression)
+  if cond == nil {
+    return
+  }
+  // Accept either the bare type check (`typeof x !== "number"`) or a
+  // negation of one (`!(x instanceof Foo)`).
+  if cond.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := cond.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
+      return
+    }
+    cond = stripParens(prefix.Operand)
+  }
+  if !unicornPreferTypeErrorIsTypeCheck(cond) {
+    return
+  }
+  throw := unicornPreferTypeErrorSingleThrow(stmt.ThenStatement)
+  if throw == nil {
+    return
+  }
+  throwStmt := throw.AsThrowStatement()
+  if throwStmt == nil {
+    return
+  }
+  expr := stripParens(throwStmt.Expression)
+  if expr == nil || expr.Kind != shimast.KindNewExpression {
+    return
+  }
+  ne := expr.AsNewExpression()
+  if ne == nil || identifierText(ne.Expression) != "Error" {
+    return
+  }
+  ctx.Report(throw, "Throw `TypeError` (not `Error`) when the surrounding check is a runtime type check.")
+}
+
+// unicornPreferTypeErrorIsTypeCheck reports whether `node` is a
+// `typeof x` expression or `x instanceof Y` BinaryExpression. Both
+// shapes encode a runtime type test, which is what the rule keys off.
+func unicornPreferTypeErrorIsTypeCheck(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindTypeOfExpression:
+    return true
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    if bin.OperatorToken.Kind == shimast.KindInstanceOfKeyword {
+      return true
+    }
+    // `typeof x !== "string"` style — covers the common idiom.
+    switch bin.OperatorToken.Kind {
+    case shimast.KindEqualsEqualsEqualsToken,
+      shimast.KindEqualsEqualsToken,
+      shimast.KindExclamationEqualsEqualsToken,
+      shimast.KindExclamationEqualsToken:
+      left := stripParens(bin.Left)
+      right := stripParens(bin.Right)
+      return (left != nil && left.Kind == shimast.KindTypeOfExpression) ||
+        (right != nil && right.Kind == shimast.KindTypeOfExpression)
+    }
+  }
+  return false
+}
+
+// unicornPreferTypeErrorSingleThrow returns the single `throw`
+// statement inside `branch` — accepting either a bare ThrowStatement
+// or a Block wrapping exactly one ThrowStatement. Returns nil for any
+// other shape.
+func unicornPreferTypeErrorSingleThrow(branch *shimast.Node) *shimast.Node {
+  if branch == nil {
+    return nil
+  }
+  if branch.Kind == shimast.KindThrowStatement {
+    return branch
+  }
+  if branch.Kind != shimast.KindBlock {
+    return nil
+  }
+  block := branch.AsBlock()
+  if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+    return nil
+  }
+  stmt := block.Statements.Nodes[0]
+  if stmt == nil || stmt.Kind != shimast.KindThrowStatement {
+    return nil
+  }
+  return stmt
+}
+
+func init() {
+  Register(unicornPreferTypeError{})
+}

package/linthost/rules_unicorn_prevent_abbreviations.go

@@ -0,0 +1,127 @@
+// unicorn/prevent-abbreviations: abbreviated identifier names (`err`,
+// `cb`, `ctx`, `idx`) are a project-wide readability tax — every
+// reader has to expand the shorthand mentally on the spot. The
+// upstream rule maintains a large allowlist + replacements map; this
+// MVP carries the most universal abbreviations only and fires on any
+// identifier whose lower-cased text matches one of them, in both
+// reference and declaration positions, so a `param` parameter and a
+// `void param` read are both reported.
+//
+// AST-only: visit every `Identifier`, lowercase the lexeme, look it up
+// in `unicornPreventAbbreviationsDictionary`. No scope analysis is
+// performed because the rule's diagnostic is about the *name*, not the
+// binding — every occurrence of `idx` is equally noisy.
+//
+// Hot-path budget: `KindIdentifier` is the most frequent AST kind in
+// any TypeScript program, so this Check is invoked tens-of-thousands
+// of times per file. A length pre-filter eliminates ~90 % of inputs
+// without touching memory (the longest dictionary entry is six
+// characters); an additional `isAllLowerASCII` check skips
+// `strings.ToLower`'s allocation for the common case of already-
+// lower-cased identifiers.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prevent-abbreviations.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// unicornPreventAbbreviationsDictionary is the MVP allowlist of
+// abbreviations that fire the rule. Lower-cased keys; the rule
+// case-folds the identifier before lookup. Intentionally conservative
+// — picks the abbreviations universally agreed across upstream
+// presets so the rule doesn't flap on neutral words.
+var unicornPreventAbbreviationsDictionary = map[string]struct{}{
+  "arr":    {},
+  "args":   {},
+  "attr":   {},
+  "btn":    {},
+  "cb":     {},
+  "cmd":    {},
+  "ctx":    {},
+  "db":     {},
+  "dest":   {},
+  "dir":    {},
+  "doc":    {},
+  "el":     {},
+  "elem":   {},
+  "env":    {},
+  "err":    {},
+  "evt":    {},
+  "fn":     {},
+  "func":   {},
+  "idx":    {},
+  "len":    {},
+  "lib":    {},
+  "mgr":    {},
+  "mod":    {},
+  "msg":    {},
+  "num":    {},
+  "obj":    {},
+  "opts":   {},
+  "param":  {},
+  "params": {},
+  "pkg":    {},
+  "prev":   {},
+  "prop":   {},
+  "props":  {},
+  "ref":    {},
+  "res":    {},
+  "ret":    {},
+  "src":    {},
+  "str":    {},
+  "tmp":    {},
+  "val":    {},
+  "var":    {},
+}
+
+// unicornPreventAbbreviationsMaxLen is the longest dictionary key
+// length. Any identifier longer than this cannot match — the Check
+// returns immediately without touching the dictionary.
+const unicornPreventAbbreviationsMaxLen = 6
+
+type unicornPreventAbbreviations struct{}
+
+func (unicornPreventAbbreviations) Name() string { return "unicorn/prevent-abbreviations" }
+func (unicornPreventAbbreviations) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindIdentifier}
+}
+func (unicornPreventAbbreviations) Check(ctx *Context, node *shimast.Node) {
+  name := identifierText(node)
+  if name == "" || len(name) > unicornPreventAbbreviationsMaxLen {
+    return
+  }
+  // Fast path: dictionary keys are pre-lowercased, so an
+  // already-lower-case identifier avoids `strings.ToLower`'s
+  // allocation entirely. The Check is invoked once per identifier
+  // in the file, so the saved allocations multiply.
+  lookup := name
+  if !isAllLowerASCII(name) {
+    lookup = strings.ToLower(name)
+  }
+  if _, ok := unicornPreventAbbreviationsDictionary[lookup]; !ok {
+    return
+  }
+  ctx.Report(node, "Prefer the long form over abbreviated identifiers (e.g. `error` over `err`).")
+}
+
+// isAllLowerASCII reports whether `s` is a non-empty ASCII string
+// whose every byte is a lower-case letter. Used by hot-path Checks
+// that look up an already-normalized dictionary — the result is
+// equivalent to `s == strings.ToLower(s)` for all-ASCII inputs but
+// avoids the lowercase allocation.
+func isAllLowerASCII(s string) bool {
+  for i := 0; i < len(s); i++ {
+    c := s[i]
+    if c >= 'A' && c <= 'Z' {
+      return false
+    }
+  }
+  return true
+}
+
+func init() {
+  Register(unicornPreventAbbreviations{})
+}

package/linthost/rules_unicorn_relative_url_style.go

@@ -0,0 +1,49 @@
+// unicorn/relative-url-style: `new URL("./foo", base)` and
+// `new URL("foo", base)` resolve identically, so the leading `./` is
+// noise. The rule normalizes on the "never leading `./`" style and
+// fires whenever a `new URL(…)` literal first argument starts with
+// `./`.
+//
+// AST-only: visit `KindNewExpression`, accept when the callee is the
+// bare `URL` identifier, and inspect the first argument — when it's a
+// string-shaped literal whose text starts with `./`, report the
+// argument node. Absolute URLs (`http://…`), schemeless protocol
+// references, and paths starting with `/` or `../` are untouched; only
+// the explicit `./` prefix is the redundant case the rule targets.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/relative-url-style.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornRelativeURLStyle struct{}
+
+func (unicornRelativeURLStyle) Name() string { return "unicorn/relative-url-style" }
+func (unicornRelativeURLStyle) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNewExpression}
+}
+func (unicornRelativeURLStyle) Check(ctx *Context, node *shimast.Node) {
+  expr := node.AsNewExpression()
+  if expr == nil || identifierText(expr.Expression) != "URL" {
+    return
+  }
+  if expr.Arguments == nil || len(expr.Arguments.Nodes) == 0 {
+    return
+  }
+  arg := expr.Arguments.Nodes[0]
+  text := stringLiteralText(arg)
+  if text == "" {
+    return
+  }
+  if strings.HasPrefix(text, "./") {
+    ctx.Report(arg, "Drop the leading `./` from relative URLs passed to `new URL`.")
+  }
+}
+
+func init() {
+  Register(unicornRelativeURLStyle{})
+}

package/linthost/rules_unicorn_require_array_join_separator.go

@@ -0,0 +1,45 @@
+// unicorn/require-array-join-separator: `Array#join()` defaults its
+// separator to a comma when called with no arguments. Authors rarely
+// mean to rely on that — the implicit separator is locale-flavored in
+// related APIs (`Intl.ListFormat`) and the comma default is one of the
+// quieter sources of "why is this comma here?" diffs. The rule pushes
+// every call site to spell out the separator so the intent is in the
+// source.
+//
+// AST-only: visit each `CallExpression`, accept only the property-access
+// `x.join` shape, and report when the call carries zero arguments. Any
+// explicit argument — empty string included — passes.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-array-join-separator.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireArrayJoinSeparator struct{}
+
+func (unicornRequireArrayJoinSeparator) Name() string {
+  return "unicorn/require-array-join-separator"
+}
+func (unicornRequireArrayJoinSeparator) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornRequireArrayJoinSeparator) 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
+  }
+  if identifierText(access.Name()) != "join" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Pass an explicit separator argument to `Array#join()`.")
+}
+
+func init() {
+  Register(unicornRequireArrayJoinSeparator{})
+}

package/linthost/rules_unicorn_require_module_attributes.go

@@ -0,0 +1,54 @@
+// unicorn/require-module-attributes: import / export `with { … }`
+// clauses carry semantic information (`type: "json"`, `type: "css"`).
+// Writing `with {}` with no entries serves no purpose and is almost
+// always a mistake. The rule fires when an import or export carries an
+// attributes clause with zero attribute entries.
+//
+// AST-only: visit `KindImportDeclaration` and `KindExportDeclaration`,
+// follow the `.Attributes` field (an `ImportAttributesNode`), descend
+// into its inner `ImportAttributes.Attributes` list, and report when
+// the list is present but empty. The clause-present-but-empty shape is
+// rare in practice but legal syntax, so a precise zero-entry check is
+// the right anchor.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-module-attributes.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireModuleAttributes struct{}
+
+func (unicornRequireModuleAttributes) Name() string {
+  return "unicorn/require-module-attributes"
+}
+func (unicornRequireModuleAttributes) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+}
+func (unicornRequireModuleAttributes) Check(ctx *Context, node *shimast.Node) {
+  var attrs *shimast.Node
+  switch node.Kind {
+  case shimast.KindImportDeclaration:
+    if decl := node.AsImportDeclaration(); decl != nil {
+      attrs = decl.Attributes
+    }
+  case shimast.KindExportDeclaration:
+    if decl := node.AsExportDeclaration(); decl != nil {
+      attrs = decl.Attributes
+    }
+  }
+  if attrs == nil {
+    return
+  }
+  imp := attrs.AsImportAttributes()
+  if imp == nil {
+    return
+  }
+  if imp.Attributes != nil && len(imp.Attributes.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Import/export `with {}` should have at least one attribute.")
+}
+
+func init() {
+  Register(unicornRequireModuleAttributes{})
+}