@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_gap.go

@@ -13,7 +13,7 @@ import (
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// no-empty-static-block: `class C { static {} }` has no effect.
+// noEmptyStaticBlock: `class C { static {} }` has no effect.
 // ESLint recommended: https://eslint.org/docs/latest/rules/no-empty-static-block
 type noEmptyStaticBlock struct{}
 
@@ -32,7 +32,7 @@ func (noEmptyStaticBlock) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-setter-return: setters must not return a value.
+// noSetterReturn: setters must not return a value.
 // ESLint recommended: https://eslint.org/docs/latest/rules/no-setter-return
 type noSetterReturn struct{}
 
@@ -61,7 +61,7 @@ func isInsideDirectSetter(node *shimast.Node) bool {
   return false
 }
 
-// no-unused-labels: a label is useful only when a break/continue targets it.
+// noUnusedLabels: a label is useful only when a break/continue targets it.
 // ESLint recommended: https://eslint.org/docs/latest/rules/no-unused-labels
 type noUnusedLabels struct{}
 
@@ -95,11 +95,11 @@ func (noUnusedLabels) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-dynamic-delete: avoid deleting properties through dynamic keys.
+// noDynamicDelete: avoid deleting properties through dynamic keys.
 // typescript-eslint strict: https://typescript-eslint.io/rules/no-dynamic-delete/
 type noDynamicDelete struct{}
 
-func (noDynamicDelete) Name() string           { return "no-dynamic-delete" }
+func (noDynamicDelete) Name() string           { return "typescript/no-dynamic-delete" }
 func (noDynamicDelete) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindDeleteExpression} }
 func (noDynamicDelete) Check(ctx *Context, node *shimast.Node) {
   del := node.AsDeleteExpression()
@@ -114,7 +114,7 @@ func (noDynamicDelete) Check(ctx *Context, node *shimast.Node) {
 }
 
 // isStaticPropertyKey reports whether node is a literal key that can
-// appear in a delete expression without triggering no-dynamic-delete:
+// appear in a delete expression without triggering noDynamicDelete:
 // string literals, no-substitution template literals, and numeric literals.
 func isStaticPropertyKey(node *shimast.Node) bool {
   node = stripParens(node)
@@ -130,12 +130,12 @@ func isStaticPropertyKey(node *shimast.Node) bool {
   return false
 }
 
-// no-non-null-asserted-nullish-coalescing: `foo! ?? bar` is contradictory.
+// noNonNullAssertedNullishCoalescing: `foo! ?? bar` is contradictory.
 // typescript-eslint strict: https://typescript-eslint.io/rules/no-non-null-asserted-nullish-coalescing/
 type noNonNullAssertedNullishCoalescing struct{}
 
 func (noNonNullAssertedNullishCoalescing) Name() string {
-  return "no-non-null-asserted-nullish-coalescing"
+  return "typescript/no-non-null-asserted-nullish-coalescing"
 }
 func (noNonNullAssertedNullishCoalescing) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindBinaryExpression}
@@ -153,11 +153,11 @@ func (noNonNullAssertedNullishCoalescing) Check(ctx *Context, node *shimast.Node
   }
 }
 
-// no-unnecessary-type-constraint: `<T extends any>` / `<T extends unknown>`.
+// noUnnecessaryTypeConstraint: `<T extends any>` / `<T extends unknown>`.
 // typescript-eslint recommended: https://typescript-eslint.io/rules/no-unnecessary-type-constraint/
 type noUnnecessaryTypeConstraint struct{}
 
-func (noUnnecessaryTypeConstraint) Name() string { return "no-unnecessary-type-constraint" }
+func (noUnnecessaryTypeConstraint) Name() string { return "typescript/no-unnecessary-type-constraint" }
 func (noUnnecessaryTypeConstraint) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindTypeParameter}
 }
@@ -184,11 +184,11 @@ func (noUnnecessaryTypeConstraint) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// no-unsafe-function-type: `Function` accepts any callable shape.
+// noUnsafeFunctionType: `Function` accepts any callable shape.
 // typescript-eslint recommended: https://typescript-eslint.io/rules/no-unsafe-function-type/
 type noUnsafeFunctionType struct{}
 
-func (noUnsafeFunctionType) Name() string           { return "no-unsafe-function-type" }
+func (noUnsafeFunctionType) Name() string           { return "typescript/no-unsafe-function-type" }
 func (noUnsafeFunctionType) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindTypeReference} }
 func (noUnsafeFunctionType) Check(ctx *Context, node *shimast.Node) {
   ref := node.AsTypeReferenceNode()
@@ -198,12 +198,12 @@ func (noUnsafeFunctionType) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "The Function type is unsafe. Use a specific function type instead.")
 }
 
-// no-wrapper-object-types: prefer primitive type keywords over boxed object
+// noWrapperObjectTypes: prefer primitive type keywords over boxed object
 // type names such as `String` and `Boolean`.
 // typescript-eslint recommended: https://typescript-eslint.io/rules/no-wrapper-object-types/
 type noWrapperObjectTypes struct{}
 
-func (noWrapperObjectTypes) Name() string           { return "no-wrapper-object-types" }
+func (noWrapperObjectTypes) Name() string           { return "typescript/no-wrapper-object-types" }
 func (noWrapperObjectTypes) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindTypeReference} }
 func (noWrapperObjectTypes) Check(ctx *Context, node *shimast.Node) {
   ref := node.AsTypeReferenceNode()
@@ -301,31 +301,11 @@ func wrapperPrimitive(name string) (string, bool) {
   return "", false
 }
 
-// no-useless-constructor: an empty constructor with no parameters is noise.
-// typescript-eslint strict: https://typescript-eslint.io/rules/no-useless-constructor/
-type noUselessConstructor struct{}
-
-func (noUselessConstructor) Name() string           { return "no-useless-constructor" }
-func (noUselessConstructor) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindConstructor} }
-func (noUselessConstructor) Check(ctx *Context, node *shimast.Node) {
-  ctor := node.AsConstructorDeclaration()
-  if ctor == nil || ctor.Body == nil {
-    return
-  }
-  if len(node.Parameters()) != 0 {
-    return
-  }
-  body := ctor.Body.AsBlock()
-  if body == nil || body.Statements == nil || len(body.Statements.Nodes) == 0 {
-    ctx.Report(node, "Useless empty constructor.")
-  }
-}
-
-// prefer-literal-enum-member: computed enum members are harder to inspect.
+// preferLiteralEnumMember: computed enum members are harder to inspect.
 // typescript-eslint strict: https://typescript-eslint.io/rules/prefer-literal-enum-member/
 type preferLiteralEnumMember struct{}
 
-func (preferLiteralEnumMember) Name() string           { return "prefer-literal-enum-member" }
+func (preferLiteralEnumMember) Name() string           { return "typescript/prefer-literal-enum-member" }
 func (preferLiteralEnumMember) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindEnumMember} }
 func (preferLiteralEnumMember) Check(ctx *Context, node *shimast.Node) {
   member := node.AsEnumMember()
@@ -335,11 +315,11 @@ func (preferLiteralEnumMember) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(member.Initializer, "Enum member initializer should be a literal value.")
 }
 
-// consistent-type-assertions: prefer `value as Type` over `<Type>value`.
+// consistentTypeAssertions: prefer `value as Type` over `<Type>value`.
 // typescript-eslint stylistic: https://typescript-eslint.io/rules/consistent-type-assertions/
 type consistentTypeAssertions struct{}
 
-func (consistentTypeAssertions) Name() string { return "consistent-type-assertions" }
+func (consistentTypeAssertions) Name() string { return "typescript/consistent-type-assertions" }
 func (consistentTypeAssertions) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindTypeAssertionExpression}
 }
@@ -347,12 +327,12 @@ func (consistentTypeAssertions) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Use `as` type assertions instead of angle-bracket assertions.")
 }
 
-// consistent-type-definitions: prefer interfaces for object-shaped public
+// consistentTypeDefinitions: prefer interfaces for object-shaped public
 // contracts. This mirrors typescript-eslint's default option.
 // typescript-eslint stylistic: https://typescript-eslint.io/rules/consistent-type-definitions/
 type consistentTypeDefinitions struct{}
 
-func (consistentTypeDefinitions) Name() string { return "consistent-type-definitions" }
+func (consistentTypeDefinitions) Name() string { return "typescript/consistent-type-definitions" }
 func (consistentTypeDefinitions) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindTypeAliasDeclaration}
 }
@@ -364,7 +344,7 @@ func (consistentTypeDefinitions) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Use an interface instead of a type literal alias.")
 }
 
-// dot-notation: `obj["prop"]` should be `obj.prop` when the key is a valid
+// dotNotation: `obj["prop"]` should be `obj.prop` when the key is a valid
 // identifier.
 // ESLint canonical: https://eslint.org/docs/latest/rules/dot-notation
 type dotNotation struct{}
@@ -436,7 +416,7 @@ func isReservedWord(value string) bool {
 
 // isSimpleIdentifierName reports whether value is a valid bare identifier
 // (ASCII letters, digits, underscore, dollar sign; digits not first). Used
-// by dot-notation to decide whether bracket access can become dot access.
+// by dotNotation to decide whether bracket access can become dot access.
 func isSimpleIdentifierName(value string) bool {
   if value == "" {
     return false
@@ -453,12 +433,12 @@ func isSimpleIdentifierName(value string) bool {
   return true
 }
 
-// no-unsafe-declaration-merging: class/interface merging hides runtime vs type
+// noUnsafeDeclarationMerging: class/interface merging hides runtime vs type
 // surface differences.
 // typescript-eslint recommended: https://typescript-eslint.io/rules/no-unsafe-declaration-merging/
 type noUnsafeDeclarationMerging struct{}
 
-func (noUnsafeDeclarationMerging) Name() string { return "no-unsafe-declaration-merging" }
+func (noUnsafeDeclarationMerging) Name() string { return "typescript/no-unsafe-declaration-merging" }
 func (noUnsafeDeclarationMerging) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindSourceFile}
 }
@@ -500,7 +480,6 @@ func init() {
   Register(noUnsafeDeclarationMerging{})
   Register(noUnsafeFunctionType{})
   Register(noWrapperObjectTypes{})
-  Register(noUselessConstructor{})
   Register(preferLiteralEnumMember{})
   Register(consistentTypeAssertions{})
   Register(consistentTypeDefinitions{})

package/linthost/rules_grouped_accessor_pairs.go

@@ -0,0 +1,87 @@
+// groupedAccessorPairs: a `get` and `set` accessor that share the same
+// property name should be declared next to each other in the class
+// body. When the pair is split apart by unrelated members, a reader
+// scanning the class has to chase the read and write halves separately
+// — and patches to one half are easy to make without noticing the
+// other.
+//
+// AST-only: walk every class declaration/expression, group members by
+// (name, static-ness), and for any group that contains both a getter
+// and a setter check that their member indices are adjacent. The
+// second-encountered half is the one reported, because the first half
+// reads correctly until the reader hits the second declaration.
+// https://eslint.org/docs/latest/rules/grouped-accessor-pairs
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type groupedAccessorPairs struct{}
+
+func (groupedAccessorPairs) Name() string { return "grouped-accessor-pairs" }
+func (groupedAccessorPairs) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindClassDeclaration, shimast.KindClassExpression}
+}
+func (groupedAccessorPairs) Check(ctx *Context, node *shimast.Node) {
+	members := classMembers(node)
+	if len(members) < 2 {
+		return
+	}
+	type slot struct {
+		name   string
+		static bool
+	}
+	type entry struct {
+		index int
+		kind  shimast.Kind
+		node  *shimast.Node
+	}
+	groups := map[slot][]entry{}
+	for i, member := range members {
+		if member == nil {
+			continue
+		}
+		if member.Kind != shimast.KindGetAccessor && member.Kind != shimast.KindSetAccessor {
+			continue
+		}
+		name := classMemberName(member)
+		if name == "" {
+			continue
+		}
+		key := slot{name: name, static: hasModifier(member, shimast.KindStaticKeyword)}
+		groups[key] = append(groups[key], entry{index: i, kind: member.Kind, node: member})
+	}
+	for _, entries := range groups {
+		if len(entries) < 2 {
+			continue
+		}
+		// Find a getter/setter pair within the group.
+		var get, set *entry
+		for i := range entries {
+			e := &entries[i]
+			if e.kind == shimast.KindGetAccessor && get == nil {
+				get = e
+			} else if e.kind == shimast.KindSetAccessor && set == nil {
+				set = e
+			}
+		}
+		if get == nil || set == nil {
+			continue
+		}
+		// Adjacent indices in the members list satisfy the rule.
+		diff := get.index - set.index
+		if diff == 1 || diff == -1 {
+			continue
+		}
+		// Report on whichever half appears later — the earlier one
+		// reads fine in isolation; the later one is the surprise.
+		later := get
+		if set.index > get.index {
+			later = set
+		}
+		ctx.Report(later.node, "Accessor pair should be grouped.")
+	}
+}
+
+func init() {
+	Register(groupedAccessorPairs{})
+}

package/linthost/rules_guard_for_in.go

@@ -0,0 +1,198 @@
+// guardForIn: `for (key in obj)` walks the prototype chain and yields
+// every enumerable name, inherited or own. Most authors only ever care
+// about own keys, so an unguarded body silently leaks work onto
+// prototype-chain entries someone else attached. The canonical guard is
+// `if (Object.hasOwn(obj, key))` or the older
+// `Object.prototype.hasOwnProperty.call(obj, key)`; an inverted-guard
+// `continue` (`if (!Object.hasOwn(...)) continue;`) is the equivalent
+// early-skip shape.
+//
+// Conservative baseline: the rule only inspects the FIRST executable
+// statement of the loop body. The body either opens with a guard
+// covering everything that follows, or it does not — anything more
+// nuanced is the developer's responsibility. The guard expression must
+// reference the loop's own key binding; a hard-coded call on an
+// unrelated identifier is not a real guard.
+// https://eslint.org/docs/latest/rules/guard-for-in
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type guardForIn struct{}
+
+func (guardForIn) Name() string           { return "guard-for-in" }
+func (guardForIn) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindForInStatement} }
+func (guardForIn) Check(ctx *Context, node *shimast.Node) {
+	stmt := node.AsForInOrOfStatement()
+	if stmt == nil || stmt.Statement == nil {
+		return
+	}
+	first := firstBodyStatement(stmt.Statement)
+	if first == nil {
+		return
+	}
+	key := forInKeyName(stmt.Initializer)
+	if isHasOwnGuard(first, key) {
+		return
+	}
+	ctx.Report(node, "The body of a `for...in` should be wrapped in an `if (Object.hasOwn(...))` statement to filter unwanted properties from the prototype.")
+}
+
+// firstBodyStatement returns the first executable statement inside a
+// loop body. A block body unwraps to its first statement; a bare
+// non-block body is itself the only statement. Returns nil for an
+// empty block — an empty body cannot leak inherited keys.
+func firstBodyStatement(body *shimast.Node) *shimast.Node {
+	if body == nil {
+		return nil
+	}
+	if body.Kind != shimast.KindBlock {
+		return body
+	}
+	block := body.AsBlock()
+	if block == nil || block.Statements == nil {
+		return nil
+	}
+	for _, s := range block.Statements.Nodes {
+		if s != nil {
+			return s
+		}
+	}
+	return nil
+}
+
+// forInKeyName extracts the identifier text of the loop key from a
+// `for (… in obj)` initializer. The initializer is either a
+// VariableDeclarationList with one declaration (`for (const key in …)`)
+// or a bare Identifier (`for (key in …)`). Destructuring patterns and
+// other shapes return "" so the rule skips its key-identity check.
+func forInKeyName(init *shimast.Node) string {
+	if init == nil {
+		return ""
+	}
+	if name := identifierText(init); name != "" {
+		return name
+	}
+	if init.Kind != shimast.KindVariableDeclarationList {
+		return ""
+	}
+	list := init.AsVariableDeclarationList()
+	if list == nil || list.Declarations == nil || len(list.Declarations.Nodes) != 1 {
+		return ""
+	}
+	decl := list.Declarations.Nodes[0]
+	if decl == nil {
+		return ""
+	}
+	v := decl.AsVariableDeclaration()
+	if v == nil {
+		return ""
+	}
+	return identifierText(v.Name())
+}
+
+// isHasOwnGuard reports whether `stmt` is the canonical own-key guard
+// that should open a `for...in` body. Two shapes count:
+//
+//  1. `if (<has-own>(obj, key)) { … }` — positive guard wrapping the
+//     real body. The else branch (if any) is allowed because the
+//     developer has explicitly handled the inherited-key case.
+//  2. `if (!<has-own>(obj, key)) continue;` — inverted-guard early
+//     skip. The then branch must be a single `continue` (with or
+//     without a block wrapper) so the rest of the loop body only runs
+//     for own keys.
+//
+// `<has-own>` is either `Object.hasOwn(obj, key)` or
+// `Object.prototype.hasOwnProperty.call(obj, key)`. The second
+// argument must match `key` when one was extracted from the
+// initializer; otherwise any second argument is accepted (the rule
+// has no reliable handle on the key name).
+func isHasOwnGuard(stmt *shimast.Node, key string) bool {
+	if stmt == nil || stmt.Kind != shimast.KindIfStatement {
+		return false
+	}
+	ifStmt := stmt.AsIfStatement()
+	if ifStmt == nil || ifStmt.Expression == nil {
+		return false
+	}
+	cond := stripParens(ifStmt.Expression)
+	if cond == nil {
+		return false
+	}
+	if isHasOwnCall(cond, key) {
+		return true
+	}
+	if cond.Kind != shimast.KindPrefixUnaryExpression {
+		return false
+	}
+	pre := cond.AsPrefixUnaryExpression()
+	if pre == nil || pre.Operator != shimast.KindExclamationToken {
+		return false
+	}
+	if !isHasOwnCall(stripParens(pre.Operand), key) {
+		return false
+	}
+	// Negated guard: require the then branch to be a single `continue`
+	// so the rest of the loop runs only for own keys.
+	return isLoneContinue(ifStmt.ThenStatement)
+}
+
+// isHasOwnCall reports whether `node` is `Object.hasOwn(obj, key)` or
+// `Object.prototype.hasOwnProperty.call(obj, key)`. The second
+// argument must match `key` when one is supplied.
+func isHasOwnCall(node *shimast.Node, key string) bool {
+	if node == nil || node.Kind != shimast.KindCallExpression {
+		return false
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Arguments == nil {
+		return false
+	}
+	args := call.Arguments.Nodes
+	if len(args) < 2 {
+		return false
+	}
+	callee := stripParens(call.Expression)
+	switch {
+	case isMatchingPropertyAccess(callee, "Object", "hasOwn"):
+		// `Object.hasOwn(obj, key)` — both arguments belong to the
+		// caller; the key check is the second argument.
+	case isMatchingPropertyAccess(callee, "Object", "prototype", "hasOwnProperty", "call"):
+		// `Object.prototype.hasOwnProperty.call(obj, key)` — same
+		// argument layout because `.call(obj, key)` passes the
+		// receiver explicitly.
+	default:
+		return false
+	}
+	if key == "" {
+		return true
+	}
+	return identifierText(stripParens(args[1])) == key
+}
+
+// isLoneContinue reports whether `stmt` is a bare `continue;` (or a
+// block containing exactly one `continue;`). Used to validate the
+// then-branch of the negated-guard shape.
+func isLoneContinue(stmt *shimast.Node) bool {
+	if stmt == nil {
+		return false
+	}
+	if stmt.Kind == shimast.KindContinueStatement {
+		return true
+	}
+	if stmt.Kind != shimast.KindBlock {
+		return false
+	}
+	block := stmt.AsBlock()
+	if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+		return false
+	}
+	return block.Statements.Nodes[0] != nil &&
+		block.Statements.Nodes[0].Kind == shimast.KindContinueStatement
+}
+
+func init() {
+	Register(guardForIn{})
+}

package/linthost/rules_id_length.go

@@ -0,0 +1,77 @@
+// idLength reports declaration names shorter than the default minimum
+// of two characters. Single-letter bindings (`a`, `x`, `t`) are
+// notoriously hard to grep, fold poorly into call-site documentation,
+// and frequently collide with the convention of using single letters
+// only for true free variables.
+// https://eslint.org/docs/latest/rules/id-length
+//
+// Conservative baseline: only the four declaration kinds the ESLint
+// rule documents as in-scope are inspected — variable, function,
+// class, and parameter declarations. Each name is read through the
+// shared `identifierText` helper so destructuring patterns and
+// computed property names contribute zero findings.
+package linthost
+
+import (
+	"strconv"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// idLengthMinimum is the default minimum identifier length. ESLint
+// uses 2; mirroring it keeps the rule's default behavior aligned with
+// upstream and lets the existing fixture annotations remain stable.
+const idLengthMinimum = 2
+
+type idLength struct{}
+
+func (idLength) Name() string { return "id-length" }
+func (idLength) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindVariableDeclaration,
+		shimast.KindParameter,
+		shimast.KindFunctionDeclaration,
+		shimast.KindClassDeclaration,
+	}
+}
+func (idLength) Check(ctx *Context, node *shimast.Node) {
+	var nameNode *shimast.Node
+	switch node.Kind {
+	case shimast.KindVariableDeclaration:
+		decl := node.AsVariableDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	case shimast.KindParameter:
+		decl := node.AsParameterDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	case shimast.KindFunctionDeclaration:
+		decl := node.AsFunctionDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	case shimast.KindClassDeclaration:
+		decl := node.AsClassDeclaration()
+		if decl == nil {
+			return
+		}
+		nameNode = decl.Name()
+	}
+	name := identifierText(nameNode)
+	if name == "" {
+		return
+	}
+	if len([]rune(name)) >= idLengthMinimum {
+		return
+	}
+	ctx.Report(nameNode, "Identifier name '"+name+"' is too short (< "+strconv.Itoa(idLengthMinimum)+").")
+}
+
+func init() {
+	Register(idLength{})
+}

package/linthost/rules_imports.go

@@ -5,14 +5,14 @@ import (
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// no-import-type-side-effects: an import whose every named specifier
+// noImportTypeSideEffects: an import whose every named specifier
 // uses the inline `type` modifier is morally a type-only import; hoist
 // the `type` to the import clause to make that intent explicit and let
 // `verbatimModuleSyntax` elide the import entirely. typescript-eslint
 // stylistic: https://typescript-eslint.io/rules/no-import-type-side-effects/
 type noImportTypeSideEffects struct{}
 
-func (noImportTypeSideEffects) Name() string { return "no-import-type-side-effects" }
+func (noImportTypeSideEffects) Name() string { return "typescript/no-import-type-side-effects" }
 func (noImportTypeSideEffects) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindImportDeclaration}
 }
@@ -94,6 +94,74 @@ func (noImportTypeSideEffects) Check(ctx *Context, node *shimast.Node) {
   ctx.ReportFix(node, message, edits...)
 }
 
+// noUselessEmptyExport: `export {}` is only useful as a module marker.
+// Once a file or namespace block already contains another import/export,
+// the empty export does not change module-ness and can be removed.
+type noUselessEmptyExport struct{}
+
+func (noUselessEmptyExport) Name() string { return "typescript/no-useless-empty-export" }
+func (noUselessEmptyExport) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile, shimast.KindModuleBlock}
+}
+func (noUselessEmptyExport) Check(ctx *Context, node *shimast.Node) {
+  if ctx.File != nil && ctx.File.IsDeclarationFile {
+    return
+  }
+  statements := node.Statements()
+  if len(statements) == 0 {
+    return
+  }
+  emptyExports := []*shimast.Node{}
+  foundOtherModuleSyntax := false
+  for _, stmt := range statements {
+    if stmt == nil {
+      continue
+    }
+    if isEmptyExportDeclaration(stmt) {
+      emptyExports = append(emptyExports, stmt)
+      continue
+    }
+    if isModuleSyntaxStatement(stmt) {
+      foundOtherModuleSyntax = true
+    }
+  }
+  if !foundOtherModuleSyntax {
+    return
+  }
+  for _, stmt := range emptyExports {
+    ctx.Report(stmt, "Empty export does not change module-ness here.")
+  }
+}
+
+func isEmptyExportDeclaration(node *shimast.Node) bool {
+  if node == nil || node.Kind != shimast.KindExportDeclaration {
+    return false
+  }
+  decl := node.AsExportDeclaration()
+  if decl == nil || decl.ExportClause == nil || decl.ModuleSpecifier != nil {
+    return false
+  }
+  if decl.ExportClause.Kind != shimast.KindNamedExports {
+    return false
+  }
+  named := decl.ExportClause.AsNamedExports()
+  return named != nil && (named.Elements == nil || len(named.Elements.Nodes) == 0)
+}
+
+func isModuleSyntaxStatement(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindImportDeclaration, shimast.KindImportEqualsDeclaration, shimast.KindExportAssignment:
+    return true
+  case shimast.KindExportDeclaration:
+    return !isEmptyExportDeclaration(node)
+  }
+  return hasModifier(node, shimast.KindExportKeyword)
+}
+
 func init() {
   Register(noImportTypeSideEffects{})
+  Register(noUselessEmptyExport{})
 }