@ttsc/lint 0.30.3 → 0.31.0

package/linthost/no_duplicate_imports_allow_separate_type_imports_still_reports_value_pairs_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsAllowSeparateTypeImportsStillReportsValuePairs
+// verifies `allowSeparateTypeImports: true` keeps reporting two
+// mergeable value imports of the same module.
+//
+// Negative twin of the option's acceptance case: the option only exempts
+// pairs whose clause-level type-ness differs. Two value declarations
+// remain in the ordinary comparison, so an over-broad option
+// implementation that mutes every duplicate would fail here.
+//
+// 1. Import named value bindings from the same module twice.
+// 2. Run the rule with `allowSeparateTypeImports: true`.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. The enabled separation option still reports two value named imports at line 2. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The option cannot excuse duplicates within the value category; the literal line and duplicated-import message follow the policy. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Same-category value pair complements mixed type/value acceptance and the type-pair positive case.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsAllowSeparateTypeImportsStillReportsValuePairs(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { first } from "m";
+import { second } from "m";
+`, `{"allowSeparateTypeImports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_allows_inline_type_specifier_beside_type_import_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsAllowsInlineTypeSpecifierBesideTypeImport
+// verifies `allowSeparateTypeImports: true` accepts a clause-level type
+// import next to an inline-type-specifier import of the same module.
+//
+// Companion of the inline-classification case: because `import { type B
+// }` is a value declaration, the option's type/value separation exempts
+// it from comparison with the clause-level `import type { A }` above.
+// Together the two cases pin the inline form to exactly the value side —
+// compared against value imports, separated from type imports.
+//
+//  1. Import clause-level type bindings, then an inline-type specifier,
+//     from one module.
+//  2. Run the rule with `allowSeparateTypeImports: true`.
+//  3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Clause-level import type and inline type specifiers remain separate when allowSeparateTypeImports is true. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The clause modifier governs declaration category, not the individual specifier modifier; zero findings follows the explicit separation option. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases The type/inline pair is the negative twin of TestNoDuplicateImportsClassifiesInlineTypeSpecifierAsValue.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsAllowsInlineTypeSpecifierBesideTypeImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import type { Alpha } from "m";
+import { type Beta } from "m";
+`, `{"allowSeparateTypeImports":true}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_allows_named_and_namespace_value_imports_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsAllowsNamedAndNamespaceValueImports verifies
+// no-duplicate-imports accepts a named and a namespace import of the
+// same module, in both declaration orders.
+//
+// Locks the namespace/named exclusion in `duplicateImportsCanMerge`:
+// TypeScript has no declaration form carrying both `* as ns` and named
+// bindings, so the pair is not consolidatable and must not be reported.
+// Both orders exercise both operand sides of the symmetric guard; the
+// old specifier-string implementation reported both, so this is the
+// regression pin for issue #401's second consequence.
+//
+// 1. Import named-then-namespace from "m" and namespace-then-named from "n".
+// 2. Run the rule with default options.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Named and namespace value imports from one module are accepted in both declaration orders. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations TypeScript has no legal import declaration combining named bindings and a namespace clause, so these cannot be consolidated. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Both m and n reverse order; default-plus-named and two namespaces have separate reporting cases.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsAllowsNamedAndNamespaceValueImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { named } from "m";
+import * as namespace from "m";
+import * as other from "n";
+import { thing } from "n";
+`, `{}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_allows_type_default_and_type_named_imports_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsAllowsTypeDefaultAndTypeNamedImports verifies a
+// type-only default import and a type-only named import of the same
+// module are accepted, in both declaration orders.
+//
+// Locks parity with the ESLint 9.30.1 correction: `import type Def, {
+// Named } from "m"` is not legal TypeScript, so the pair cannot be
+// consolidated and is not a duplicate — under the default options, with
+// no `allowSeparateTypeImports` involved. Both orders exercise both
+// operand sides of the guard in `duplicateImportsCanMerge`.
+//
+//  1. Import a type-only default then type-only named bindings from "m",
+//     and the reverse order from "n".
+//  2. Run the rule with default options.
+//  3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Type-only default and type-only named declarations remain accepted in both orders. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations TypeScript forbids a combined type-only default/named declaration; ESLint 9.30.1 parity therefore requires zero findings. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Both orders isolate mergeability from merely repeating a module specifier; two type defaults remain covered by the reporting sibling.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsAllowsTypeDefaultAndTypeNamedImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import type DefaultType from "m";
+import type { NamedType } from "m";
+import type { OtherNamed } from "n";
+import type OtherDefault from "n";
+`, `{}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_allows_type_namespace_and_type_named_imports_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsAllowsTypeNamespaceAndTypeNamedImports verifies
+// a type-only namespace import and a type-only named import of the same
+// module are accepted.
+//
+// Locks the interaction of the two exclusions in
+// `duplicateImportsCanMerge`: the type-only default/named guard does not
+// match this pair (neither side is a default), so acceptance must come
+// from the general namespace/named exclusion — which applies to
+// type-only declarations exactly as it does to value declarations.
+//
+// 1. Import `type * as ns` and then `type { Named }` from one module.
+// 2. Run the rule with default options.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Type-only namespace and named imports remain accepted. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Namespace and named clauses cannot share one import declaration, including when both are type-only. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases This type/type pair rules out applying namespace exclusion only to values; named/namespace value symmetry has a separate case.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsAllowsTypeNamespaceAndTypeNamedImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import type * as namespace from "m";
+import type { NamedType } from "m";
+`, `{}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_classifies_inline_type_specifier_as_value_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsClassifiesInlineTypeSpecifierAsValue verifies
+// `import { type Foo } from "m"` counts as a value declaration under
+// `allowSeparateTypeImports: true`, not as a clause-level type import.
+//
+// Locks the clause-level reading of type-ness in
+// `duplicateImportsImportEntry`: only `ImportClause.IsTypeOnly()`
+// (`import type …`) makes a declaration type-only; an inline `type`
+// modifier on a specifier keeps this rule's category on the value side. If the
+// inline modifier leaked into the declaration's type-ness, the option
+// would wrongly exempt this pair and the finding would disappear.
+//
+// 1. Import named value bindings, then an inline-type specifier, from "m".
+// 2. Run the rule with `allowSeparateTypeImports: true`.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. An inline type specifier joins a preceding named value import despite allowSeparateTypeImports. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Only clause-level import type makes the whole declaration type-only; the exact line-2 duplicate follows that syntax distinction. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases The inline form differs from the clause-level type acceptance sibling, preventing an overbroad type separation.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsClassifiesInlineTypeSpecifierAsValue(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+import { type Foo } from "m";
+`, `{"allowSeparateTypeImports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_helpers_test.go

@@ -0,0 +1,78 @@
+package linthost
+
+import (
+  "encoding/json"
+  "sort"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// duplicateImportsFinding is the normalized (line, message) pair the
+// no-duplicate-imports unit cases assert on. Messages are part of the
+// contract because the rule distinguishes the four official pairings
+// (import/import, import/export, export/export, export/import), and a
+// line-only assertion could not tell them apart.
+type duplicateImportsFinding struct {
+  Line    int
+  Message string
+}
+
+// runNoDuplicateImports runs the no-duplicate-imports rule over one
+// virtual TypeScript source with the given options JSON and returns
+// normalized findings sorted by (line, message) so assertions do not
+// depend on engine emission order.
+func runNoDuplicateImports(t *testing.T, source, optsJSON string) []duplicateImportsFinding {
+  t.Helper()
+  const ruleName = "no-duplicate-imports"
+  file := parseTSFile(t, "/virtual/no-duplicate-imports.ts", source)
+  resolver := InlineRuleResolver{
+    Rules:   RuleConfig{ruleName: SeverityError},
+    Options: RuleOptionsMap{ruleName: json.RawMessage(optsJSON)},
+  }
+  findings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil)
+  out := make([]duplicateImportsFinding, 0, len(findings))
+  for _, finding := range findings {
+    if finding.Rule != ruleName {
+      t.Fatalf("unexpected rule %q in findings: %+v", finding.Rule, finding)
+    }
+    if len(finding.Fix) != 0 {
+      t.Fatalf("no-duplicate-imports must not offer autofixes, got %+v", finding.Fix)
+    }
+    out = append(out, duplicateImportsFinding{
+      Line:    shimscanner.GetECMALineOfPosition(file, finding.Pos) + 1,
+      Message: finding.Message,
+    })
+  }
+  sort.Slice(out, func(i, j int) bool {
+    if out[i].Line != out[j].Line {
+      return out[i].Line < out[j].Line
+    }
+    return out[i].Message < out[j].Message
+  })
+  return out
+}
+
+// assertDuplicateImportsFindings compares normalized findings against the
+// expected (line, message) list. `want` must be pre-sorted by (line,
+// message), matching runNoDuplicateImports output order.
+func assertDuplicateImportsFindings(t *testing.T, got, want []duplicateImportsFinding) {
+  t.Helper()
+  if len(got) != len(want) {
+    t.Fatalf("want %d findings %+v, got %d findings %+v", len(want), want, len(got), got)
+  }
+  for i := range want {
+    if got[i] != want[i] {
+      t.Fatalf("finding[%d]: want %+v, got %+v; all=%+v", i, want[i], got[i], got)
+    }
+  }
+}
+
+// assertNoDuplicateImportsFindings asserts the rule stayed silent.
+func assertNoDuplicateImportsFindings(t *testing.T, got []duplicateImportsFinding) {
+  t.Helper()
+  if len(got) != 0 {
+    t.Fatalf("expected zero findings, got %+v", got)
+  }
+}

package/linthost/no_duplicate_imports_ignores_misspelled_option_keys_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIgnoresMisspelledOptionKeys verifies a
+// misspelled option key leaves the rule on its official defaults
+// instead of disabling it or panicking.
+//
+// Locks the options decode path: `DecodeOptions` ignores unknown JSON
+// keys, so `allowSeparateTypeImport` (missing the trailing `s`) must not
+// activate the type/value separation. This preserves the default duplicate
+// finding for untyped JSON options; it does not reject the misspelled key.
+// Compile-time typo rejection belongs to the TypeScript typing test.
+//
+// 1. Import a value binding and a clause-level type binding from one module.
+// 2. Run the rule with a misspelled `allowSeparateTypeImport` key.
+// 3. Assert the default behavior still reports the second declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. A misspelled allowSeparateTypeImport key leaves the value/type duplicate at line 2. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Unknown JSON keys do not enable the official plural option; authored defaults require the exact duplicated-import message. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Contrasts a near-miss key with the correctly spelled acceptance case without treating configuration text itself as the observable.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIgnoresMisspelledOptionKeys(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+import type { Entity } from "m";
+`, `{"allowSeparateTypeImport":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_ignores_reexports_by_default_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIgnoresReexportsByDefault verifies the official
+// default `includeExports: false` leaves `export … from` declarations
+// out of the analysis entirely.
+//
+// Locks the option gate in the rule's statement walk: without
+// `includeExports`, re-exports are neither reported nor recorded, so a
+// re-export of an imported module and two same-module re-exports stay
+// silent. This is the negative twin of every include-exports case.
+//
+// 1. Import from "m", then re-export from "m" twice.
+// 2. Run the rule with default options.
+// 3. Assert zero findings, including a re-export before a lone import.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Default no-duplicate-imports ignores both reexports after an import. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations includeExports defaults false, so reexports neither report nor seed later duplicate comparisons. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases An import and two same-module reexports would report if the gate were absent; enabled-export cases own the positive side.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIgnoresReexportsByDefault(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+export { first } from "m";
+export { second } from "m";
+`, `{}`)
+  assertNoDuplicateImportsFindings(t, got)
+  got = runNoDuplicateImports(t, `export { first } from "n";
+import { value } from "n";
+`, `{}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_include_exports_allows_export_star_beside_named_import_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsAllowsExportStarBesideNamedImport
+// verifies `includeExports: true` accepts `export * from "m"` next to a
+// named import of "m", in both declaration orders.
+//
+// Locks the export-all exclusion in `duplicateImportsCanMerge`: `export
+// *` cannot be folded into a named import
+// (or vice versa) — only another `export *` or a bare side-effect import
+// merges with it. Both orders exercise both operand sides of the
+// symmetric guard.
+//
+//  1. Import named bindings then `export *` for "m"; `export *` then a
+//     named import for "n".
+//  2. Run the rule with `includeExports: true`.
+//  3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Enabled export checking accepts export-all beside named imports in both orders. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations An export-all clause cannot be consolidated into a named import; zero findings follows mergeability rather than module equality. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Both operand orders contrast with export-all beside a side-effect import, which is mergeable and separately reported.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsAllowsExportStarBesideNamedImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+export * from "m";
+export * from "n";
+import { other } from "n";
+`, `{"includeExports":true}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_include_exports_allows_export_star_beside_namespace_reexport_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsAllowsExportStarBesideNamespaceReexport
+// verifies `includeExports: true` accepts `export * as ns from "m"`
+// next to a bare `export * from "m"`.
+//
+// Discriminates the namespace-export category from export-all in
+// `duplicateImportsExportEntry`: the two star forms cannot merge (the
+// export-all exclusion blocks export-all against namespace bindings),
+// but if the aliased form were miscategorized as export-all the pair
+// would look like two mergeable `export *` declarations and produce a
+// false finding.
+//
+// 1. Write `export * as ns from "m"` and then `export * from "m"`.
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Enabled export checking accepts namespace reexport beside export-all. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations export * as namespace and export * are different binding forms that cannot be merged; treating both as export-all would falsely report. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases This pair discriminates namespace classification where the named-import/namespace case alone cannot.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsAllowsExportStarBesideNamespaceReexport(t *testing.T) {
+  got := runNoDuplicateImports(t, `export * as namespace from "m";
+export * from "m";
+`, `{"includeExports":true}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_include_exports_allows_namespace_reexport_beside_named_import_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsAllowsNamespaceReexportBesideNamedImport
+// verifies `includeExports: true` accepts `export * as ns from "m"`
+// next to a named import of "m".
+//
+// Locks the namespace categorization of aliased star re-exports in
+// `duplicateImportsExportEntry`: `export * as ns` is a namespace
+// specifier, so the namespace/named exclusion applies across declaration
+// kinds. Miscategorizing it as export-all would also pass here, which is
+// why the export-star-beside-namespace-reexport case exists as the
+// discriminating twin.
+//
+// 1. Re-export `* as ns` from "m", then import named bindings from "m".
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Enabled export checking accepts namespace reexport beside a named import. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Namespace/named exclusion crosses declaration kinds; the literal zero result follows the same syntax mergeability constraint. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases This case alone cannot distinguish an export-all misclassification; TestNoDuplicateImportsIncludeExportsAllowsExportStarBesideNamespaceReexport supplies that distinction.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsAllowsNamespaceReexportBesideNamedImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `export * as namespace from "m";
+import { value } from "m";
+`, `{"includeExports":true}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_include_exports_reports_both_pairings_on_one_declaration_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsReportsBothPairingsOnOneDeclaration
+// verifies a re-export mergeable with an earlier re-export AND an
+// earlier import produces both findings on the same declaration.
+//
+// Locks the two independent report arms in `reportDuplicateImports`: the
+// official rule pushes one message per pairing kind, so the third
+// declaration below carries the plain export duplicate and the
+// duplicated-as-import finding simultaneously. Collapsing the arms into
+// a single first-match report would drop one of them.
+//
+//  1. Import from "m", re-export from "m", then re-export from "m" again.
+//  2. Run the rule with `includeExports: true`.
+//  3. Assert the middle line reports duplicated-as-import and the last
+//     line reports both pairings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. One later reexport reports both its earlier import pairing and earlier export pairing. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The authored three (line,message) entries require separate import/export message kinds, including two reports at line 3. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Import then two reexports exposes first-match suppression and duplicate cardinality; default export omission is separately covered.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsReportsBothPairingsOnOneDeclaration(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+export { first } from "m";
+export { second } from "m";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` export is duplicated as import."},
+    {Line: 3, Message: "`m` export is duplicated as import."},
+    {Line: 3, Message: "`m` export is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_include_exports_reports_export_star_beside_side_effect_import_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsReportsExportStarBesideSideEffectImport
+// verifies `includeExports: true` pairs `export * from "m"` with a bare
+// side-effect import of "m" as duplicates, in both declaration orders.
+//
+// Locks the side-effect carve-out inside the export-all exclusion: the
+// official guard blocks export-all only against binding forms, and a
+// bare `import "m"` is subsumed by the module load `export *` already
+// performs. The first order yields the export message pair, the reverse
+// order the import message pair, pinning both report arms.
+//
+//  1. `import "m"` then `export * from "m"`; `export * from "n"` then
+//     `import "n"`.
+//  2. Run the rule with `includeExports: true`.
+//  3. Assert one duplicated-as-import finding on line 2 and one
+//     duplicated-as-export finding on line 4.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Export-all and side-effect imports report as mergeable in both declaration orders. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The authored messages identify export-as-import at line 2 and import-as-export at line 4, independently of emission order. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Both m and n orderings complement nonmergeable export-all/named acceptance.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsReportsExportStarBesideSideEffectImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import "m";
+export * from "m";
+export * from "n";
+import "n";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` export is duplicated as import."},
+    {Line: 4, Message: "`n` import is duplicated as export."},
+  })
+}

package/linthost/no_duplicate_imports_include_exports_reports_import_after_reexport_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsReportsImportAfterReexport
+// verifies `includeExports: true` reports an import of a module that was
+// already re-exported above.
+//
+// Locks the import-versus-exports pairing (the official `importAs`
+// message): the import handler additionally compares against recorded
+// re-exports when the option is on, and the finding carries the
+// duplicated-as-export message. With the option off, the earlier
+// re-export would never have been recorded and this import would pass.
+//
+// 1. Re-export named bindings from "m", then import from "m".
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert exactly one duplicated-as-export finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. A named import after a same-module reexport reports import duplicated as export at line 2. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The earlier declaration is an export, so the literal directional message must differ from export duplicated as import. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Pins one directional pairing; the reexport-after-import sibling covers the reverse.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsReportsImportAfterReexport(t *testing.T) {
+  got := runNoDuplicateImports(t, `export { thing } from "m";
+import { value } from "m";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated as export."},
+  })
+}

package/linthost/no_duplicate_imports_include_exports_reports_reexport_after_import_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsReportsReexportAfterImport
+// verifies `includeExports: true` reports a named re-export of a module
+// that already has a mergeable import above.
+//
+// Locks the export-versus-imports pairing (the official `exportAs`
+// message): the re-export could be folded into the existing import plus
+// a local `export`, so the pair is a duplicate across declaration kinds
+// and carries the duplicated-as-import message rather than the plain
+// export message.
+//
+// 1. Import named bindings from "m", then `export { … } from "m"`.
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert exactly one duplicated-as-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. A reexport after a same-module named import reports export duplicated as import at line 2. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The earlier declaration is an import, establishing the independently authored directional message. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Pins the reverse of TestNoDuplicateImportsIncludeExportsReportsImportAfterReexport.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsReportsReexportAfterImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+export { value } from "m";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` export is duplicated as import."},
+  })
+}

package/linthost/no_duplicate_imports_include_exports_reports_repeated_export_star_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsReportsRepeatedExportStar verifies
+// `includeExports: true` reports the second of two `export * from "m"`
+// declarations.
+//
+// Positive twin of the export-all exclusion: the guard in
+// `duplicateImportsCanMerge` only blocks export-all against binding
+// forms; two identical `export *` declarations reduce to one and remain
+// a duplicate. An over-broad exclusion that isolates export-all from
+// everything would fail here.
+//
+// 1. Write `export * from "m"` twice.
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert exactly one duplicated-export finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Two export-all declarations report the second as an export duplicate. The shared assertion also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Identical export-all operations can be consolidated; the authored line-2 plain export message follows the declaration kinds. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Same-kind export-all positive contrasts with export-all/namespace negative and mixed import/export messages.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsReportsRepeatedExportStar(t *testing.T) {
+  got := runNoDuplicateImports(t, `export * from "m";
+export * from "m";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` export is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_include_exports_reports_second_reexport_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsReportsSecondReexport verifies
+// `includeExports: true` reports the second of two mergeable named
+// re-exports of the same module.
+//
+// Locks the export-versus-exports pairing (the official `export`
+// message): two `export { … } from "m"` declarations consolidate into
+// one, making the second a plain export duplicate with its own message
+// distinct from the cross-kind duplicated-as-import case.
+//
+// 1. Re-export named bindings from the same module twice.
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert exactly one duplicated-export finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Two named reexports report the second as an export duplicate. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Named bindings from the same module can share one export declaration; the exact plain export message distinguishes mixed-kind pairings. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Named reexports complement export-all duplicates and the default ignore-exports case.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsReportsSecondReexport(t *testing.T) {
+  got := runNoDuplicateImports(t, `export { first } from "m";
+export { second } from "m";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` export is duplicated."},
+  })
+}