@ttsc/lint 0.18.4 → 0.19.1

package/linthost/rules_format_semi.go

@@ -15,7 +15,7 @@ import (
 // optional semicolon. Body-shaped declarations (functions, classes,
 // namespaces, enums) and control-flow statements (if/for/while/try)
 // are out of scope because they parse correctly without a terminator.
-type formatSemi struct{}
+type formatSemi struct{ optionsRule }
 
 // formatSemiOptions is the Go mirror of `TtscLintRuleOptions.Semi`. The
 // JSON tag matches the TypeScript field name so users get the same key
@@ -135,12 +135,22 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// nextStatementHasASIHazard reports whether the next non-trivia byte
-// after `end` starts a token that would re-associate with the prior
-// expression if the trailing `;` is removed. Prettier handles this by
-// inserting a defensive leading `;` on the next line; this rule's
-// fixer is single-node, so the safer move is to keep the explicit
-// terminator.
+// nextStatementHasASIHazard reports whether removing the trailing `;`
+// at `end-1` could change the parse, judged by the next significant
+// byte after `end` and the line structure between them.
+//
+// ASI only inserts a semicolon at a line terminator, end of input, or
+// before `}`. So the `;` is removable in exactly two shapes:
+//
+//   - end of input or a same-line `}` follows (ASI's closing-brace and
+//     end-of-input rules apply), or
+//   - a line terminator separates the statement from the next token AND
+//     that token is not a continuation hazard.
+//
+// Any other same-line successor (`else`, `while` of a do-loop, another
+// statement after a gap comment) makes the `;` a REQUIRED separator:
+// no line terminator means ASI cannot fire, so stripping would be a
+// syntax error, not a style change.
 //
 // Hazard tokens per the ASI spec:
 //
@@ -149,18 +159,72 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
 //   - “ ` “: tagged template literal continues
 //   - `+`, `-`, `*`: binary operator continues
 //   - `,`: comma operator continues
-//   - `/`: division operator or regex literal continues; handled by
-//     the comment-or-regex branch below (a leading `//` or `/*` is not a
-//     hazard, a bare `/` is), so it is absent from the token switch.
+//   - `/`: division operator or regex literal continues (a leading `//`
+//     or `/*` is trivia consumed by scanPastTrivia; a bare `/` is a
+//     hazard).
 func nextStatementHasASIHazard(src string, end int) bool {
-  for i := end; i < len(src); i++ {
+  i, sawNewline := scanPastTrivia(src, end)
+  if i >= len(src) {
+    return false
+  }
+  c := src[i]
+  if c == '}' {
+    // ASI applies before a closing brace regardless of line
+    // structure: `{ a(); }` → `{ a() }` stays valid.
+    return false
+  }
+  if !sawNewline {
+    // Next token on the same line: ASI cannot fire without a line
+    // terminator, so the `;` separates the two constructs
+    // (`if (a) b(); else c();`, `do f(); while (x);`,
+    // `a = 1; /* note */ b = 2`). Keep it.
+    return true
+  }
+  if c == '/' {
+    // bare `/` starts a regex literal or division, hazard.
+    return true
+  }
+  switch c {
+  // If the next significant byte is one of these, dropping the terminator
+  // could let the following line re-associate with the prior expression.
+  // `( [`, a unary `+ -`, and a tagged-template backtick are the cases
+  // actually reachable from a valid statement start; `<` matters in .tsx
+  // (a leading `<` opens a JSX element). The remaining infix bytes cannot
+  // begin a valid statement on their own, but are listed defensively so
+  // the strip always cedes rather than risk a parse-changing edit.
+  case '[', '(', '`', '+', '-', '*', ',', '.', '<', '>', '=', '?', '%', '&', '|', '^':
+    return true
+  }
+  return false
+}
+
+// scanPastTrivia advances from `pos` past whitespace and comments,
+// returning the index of the next significant byte (len(src) at end of
+// input) and whether a line terminator was crossed on the way. Both
+// semicolon scanners (statement and member) share it so the ASI line
+// rules cannot drift apart.
+//
+// A block comment that spans lines counts as a crossed line: per
+// ECMA-262 (Comments), a multi-line comment containing a line
+// terminator is treated as a line terminator for ASI, so the decision
+// keys on comment content, not comment kind. `\r` counts as a line
+// terminator on its own, which also covers CRLF sources.
+func scanPastTrivia(src string, pos int) (next int, sawNewline bool) {
+  i := pos
+  for i < len(src) {
     c := src[i]
-    if c == ' ' || c == '\t' || c == '\r' || c == '\n' {
+    if c == '\n' || c == '\r' {
+      sawNewline = true
+      i++
+      continue
+    }
+    if c == ' ' || c == '\t' {
+      i++
       continue
     }
     if c == '/' && i+1 < len(src) {
       if src[i+1] == '/' {
-        for i < len(src) && src[i] != '\n' {
+        for i < len(src) && src[i] != '\n' && src[i] != '\r' {
           i++
         }
         continue
@@ -168,30 +232,22 @@ func nextStatementHasASIHazard(src string, end int) bool {
       if src[i+1] == '*' {
         i += 2
         for i+1 < len(src) && !(src[i] == '*' && src[i+1] == '/') {
+          if src[i] == '\n' || src[i] == '\r' {
+            sawNewline = true
+          }
           i++
         }
         if i+1 < len(src) {
-          i++ // step past '*/'
+          i += 2 // step past '*/'
+        } else {
+          i = len(src) // unterminated block comment swallows the rest
         }
         continue
       }
-      // bare `/` starts a regex literal or division, hazard.
-      return true
-    }
-    switch c {
-    // If the next significant byte is one of these, dropping the terminator
-    // could let the following line re-associate with the prior expression.
-    // `( [`, a unary `+ -`, and a tagged-template backtick are the cases
-    // actually reachable from a valid statement start; `<` matters in .tsx
-    // (a leading `<` opens a JSX element). The remaining infix bytes cannot
-    // begin a valid statement on their own, but are listed defensively so
-    // the strip always cedes rather than risk a parse-changing edit.
-    case '[', '(', '`', '+', '-', '*', ',', '.', '<', '>', '=', '?', '%', '&', '|', '^':
-      return true
     }
-    return false
+    return i, sawNewline
   }
-  return false
+  return len(src), sawNewline
 }
 
 // preferNeverSafeKind reports whether stripping the trailing semicolon
@@ -291,8 +347,9 @@ func stripMemberSemicolon(ctx *Context, src string, node *shimast.Node, isClassF
 
 // memberSemicolonRedundant reports whether the member terminator `;`
 // whose following byte is at `after` can be dropped without changing the
-// parse. It scans past trivia (whitespace + comments) to the next
-// significant byte and applies Prettier's semi:false member rules:
+// parse. It scans past trivia (whitespace + comments, via
+// scanPastTrivia) to the next significant byte and applies Prettier's
+// semi:false member rules:
 //
 //   - The closing `}` (or end of file) always makes the `;` redundant.
 //   - A next member on the SAME line (no newline crossed) keeps the `;`
@@ -305,57 +362,27 @@ func stripMemberSemicolon(ctx *Context, src string, node *shimast.Node, isClassF
 //     call/construct/generic signature (`(` / `<`) for type members
 //     (a leading `[` is an index signature there, not a continuation).
 func memberSemicolonRedundant(src string, after int, isClassField bool) bool {
-  sawNewline := false
-  for i := after; i < len(src); {
-    c := src[i]
-    if c == '\n' {
-      sawNewline = true
-      i++
-      continue
-    }
-    if c == ' ' || c == '\t' || c == '\r' {
-      i++
-      continue
-    }
-    if c == '/' && i+1 < len(src) {
-      if src[i+1] == '/' {
-        for i < len(src) && src[i] != '\n' {
-          i++
-        }
-        continue
-      }
-      if src[i+1] == '*' {
-        i += 2
-        for i+1 < len(src) && !(src[i] == '*' && src[i+1] == '/') {
-          if src[i] == '\n' {
-            sawNewline = true
-          }
-          i++
-        }
-        if i+1 < len(src) {
-          i += 2
-        }
-        continue
-      }
-    }
-    if c == '}' {
-      return true
-    }
-    if !sawNewline {
+  i, sawNewline := scanPastTrivia(src, after)
+  if i >= len(src) {
+    return true
+  }
+  c := src[i]
+  if c == '}' {
+    return true
+  }
+  if !sawNewline {
+    return false
+  }
+  if isClassField {
+    switch c {
+    case '[', '(', '`', '+', '-', '*', '/', ',':
       return false
     }
-    if isClassField {
-      switch c {
-      case '[', '(', '`', '+', '-', '*', '/', ',':
-        return false
-      }
-    } else {
-      switch c {
-      case '(', '<':
-        return false
-      }
+  } else {
+    switch c {
+    case '(', '<':
+      return false
     }
-    return true
   }
   return true
 }

package/linthost/rules_format_sort_imports.go

@@ -27,11 +27,15 @@ const (
   separatorPlaceholder = ""
 )
 
-// formatSortImportsOptions mirrors `ITtscLintFormatSortImports`.
+// formatSortImportsOptions mirrors `ITtscLintFormatSortImports`, plus the
+// top-level `endOfLine` the config layer threads in so the rebuilt block
+// joins declarations with the file's line ending.
 type formatSortImportsOptions struct {
-  Order               []string `json:"order"`
-  CaseSensitive       bool     `json:"caseSensitive"`
-  CombineTypeAndValue bool     `json:"combineTypeAndValue"`
+  Order                    []string `json:"order"`
+  CaseSensitive            bool     `json:"caseSensitive"`
+  CombineTypeAndValue      bool     `json:"combineTypeAndValue"`
+  UnsafeSortRuntimeImports bool     `json:"unsafeSortRuntimeImports"`
+  EndOfLine                *string  `json:"endOfLine"`
 }
 
 // defaultImportOrder is used when the user supplies no `order`: Node built-ins,
@@ -44,12 +48,13 @@ var defaultImportOrder = []string{
   `^[.]`,
 }
 
-// formatSortImports orders the file's top-level import declarations into
-// canonical groups, alphabetizes each group, merges duplicate imports of the
-// same module, and (when `combineTypeAndValue` is on) folds a type-only
-// import into a value import of the same module. Groups are user-configurable
-// via the `order` option; when omitted, the rule falls back to {@link
-// defaultImportOrder}.
+// formatSortImports safely sorts named specifiers and erased type-only import
+// blocks. Runtime-bearing declarations retain source order unless the user
+// explicitly enables `unsafeSortRuntimeImports`; only then are they grouped,
+// alphabetized, and merged. When that unsafe mode and `combineTypeAndValue`
+// are both on, a type-only import may fold into a value import of the same
+// module. Groups are user-configurable via the `order` option; when omitted,
+// the rule falls back to {@link defaultImportOrder}.
 //
 // Within each group, declarations are sorted by their module-specifier text
 // (ASCII order, or case-insensitive unless `caseSensitive: true`). Named
@@ -58,10 +63,10 @@ var defaultImportOrder = []string{
 // Safety policy: if any byte between the contiguous imports is not
 // whitespace, the rule bails. Comments anchored to specific imports would
 // otherwise move with the wrong declaration, which is a strictly worse
-// outcome than declining to sort. Side-effect imports (`import "foo"`) also
-// bail the whole block because their evaluation order can carry meaning the
-// rule cannot reason about.
-type formatSortImports struct{}
+// outcome than declining to sort. Every import other than `import type` can
+// evaluate a module, including default, namespace, and named binding imports,
+// so declaration-level rewriting is disabled for those blocks by default.
+type formatSortImports struct{ optionsRule }
 
 func (formatSortImports) Name() string   { return "format/sort-imports" }
 func (formatSortImports) IsFormat() bool { return true }
@@ -80,19 +85,15 @@ func (formatSortImports) Check(ctx *Context, node *shimast.Node) {
     return
   }
   imports := collectLeadingImports(statements.Nodes)
-  // Block-level reorder runs only when the rule can do it safely:
-  // two or more contiguous imports with no comment trivia between
-  // them (comments anchor to specific imports and moving them would
-  // mis-attach the user's intent), AND no side-effect-only imports
-  // in the block. A side-effect import (`import "./polyfill"`) runs
-  // its module's top-level code for its observable effect; sorting it
-  // across a sibling import that depends on the polyfill being
-  // initialized first would silently change runtime behavior. The
-  // rule conservatively refuses to reorder the entire block in that
-  // case.
+  // Block-level rewriting runs only for erased type-only imports or after the
+  // caller explicitly accepts runtime reordering. Binding imports execute
+  // their dependencies just like bare imports, so preserving only
+  // `import "./polyfill"` is insufficient. Comment trivia remains an
+  // unconditional barrier even in unsafe mode because the rebuilder cannot
+  // preserve a comment's declaration attachment.
   if len(imports) >= 2 &&
     leadingTriviaIsAllWhitespace(src, imports) &&
-    !containsSideEffectImport(imports) {
+    (opts.unsafeSortRuntimeImports || !importsHaveRuntimeEvaluation(imports)) {
     first := imports[0]
     last := imports[len(imports)-1]
     replaceStart := shimscanner.SkipTrivia(src, first.Pos())
@@ -118,9 +119,14 @@ func (formatSortImports) Check(ctx *Context, node *shimast.Node) {
 // during one Check call. All option defaults are applied here so the
 // rest of the rule code does not branch on nil-ness.
 type resolvedSortImportsOptions struct {
-  groups              []sortImportsGroup
-  caseSensitive       bool
-  combineTypeAndValue bool
+  groups                   []sortImportsGroup
+  caseSensitive            bool
+  combineTypeAndValue      bool
+  unsafeSortRuntimeImports bool
+  // eol is the newline joined between rebuilt declarations: `"\n"` by
+  // default, `"\r\n"` under endOfLine:"crlf". Verbatim declaration text is
+  // preserved as-is; only the synthesized inter-declaration joins use it.
+  eol string
 }
 
 // sortImportsGroup is one resolved entry of the `order` array. A separator
@@ -143,10 +149,16 @@ func loadSortImportsOptions(ctx *Context) resolvedSortImportsOptions {
     order = defaultImportOrder
   }
   groups := parseImportOrder(order)
+  eol := "\n"
+  if raw.EndOfLine != nil && *raw.EndOfLine == "crlf" {
+    eol = "\r\n"
+  }
   return resolvedSortImportsOptions{
-    groups:              groups,
-    caseSensitive:       raw.CaseSensitive,
-    combineTypeAndValue: raw.CombineTypeAndValue,
+    groups:                   groups,
+    caseSensitive:            raw.CaseSensitive,
+    combineTypeAndValue:      raw.CombineTypeAndValue,
+    unsafeSortRuntimeImports: raw.UnsafeSortRuntimeImports,
+    eol:                      eol,
   }
 }
 
@@ -298,21 +310,22 @@ func specifierListHasCommentTrivia(src string, specifiers []*shimast.Node) bool
   return false
 }
 
-// containsSideEffectImport reports whether any import in the contiguous
-// block has no import clause (i.e. is a side-effect-only `import "x"`).
-// These imports are evaluated for their top-level effect; their order
-// relative to other imports may carry meaning the rule cannot reason
-// about, so the safety policy is to refuse to sort.
-func containsSideEffectImport(imports []*shimast.Node) bool {
+// importsHaveRuntimeEvaluation reports whether a contiguous block contains an
+// import that survives as a module dependency. Bare, default, namespace,
+// named, and deferred imports can all trigger top-level evaluation; only a
+// clause explicitly marked `type` is erased. Unexpected AST shapes are treated
+// as runtime-bearing so a parser change cannot silently weaken the guard.
+func importsHaveRuntimeEvaluation(imports []*shimast.Node) bool {
   for _, decl := range imports {
     if decl == nil {
-      continue
+      return true
     }
     imp := decl.AsImportDeclaration()
-    if imp == nil {
-      continue
+    if imp == nil || imp.ImportClause == nil {
+      return true
     }
-    if imp.ImportClause == nil {
+    clause := imp.ImportClause.AsImportClause()
+    if clause == nil || clause.PhaseModifier != shimast.KindTypeKeyword {
       return true
     }
   }
@@ -420,9 +433,11 @@ func buildSortedImportBlock(src string, imports []*shimast.Node, opts resolvedSo
   for i, e := range entries {
     if i > 0 {
       if e.group != prevGroup && separatorBetween(opts.groups, prevGroup, e.group) {
-        b.WriteString("\n\n")
+        // A blank line between groups is two line endings.
+        b.WriteString(opts.eol)
+        b.WriteString(opts.eol)
       } else {
-        b.WriteString("\n")
+        b.WriteString(opts.eol)
       }
     }
     b.WriteString(e.text)
@@ -594,14 +609,25 @@ func originalEntry(d siDecl) siEntry {
 // renderMergedDecl folds a bucket of mergeable declarations into one statement.
 // It returns the rendered text, whether the merged result is a type-only import,
 // and an `ok` flag that is false when the declarations cannot be merged
-// (conflicting default names, or a type-only default that cannot survive in a
-// mixed value import).
+// (conflicting default names, a type-only default that cannot survive in a
+// mixed value import, a type-only default alongside named bindings, or a
+// bucket containing a namespace or comment-bearing declaration).
 func renderMergedDecl(group []siDecl, opts resolvedSortImportsOptions) (string, bool, bool) {
   mergedTypeOnly := true
   for _, d := range group {
     if !d.typeOnly {
       mergedTypeOnly = false
     }
+    // Namespace bindings and comment-bearing declarations are never mergeable:
+    // the rebuilt statement carries no `* as ns` slot and would drop comment
+    // bytes. mergeKey normally isolates them in per-declaration buckets, but
+    // its key embeds the original text, so byte-identical declarations (a
+    // duplicate-binding error TypeScript reports later, which the parse-level
+    // formatter still sees) collide into one bucket. Refuse here so the
+    // originals are re-emitted verbatim instead of silently losing bindings.
+    if d.namespace || d.hasSpecComment {
+      return "", false, false
+    }
   }
   defaultName := ""
   defaultTypeOnly := false
@@ -624,6 +650,14 @@ func renderMergedDecl(group []siDecl, opts resolvedSortImportsOptions) (string,
   if defaultName == "" && len(specs) == 0 {
     return "", false, false
   }
+  // A type-only import cannot carry both a default binding and named bindings:
+  // `import type D, { A } from "m"` is a syntax error (TS1363). Refuse the
+  // merge so the declarations stay separate. (A type-only default with an
+  // empty merged spec list still folds to `import type D from "m"`, which is
+  // legal.)
+  if mergedTypeOnly && defaultName != "" && len(specs) > 0 {
+    return "", false, false
+  }
 
   var b strings.Builder
   b.WriteString("import ")

package/linthost/rules_format_statement_split.go

@@ -36,7 +36,7 @@ import (
 //
 // Idempotent: once each statement is alone on its line, step 2 abstains
 // for all of them and the rule emits nothing.
-type formatStatementSplit struct{}
+type formatStatementSplit struct{ optionsRule }
 
 // formatStatementSplitOptions carries the indentation + EOL settings the
 // rule needs to synthesize the inserted line break. The JSON tags match

package/linthost/rules_format_ternary_nullish_parens.go

@@ -19,7 +19,7 @@ import (
 // so it is a normalization rule rather than part of the print-width
 // reflow. Idempotent: a wrapped operand parses as a parenthesized
 // expression, not a bare `??`, so the next pass leaves it alone.
-type formatTernaryNullishParens struct{}
+type formatTernaryNullishParens struct{ optionsRule }
 
 func (formatTernaryNullishParens) Name() string   { return "format/ternary-nullish-parens" }
 func (formatTernaryNullishParens) IsFormat() bool { return true }

package/linthost/rules_format_trailing_comma.go

@@ -35,12 +35,22 @@ import (
 // element. The same restriction applies to rest binding patterns, which
 // the rule does not visit at all.
 //
+// Destructuring assignment TARGETS are the one array/object-literal shape
+// where the same rest restriction bites: `({ a, ...rest } = obj)` and
+// `[a, ...rest] = arr` parse as ObjectLiteralExpression /
+// ArrayLiteralExpression (not binding patterns) and are therefore visited,
+// yet a trailing comma after their `AssignmentRestProperty` /
+// `AssignmentRestElement` is a syntax error. `isRestAssignmentTargetLiteral`
+// suppresses the insert for exactly those; a real value literal with a
+// trailing spread (`{ a, ...o }`) and a non-rest target (`{ a, b } = obj`)
+// both legally keep the comma.
+//
 // Unparenthesized arrow parameters (`a => …`) are also skipped: there is
 // no parameter-list paren to anchor the comma against, and ECMAScript has
 // no place to insert one. `findCloseTokenAfter` bails on the first
 // non-trivia byte after the parameter's `End()` (the `=>` token), so the
 // rule abstains without emitting an edit.
-type formatTrailingComma struct{}
+type formatTrailingComma struct{ optionsRule }
 
 // formatTrailingCommaOptions mirrors `TtscLintRuleOptions.TrailingComma`.
 type formatTrailingCommaOptions struct {
@@ -94,12 +104,18 @@ func (formatTrailingComma) Check(ctx *Context, node *shimast.Node) {
     if arr == nil {
       return
     }
+    if isRestAssignmentTargetLiteral(node) {
+      return
+    }
     considerTrailingComma(ctx, arr.Elements, node.End()-1)
   case shimast.KindObjectLiteralExpression:
     obj := node.AsObjectLiteralExpression()
     if obj == nil {
       return
     }
+    if isRestAssignmentTargetLiteral(node) {
+      return
+    }
     considerTrailingComma(ctx, obj.Properties, node.End()-1)
   case shimast.KindCallExpression:
     if mode == "es5" {
@@ -351,6 +367,53 @@ func considerFunctionParameterComma(ctx *Context, list *shimast.NodeList) {
   considerTrailingComma(ctx, list, closePos)
 }
 
+// isRestAssignmentTargetLiteral reports whether node is an object- or
+// array-literal used as a destructuring ASSIGNMENT TARGET whose last
+// element is a rest (`...x`). ECMAScript forbids a trailing comma after an
+// `AssignmentRestElement` / `AssignmentRestProperty`, so neither this rule
+// nor the print-width printer (which shares this helper) may add one there.
+//
+// The two-pronged guard is what keeps it from over-suppressing. Only a
+// destructuring assignment target that ENDS in a rest is illegal:
+//
+//   - A real value literal with a trailing spread (`{ a, ...o }`,
+//     `[a, ...rest]`) is not a target, so isDestructuringAssignmentTarget
+//     returns false and the comma stays legal.
+//   - A non-rest assignment target (`{ a, b } = obj`) fails the
+//     last-element-is-rest check and keeps its comma.
+//
+// It handles nested targets (`[{ a, ...rest }] = arr`,
+// `({ x: [a, ...rest] } = obj)`) and for-of/for-in assignment initializers
+// through isDestructuringAssignmentTarget's ancestor walk.
+func isRestAssignmentTargetLiteral(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindArrayLiteralExpression:
+    arr := node.AsArrayLiteralExpression()
+    if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) == 0 {
+      return false
+    }
+    last := arr.Elements.Nodes[len(arr.Elements.Nodes)-1]
+    if last == nil || last.Kind != shimast.KindSpreadElement {
+      return false
+    }
+  case shimast.KindObjectLiteralExpression:
+    obj := node.AsObjectLiteralExpression()
+    if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) == 0 {
+      return false
+    }
+    last := obj.Properties.Nodes[len(obj.Properties.Nodes)-1]
+    if last == nil || last.Kind != shimast.KindSpreadAssignment {
+      return false
+    }
+  default:
+    return false
+  }
+  return isDestructuringAssignmentTarget(node)
+}
+
 // lastParameterIsRest reports whether the parameter list ends with a
 // rest element (`...rest`). ECMAScript syntax disallows a trailing
 // comma after a rest element; the rule must not insert one.

package/linthost/rules_format_whitespace.go

@@ -34,7 +34,7 @@ import (
 // Idempotent: a file that already has no trailing whitespace, at most
 // one consecutive blank line, no leading/trailing blank lines, and a
 // single final EOL produces no edits.
-type formatWhitespace struct{}
+type formatWhitespace struct{ optionsRule }
 
 // formatWhitespaceOptions carries only the EOL setting; the rule needs
 // it to synthesize the file's final newline. Indentation is irrelevant

package/linthost/rules_functional.go

@@ -1,32 +1,31 @@
 package linthost
 
 import (
-  "regexp"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-type functionalParameters struct{}
-type functionalImmutableData struct{}
-type functionalNoClassInheritance struct{}
-type functionalNoClasses struct{}
-type functionalNoConditionalStatements struct{}
-type functionalNoExpressionStatements struct{}
-type functionalNoLet struct{}
-type functionalNoLoopStatements struct{}
-type functionalNoMixedTypes struct{}
-type functionalNoPromiseReject struct{}
-type functionalNoReturnVoid struct{}
-type functionalNoThisExpressions struct{}
-type functionalNoThrowStatements struct{}
-type functionalNoTryStatements struct{}
-type functionalPreferImmutableTypes struct{}
-type functionalPreferPropertySignatures struct{}
-type functionalPreferReadonlyType struct{}
-type functionalPreferTacit struct{}
-type functionalReadonlyType struct{}
-type functionalTypeDeclarationImmutability struct{}
+type functionalParameters struct{ optionsRule }
+type functionalImmutableData struct{ optionsRule }
+type functionalNoClassInheritance struct{ optionsRule }
+type functionalNoClasses struct{ optionsRule }
+type functionalNoConditionalStatements struct{ optionsRule }
+type functionalNoExpressionStatements struct{ optionsRule }
+type functionalNoLet struct{ optionsRule }
+type functionalNoLoopStatements struct{ optionsRule }
+type functionalNoMixedTypes struct{ optionsRule }
+type functionalNoPromiseReject struct{ optionsRule }
+type functionalNoReturnVoid struct{ optionsRule }
+type functionalNoThisExpressions struct{ optionsRule }
+type functionalNoThrowStatements struct{ optionsRule }
+type functionalNoTryStatements struct{ optionsRule }
+type functionalPreferImmutableTypes struct{ optionsRule }
+type functionalPreferPropertySignatures struct{ optionsRule }
+type functionalPreferReadonlyType struct{ optionsRule }
+type functionalPreferTacit struct{ optionsRule }
+type functionalReadonlyType struct{ optionsRule }
+type functionalTypeDeclarationImmutability struct{ optionsRule }
 
 func (functionalParameters) Name() string              { return "functional/functional-parameters" }
 func (functionalImmutableData) Name() string           { return "functional/immutable-data" }
@@ -921,7 +920,7 @@ func functionalPatternMatches(pattern, name string) bool {
   if pattern == name {
     return true
   }
-  re, err := regexp.Compile(pattern)
+  re, err := compileUserPattern(pattern)
   return err == nil && re.MatchString(name)
 }