@ttsc/lint 0.19.3 → 0.20.0

package/linthost/print_nodes_function.go

@@ -57,9 +57,51 @@ func printArrowFunction(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if arrow == nil || arrow.Body == nil {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  if arrowBodyBreaksAfterArrow(arrow.Body) {
+    return printArrowWithBreakableExpressionBody(ctx, node, arrow.Body)
+  }
   return printFunctionLike(ctx, node, arrow.Body)
 }
 
+// arrowBodyBreaksAfterArrow reports the expression-body shapes for which
+// Prettier can keep an arrow hugged to a call's opening line and break after
+// `=>`. Object and array bodies already carry their own group and use the
+// ordinary arrow printer; these shapes need a group owned by the arrow itself.
+func arrowBodyBreaksAfterArrow(body *shimast.Node) bool {
+  if body == nil {
+    return false
+  }
+  switch body.Kind {
+  case shimast.KindCallExpression,
+    shimast.KindConditionalExpression,
+    shimast.KindJsxElement,
+    shimast.KindJsxSelfClosingElement,
+    shimast.KindJsxFragment:
+    return true
+  }
+  return false
+}
+
+// printArrowWithBreakableExpressionBody renders a concise arrow as one group
+// with a Line immediately after `=>`. Flat mode emits the ordinary space;
+// broken mode places the expression one indentation level below the arrow.
+func printArrowWithBreakableExpressionBody(ctx *PrintContext, node, body *shimast.Node) (Doc, bool) {
+  nodeStart := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  bodyStart := shimscanner.SkipTrivia(ctx.Source, body.Pos())
+  if nodeStart < 0 || bodyStart < nodeStart || bodyStart > len(ctx.Source) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  prefix := strings.TrimRight(ctx.Source[nodeStart:bodyStart], " \t\r\n")
+  if strings.Contains(prefix, "\n") || !strings.HasSuffix(prefix, "=>") {
+    return printFunctionLike(ctx, node, body)
+  }
+  bodyDoc, covered := PrintNode(ctx, body)
+  return Group(
+    Text(prefix),
+    Indent(ctx.indentUnit(), Line(), bodyDoc),
+  ), covered
+}
+
 // printFunctionExpression renders a `function` expression. Like the
 // arrow printer, the signature is verbatim and only the body reflows.
 // Function expressions always carry a block body, so the body always
@@ -100,6 +142,66 @@ func printFunctionLike(ctx *PrintContext, node, body *shimast.Node) (Doc, bool)
   return Concat(prefix, bodyDoc), prefixCovered && bodyCovered
 }
 
+// printObjectMember renders one member of an object literal by slicing its
+// head verbatim and dispatching what follows.
+//
+// A member is the same shape as a function expression — a signature the printer
+// keeps as written, then a body it lays out — so it goes through
+// printFunctionLike. A shorthand method's body starts at its `{`, an accessor's
+// likewise, and a property assignment's "body" is its initializer, which makes
+// `m: () => { … }` reflow through the arrow printer instead of freezing.
+//
+// Without this every member printed verbatim, so an object literal held a
+// single-line slice no enclosing reflow could break into: `{ m() { return 1; }
+// }` had no hardline to honour however the layout was forced, which is why
+// denying the print-width fast path for it changed nothing.
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printObjectMember(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  body := objectMemberBody(node)
+  if body == nil {
+    // A shorthand property (`{ a }`), a spread (`{ ...rest }`), or a member
+    // whose body the parser did not produce. There is nothing to lay out, so
+    // the source bytes round-trip.
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  // A comment between the head and the body would sit inside the verbatim
+  // prefix and survive, but one after the body's close brace would not, so the
+  // same guard the sibling printers use applies here.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
+  return printFunctionLike(ctx, node, body)
+}
+
+// objectMemberBody returns the part of an object-literal member the printer
+// lays out — a callable member's block, or a property assignment's initializer
+// — or nil when the member has neither.
+func objectMemberBody(node *shimast.Node) *shimast.Node {
+  switch node.Kind {
+  case shimast.KindPropertyAssignment:
+    if p := node.AsPropertyAssignment(); p != nil {
+      return p.Initializer
+    }
+  case shimast.KindMethodDeclaration:
+    if m := node.AsMethodDeclaration(); m != nil {
+      return m.Body
+    }
+  case shimast.KindGetAccessor:
+    if g := node.AsGetAccessorDeclaration(); g != nil {
+      return g.Body
+    }
+  case shimast.KindSetAccessor:
+    if s := node.AsSetAccessorDeclaration(); s != nil {
+      return s.Body
+    }
+  }
+  return nil
+}
+
 // printParenthesizedExpression renders `( expr )`. The parentheses are
 // fixed punctuation; the inner expression is dispatched so a call or
 // object literal wrapped in parens still reflows.
@@ -164,8 +266,27 @@ func printBlock(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   hasComment := blockHasNonStatementComment(ctx, node, block.Statements.Nodes)
   if len(block.Statements.Nodes) == 0 {
     if hasComment {
-      // `{ /* … */ }` — not collapsible without dropping the comment.
-      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+      // A one-line comment-only block is non-empty to Prettier: keep the
+      // comment and give it the same hardline layout as a statement. A
+      // multi-line comment body keeps its original columns and therefore
+      // remains uncovered.
+      start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+      end := node.End()
+      if start < 0 || end <= start+1 || end > len(ctx.Source) ||
+        ctx.Source[start] != '{' || ctx.Source[end-1] != '}' {
+        return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+      }
+      rawInner := ctx.Source[start+1 : end-1]
+      inner := strings.TrimSpace(rawInner)
+      if inner == "" || strings.ContainsAny(rawInner, "\r\n") {
+        return verbatim(ctx, node), false
+      }
+      return Concat(
+        Text("{"),
+        Indent(ctx.indentUnit(), Hardline(), Text(inner)),
+        Hardline(),
+        Text("}"),
+      ), true
     }
     return Text("{}"), true
   }
@@ -254,30 +375,29 @@ func blankLineBetweenStatements(src string, prevEnd, nextPos int) bool {
   return false
 }
 
-// blockHasNonStatementComment reports whether the block's byte range
-// holds a `//` or `/*` outside every statement's token range. The block
-// printer joins statements with bare Hardlines that have no slot for
-// inter-statement trivia, so a stray comment would be dropped by a
-// reflow. Detecting it lets printBlock report the block uncovered and
-// the formatPrintWidth rule abstain.
+// nodeHasNonItemComment reports whether the node's byte range holds a `//` or
+// `/*` outside every supplied item's token range. Block and switch printers
+// join their items with minted Hardlines that have no slot for inter-item
+// trivia, so a stray comment would be dropped by a reflow. Detecting it lets
+// the printer report the node uncovered and the formatPrintWidth rule abstain.
 //
 // The scan mirrors rules_format_print_width.go::hasNonChildComments:
 // comment-shaped bytes inside a complete statement token range (string
 // literals, nested comments) are masked, so only genuine
 // inter-statement comments surface.
-func blockHasNonStatementComment(ctx *PrintContext, node *shimast.Node, stmts []*shimast.Node) bool {
+func nodeHasNonItemComment(ctx *PrintContext, node *shimast.Node, items []*shimast.Node) bool {
   start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
   end := node.End()
   if start < 0 || end < start || end > len(ctx.Source) {
     return false
   }
   type span struct{ pos, end int }
-  ranges := make([]span, 0, len(stmts))
-  for _, stmt := range stmts {
-    if stmt == nil {
+  ranges := make([]span, 0, len(items))
+  for _, item := range items {
+    if item == nil {
       continue
     }
-    ranges = append(ranges, span{shimscanner.SkipTrivia(ctx.Source, stmt.Pos()), stmt.End()})
+    ranges = append(ranges, span{shimscanner.SkipTrivia(ctx.Source, item.Pos()), item.End()})
   }
   inStatement := func(i int) bool {
     for _, r := range ranges {
@@ -299,6 +419,13 @@ func blockHasNonStatementComment(ctx *PrintContext, node *shimast.Node, stmts []
   return false
 }
 
+// blockHasNonStatementComment is the block-specific name retained for callers
+// and focused tests; switch printers use the generalized item-range helper
+// directly for clauses and statements.
+func blockHasNonStatementComment(ctx *PrintContext, node *shimast.Node, stmts []*shimast.Node) bool {
+  return nodeHasNonItemComment(ctx, node, stmts)
+}
+
 // printExpressionStatement renders an `expr;` statement. The expression
 // is dispatched so a callback-body statement that is itself a call or
 // object literal reflows; the trailing `;` is preserved when the source

package/linthost/print_nodes_list.go

@@ -52,14 +52,17 @@ type listShape struct {
   Items    []Doc
   Space    bool // emit a space after OPEN / before CLOSE in flat mode
   AddComma bool // emit a trailing comma in broken mode
-  // HugLast keeps the final item attached to the parens instead of
-  // exploding the whole list. It is set by the call/new argument
-  // printer when the last argument is a callback or object literal —
-  // see printArgList. When true, the last item is emitted directly
-  // against OPEN…CLOSE with no leading/trailing soft break, so a
-  // multi-line callback body does not force every preceding argument
-  // onto its own line.
+  // HugLast keeps the final item attached to OPEN instead of exploding the
+  // whole list. Ordinarily it also stays against CLOSE, so a multi-line
+  // callback body does not force preceding arguments onto separate lines.
+  // HugLastBreakClose supplies the expression-bodied-arrow exception.
   HugLast bool
+  // HugLastBreakClose keeps an expression-bodied trailing arrow attached to
+  // OPEN through its `=>`, but finishes a broken argument list with the
+  // optional trailing comma and CLOSE on a fresh line. Unlike a block-bodied
+  // callback, the arrow's expression does not own the call's closing line:
+  // `run(() =>\n  nested(),\n)`. Requires HugLast.
+  HugLastBreakClose bool
   // HugFirst keeps the FIRST item attached to the open paren and flows
   // the remaining simple items after it, the mirror of HugLast. The
   // call-argument printer sets it for the two-argument
@@ -274,8 +277,9 @@ func printListPlain(ctx *PrintContext, shape listShape) Doc {
 
 // printListHuggingLast renders the "last-argument hugging" shape that
 // Prettier uses for `foo(a, b, () => { … })`: the leading items flow
-// comma-separated and the final item stays attached to the closing
-// paren instead of being pushed onto its own indented line.
+// comma-separated and the final item stays attached to the opening line
+// instead of being pushed onto its own indented line. Most expandable items
+// hug CLOSE too; an expression-bodied arrow uses HugLastBreakClose.
 //
 //  hugged: OPEN a, b, OPEN-of-last … CLOSE-of-last CLOSE
 //
@@ -308,7 +312,15 @@ func printListHuggingLast(ctx *PrintContext, shape listShape) Doc {
   for _, item := range lead {
     parts = append(parts, item, Text(", "))
   }
-  parts = append(parts, last, Text(shape.CloseTok))
+  parts = append(parts, last)
+  if shape.HugLastBreakClose {
+    if shape.AddComma {
+      parts = append(parts, Text(","))
+    }
+    parts = append(parts, Hardline(), Text(shape.CloseTok))
+  } else {
+    parts = append(parts, Text(shape.CloseTok))
+  }
   return Concat(parts...)
 }
 

package/linthost/project_engine.go

@@ -1,6 +1,7 @@
 package linthost
 
 import (
+  "encoding/json"
   "fmt"
   "sort"
   "sync"
@@ -18,6 +19,11 @@ type projectCycleResult struct {
   status   publicrule.ProjectRuleStatus
   severity Severity
   reporter *projectReporter
+  // identity and options are the configuration this rule ran under, retained so
+  // a later consumer of its state — a hint corpus, say — can be handed the same
+  // context Check saw without the rule stashing a copy inside its own state.
+  identity publicrule.ProjectIdentity
+  options  json.RawMessage
 }
 
 func (r *projectCycleResults) ProjectResult(name string) publicrule.ProjectRuleResult {
@@ -178,11 +184,20 @@ func (e *Engine) evaluateProject(
       sources = e.projectSources(files)
       sourcesResolved = true
     }
+    // A rule that declared it needs no checker is handed none, matching the
+    // TypeAwareRule contract that the host is free to leave it nil. Passing one
+    // anyway would let such a rule read the checker and keep working while its
+    // own declaration says it does not — until the day the engine acts on that
+    // declaration and the rule faults far from the marker that caused it.
+    ruleChecker := checker
+    if adapter.declinesTypeChecker {
+      ruleChecker = nil
+    }
     reporter := &projectReporter{active: true}
     context := publicrule.NewProjectContext(
       identity,
       sources,
-      checker,
+      ruleChecker,
       publicrule.Severity(setting.Severity),
       setting.Options,
       reporter,
@@ -191,6 +206,8 @@ func (e *Engine) evaluateProject(
     results.byName[name] = projectCycleResult{
       severity: setting.Severity,
       reporter: reporter,
+      identity: identity,
+      options:  setting.Options,
     }
   }
   return cycle

package/linthost/project_rules.go

@@ -14,10 +14,48 @@ type projectRuleAdapter struct {
   inner          publicrule.ProjectRule
   name           string
   acceptsOptions bool
+  // declinesTypeChecker records an explicit opt-out, so the zero value keeps
+  // the conservative default: a rule that never spoke still receives a checker.
+  //
+  // The negative spelling is deliberate. Adapters are constructed directly in
+  // several test helpers rather than through inspectProjectContributor, and a
+  // positive needsTypeChecker field would make those zero values silently deny
+  // a checker to a rule that reads one — the unsafe direction, reached by
+  // forgetting rather than by deciding.
+  declinesTypeChecker bool
 }
 
 var registeredProjectRules = map[string]projectRuleAdapter{}
 
+// registerBuiltInProjectCompanion attaches a project lifecycle to an existing
+// built-in file rule. Both halves deliberately share one public rule name and
+// therefore one config setting: the file rule keeps reporting source ranges,
+// while the project companion can publish finished state for consumers such as
+// editor hints.
+//
+// Contributor rules remain single-lifecycle registrations. Their collision
+// checks in registerProjectContributors still reject a file/project name pair,
+// because only built-ins can be audited together as one rule implementation.
+func registerBuiltInProjectCompanion(project publicrule.ProjectRule) {
+  adapter, err := inspectProjectContributor(project)
+  if err != nil {
+    panic(fmt.Sprintf("@ttsc/lint: invalid built-in project companion: %v", err))
+  }
+  if adapter.name == "" {
+    panic("@ttsc/lint: built-in project companion has an empty name")
+  }
+  if LookupRule(adapter.name) == nil {
+    panic(fmt.Sprintf("@ttsc/lint: built-in project companion %q has no file rule", adapter.name))
+  }
+  if _, builtIn := builtInRuleCodes[adapter.name]; !builtIn {
+    panic(fmt.Sprintf("@ttsc/lint: project companion %q is not a built-in rule", adapter.name))
+  }
+  if _, exists := registeredProjectRules[adapter.name]; exists {
+    panic(fmt.Sprintf("@ttsc/lint: project rule %q registered twice", adapter.name))
+  }
+  registeredProjectRules[adapter.name] = adapter
+}
+
 func registerProjectContributors() {
   projects := publicrule.RegisteredProjects()
   adapters := make([]projectRuleAdapter, 0, len(projects))
@@ -65,9 +103,18 @@ func inspectProjectContributor(project publicrule.ProjectRule) (adapter projectR
   if optionsRule, ok := project.(publicrule.OptionsRule); ok {
     adapter.acceptsOptions = optionsRule.AcceptsTtscLintOptions()
   }
+  if typeAware, ok := project.(publicrule.TypeAwareRule); ok {
+    adapter.declinesTypeChecker = !typeAware.NeedsTypeChecker()
+  }
   return adapter, nil
 }
 
+// projectRuleNeedsTypeChecker reports whether a registered project rule wants a
+// live checker. An unknown name and a rule that never spoke both answer true.
+func projectRuleNeedsTypeChecker(name string) bool {
+  return !registeredProjectRules[name].declinesTypeChecker
+}
+
 func allProjectRuleNames() []string {
   names := make([]string, 0, len(registeredProjectRules))
   for name := range registeredProjectRules {

package/linthost/rule_docs.go

@@ -0,0 +1,114 @@
+package linthost
+
+import "strings"
+
+// Rule documentation lives in one of two places, and which one is decided by
+// the rule's family alone — no per-rule table is maintained here.
+//
+// Families ported from a plugin that publishes its own rule reference keep
+// pointing at that upstream reference, because those pages are the behavioral
+// specification `@ttsc/lint` ports against and the one the rule sources already
+// cite in their header comments. Every other family is documented only by the
+// ttsc website's rule catalog, so its rules link there.
+const (
+  eslintRuleDocsBaseURL     = "https://eslint.org/docs/latest/rules/"
+  unicornRuleDocsBaseURL    = "https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/"
+  typescriptRuleDocsBaseURL = "https://typescript-eslint.io/rules/"
+  websiteRuleDocsBaseURL    = "https://ttsc.dev/docs/lint/rules/"
+)
+
+// websiteDocumentedRuleFamilies lists the families whose whole rule set is
+// catalogued on the ttsc website, as one level-3 heading per rule (the rule
+// name in a code span) in website/src/content/docs/lint/rules/<family>.mdx.
+//
+// `format` is deliberately absent. Its 17 rules have no page of their own: the
+// `lint/format` guide documents the configuration keys (`semi`, `printWidth`,
+// …), which do not correspond one-to-one with the rule names (`format/quotes`,
+// `format/clause-join`, `format/whitespace`, …). Emitting an anchor there would
+// produce a link to a heading that does not exist, so format findings carry no
+// codeDescription at all.
+//
+// A family missing from this set simply gets no documentation link, which keeps
+// a newly added family silent rather than pointing at a page nobody wrote yet.
+var websiteDocumentedRuleFamilies = map[string]struct{}{
+  "boundaries":      {},
+  "cypress":         {},
+  "functional":      {},
+  "jest":            {},
+  "jsdoc":           {},
+  "jsx-a11y":        {},
+  "nextjs":          {},
+  "playwright":      {},
+  "promise":         {},
+  "react":           {},
+  "react-perf":      {},
+  "regexp":          {},
+  "security":        {},
+  "solid":           {},
+  "storybook":       {},
+  "tanstack-query":  {},
+  "testing-library": {},
+  "vitest":          {},
+}
+
+// ruleDocumentationURL returns the documentation page for a rule name, or an
+// empty string when no vetted page exists for it.
+//
+// Only active built-in rules resolve. The rule-code ledger is append-only, so a
+// removed built-in name remains reserved and is not enough to establish runtime
+// provenance by itself. The registered rule must also be a native rule rather
+// than a public contributor adapter. That keeps a contributor which reuses a
+// retired ledger name from inheriting a ttsc or upstream URL.
+func ruleDocumentationURL(name string) string {
+  candidate := LookupRule(name)
+  if candidate == nil {
+    return ""
+  }
+  switch candidate.(type) {
+  case contributorAdapter, formatContributorAdapter:
+    return ""
+  }
+  if _, builtIn := builtInRuleCodes[name]; !builtIn {
+    return ""
+  }
+  family, bare, prefixed := strings.Cut(name, "/")
+  if !prefixed {
+    // An unprefixed built-in name is a core ESLint rule id verbatim.
+    return eslintRuleDocsBaseURL + name
+  }
+  switch family {
+  case "unicorn":
+    return unicornRuleDocsBaseURL + bare + ".md"
+  case "typescript":
+    return typescriptRuleDocsBaseURL + bare
+  }
+  if _, documented := websiteDocumentedRuleFamilies[family]; !documented {
+    return ""
+  }
+  return websiteRuleDocsBaseURL + family + "#" + websiteRuleAnchor(name)
+}
+
+// websiteRuleAnchor reproduces the heading id Nextra assigns to the level-3
+// heading that documents a rule.
+//
+// Nextra's remark-headings plugin slugs the heading's flattened text with
+// github-slugger, which lowercases and drops characters it does not consider
+// word characters — the `/` separator among them. `jsx-a11y/alt-text` therefore
+// renders as `#jsx-a11yalt-text`, not `#jsx-a11y-alt-text`, and the one rule
+// name carrying an uppercase letter (`security/detect-pseudoRandomBytes`)
+// renders fully lowercased. Both fall out of this transform; neither is special
+// cased.
+func websiteRuleAnchor(name string) string {
+  return strings.ToLower(strings.ReplaceAll(name, "/", ""))
+}
+
+// lspCodeDescriptionForRule wraps a rule's documentation URL for the wire, or
+// returns nil when the rule has none. A nil result keeps `codeDescription`
+// absent from the marshalled diagnostic rather than emitting an empty object.
+func lspCodeDescriptionForRule(name string) *lspCodeDescription {
+  href := ruleDocumentationURL(name)
+  if href == "" {
+    return nil
+  }
+  return &lspCodeDescription{Href: href}
+}

package/linthost/rules_boundaries.go

@@ -59,7 +59,10 @@ func (boundariesElementTypes) Check(ctx *Context, node *shimast.Node) {
     }
     message := fmt.Sprintf("Import from boundary element %q is not allowed in %q.", target.Type, source.Type)
     if rule != nil && rule.Message != "" {
+      // A user wrote this; appending to it would be presumptuous.
       message = rule.Message
+    } else if rule != nil {
+      message += describeBoundaryAllowed(rule.Allow)
     }
     reportBoundaryDependency(ctx, dep, message)
   }
@@ -80,6 +83,8 @@ func (boundariesExternal) Check(ctx *Context, node *shimast.Node) {
     message := fmt.Sprintf("External dependency %q is not allowed.", dep.specifier)
     if opts.Message != "" {
       message = opts.Message
+    } else {
+      message += describeBoundaryAllowed(opts.Allow)
     }
     reportBoundaryDependency(ctx, dep, message)
   }
@@ -109,7 +114,11 @@ func (boundariesEntryPoint) Check(ctx *Context, node *shimast.Node) {
     if matchBoundaryElementLocalPattern(target.Entry, target) {
       continue
     }
-    reportBoundaryDependency(ctx, dep, fmt.Sprintf("Import %q through an allowed boundary entry point.", target.RelativePath))
+    reportBoundaryDependency(ctx, dep, fmt.Sprintf(
+      "Import %q through an allowed boundary entry point.%s",
+      target.RelativePath,
+      describeBoundaryAllowed(target.Entry),
+    ))
   }
 }
 
@@ -157,7 +166,11 @@ func (boundariesNoUnknown) Check(ctx *Context, node *shimast.Node) {
     if classifyBoundaryFile(targetPath, opts.Elements) != nil {
       continue
     }
-    reportBoundaryDependency(ctx, dep, fmt.Sprintf("Imported file %q does not match any configured boundary element.", boundaryDisplayPath(targetPath)))
+    reportBoundaryDependency(ctx, dep, fmt.Sprintf(
+      "Imported file %q does not match any configured boundary element.%s",
+      boundaryDisplayPath(targetPath),
+      describeBoundaryElements(opts.Elements),
+    ))
   }
 }
 
@@ -460,6 +473,71 @@ func resolveBoundaryImport(sourceFileName, specifier string) (string, bool) {
   return "", false
 }
 
+// describeBoundaryAllowed renders a set of allowed patterns as a clause a
+// message can append, or "" when there is nothing to name.
+//
+// A boundary rule computes what would be acceptable in order to decide, then
+// reports only that the code is wrong — leaving the reader to open lint.config
+// to learn what is allowed. Naming the set closes that gap for the cost of a
+// join, and matches what unicorn/import-style and prevent-abbreviations already
+// do. An empty set returns "" rather than an empty list, because a deny-only
+// policy has no allowed set to offer and "allowed here: " with nothing after it
+// is worse than silence.
+func describeBoundaryAllowed(patterns boundaryStringList) string {
+  if len(patterns) == 0 {
+    return ""
+  }
+  items := make([]string, 0, len(patterns))
+  for _, pattern := range patterns {
+    if pattern == "" {
+      continue
+    }
+    items = append(items, pattern)
+  }
+  if len(items) == 0 {
+    return ""
+  }
+  // Truncate rather than print a wall. A message that scrolls off the line is
+  // its own failure, and the first several patterns are enough to orient.
+  const limit = 6
+  suffix := ""
+  if len(items) > limit {
+    suffix = ", ..."
+    items = items[:limit]
+  }
+  return " Allowed here: " + strings.Join(items, ", ") + suffix + "."
+}
+
+// describeBoundaryElements names the configured element types, for a
+// "does not match any element" message that would otherwise make the reader
+// go find the list themselves. Phrased as "Configured elements" rather than
+// "Allowed", because no-unknown is about which elements exist, not which imports
+// a policy permits.
+func describeBoundaryElements(elements []boundaryElement) string {
+  types := make([]string, 0, len(elements))
+  seen := map[string]struct{}{}
+  for _, element := range elements {
+    if element.Type == "" {
+      continue
+    }
+    if _, ok := seen[element.Type]; ok {
+      continue
+    }
+    seen[element.Type] = struct{}{}
+    types = append(types, element.Type)
+  }
+  if len(types) == 0 {
+    return ""
+  }
+  const limit = 6
+  suffix := ""
+  if len(types) > limit {
+    suffix = ", ..."
+    types = types[:limit]
+  }
+  return " Configured elements: " + strings.Join(types, ", ") + suffix + "."
+}
+
 func reportBoundaryDependency(ctx *Context, dep boundaryDependency, message string) {
   if dep.node != nil {
     ctx.Report(dep.node, message)

package/linthost/rules_format_bracket_spacing.go

@@ -13,9 +13,10 @@ import (
 //   - prefer false: no inner space, `{x: 1}`, `{a, b}`, `import {foo}`.
 //
 // It applies to object literals, object binding patterns (destructuring),
-// named imports/exports, and type literals, the brace kinds Prettier's
-// bracketSpacing governs. Block, class, interface, enum, and module braces
-// are NOT affected (their layout is owned by the indentation rules).
+// named imports/exports, type literals, mapped types, and import attributes,
+// the brace kinds Prettier's bracketSpacing governs. Block, class, interface,
+// enum, and module braces are NOT affected (their layout is owned by the
+// indentation rules).
 //
 // The rule touches only a brace pair that opens and closes on the SAME
 // line: a multi-line container's interior is the indentation rules' surface,
@@ -38,6 +39,8 @@ func (formatBracketSpacing) Visits() []shimast.Kind {
     shimast.KindNamedImports,
     shimast.KindNamedExports,
     shimast.KindTypeLiteral,
+    shimast.KindMappedType,
+    shimast.KindImportAttributes,
   }
 }
 
@@ -58,11 +61,20 @@ func (formatBracketSpacing) Check(ctx *Context, node *shimast.Node) {
   if start < 0 || end <= start || end > len(src) {
     return
   }
-  // The node's first byte should be `{` and last `}`; a parenthesized or
-  // otherwise-wrapped form is out of scope.
-  if src[start] != '{' || src[end-1] != '}' {
+  if src[end-1] != '}' {
     return
   }
+  // ImportAttributes begins at `with` or `assert`, not at its opening brace.
+  // Every other supported kind begins with `{`. Restrict the fallback search
+  // to that syntax node so a brace in an earlier expression cannot be chosen.
+  if src[start] != '{' {
+    for start < end && src[start] != '{' {
+      start++
+    }
+    if start >= end {
+      return
+    }
+  }
   inner := src[start+1 : end-1]
   if len(inner) == 0 {
     return // empty `{}`, nothing to pad