@ttsc/lint 0.30.4 → 0.31.1

package/linthost/format_quote_props_consistent_unquotes_proto_with_identifier_keys_test.go

@@ -0,0 +1,21 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsConsistentUnquotesProtoWithIdentifierKeys verifies quote removal preserves the key kind.
+//
+// The identifier-shaped __proto__ key does not force an object key group
+// to remain quoted. Both noncomputed spellings retain setter semantics,
+// while the computed spelling must remain an ordinary property.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props consistent mode must unquote both __proto__ and foo when their object group contains only removable static identifier keys.
+// @evidence contracts/testing.md#independent-expectations Complete literal outputs preserve each holder and its contents while changing only key quotes, following the supported static-identifier quoting policy. ECMAScript PropertyDefinitionEvaluation assigns the same setter semantics to quoted and bare noncomputed __proto__, so removing these quotes preserves meaning and property values.
+// @evidence contracts/testing.md#distinguishing-cases The original two-key numeric fixture retains its input with a corrected output. The added null-valued setter plus computed key keeps the computed property unchanged; the mixed bar-baz group separately owns consistent add-quote behavior. Added class method, interface and type-literal cases ensure their non-object holders also remove the redundant quotes without changing bodies or number types.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsConsistentUnquotesProtoWithIdentifierKeys is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns all five complete source fixtures and literal output comparisons; the shared syntax-only harness invokes the rule and applies edits in the same process without a consumer install, native product build or product host.
+func TestFormatQuotePropsConsistentUnquotesProtoWithIdentifierKeys(t *testing.T) {
+  assertFixSnapshotWithOptions(t, "format/quote-props", "const c = { \"__proto__\": 1, \"foo\": 2 };\n", `{"mode":"consistent"}`, "const c = { __proto__: 1, foo: 2 };\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "const obj = { \"__proto__\": null, [\"__proto__\"]: null, \"foo\": 2 };\n", `{"mode":"consistent"}`, "const obj = { __proto__: null, [\"__proto__\"]: null, foo: 2 };\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "class C { \"__proto__\"() {} }\n", `{"mode":"consistent"}`, "class C { __proto__() {} }\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "interface Shape { \"__proto__\": number }\n", `{"mode":"consistent"}`, "interface Shape { __proto__: number }\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "type Shape = { \"__proto__\": number };\n", `{"mode":"consistent"}`, "type Shape = { __proto__: number };\n")
+}

package/linthost/format_quote_props_keeps_non_identifier_key_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsKeepsNonIdentifierKey verifies quoteProps:"as-needed"
+// keeps the quotes on a key that is not a valid identifier (`"bar-baz"`),
+// matching Prettier — only identifier keys are unquoted.
+//
+//  1. Parse `{ foo: 1, "bar-baz": 2 }`.
+//  2. Run format/quote-props with mode:"as-needed".
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed mode must leave the already-bare foo and necessary quoted bar-baz key without findings.
+// @evidence contracts/testing.md#independent-expectations bar-baz contains punctuation and cannot be spelled as a bare IdentifierName. The fixed source is the independent canonical as-needed oracle and zero findings forbids removing its necessary quotes.
+// @evidence contracts/testing.md#distinguishing-cases This hyphenated-key negative shares its exact object input with the consistent add-quote positive; identifier-only unquoting owns the adjacent removable-key behavior.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsKeepsNonIdentifierKey is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule in process for this host's literal input and zero-finding assertion. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsKeepsNonIdentifierKey(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/quote-props",
+    "const b = { foo: 1, \"bar-baz\": 2 };\n",
+    `{"mode":"as-needed"}`,
+  )
+}

package/linthost/format_quote_props_keeps_numeric_key_test.go

@@ -0,0 +1,20 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsKeepsNumericKey verifies that the conservative as-needed
+// policy retains quoted numeric-looking string keys, matching Prettier.
+// Numeric-looking keys remain outside identifier unquoting.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed mode must retain the quoted numeric-looking string key 123 without findings.
+// @evidence contracts/testing.md#independent-expectations The supported conservative quoting policy removes only identifier-shaped keys, so the authored unchanged numeric-key input independently fixes the required spelling. This is a spelling policy, not a claim that numeric 123 would name a different property.
+// @evidence contracts/testing.md#distinguishing-cases This leading-digit negative distinguishes numeric-looking strings from removable alphabetic keys; the hyphenated-key negative covers a different non-identifier boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsKeepsNumericKey is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule in process for this host's literal input and zero-finding assertion. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsKeepsNumericKey(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/quote-props",
+    "const e = { \"123\": 1 };\n",
+    `{"mode":"as-needed"}`,
+  )
+}

package/linthost/format_quote_props_preserve_is_noop_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsPreserveIsNoop verifies quoteProps:"preserve" never
+// changes key quoting.
+//
+//  1. Parse `{ "foo": 1 }`.
+//  2. Run format/quote-props with mode:"preserve".
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props preserve mode must report no finding for a quoted foo key that as-needed mode would otherwise remove.
+// @evidence contracts/testing.md#independent-expectations The preserve option independently requires the existing literal spelling to stay untouched even though foo is a valid IdentifierName.
+// @evidence contracts/testing.md#distinguishing-cases This option-controlled negative contrasts with the as-needed identifier-key positive and consistent mode transformations, preventing key eligibility alone from overriding preserve.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsPreserveIsNoop is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule in process for this host's literal input and zero-finding assertion. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsPreserveIsNoop(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/quote-props",
+    "const a = { \"foo\": 1 };\n",
+    `{"mode":"preserve"}`,
+  )
+}

package/linthost/format_quote_props_unquotes_class_method_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsUnquotesClassMethod verifies class method names use the
+// as-needed quote policy.
+//
+// Class fields intentionally preserve their quoted spelling, but methods are
+// property names in Prettier's quoteProps surface and must not be skipped with
+// their containing class declaration.
+//
+// 1. Parse a class with a quoted method name.
+// 2. Apply format/quote-props with mode `as-needed`.
+// 3. Assert the method name becomes an identifier.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed mode must unquote the class run method name while preserving a neighboring quoted class field name.
+// @evidence contracts/testing.md#independent-expectations The complete literal outputs retain the class, method body and added field initializer; the supported member surface removes method quotes while preserving quoted class fields, fixed by these independently authored literals.
+// @evidence contracts/testing.md#distinguishing-cases The original method-only positive remains. The added same-class quoted field plus method fixture requires the method to change and the adjacent ordinary and __proto__ fields to stay quoted, distinguishing whole-class abstention from indiscriminate member unquoting.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsUnquotesClassMethod is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule and applies edits in process for this host's literal inputs and complete output comparisons. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsUnquotesClassMethod(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quote-props",
+    "class C { \"run\"() {} }\n",
+    `{"mode":"as-needed"}`,
+    "class C { run() {} }\n",
+  )
+  assertFixSnapshotWithOptions(t, "format/quote-props", "class C { \"field\" = 1; \"run\"() {} }\n", `{"mode":"as-needed"}`, "class C { \"field\" = 1; run() {} }\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "class C { \"__proto__\" = 1; \"run\"() {} }\n", `{"mode":"as-needed"}`, "class C { \"__proto__\" = 1; run() {} }\n")
+}

package/linthost/format_quote_props_unquotes_identifier_keys_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsUnquotesIdentifierKeys verifies quoteProps:"as-needed"
+// (the default, matching Prettier) drops quotes from object keys that are
+// valid identifiers.
+//
+//  1. Parse `{ "foo": 1, "bar": 2 }`.
+//  2. Apply format/quote-props with mode:"as-needed".
+//  3. Assert it becomes `{ foo: 1, bar: 2 }`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed mode must remove redundant foo and bar property-key quotes without changing their values or object membership.
+// @evidence contracts/testing.md#independent-expectations The complete literal output preserves the two property keys and numeric values because foo and bar are valid IdentifierNames, and follows the supported as-needed spelling policy.
+// @evidence contracts/testing.md#distinguishing-cases This two-key positive complements numeric-looking and punctuation-bearing negative keys; preserve mode supplies an adjacent option where otherwise-removable quotes must remain.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsUnquotesIdentifierKeys is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule and applies edits in process for this host's literal inputs and complete output comparisons. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsUnquotesIdentifierKeys(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quote-props",
+    "const a = { \"foo\": 1, \"bar\": 2 };\n",
+    `{"mode":"as-needed"}`,
+    "const a = { foo: 1, bar: 2 };\n",
+  )
+}

package/linthost/format_quote_props_unquotes_interface_member_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsUnquotesInterfaceMember verifies interface members use
+// the as-needed quote policy.
+//
+// Interface members are a distinct supported holder from object literals.
+// This positive requires the interface visitor to reach and unquote the
+// redundant name while preserving its type annotation.
+//
+// 1. Parse an interface with a quoted property name.
+// 2. Apply format/quote-props with mode `as-needed`.
+// 3. Assert the member name becomes an identifier.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed mode must unquote the interface width member while preserving its number type and interface declaration.
+// @evidence contracts/testing.md#independent-expectations The complete literal output spells the same width property name as an IdentifierName and retains its number annotation; the supported quoteProps surface includes interface members.
+// @evidence contracts/testing.md#distinguishing-cases This interface-member positive distinguishes a non-object member holder from ordinary object keys; type-literal and class-method positives separately cover their distinct holders, while preserve mode owns abstention.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsUnquotesInterfaceMember is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule and applies edits in process for this host's literal inputs and complete output comparisons. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsUnquotesInterfaceMember(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quote-props",
+    "interface Shape { \"width\": number }\n",
+    `{"mode":"as-needed"}`,
+    "interface Shape { width: number }\n",
+  )
+}

package/linthost/format_quote_props_unquotes_proto_key_without_changing_setter_semantics_test.go

@@ -0,0 +1,21 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsUnquotesProtoKeyWithoutChangingSetterSemantics verifies quote removal preserves the key kind.
+//
+// Quoted and bare noncomputed __proto__ property definitions both use the
+// ECMAScript prototype-setter semantics. Removing the quotes must retain
+// that behavior; computed ["__proto__"] remains an ordinary own property.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed must unquote the noncomputed __proto__ key without rewriting its computed counterpart or changing either value.
+// @evidence contracts/testing.md#independent-expectations The complete literal outputs change only independently authored supported static-identifier quoteProps spellings. ECMAScript PropertyDefinitionEvaluation treats noncomputed __proto__ as a setter regardless of quotes, while a computed key is ordinary; the outputs retain that distinction and the null values.
+// @evidence contracts/testing.md#distinguishing-cases The original numeric-value fixture remains with its corrected specification-based output. The added null-valued setter and adjacent computed-key fixture require both eligible quotes to change while computed syntax remains intact. Added class method, interface and type-literal holders require the same static name eligibility without changing their bodies or number types.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsUnquotesProtoKeyWithoutChangingSetterSemantics is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns all five complete source fixtures and literal output comparisons; the shared syntax-only harness invokes the rule and applies edits in the same process without a consumer install, native product build or product host.
+func TestFormatQuotePropsUnquotesProtoKeyWithoutChangingSetterSemantics(t *testing.T) {
+  assertFixSnapshotWithOptions(t, "format/quote-props", "const a = { \"__proto__\": 1, \"foo\": 2 };\n", `{"mode":"as-needed"}`, "const a = { __proto__: 1, foo: 2 };\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "const obj = { \"__proto__\": null, [\"__proto__\"]: null, \"foo\": 2 };\n", `{"mode":"as-needed"}`, "const obj = { __proto__: null, [\"__proto__\"]: null, foo: 2 };\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "class C { \"__proto__\"() {} }\n", `{"mode":"as-needed"}`, "class C { __proto__() {} }\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "interface Shape { \"__proto__\": number }\n", `{"mode":"as-needed"}`, "interface Shape { __proto__: number }\n")
+  assertFixSnapshotWithOptions(t, "format/quote-props", "type Shape = { \"__proto__\": number };\n", `{"mode":"as-needed"}`, "type Shape = { __proto__: number };\n")
+}

package/linthost/format_quote_props_unquotes_reserved_word_key_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsUnquotesReservedWordKey verifies quoteProps:"as-needed"
+// unquotes a reserved-word key (`"default"`) — reserved words are valid
+// property names, so Prettier drops the quotes.
+//
+//  1. Parse `{ "default": 1 }`.
+//  2. Apply format/quote-props with mode:"as-needed".
+//  3. Assert it becomes `{ default: 1 }`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed mode must unquote the default property key while preserving the numeric value and object declaration.
+// @evidence contracts/testing.md#independent-expectations ECMAScript property names accept IdentifierName, including the reserved word default. The complete literal output therefore preserves the same property key and value under the supported as-needed policy.
+// @evidence contracts/testing.md#distinguishing-cases This reserved-word positive distinguishes valid property names from variable-identifier restrictions; the hyphenated and leading-digit string negatives own truly ineligible quoted spellings.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsUnquotesReservedWordKey is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule and applies edits in process for this host's literal inputs and complete output comparisons. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsUnquotesReservedWordKey(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quote-props",
+    "const f = { \"default\": 1 };\n",
+    `{"mode":"as-needed"}`,
+    "const f = { default: 1 };\n",
+  )
+}

package/linthost/format_quote_props_unquotes_type_literal_member_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsUnquotesTypeLiteralMember verifies type-literal
+// members use the as-needed quote policy.
+//
+// A type literal has its own member list rather than an object-literal
+// property list. Visiting it prevents the same quoted identifier divergence
+// from reappearing in structural type declarations.
+//
+// 1. Parse a type literal with a quoted property name.
+// 2. Apply format/quote-props with mode `as-needed`.
+// 3. Assert the member name becomes an identifier.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props as-needed mode must unquote the structural height member without changing its number annotation or type alias.
+// @evidence contracts/testing.md#independent-expectations The complete literal output retains the height property name and number type; the supported quoteProps surface includes type-literal members rather than only object-expression properties.
+// @evidence contracts/testing.md#distinguishing-cases This TypeLiteral positive complements the interface-holder and class-method positives; preservation and ineligible-key negatives distinguish eligibility from unconditional rewriting.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsUnquotesTypeLiteralMember is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule and applies edits in process for this host's literal inputs and complete output comparisons. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsUnquotesTypeLiteralMember(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quote-props",
+    "type Shape = { \"height\": number };\n",
+    `{"mode":"as-needed"}`,
+    "type Shape = { height: number };\n",
+  )
+}

package/linthost/format_quotes_converts_double_to_single_preserving_apostrophe_escape_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesConvertsDoubleToSinglePreservingApostropheEscape verifies the required quote conversion.
+//
+// Under prefer:single, the mixed value becomes cheaper with single quotes.
+// The two double quotes lose their escapes, but the apostrophe must stay
+// escaped under its new delimiter under the supported escape-cost policy.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must convert the double-quoted mixed payload under prefer:single while retaining the apostrophe escape required by the new delimiter.
+// @evidence contracts/testing.md#independent-expectations The complete literal output spells the same cooked value a"b"c' with two bare double quotes and one escaped apostrophe; the independently specified spelling follows the required new-delimiter escaping.
+// @evidence contracts/testing.md#distinguishing-cases This positive conversion owns two escaped doubles plus a redundant escaped apostrophe; redundant-escape abstention siblings distinguish a cheaper existing delimiter.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesConvertsDoubleToSinglePreservingApostropheEscape is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatQuotesConvertsDoubleToSinglePreservingApostropheEscape(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quotes",
+    "const s = "+`"a\"b\"c\'"`+";\n",
+    `{"prefer":"single"}`,
+    "const s = "+`'a"b"c\''`+";\n",
+  )
+}

package/linthost/format_quotes_converts_single_to_double_test.go

@@ -0,0 +1,22 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesConvertsSingleToDouble verifies the required quote conversion.
+//
+// A plain hello string has zero required escapes with either delimiter.
+// The default double preference must therefore change the single-quoted
+// form while preserving its value, declaration and use.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must change the plain single-quoted hello to the default double-quoted spelling without changing its declaration or JSON.stringify call.
+// @evidence contracts/testing.md#independent-expectations The complete output literal follows the preferred-double zero-escape tie policy and preserves the cooked hello payload and surrounding program bytes.
+// @evidence contracts/testing.md#distinguishing-cases This zero-cost tie must change; TestFormatQuotesSkipsDoubleQuotedLiterals owns the already-preferred negative and escape-minimization cases own strict cost differences.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesConvertsSingleToDouble is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatQuotesConvertsSingleToDouble(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/quotes",
+    "const greeting = 'hello';\nJSON.stringify(greeting);\n",
+    "const greeting = \"hello\";\nJSON.stringify(greeting);\n",
+  )
+}

package/linthost/format_quotes_escapes_double_quote_when_converting_test.go

@@ -0,0 +1,22 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesEscapesDoubleQuoteWhenConverting verifies the required quote conversion.
+//
+// The mixed payload has one required escape with either delimiter.
+// Choosing the default double form must introduce its double-quote escape
+// and remove the apostrophe escape without changing the cooked value.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must escape the embedded double quote and unescape the apostrophe when the mixed single-quoted payload converts to double quotes.
+// @evidence contracts/testing.md#independent-expectations The literal output encodes the same cooked a"b'c value with the new delimiter, preserving the declaration and JSON.stringify call; the ECMAScript string spelling requires the new double-quote escape.
+// @evidence contracts/testing.md#distinguishing-cases This one-versus-one escape tie changes to the default delimiter; unescaped-double negatives own the strictly more-expensive conversion and the apostrophe-only case owns removal without a new quote escape.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesEscapesDoubleQuoteWhenConverting is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatQuotesEscapesDoubleQuoteWhenConverting(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/quotes",
+    "const mixed = 'a\"b\\'c';\nJSON.stringify(mixed);\n",
+    "const mixed = \"a\\\"b'c\";\nJSON.stringify(mixed);\n",
+  )
+}

package/linthost/format_quotes_honors_prefer_single_option_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesHonorsPreferSingleOption verifies that the `prefer:
+// "single"` option flips formatQuotes' direction.
+//
+// The default behavior converts single-quoted literals to double-quoted.
+// Passing `{ prefer: "single" }` flips the contract: double-quoted
+// literals convert to single-quoted (still subject to the escape-cost
+// tie-breaker). This scenario locks the InlineRuleResolver options path
+// end-to-end — JSON blob → DecodeOptions → behavioral switch — without
+// touching the engine internals directly.
+//
+// 1. Parse a double-quoted literal with `prefer: "single"` configured.
+// 2. Apply the rule's edits through the disk-backed fixer.
+// 3. Assert the literal is now single-quoted.
+//
+// @evidence contracts/testing.md#behavioral-verification The inline resolver option prefer:single must make format/quotes convert the plain double-quoted hello while preserving its declaration and use.
+// @evidence contracts/testing.md#independent-expectations The full output literal follows the configured single delimiter on a zero-escape tie and retains the hello value and JSON.stringify call.
+// @evidence contracts/testing.md#distinguishing-cases This option-controlled positive complements the default-double positive; cost-minimization siblings distinguish when fewer escapes override the option.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesHonorsPreferSingleOption is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatQuotesHonorsPreferSingleOption(t *testing.T) {
+  source := "const greeting = \"hello\";\nJSON.stringify(greeting);\n"
+  want := "const greeting = 'hello';\nJSON.stringify(greeting);\n"
+  assertFixSnapshotWithOptions(t, "format/quotes", source, `{"prefer":"single"}`, want)
+}

package/linthost/format_quotes_keeps_double_on_escape_tie_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesKeepsDoubleOnEscapeTie verifies the configured
+// preference breaks an escape-count tie: a double-quoted literal whose
+// single- and double-quoted forms need the same number of escapes stays
+// double under prefer:"double", so the rule emits no edit.
+//
+// This pins the tie branch of the minimize-escapes logic. `"\"'"` needs
+// one escape as double (the `\"`) and one as single (the bare `'`), a
+// tie that must resolve to the preferred double quote and leave the
+// source untouched (keeping the rule idempotent).
+//
+//  1. Parse a source file with a double-quoted literal that ties.
+//  2. Run the rule with default (prefer:"double") options.
+//  3. Assert the rule reports nothing and the source is unchanged.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must emit no finding for the already-preferred double-quoted literal when both delimiter choices require one escape.
+// @evidence contracts/testing.md#independent-expectations The fixed source literal contains a double quote and an apostrophe; the configured tie policy selects its current double delimiter independently of the rule computation.
+// @evidence contracts/testing.md#distinguishing-cases This one-versus-one tie is the negative counterpart to default-double conversion; strict-cost positives distinguish preference from unconditional retention.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesKeepsDoubleOnEscapeTie is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal source and no-finding assertions; the shared syntax-only harness invokes the owning rule in process without a consumer install, native product build or product host.
+func TestFormatQuotesKeepsDoubleOnEscapeTie(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/quotes",
+    `const s = "\"'";`+"\n",
+  )
+}

package/linthost/format_quotes_keeps_double_with_redundant_single_escape_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesKeepsDoubleWithRedundantSingleEscape verifies that a
+// double-quoted literal carrying a redundant `\'` escape is left alone
+// under prefer:"single".
+//
+// The cooked value `a'b` holds one single quote: double quotes spell it
+// with zero required escapes, while single quotes need one. The supported
+// policy retains the cheaper delimiter even under the single preference.
+// This rule does not normalize the redundant backslash. The counter must treat
+// redundant `\'` as a single-quote occurrence, or the literal looks like
+// a 0-vs-0 tie and wrongly flips to single.
+//
+//  1. Parse a double-quoted literal with a redundant `\'`.
+//  2. Run format/quotes with prefer:"single".
+//  3. Assert the rule reports nothing (double quotes are cheaper, kept).
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must not change a double-quoted a-apostrophe-b payload under prefer:single when that preferred delimiter needs more escapes.
+// @evidence contracts/testing.md#independent-expectations The literal source encodes a'b; zero required escapes with double versus one with single makes delimiter retention correct under the supported escape-cost policy. This rule leaves the redundant backslash untouched and does not claim reference-normalized full bytes.
+// @evidence contracts/testing.md#distinguishing-cases This redundant escaped apostrophe must count toward the cooked payload rather than look like a zero-cost tie; the mixed conversion sibling owns a case that actually changes.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesKeepsDoubleWithRedundantSingleEscape is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal source and no-finding assertions; the shared syntax-only harness invokes the owning rule in process without a consumer install, native product build or product host.
+func TestFormatQuotesKeepsDoubleWithRedundantSingleEscape(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/quotes",
+    "const a = \"a\\'b\";\n",
+    `{"prefer":"single"}`,
+  )
+}

package/linthost/format_quotes_keeps_single_with_redundant_double_escape_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesKeepsSingleWithRedundantDoubleEscape is the mirror of
+// TestFormatQuotesKeepsDoubleWithRedundantSingleEscape: a single-quoted
+// literal carrying a redundant `\"` escape is left alone under
+// prefer:"double".
+//
+// The cooked value `a"b` holds one double quote: single quotes spell it
+// with zero required escapes, while double quotes need one. The supported
+// policy retains the cheaper delimiter even under the double preference.
+// The rule leaves the redundant backslash untouched; the counter must treat the
+// redundant `\"` as a double-quote occurrence.
+//
+//  1. Parse a single-quoted literal with a redundant `\"`.
+//  2. Run format/quotes with prefer:"double".
+//  3. Assert the rule reports nothing (single quotes are cheaper, kept).
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must retain the single-quoted a-double-quote-b payload under prefer:double because the preferred delimiter would require an escape.
+// @evidence contracts/testing.md#independent-expectations The literal source encodes a"b; the supported minimum-required-escape policy preserves its cheaper single delimiter and existing redundant escape. This owns delimiter retention, not reference-normalized full bytes.
+// @evidence contracts/testing.md#distinguishing-cases This redundant escaped double quote is the mirror of the escaped-apostrophe negative; default-double tie conversion distinguishes this strict-cost abstention.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesKeepsSingleWithRedundantDoubleEscape is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal source and no-finding assertions; the shared syntax-only harness invokes the owning rule in process without a consumer install, native product build or product host.
+func TestFormatQuotesKeepsSingleWithRedundantDoubleEscape(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/quotes",
+    "const b = 'a\\\"b';\n",
+    `{"prefer":"double"}`,
+  )
+}

package/linthost/format_quotes_preserves_strings_with_unescaped_double_quotes_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatQuotesPreservesStringsWithUnescapedDoubleQuotes verifies the
+// strict escape-cost comparison: a single-quoted literal that contains unescaped
+// double quotes is left as-is.
+//
+// Converting `'say "hi"'` to double would add two backslash escapes
+// (`"say \"hi\""`) — strictly more characters than the source. Prettier's
+// rule (which this implementation mirrors) keeps the original literal in
+// that case. This scenario pins the inequality so a future flip of the
+// `>` operator cannot silently start adding noise to source.
+//
+// 1. Parse a source file with single-quoted literals containing `"`.
+// 2. Run the engine with formatQuotes enabled.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification The engine must emit no quote-style finding for the single-quoted say "hi" literal because conversion would introduce two escapes.
+// @evidence contracts/testing.md#independent-expectations The parsed literal has the cooked say "hi" payload and no required escapes with its current delimiter; the supported escape-minimization policy makes its existing form the independent negative oracle.
+// @evidence contracts/testing.md#distinguishing-cases This strict-cost negative preserves the declaration and call by reporting no edits; the mixed tie and plain-string positives distinguish it from unconditional abstention.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesPreservesStringsWithUnescapedDoubleQuotes is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the parsed source fixtures and direct in-process Engine assertions; it starts no consumer install, native product build or product host.
+func TestFormatQuotesPreservesStringsWithUnescapedDoubleQuotes(t *testing.T) {
+  file := parseTS(t, "const greeting = 'say \"hi\"';\nJSON.stringify(greeting);\n")
+  findings := NewEngine(RuleConfig{"format/quotes": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings, got %d", len(findings))
+  }
+}

package/linthost/format_quotes_skips_double_quoted_literals_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatQuotesSkipsDoubleQuotedLiterals verifies a plain double-quoted hello
+// produces no edit under the default double preference. This is a
+// zero-escape tie; cost-minimizing cases may change other double-quoted values.
+//
+// @evidence contracts/testing.md#behavioral-verification The engine must report no quote-style finding for the plain double-quoted hello already canonical under the default preference.
+// @evidence contracts/testing.md#independent-expectations The literal hello has zero required escapes under either delimiter, so the supported default-double tie policy independently selects its existing spelling.
+// @evidence contracts/testing.md#distinguishing-cases This canonical plain-string negative complements the single-to-double positive; it does not claim that all double-quoted strings are immune, since the strict-cost positive flips one.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesSkipsDoubleQuotedLiterals is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the parsed source fixtures and direct in-process Engine assertions; it starts no consumer install, native product build or product host.
+func TestFormatQuotesSkipsDoubleQuotedLiterals(t *testing.T) {
+  file := parseTS(t, `const greeting = "hello";`+"\n"+`JSON.stringify(greeting);`+"\n")
+  findings := NewEngine(RuleConfig{"format/quotes": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings, got %d", len(findings))
+  }
+}

package/linthost/format_quotes_skips_jsx_attribute_strings_test.go

@@ -0,0 +1,44 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatQuotesSkipsJsxAttributeStrings verifies that prefer:single formats ordinary strings
+// while JSX attribute spelling remains outside this option. Both delimiters
+// are valid JSX syntax; JSX quote style has a separate option.
+//
+// @evidence contracts/testing.md#behavioral-verification The engine must exclude JSX attribute literals from format/quotes while still returning the exact prefer:single edit for an ordinary JavaScript string in the same TSX file.
+// @evidence contracts/testing.md#independent-expectations The JSX specification permits both quote delimiters, but JSX spelling belongs to a separate JSX option. The literal expected edit changes only the ordinary foo string to single quotes; its positions exclude the attribute.
+// @evidence contracts/testing.md#distinguishing-cases The original attribute-only negative is retained. The paired TSX input adds an adjacent ordinary-string positive with exactly one format/quotes finding and exact replacement, preventing a rule that skips all TSX strings from passing.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesSkipsJsxAttributeStrings is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the parsed source fixtures and direct in-process Engine assertions; it starts no consumer install, native product build or product host.
+func TestFormatQuotesSkipsJsxAttributeStrings(t *testing.T) {
+  source := "const el = <div className=\"foo\" />;\n"
+  file := parseTSXFile(t, "/virtual/main.tsx", source)
+  resolver := InlineRuleResolver{
+    Rules: RuleConfig{"format/quotes": SeverityError},
+    Options: RuleOptionsMap{
+      "format/quotes": []byte(`{"prefer":"single"}`),
+    },
+  }
+  findings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings on JSX attribute string, got %d:\n%v", len(findings), findings)
+  }
+  paired := "const label = \"foo\";\nconst el = <div className=\"foo\" />;\n"
+  pairedFile := parseTSXFile(t, "/virtual/paired.tsx", paired)
+  pairedFindings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{pairedFile}, nil)
+  if len(pairedFindings) != 1 {
+    t.Fatalf("expected only the ordinary JS string to change, got %d: %v", len(pairedFindings), pairedFindings)
+  }
+  finding := pairedFindings[0]
+  if finding.Rule != "format/quotes" || !finding.IsFormat || len(finding.Fix) != 1 {
+    t.Fatalf("unexpected ordinary string finding: %+v", finding)
+  }
+  edit := finding.Fix[0]
+  if edit.Pos != len("const label = ") || edit.End != len("const label = \"foo\"") || edit.Text != "'foo'" {
+    t.Fatalf("ordinary string edit must exclude JSX attribute: %+v", edit)
+  }
+}

package/linthost/format_quotes_skips_template_literals_test.go

@@ -0,0 +1,38 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatQuotesSkipsTemplateLiterals verifies template literals stay
+// untouched by the quote-style formatter.
+//
+// Template literals use a distinct AST kind (NoSubstitutionTemplateLiteral /
+// TemplateExpression). The rule's Visits() list omits those kinds, and
+// its delimiter guard also rejects non-single/double-quoted tokens.
+// These direct engine assertions require no finding on both template
+// forms; they do not prove that changing the visitor alone corrupts them.
+//
+// 1. Parse a source file using only backtick template literals.
+// 2. Run the engine with formatQuotes enabled.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification The engine must emit no quote-style findings for both no-substitution templates and a template expression with a real interpolation.
+// @evidence contracts/testing.md#independent-expectations The source literals retain backticks and the ${name} substitution because template grammar is outside the ordinary string-delimiter operation; zero findings is the independent unchanged-source oracle.
+// @evidence contracts/testing.md#distinguishing-cases The original two no-substitution literals remain asserted, and the added interpolation exercises TemplateExpression rather than merely claiming it. Ordinary quoted-string positives own actual conversion.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesSkipsTemplateLiterals is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the parsed source fixtures and direct in-process Engine assertions; it starts no consumer install, native product build or product host.
+func TestFormatQuotesSkipsTemplateLiterals(t *testing.T) {
+  file := parseTS(t, "const greeting = `hello`;\nconst name = `world`;\n")
+  findings := NewEngine(RuleConfig{"format/quotes": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings, got %d", len(findings))
+  }
+  interpolated := parseTS(t, "const name = `world`;\nconst greeting = `hello ${name}`;\n")
+  interpolatedFindings := NewEngine(RuleConfig{"format/quotes": SeverityError}).Run([]*shimast.SourceFile{interpolated}, nil)
+  if len(interpolatedFindings) != 0 {
+    t.Fatalf("expected no findings on interpolated template, got %d: %v", len(interpolatedFindings), interpolatedFindings)
+  }
+}