@ttsc/lint 0.18.3 → 0.19.0

package/linthost/print_nodes_array.go

@@ -53,12 +53,18 @@ func printArrayLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   // suppresses. Hardcoding `true` would oscillate against Prettier on
   // every `none` project (the trailing-comma rule wouldn't insert one
   // and the printer would put one back).
+  //
+  // A destructuring assignment target ending in a rest
+  // (`[a, ...rest] = arr`) is the one exception: a trailing comma after
+  // its `AssignmentRestElement` is a syntax error, so the reflow must not
+  // emit one even under "all"/"es5". Matches the same suppression in
+  // `format/trailing-comma`; see isRestAssignmentTargetLiteral.
   return printList(ctx, listShape{
     OpenTok:     "[",
     CloseTok:    "]",
     Items:       items,
     Space:       false,
-    AddComma:    ctx.allowsEs5TrailingComma(),
+    AddComma:    ctx.allowsEs5TrailingComma() && !isRestAssignmentTargetLiteral(node),
     Fill:        isConciselyPrintedArray(arr.Elements.Nodes),
     ForceBreak:  arrayShouldForceBreak(arr.Elements.Nodes),
     BlankBefore: blankBeforeItems(ctx.Source, arr.Elements.Nodes),

package/linthost/print_nodes_object.go

@@ -66,12 +66,18 @@ func printObjectLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   // trailing commas in ES5 so both "all" and "es5" keep them; only
   // "none" suppresses. Pairs with the call/array branches so the printer
   // never disagrees with the trailing-comma rule on the same setting.
+  //
+  // A destructuring assignment target ending in a rest
+  // (`({ a, ...rest } = obj)`) is the one exception: a trailing comma
+  // after its `AssignmentRestProperty` is a syntax error, so the reflow
+  // must not emit one even under "all"/"es5". Matches the same suppression
+  // in `format/trailing-comma`; see isRestAssignmentTargetLiteral.
   return printList(ctx, listShape{
     OpenTok:     "{",
     CloseTok:    "}",
     Items:       items,
     Space:       true,
-    AddComma:    ctx.allowsEs5TrailingComma(),
+    AddComma:    ctx.allowsEs5TrailingComma() && !isRestAssignmentTargetLiteral(node),
     ForceBreak:  forceBreak,
     BlankBefore: blankBeforeItems(ctx.Source, obj.Properties.Nodes),
   }), covered

package/linthost/project_engine.go

@@ -0,0 +1,151 @@
+package linthost
+
+import (
+  "fmt"
+  "sort"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
+)
+
+type projectCycleResults struct {
+  byName map[string]publicrule.ProjectRuleResult
+}
+
+func (r *projectCycleResults) ProjectResult(name string) publicrule.ProjectRuleResult {
+  if r == nil {
+    return publicrule.ProjectRuleResult{Status: publicrule.ProjectRuleAbsent}
+  }
+  result, ok := r.byName[name]
+  if !ok {
+    return publicrule.ProjectRuleResult{Status: publicrule.ProjectRuleAbsent}
+  }
+  result.Findings = append([]publicrule.ProjectFinding(nil), result.Findings...)
+  return result
+}
+
+type projectCycle struct {
+  findings []*Finding
+  results  *projectCycleResults
+}
+
+type projectReporter struct {
+  failed   bool
+  messages map[string]struct{}
+}
+
+func (r *projectReporter) Fail() {
+  if r != nil {
+    r.failed = true
+  }
+}
+
+func (r *projectReporter) Report(message string) {
+  if r == nil {
+    return
+  }
+  r.failed = true
+  if r.messages == nil {
+    r.messages = map[string]struct{}{}
+  }
+  r.messages[message] = struct{}{}
+}
+
+func (e *Engine) evaluateProject(
+  identity publicrule.ProjectIdentity,
+  files []*shimast.SourceFile,
+  checker *shimchecker.Checker,
+) projectCycle {
+  results := &projectCycleResults{byName: map[string]publicrule.ProjectRuleResult{}}
+  cycle := projectCycle{results: results}
+  names := allProjectRuleNames()
+  if len(names) == 0 {
+    return cycle
+  }
+  var sources []*shimast.SourceFile
+  sourcesResolved := false
+  for _, name := range names {
+    setting := e.projectSettings[name]
+    if !setting.Declared {
+      results.byName[name] = publicrule.ProjectRuleResult{Status: publicrule.ProjectRuleNotEvaluated}
+      continue
+    }
+    if setting.Severity == SeverityOff {
+      results.byName[name] = publicrule.ProjectRuleResult{Status: publicrule.ProjectRuleOff}
+      continue
+    }
+    adapter, exists := registeredProjectRules[name]
+    if !exists {
+      continue
+    }
+    if !sourcesResolved {
+      sources = e.projectSources(files)
+      sourcesResolved = true
+    }
+    reporter := &projectReporter{}
+    context := publicrule.NewProjectContext(
+      identity,
+      sources,
+      checker,
+      publicrule.Severity(setting.Severity),
+      setting.Options,
+      reporter,
+    )
+    runProjectRuleCheck(adapter, context, reporter)
+    messages := make([]string, 0, len(reporter.messages))
+    for message := range reporter.messages {
+      messages = append(messages, message)
+    }
+    sort.Strings(messages)
+    status := publicrule.ProjectRulePassed
+    if reporter.failed {
+      status = publicrule.ProjectRuleFailed
+    }
+    result := publicrule.ProjectRuleResult{Status: status}
+    for _, message := range messages {
+      result.Findings = append(result.Findings, publicrule.ProjectFinding{Message: message})
+      cycle.findings = append(cycle.findings, &Finding{
+        Rule:     name,
+        Severity: setting.Severity,
+        Message:  message,
+      })
+    }
+    results.byName[name] = result
+  }
+  return cycle
+}
+
+// projectSources applies only project-wide ignores to the source set exposed
+// to project rules. File-scoped ignores merely refine their containing entry,
+// while ResolveRules marks a source Ignored only for a global ignore entry.
+func (e *Engine) projectSources(files []*shimast.SourceFile) []*shimast.SourceFile {
+  sources := make([]*shimast.SourceFile, 0, len(files))
+  for _, file := range files {
+    if file == nil {
+      continue
+    }
+    if e != nil && e.config != nil && e.config.ResolveRules(file.FileName()).Ignored {
+      continue
+    }
+    sources = append(sources, file)
+  }
+  return sources
+}
+
+func runProjectRuleCheck(
+  adapter projectRuleAdapter,
+  context *publicrule.ProjectContext,
+  reporter *projectReporter,
+) {
+  defer func() {
+    if recovered := recover(); recovered != nil {
+      reporter.Report(fmt.Sprintf(
+        "Project rule %q panicked while checking this Program: %v. Report this to the rule's author.",
+        adapter.name,
+        recovered,
+      ))
+    }
+  }()
+  adapter.inner.Check(context)
+}

package/linthost/project_rules.go

@@ -0,0 +1,78 @@
+package linthost
+
+import (
+  "fmt"
+  "os"
+  "sort"
+
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
+)
+
+// projectRuleAdapter caches contributor metadata and keeps project checks on a
+// separate lifecycle from node rules.
+type projectRuleAdapter struct {
+  inner          publicrule.ProjectRule
+  name           string
+  acceptsOptions bool
+}
+
+var registeredProjectRules = map[string]projectRuleAdapter{}
+
+func registerProjectContributors() {
+  projects := publicrule.RegisteredProjects()
+  adapters := make([]projectRuleAdapter, 0, len(projects))
+  for _, project := range projects {
+    adapter, err := inspectProjectContributor(project)
+    if err != nil {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: %v; dropping project contributor entry\n", err)
+      continue
+    }
+    adapters = append(adapters, adapter)
+  }
+  sort.SliceStable(adapters, func(i, j int) bool { return adapters[i].name < adapters[j].name })
+  for _, adapter := range adapters {
+    if adapter.name == "" {
+      fmt.Fprintln(os.Stderr, "@ttsc/lint: contributor project rule with empty name ignored")
+      continue
+    }
+    if LookupRule(adapter.name) != nil {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: contributor project rule %q collides with a file rule; dropping project contributor entry\n", adapter.name)
+      continue
+    }
+    if _, exists := registeredProjectRules[adapter.name]; exists {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: contributor project rule %q collides with an existing project rule; dropping contributor entry\n", adapter.name)
+      continue
+    }
+    registeredProjectRules[adapter.name] = adapter
+    invalidateRuntimeRuleCodes()
+  }
+}
+
+func inspectProjectContributor(project publicrule.ProjectRule) (adapter projectRuleAdapter, err error) {
+  defer func() {
+    if recovered := recover(); recovered != nil {
+      err = fmt.Errorf("contributor project rule %T metadata panicked: %v", project, recovered)
+    }
+  }()
+  if project == nil {
+    return projectRuleAdapter{}, fmt.Errorf("nil contributor project rule")
+  }
+  adapter = projectRuleAdapter{
+    inner:          project,
+    name:           project.Name(),
+    acceptsOptions: true,
+  }
+  if optionsRule, ok := project.(publicrule.OptionsRule); ok {
+    adapter.acceptsOptions = optionsRule.AcceptsTtscLintOptions()
+  }
+  return adapter, nil
+}
+
+func allProjectRuleNames() []string {
+  names := make([]string, 0, len(registeredProjectRules))
+  for name := range registeredProjectRules {
+    names = append(names, name)
+  }
+  sort.Strings(names)
+  return names
+}

package/linthost/regex_clean.go

@@ -0,0 +1,191 @@
+// regex_clean.go ports the `clean-regexp` npm package (v1.0.0), the exact
+// dependency the upstream unicorn/better-regex rule uses for its
+// `new RegExp("pattern", "flags")` string-constructor branch. Unlike the
+// literal branch (which runs the full regexp-tree optimizer in
+// regex_tree_optimizer.go), upstream's constructor branch applies a fixed,
+// ordered table of character-class shorthands via a global substring
+// replace, gated by whether the regex carries the flags a replacement needs.
+// Reproducing that table verbatim is what keeps the constructor branch's
+// diagnostics and fixes identical to upstream; the full optimizer would
+// rewrite strictly more and diverge.
+//
+// clean-regexp source: https://github.com/sindresorhus/clean-regexp
+package linthost
+
+import "strings"
+
+type regexCleanMapping struct {
+  key   string
+  value string
+  flags string
+}
+
+// regexCleanMappings mirrors clean-regexp's `lib/mappings` Map in declaration
+// order. Entries without flags always apply; entries with `flags: "i"` apply
+// only when the regex is case-insensitive.
+var regexCleanMappings = []regexCleanMapping{
+  {key: "[0-9]", value: `\d`},
+  {key: "[^0-9]", value: `\D`},
+
+  // Word
+  {key: "[a-zA-Z0-9_]", value: `\w`},
+  {key: "[a-zA-Z_0-9]", value: `\w`},
+  {key: "[a-z0-9A-Z_]", value: `\w`},
+  {key: "[a-z0-9_A-Z]", value: `\w`},
+  {key: "[a-z_A-Z0-9]", value: `\w`},
+  {key: "[a-z_0-9A-Z]", value: `\w`},
+  {key: "[A-Za-z0-9_]", value: `\w`},
+  {key: "[A-Za-z_0-9]", value: `\w`},
+  {key: "[A-Z0-9a-z_]", value: `\w`},
+  {key: "[A-Z0-9_a-z]", value: `\w`},
+  {key: "[A-Z_a-z0-9]", value: `\w`},
+  {key: "[A-Z_0-9a-z]", value: `\w`},
+  {key: "[0-9a-zA-Z_]", value: `\w`},
+  {key: "[0-9a-z_A-Z]", value: `\w`},
+  {key: "[0-9A-Za-z_]", value: `\w`},
+  {key: "[0-9A-Z_a-z]", value: `\w`},
+  {key: "[0-9_a-zA-Z]", value: `\w`},
+  {key: "[0-9_A-Za-z]", value: `\w`},
+  {key: "[_a-zA-Z0-9]", value: `\w`},
+  {key: "[_a-z0-9A-Z]", value: `\w`},
+  {key: "[_A-Za-z0-9]", value: `\w`},
+  {key: "[_A-Z0-9a-z]", value: `\w`},
+  {key: "[_0-9a-zA-Z]", value: `\w`},
+  {key: "[_0-9A-Za-z]", value: `\w`},
+
+  // Word with digit
+  {key: `[a-zA-Z\d_]`, value: `\w`},
+  {key: `[a-zA-Z_\d]`, value: `\w`},
+  {key: `[a-z\dA-Z_]`, value: `\w`},
+  {key: `[a-z\d_A-Z]`, value: `\w`},
+  {key: `[a-z_A-Z\d]`, value: `\w`},
+  {key: `[a-z_\dA-Z]`, value: `\w`},
+  {key: `[A-Za-z\d_]`, value: `\w`},
+  {key: `[A-Za-z_\d]`, value: `\w`},
+  {key: `[A-Z\da-z_]`, value: `\w`},
+  {key: `[A-Z\d_a-z]`, value: `\w`},
+  {key: `[A-Z_a-z\d]`, value: `\w`},
+  {key: `[A-Z_\da-z]`, value: `\w`},
+  {key: `[\da-zA-Z_]`, value: `\w`},
+  {key: `[\da-z_A-Z]`, value: `\w`},
+  {key: `[\dA-Za-z_]`, value: `\w`},
+  {key: `[\dA-Z_a-z]`, value: `\w`},
+  {key: `[\d_a-zA-Z]`, value: `\w`},
+  {key: `[\d_A-Za-z]`, value: `\w`},
+  {key: `[_a-zA-Z\d]`, value: `\w`},
+  {key: `[_a-z\dA-Z]`, value: `\w`},
+  {key: `[_A-Za-z\d]`, value: `\w`},
+  {key: `[_A-Z\da-z]`, value: `\w`},
+  {key: `[_\da-zA-Z]`, value: `\w`},
+  {key: `[_\dA-Za-z]`, value: `\w`},
+
+  // Non-word
+  {key: "[^a-zA-Z0-9_]", value: `\W`},
+  {key: "[^a-zA-Z_0-9]", value: `\W`},
+  {key: "[^a-z0-9A-Z_]", value: `\W`},
+  {key: "[^a-z0-9_A-Z]", value: `\W`},
+  {key: "[^a-z_A-Z0-9]", value: `\W`},
+  {key: "[^a-z_0-9A-Z]", value: `\W`},
+  {key: "[^A-Za-z0-9_]", value: `\W`},
+  {key: "[^A-Za-z_0-9]", value: `\W`},
+  {key: "[^A-Z0-9a-z_]", value: `\W`},
+  {key: "[^A-Z0-9_a-z]", value: `\W`},
+  {key: "[^A-Z_a-z0-9]", value: `\W`},
+  {key: "[^A-Z_0-9a-z]", value: `\W`},
+  {key: "[^0-9a-zA-Z_]", value: `\W`},
+  {key: "[^0-9a-z_A-Z]", value: `\W`},
+  {key: "[^0-9A-Za-z_]", value: `\W`},
+  {key: "[^0-9A-Z_a-z]", value: `\W`},
+  {key: "[^0-9_a-zA-Z]", value: `\W`},
+  {key: "[^0-9_A-Za-z]", value: `\W`},
+  {key: "[^_a-zA-Z0-9]", value: `\W`},
+  {key: "[^_a-z0-9A-Z]", value: `\W`},
+  {key: "[^_A-Za-z0-9]", value: `\W`},
+  {key: "[^_A-Z0-9a-z]", value: `\W`},
+  {key: "[^_0-9a-zA-Z]", value: `\W`},
+  {key: "[^_0-9A-Za-z]", value: `\W`},
+
+  // Non-word with digit
+  {key: `[^a-zA-Z\d_]`, value: `\W`},
+  {key: `[^a-zA-Z_\d]`, value: `\W`},
+  {key: `[^a-z\dA-Z_]`, value: `\W`},
+  {key: `[^a-z\d_A-Z]`, value: `\W`},
+  {key: `[^a-z_A-Z\d]`, value: `\W`},
+  {key: `[^a-z_\dA-Z]`, value: `\W`},
+  {key: `[^A-Za-z\d_]`, value: `\W`},
+  {key: `[^A-Za-z_\d]`, value: `\W`},
+  {key: `[^A-Z\da-z_]`, value: `\W`},
+  {key: `[^A-Z\d_a-z]`, value: `\W`},
+  {key: `[^A-Z_a-z\d]`, value: `\W`},
+  {key: `[^A-Z_\da-z]`, value: `\W`},
+  {key: `[^\da-zA-Z_]`, value: `\W`},
+  {key: `[^\da-z_A-Z]`, value: `\W`},
+  {key: `[^\dA-Za-z_]`, value: `\W`},
+  {key: `[^\dA-Z_a-z]`, value: `\W`},
+  {key: `[^\d_a-zA-Z]`, value: `\W`},
+  {key: `[^\d_A-Za-z]`, value: `\W`},
+  {key: `[^_a-zA-Z\d]`, value: `\W`},
+  {key: `[^_a-z\dA-Z]`, value: `\W`},
+  {key: `[^_A-Za-z\d]`, value: `\W`},
+  {key: `[^_A-Z\da-z]`, value: `\W`},
+  {key: `[^_\da-zA-Z]`, value: `\W`},
+  {key: `[^_\dA-Za-z]`, value: `\W`},
+
+  // Word with case insensitivity
+  {key: "[a-z0-9_]", value: `\w`, flags: "i"},
+  {key: "[a-z_0-9]", value: `\w`, flags: "i"},
+  {key: "[0-9a-z_]", value: `\w`, flags: "i"},
+  {key: "[0-9_a-z]", value: `\w`, flags: "i"},
+  {key: "[_a-z0-9]", value: `\w`, flags: "i"},
+  {key: "[_0-9a-z]", value: `\w`, flags: "i"},
+  {key: "[^a-z0-9_]", value: `\W`, flags: "i"},
+
+  // Word with case insensitivity and digit
+  {key: `[a-z\d_]`, value: `\w`, flags: "i"},
+  {key: `[a-z_\d]`, value: `\w`, flags: "i"},
+  {key: `[\da-z_]`, value: `\w`, flags: "i"},
+  {key: `[\d_a-z]`, value: `\w`, flags: "i"},
+  {key: `[_a-z\d]`, value: `\w`, flags: "i"},
+  {key: `[_\da-z]`, value: `\w`, flags: "i"},
+
+  // Non-word with case insensitivity
+  {key: "[^a-z0-9_]", value: `\W`, flags: "i"},
+  {key: "[^a-z_0-9]", value: `\W`, flags: "i"},
+  {key: "[^0-9a-z_]", value: `\W`, flags: "i"},
+  {key: "[^0-9_a-z]", value: `\W`, flags: "i"},
+  {key: "[^_a-z0-9]", value: `\W`, flags: "i"},
+  {key: "[^_0-9a-z]", value: `\W`, flags: "i"},
+
+  // Non-word with case insensitivity and digit
+  {key: `[^a-z\d_]`, value: `\W`, flags: "i"},
+  {key: `[^a-z_\d]`, value: `\W`, flags: "i"},
+  {key: `[^\da-z_]`, value: `\W`, flags: "i"},
+  {key: `[^\d_a-z]`, value: `\W`, flags: "i"},
+  {key: `[^_a-z\d]`, value: `\W`, flags: "i"},
+  {key: `[^_\da-z]`, value: `\W`, flags: "i"},
+}
+
+// regexCleanRegexp applies clean-regexp's ordered substring replacements to a
+// `new RegExp` pattern string, gated on `flags`. Mirrors clean-regexp's
+// default export: for each mapping whose required flags are all present in the
+// regex flags, globally replace the key substring with its shorthand.
+func regexCleanRegexp(pattern, flags string) string {
+  for _, mapping := range regexCleanMappings {
+    if regexCleanHasFlags(flags, mapping.flags) {
+      pattern = strings.ReplaceAll(pattern, mapping.key, mapping.value)
+    }
+  }
+  return pattern
+}
+
+// regexCleanHasFlags reports whether every flag a replacement requires is
+// present in the regex's flags (clean-regexp's `hasFlags`). An empty
+// requirement is always satisfied.
+func regexCleanHasFlags(regexFlags, replaceFlags string) bool {
+  for _, flag := range replaceFlags {
+    if !strings.ContainsRune(regexFlags, flag) {
+      return false
+    }
+  }
+  return true
+}