@ttsc/lint 0.18.4 → 0.19.1

package/linthost/engine.go

@@ -19,6 +19,7 @@ package linthost
 
 import (
   "encoding/json"
+  "errors"
   "fmt"
   "os"
   "runtime"
@@ -27,7 +28,9 @@ import (
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimdw "github.com/microsoft/typescript-go/shim/diagnosticwriter"
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 // Rule is the contract every lint rule satisfies.
@@ -70,6 +73,29 @@ type typeAwareRule interface {
   NeedsTypeChecker() bool
 }
 
+// ruleOptionsValidator is an optional rule capability for rejecting malformed
+// configuration before the rule enters the dispatch table. The exported method
+// lets rule implementations opt in without coupling the engine to specific rule
+// names; a nil payload represents the rule's default options.
+type ruleOptionsValidator interface {
+  ValidateOptions(json.RawMessage) error
+}
+
+// ruleOptionsAcceptor is the structural declaration that a rule owns an
+// options schema. The engine uses the capability instead of a rule-name list,
+// so adding an options payload to a rule requires the implementation itself to
+// opt in. A false result is equivalent to omitting the interface.
+type ruleOptionsAcceptor interface {
+  AcceptsTtscLintOptions() bool
+}
+
+// optionsRule is embedded by built-in rules whose public configuration accepts
+// an options slot. Keeping the marker next to each implementation makes the
+// registry the runtime source of truth without a parallel name table.
+type optionsRule struct{}
+
+func (optionsRule) AcceptsTtscLintOptions() bool { return true }
+
 // isFormatRule reports whether `r` opts into the format category.
 func isFormatRule(r Rule) bool {
   fr, ok := r.(FormatRule)
@@ -81,22 +107,83 @@ func ruleNeedsTypeChecker(r Rule) bool {
   return ok && tr.NeedsTypeChecker()
 }
 
+func ruleAcceptsOptions(r Rule) bool {
+  acceptor, ok := r.(ruleOptionsAcceptor)
+  return ok && acceptor.AcceptsTtscLintOptions()
+}
+
+func validateRuleOptions(r Rule, options json.RawMessage) error {
+  if len(options) > 0 && !ruleAcceptsOptions(r) {
+    return errors.New("rule does not accept options")
+  }
+  validator, ok := r.(ruleOptionsValidator)
+  if !ok {
+    return nil
+  }
+  return validator.ValidateOptions(options)
+}
+
 // Context is the per-(file, rule) handle the engine passes to `Check`.
 //
-// `Options` is the raw JSON blob the user wrote in their rule
-// configuration's second tuple slot (`["warning", { ... }]`). It is nil
-// when the rule was configured with a bare severity literal. Rules that
-// accept options decode the blob into their own struct via
-// `(*Context).DecodeOptions` and fall back to defaults on nil.
+// `Options` is the raw JSON payload resolved for this source file from the
+// same config entries as Severity. One option slot preserves its scalar or
+// object shape; multiple positional options are an array. It is nil for a
+// bare severity. Rules decode the payload according to their public option
+// type and fall back to defaults on nil.
 type Context struct {
-  File     *shimast.SourceFile
-  Checker  *shimchecker.Checker
-  Severity Severity
-  Options  json.RawMessage
-
-  rule     Rule
-  isFormat bool
-  collect  func(*Finding)
+  File             *shimast.SourceFile
+  Checker          *shimchecker.Checker
+  CurrentDirectory string
+  Severity         Severity
+  Options          json.RawMessage
+
+  rule           Rule
+  isFormat       bool
+  quarantined    bool
+  collect        func(*Finding)
+  projectResults publicrule.ProjectResultReader
+  fileMemo       *fileMemo
+}
+
+// fileMemo caches file-invariant values that rules would otherwise
+// recompute once per visited node. The engine binds one instance per
+// source file and shares it across every Context it builds for that
+// file's rules, so a whole-file table — the security binding table, the
+// set of top-level declared JSX names — is computed once per file
+// instead of once per matching node, collapsing an O(nodes × matches)
+// rule to O(nodes). Each file's walk is serial and gets its own
+// instance, so the map needs no locking.
+//
+// Keys are sentinel zero-size struct values whose distinct types make
+// collisions impossible without a central registry; the engine never
+// inspects them, keeping the hook general.
+type fileMemo struct {
+  values map[any]any
+}
+
+// fileValue returns the cached value stored under key, reporting whether
+// one was present. A nil memo (a Context built outside the engine, e.g.
+// in a focused unit test) always misses, so callers transparently fall
+// back to recomputing.
+func (c *Context) fileValue(key any) (any, bool) {
+  if c == nil || c.fileMemo == nil || c.fileMemo.values == nil {
+    return nil, false
+  }
+  value, ok := c.fileMemo.values[key]
+  return value, ok
+}
+
+// setFileValue records value under key for the rest of this file's walk.
+// A nil memo drops the write, leaving the caller to recompute on the next
+// request — behavior-preserving, just uncached.
+func (c *Context) setFileValue(key, value any) {
+  if c == nil || c.fileMemo == nil {
+    return
+  }
+  if c.fileMemo.values == nil {
+    c.fileMemo.values = map[any]any{}
+  }
+  c.fileMemo.values[key] = value
 }
 
 // DecodeOptions unmarshals the rule's options blob into `out`. Returns
@@ -120,17 +207,20 @@ func (c *Context) DecodeOptions(out interface{}) error {
 // both categories — no filter — because `ttsc fix` is the
 // run-everything entry point.
 type Finding struct {
-  Rule     string
-  Severity Severity
-  File     *shimast.SourceFile
-  Pos      int
-  End      int
-  Message  string
-  Fix      []TextEdit
-  IsFormat bool
+  Rule        string
+  Severity    Severity
+  File        *shimast.SourceFile
+  Pos         int
+  End         int
+  Message     string
+  Fix         []TextEdit
+  Suggestions []Suggestion
+  IsFormat    bool
+
+  engineFailure bool
 }
 
-// TextEdit is one byte-range replacement offered by an autofixable finding.
+// TextEdit is one byte-range source replacement used by a fix or suggestion.
 // Positions use the same byte offsets as shim AST nodes and must point inside
 // the finding's source file.
 type TextEdit struct {
@@ -139,6 +229,14 @@ type TextEdit struct {
   Text string
 }
 
+// Suggestion is an opt-in editor action attached to a finding. Unlike Fix,
+// suggestion edits are never consumed by `ttsc fix` or source.fixAll.ttsc;
+// the LSP host exposes them as individual quick fixes selected by the user.
+type Suggestion struct {
+  Title string
+  Edits []TextEdit
+}
+
 // Report records a finding at the given node's source range. The pos is
 // trimmed past leading trivia (whitespace + comments) so the renderer's
 // `path:line:col` banner points at the offending token, not the start of
@@ -154,22 +252,80 @@ func (c *Context) ReportFix(node *shimast.Node, message string, edits ...TextEdi
   if c.Severity == SeverityOff || node == nil {
     return
   }
-  pos := node.Pos()
-  if c.File != nil {
-    pos = shimscanner.SkipTrivia(c.File.Text(), pos)
-  }
+  pos, end := c.nodeFindingRange(node)
   c.collect(&Finding{
     Rule:     c.rule.Name(),
     Severity: c.Severity,
     File:     c.File,
     Pos:      pos,
-    End:      node.End(),
+    End:      end,
     Message:  message,
     Fix:      cloneTextEdits(edits),
     IsFormat: c.isFormat,
   })
 }
 
+// ReportSuggestion records a node-scoped finding with one opt-in editor
+// action. The diagnostic is still reported when edits is empty, but no quick
+// fix is advertised.
+func (c *Context) ReportSuggestion(node *shimast.Node, message string, title string, edits ...TextEdit) {
+  if c.Severity == SeverityOff || node == nil {
+    return
+  }
+  pos, end := c.nodeFindingRange(node)
+  c.collect(&Finding{
+    Rule:        c.rule.Name(),
+    Severity:    c.Severity,
+    File:        c.File,
+    Pos:         pos,
+    End:         end,
+    Message:     message,
+    Suggestions: newSuggestions(title, edits),
+    IsFormat:    c.isFormat,
+  })
+}
+
+// ReportFixSuggestions records one node-scoped diagnostic with an optional
+// automatic fix and any number of opt-in editor suggestions. Each slice is
+// cloned before collection so a rule cannot mutate a previously reported
+// finding through retained backing storage.
+func (c *Context) ReportFixSuggestions(
+  node *shimast.Node,
+  message string,
+  fix []TextEdit,
+  suggestions ...Suggestion,
+) {
+  if c.Severity == SeverityOff || node == nil {
+    return
+  }
+  pos, end := c.nodeFindingRange(node)
+  c.collect(&Finding{
+    Rule:        c.rule.Name(),
+    Severity:    c.Severity,
+    File:        c.File,
+    Pos:         pos,
+    End:         end,
+    Message:     message,
+    Fix:         cloneTextEdits(fix),
+    Suggestions: cloneSuggestions(suggestions),
+    IsFormat:    c.isFormat,
+  })
+}
+
+// nodeFindingRange bounds an arbitrary rule-supplied node before reading the
+// current file's source text. Contributors can accidentally report a node from
+// another file, whose otherwise valid Pos may exceed this Context's source.
+func (c *Context) nodeFindingRange(node *shimast.Node) (int, int) {
+  if node == nil {
+    return shimdw.NormalizeLintRange(c.File, 0, 0)
+  }
+  pos, end := shimdw.NormalizeLintRange(c.File, node.Pos(), node.End())
+  if c.File != nil {
+    pos = shimscanner.SkipTrivia(c.File.Text(), pos)
+  }
+  return shimdw.NormalizeLintRange(c.File, pos, end)
+}
+
 // ReportRange records a finding at an explicit byte range inside the
 // current file. Use this when the rule wants to highlight a sub-token of
 // a node (e.g. an operator inside a BinaryExpression).
@@ -182,9 +338,7 @@ func (c *Context) ReportRangeFix(pos, end int, message string, edits ...TextEdit
   if c.Severity == SeverityOff || c.File == nil {
     return
   }
-  if end <= pos {
-    end = pos + 1
-  }
+  pos, end = shimdw.NormalizeLintRange(c.File, pos, end)
   c.collect(&Finding{
     Rule:     c.rule.Name(),
     Severity: c.Severity,
@@ -197,6 +351,26 @@ func (c *Context) ReportRangeFix(pos, end int, message string, edits ...TextEdit
   })
 }
 
+// ReportRangeSuggestion records an explicit-range finding with one opt-in
+// editor action. Suggestion edits stay separate from automatic fixes and are
+// ignored by `ttsc fix` and source.fixAll.ttsc.
+func (c *Context) ReportRangeSuggestion(pos, end int, message string, title string, edits ...TextEdit) {
+  if c.Severity == SeverityOff || c.File == nil {
+    return
+  }
+  pos, end = shimdw.NormalizeLintRange(c.File, pos, end)
+  c.collect(&Finding{
+    Rule:        c.rule.Name(),
+    Severity:    c.Severity,
+    File:        c.File,
+    Pos:         pos,
+    End:         end,
+    Message:     message,
+    Suggestions: newSuggestions(title, edits),
+    IsFormat:    c.isFormat,
+  })
+}
+
 // cloneTextEdits returns a shallow copy of `edits` so that the caller's
 // variadic slice cannot be mutated through the stored Finding. Returns nil
 // when the input is empty, keeping the Finding.Fix field nil rather than
@@ -210,6 +384,32 @@ func cloneTextEdits(edits []TextEdit) []TextEdit {
   return out
 }
 
+func newSuggestions(title string, edits []TextEdit) []Suggestion {
+  cloned := cloneTextEdits(edits)
+  if title == "" || len(cloned) == 0 {
+    return nil
+  }
+  return []Suggestion{{Title: title, Edits: cloned}}
+}
+
+func cloneSuggestions(suggestions []Suggestion) []Suggestion {
+  if len(suggestions) == 0 {
+    return nil
+  }
+  cloned := make([]Suggestion, 0, len(suggestions))
+  for _, suggestion := range suggestions {
+    edits := cloneTextEdits(suggestion.Edits)
+    if suggestion.Title == "" || len(edits) == 0 {
+      continue
+    }
+    cloned = append(cloned, Suggestion{Title: suggestion.Title, Edits: edits})
+  }
+  if len(cloned) == 0 {
+    return nil
+  }
+  return cloned
+}
+
 // registry stores the package-global rule list keyed by name. Tests can
 // also reach into it via `LookupRule`.
 type registry struct {
@@ -227,7 +427,11 @@ func Register(rule Rule) {
   if _, exists := registered.rules[rule.Name()]; exists {
     panic("@ttsc/lint: rule " + rule.Name() + " registered twice")
   }
-  registered.rules[rule.Name()] = rule
+  name := rule.Name()
+  registered.rules[name] = rule
+  if _, builtIn := builtInRuleCodes[name]; !builtIn {
+    invalidateRuntimeRuleCodes()
+  }
 }
 
 // LookupRule returns the registered rule by name, or nil if missing.
@@ -262,14 +466,17 @@ type Engine struct {
   unknownDirectiveMu sync.Mutex
   needsTypeChecker   bool
   serial             bool
+  projectSettings    map[string]ProjectRuleSetting
+  configError        error
+  currentDirectory   string
 }
 
 // SetSerial forces Engine.Run to walk files one at a time. The host calls
 // this when `--singleThreaded` reaches the lint sidecar so the benchmark
 // (and any caller that wants a deterministic, low-overhead pass) can opt
 // out of file-level parallelism. Type-aware rule sets always run serial
-// regardless of this flag — the single shared checker is not concurrent —
-// so callers do not need to clear it themselves.
+// regardless of this flag because their standalone checker is not concurrent,
+// so callers do not need to force serial execution themselves.
 func (e *Engine) SetSerial(serial bool) {
   if e == nil {
     return
@@ -277,9 +484,17 @@ func (e *Engine) SetSerial(serial bool) {
   e.serial = serial
 }
 
-// runsSerial reports whether Run must walk files one at a time — either
-// because the caller asked for it or because a type-aware rule pins the
-// engine to the shared single checker.
+// SetCurrentDirectory supplies the compiler Program's current directory for
+// rule options whose relative paths are project-rooted.
+func (e *Engine) SetCurrentDirectory(currentDirectory string) {
+  if e != nil {
+    e.currentDirectory = currentDirectory
+  }
+}
+
+// runsSerial reports whether Run must walk files one at a time: either because
+// the caller asked for it or because a type-aware rule uses the standalone
+// checker shared by every linted file.
 func (e *Engine) runsSerial() bool {
   return e == nil || e.serial || e.needsTypeChecker
 }
@@ -304,13 +519,52 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
     enabled:           make(map[string]Severity),
     unknownDirectives: make(map[string]struct{}),
   }
+  projectRuleNames := allProjectRuleNames()
+  eng.projectSettings, eng.configError = config.ResolveProjectRules(projectRuleNames)
+  for _, name := range projectRuleNames {
+    setting := eng.projectSettings[name]
+    if setting.Declared && len(setting.Options) > 0 && !registeredProjectRules[name].acceptsOptions {
+      eng.configError = errors.Join(
+        eng.configError,
+        fmt.Errorf("@ttsc/lint: invalid options for rule %q: rule does not accept options", name),
+      )
+    }
+    if setting.Declared && setting.Severity != SeverityOff {
+      eng.needsTypeChecker = true
+    }
+  }
   displaySeverities := config.EnabledRuleConfig()
+  invalidRuleOptions := make(map[string]struct{})
+  for _, name := range AllRuleNames() {
+    rule := registered.rules[name]
+    seenOptions := make(map[string]struct{})
+    for _, options := range resolvedRuleOptionsVariants(config, name) {
+      key := string(options)
+      if _, duplicate := seenOptions[key]; duplicate {
+        continue
+      }
+      seenOptions[key] = struct{}{}
+      if err := validateRuleOptions(rule, options); err != nil {
+        eng.configError = errors.Join(
+          eng.configError,
+          fmt.Errorf("@ttsc/lint: invalid options for rule %q: %w", name, err),
+        )
+        invalidRuleOptions[name] = struct{}{}
+      }
+    }
+  }
   for _, name := range config.ActiveRuleNames() {
+    if _, isProjectRule := registeredProjectRules[name]; isProjectRule {
+      continue
+    }
     rule, ok := registered.rules[name]
     if !ok {
       eng.unknown = append(eng.unknown, name)
       continue
     }
+    if _, invalid := invalidRuleOptions[name]; invalid {
+      continue
+    }
     if ruleNeedsTypeChecker(rule) {
       eng.needsTypeChecker = true
     }
@@ -414,6 +668,15 @@ func (e *Engine) NeedsTypeChecker() bool {
   return e != nil && e.needsTypeChecker
 }
 
+// ConfigError reports an invalid project-rule declaration or rule option
+// payload discovered while binding the resolver.
+func (e *Engine) ConfigError() error {
+  if e == nil {
+    return nil
+  }
+  return e.configError
+}
+
 // EnabledRules returns the active rule set keyed by name. Mostly for
 // tests + introspection.
 func (e *Engine) EnabledRules() map[string]Severity { return e.enabled }
@@ -425,13 +688,28 @@ func (e *Engine) EnabledRules() map[string]Severity { return e.enabled }
 // merged in source-file order so the diagnostic stream is deterministic across
 // runs even when the per-file work happens out of order.
 func (e *Engine) Run(files []*shimast.SourceFile, checker *shimchecker.Checker) []*Finding {
+  cycle := e.evaluateProject(publicrule.ProjectIdentity{}, files, checker)
+  currentDirectory := e.currentDirectory
+  if currentDirectory == "" {
+    currentDirectory, _ = os.Getwd()
+  }
+  fileFindings := e.runFiles(files, checker, cycle.results, currentDirectory)
+  return append(cycle.finalize(), fileFindings...)
+}
+
+func (e *Engine) runFiles(
+  files []*shimast.SourceFile,
+  checker *shimchecker.Checker,
+  results publicrule.ProjectResultReader,
+  currentDirectory string,
+) []*Finding {
   if e.runsSerial() {
     var findings []*Finding
     for _, file := range files {
       if file == nil {
         continue
       }
-      findings = append(findings, e.runFile(file, checker)...)
+      findings = append(findings, e.runFile(file, checker, results, currentDirectory)...)
     }
     return findings
   }
@@ -452,7 +730,7 @@ func (e *Engine) Run(files []*shimast.SourceFile, checker *shimchecker.Checker)
     go func(idx int, f *shimast.SourceFile) {
       defer wg.Done()
       defer func() { <-sem }()
-      perFile[idx] = e.runFile(f, checker)
+      perFile[idx] = e.runFile(f, checker, results, currentDirectory)
     }(i, file)
   }
   wg.Wait()
@@ -478,6 +756,19 @@ type boundRule struct {
   ctx  *Context
 }
 
+// check invokes one bound rule unless an earlier invocation panicked in this
+// file. Context is shared by every kind bucket for the same file/rule pair, so
+// the quarantine covers later nodes and later registered kinds without leaking
+// into the next source file.
+func (b boundRule) check(node *shimast.Node, collect func(*Finding)) {
+  if b.ctx == nil || b.ctx.quarantined {
+    return
+  }
+  if runRuleCheck(b.rule, b.ctx, node, collect) {
+    b.ctx.quarantined = true
+  }
+}
+
 // lintFileWalker drives the per-file AST traversal. The struct exists so
 // the `ForEachChild` callback can be a method value cached in
 // `childCB`. A naive nested-closure walker re-allocates one callback
@@ -498,7 +789,7 @@ func (w *lintFileWalker) walk(node *shimast.Node) {
   }
   if k := int(node.Kind); k >= 0 && k < len(w.byKind) {
     for _, bound := range w.byKind[k] {
-      runRuleCheck(bound.rule, bound.ctx, node, w.collect)
+      bound.check(node, w.collect)
     }
   }
   node.ForEachChild(w.childCB)
@@ -515,7 +806,12 @@ func (w *lintFileWalker) visitChild(child *shimast.Node) bool {
 // runFile is the per-file driver. The visitor is allocated once per file
 // to keep the per-node hot path branch-free; it visits children
 // post-order so parents see their already-checked subtrees.
-func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker) []*Finding {
+func (e *Engine) runFile(
+  file *shimast.SourceFile,
+  checker *shimchecker.Checker,
+  results publicrule.ProjectResultReader,
+  currentDirectory string,
+) []*Finding {
   var collected []*Finding
   collect := func(f *Finding) { collected = append(collected, f) }
   resolved := e.config.ResolveRules(file.FileName())
@@ -542,6 +838,10 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
   bound := 0
   byKind := make([][]boundRule, len(e.rules))
   ctxByRule := make(map[string]*Context, len(e.enabled))
+  // One memo per file, shared by every rule's Context below, so
+  // file-invariant tables (security bindings, declared JSX names) are
+  // built once per file instead of once per visited node.
+  memo := &fileMemo{}
   for kind, rules := range e.rules {
     if len(rules) == 0 {
       continue
@@ -554,14 +854,24 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
       ctx, built := ctxByRule[name]
       if !built {
         if severity := fileRules.Severity(name); severity != SeverityOff {
+          options := resolved.RuleOptions(name)
+          if len(options) == 0 && !resolved.OptionsResolved {
+            // Compatibility for custom RuleResolver implementations compiled
+            // against the original contract: until they opt into per-file
+            // options, their file-agnostic RuleOptions method remains active.
+            options = e.config.RuleOptions(name)
+          }
           ctx = &Context{
-            File:     file,
-            Checker:  checker,
-            Severity: severity,
-            Options:  e.config.RuleOptions(name),
-            rule:     rule,
-            isFormat: isFormatRule(rule),
-            collect:  collect,
+            File:             file,
+            Checker:          checker,
+            CurrentDirectory: currentDirectory,
+            Severity:         severity,
+            Options:          options,
+            rule:             rule,
+            isFormat:         isFormatRule(rule),
+            collect:          collect,
+            projectResults:   results,
+            fileMemo:         memo,
           }
         }
         // A nil entry memoizes "off for this file" so a rule registered
@@ -593,11 +903,11 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
 
     // SourceFile dispatches into its statement list directly; we walk
     // statements explicitly so the file node itself can be inspected by
-    // rules (e.g., `ban-ts-comment` reads CommentDirectives off the
-    // SourceFile).
+    // rules (e.g., `ban-ts-comment` scans the file's comment tokens once
+    // per SourceFile).
     if k := int(shimast.KindSourceFile); k >= 0 && k < len(byKind) {
       for _, bound := range byKind[k] {
-        runRuleCheck(bound.rule, bound.ctx, file.AsNode(), collect)
+        bound.check(file.AsNode(), collect)
       }
     }
 
@@ -634,13 +944,15 @@ func hasEnabledFileRules(rules RuleConfig) bool {
 // anyone; protecting the engine is the only way to bound the blast
 // radius of one bad rule. The recovered panic is surfaced as a
 // SeverityError finding tagged with the rule's name so the user sees
-// the failure in the normal diagnostic stream.
-func runRuleCheck(rule Rule, ctx *Context, node *shimast.Node, collect func(*Finding)) {
+// the failure in the normal diagnostic stream. The boolean result tells the
+// per-file binding to quarantine the rule after recovery.
+func runRuleCheck(rule Rule, ctx *Context, node *shimast.Node, collect func(*Finding)) (panicked bool) {
   defer func() {
     r := recover()
     if r == nil {
       return
     }
+    panicked = true
     if ctx == nil || ctx.File == nil {
       // Without source context there is nowhere to anchor the
       // diagnostic. Surface to stderr so the panic is at least
@@ -657,6 +969,7 @@ func runRuleCheck(rule Rule, ctx *Context, node *shimast.Node, collect func(*Fin
     if end <= pos {
       end = pos + 1
     }
+    pos, end = shimdw.NormalizeLintRange(ctx.File, pos, end)
     collect(&Finding{
       Rule:     rule.Name(),
       Severity: SeverityError,
@@ -666,8 +979,10 @@ func runRuleCheck(rule Rule, ctx *Context, node *shimast.Node, collect func(*Fin
         "Rule %q panicked while checking this node: %v. Report this to the rule's author; ttsc skipped the rule on this file.",
         rule.Name(), r,
       ),
-      File: ctx.File,
+      File:          ctx.File,
+      engineFailure: true,
     })
   }()
   rule.Check(ctx, node)
+  return false
 }