@ttsc/lint 0.19.3 → 0.20.0

package/linthost/rules_solid.go

@@ -4,6 +4,8 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 type solidRule struct {
@@ -11,6 +13,29 @@ type solidRule struct {
 }
 
 func (r solidRule) Name() string { return "solid/" + r.name }
+
+// DiagnosticTags marks `solid/no-react-deps` findings as unnecessary code so an
+// editor greys the dependency array out.
+//
+// The rule reports the dependency-array literal and nothing around it, and
+// Solid tracks dependencies automatically, so the array is inert: deleting
+// exactly the reported range is the whole resolution, which is what greying
+// tells the author to do.
+//
+// The marker is rule-level, so a rule whose findings do not all mean "delete
+// this" cannot take it. `solid/no-react-specific-props` is the near miss — its
+// `key` arm does mean deletion, but its `className` and `htmlFor` arms mean
+// "rename this", and one tag cannot say both.
+func (r solidRule) DiagnosticTags() []publicrule.DiagnosticTag {
+  if r.name == "no-react-deps" {
+    return []publicrule.DiagnosticTag{publicrule.DiagnosticTagUnnecessary}
+  }
+  return nil
+}
+func (r solidRule) NeedsTypeChecker() bool {
+  return r.name == "no-react-deps"
+}
+
 func (r solidRule) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindSourceFile}
 }
@@ -80,6 +105,7 @@ type solidState struct {
   declared     map[string]bool
   importedFrom map[string]string
   solidImport  map[string]string
+  solidSymbols map[string]*shimast.Symbol
   signals      map[string]bool
 }
 
@@ -88,6 +114,7 @@ func collectSolidState(ctx *Context) *solidState {
     declared:     map[string]bool{},
     importedFrom: map[string]string{},
     solidImport:  map[string]string{},
+    solidSymbols: map[string]*shimast.Symbol{},
     signals:      map[string]bool{},
   }
   if ctx == nil || ctx.File == nil {
@@ -98,7 +125,7 @@ func collectSolidState(ctx *Context) *solidState {
       continue
     }
     state.imports = append(state.imports, stmt)
-    state.collectImport(stmt)
+    state.collectImport(ctx, stmt)
   }
   walkDescendants(ctx.File.AsNode(), func(child *shimast.Node) {
     if child == nil {
@@ -132,13 +159,13 @@ func collectSolidState(ctx *Context) *solidState {
   return state
 }
 
-func (s *solidState) collectImport(node *shimast.Node) {
+func (s *solidState) collectImport(ctx *Context, node *shimast.Node) {
   decl := node.AsImportDeclaration()
   if decl == nil {
     return
   }
   source := stringLiteralText(decl.ModuleSpecifier)
-  if strings.HasPrefix(source, "solid-js") {
+  if isSolidModuleSource(source) {
     s.hasSolid = true
   }
   if decl.ImportClause == nil {
@@ -151,9 +178,30 @@ func (s *solidState) collectImport(node *shimast.Node) {
   if name := identifierText(clause.Name()); name != "" {
     s.declared[name] = true
     s.importedFrom[name] = source
+    if isSolidModuleSource(source) {
+      s.solidSymbols[name] = canonicalValueSymbol(ctx, clause.Name())
+    }
   }
   bindings := clause.NamedBindings
-  if bindings == nil || bindings.Kind != shimast.KindNamedImports {
+  if bindings == nil {
+    return
+  }
+  if bindings.Kind == shimast.KindNamespaceImport {
+    namespace := bindings.AsNamespaceImport()
+    if namespace == nil {
+      return
+    }
+    local := identifierText(namespace.Name())
+    if local != "" {
+      s.declared[local] = true
+      s.importedFrom[local] = source
+      if isSolidModuleSource(source) {
+        s.solidSymbols[local] = canonicalValueSymbol(ctx, namespace.Name())
+      }
+    }
+    return
+  }
+  if bindings.Kind != shimast.KindNamedImports {
     return
   }
   named := bindings.AsNamedImports()
@@ -175,8 +223,9 @@ func (s *solidState) collectImport(node *shimast.Node) {
     }
     s.declared[local] = true
     s.importedFrom[local] = source
-    if strings.HasPrefix(source, "solid-js") {
+    if isSolidModuleSource(source) {
       s.solidImport[local] = imported
+      s.solidSymbols[local] = canonicalValueSymbol(ctx, spec.Name())
     }
   }
 }
@@ -255,11 +304,309 @@ func (s *solidState) reportImports(ctx *Context) {
           imported = identifierText(spec.Name())
         }
       }
-      if correct := solidPreferredSource(imported); correct != "" && correct != source {
-        ctx.Report(specNode, "Import Solid API from its canonical module.")
+      correct := solidPreferredSource(imported)
+      if correct == "" || correct == source {
+        continue
       }
+      message := "Import `" + imported + "` from `" + correct + "`."
+      edits := solidImportSourceEdits(
+        ctx.File,
+        clause,
+        named,
+        decl.ModuleSpecifier,
+        correct,
+        specNode,
+        s.solidNamedImportFrom(correct, clause.IsTypeOnly()),
+      )
+      ctx.ReportFix(specNode, message, edits...)
+    }
+  }
+}
+
+// solidNamedImportFrom returns the file's named-import list for `source`, or
+// nil when the file has none. It is how the fix finds a declaration to move a
+// misrouted specifier INTO, which is what upstream's `appendImports` does and
+// what the rule's published description means by merging.
+//
+// A declaration carrying a default binding is skipped: appending there is legal
+// but rewrites a line the user did not ask about, and the synthesized path
+// covers the case without touching it.
+//
+// `typeOnly` must match the declaration the specifier is leaving. A value
+// import appended into `import type { … }` becomes unusable as a value
+// (TS1361), and a type import appended into a value declaration survives into
+// the emitted JavaScript under `verbatimModuleSyntax`. Neither is a formatting
+// difference, so the two kinds never share a destination.
+func (s *solidState) solidNamedImportFrom(source string, typeOnly bool) *shimast.NamedImports {
+  for _, node := range s.imports {
+    decl := node.AsImportDeclaration()
+    if decl == nil || decl.ImportClause == nil {
+      continue
     }
+    if stringLiteralText(decl.ModuleSpecifier) != source {
+      continue
+    }
+    clause := decl.ImportClause.AsImportClause()
+    if clause == nil || clause.Name() != nil || clause.IsTypeOnly() != typeOnly ||
+      clause.NamedBindings == nil ||
+      clause.NamedBindings.Kind != shimast.KindNamedImports {
+      continue
+    }
+    if named := clause.NamedBindings.AsNamedImports(); named != nil &&
+      named.Elements != nil && len(named.Elements.Nodes) > 0 {
+      return named
+    }
+  }
+  return nil
+}
+
+// solidImportSourceEdits relocates one misrouted specifier to its canonical
+// module.
+//
+// Three shapes, because a specifier can be alone or not and the destination can
+// exist or not:
+//
+//  1. The specifier is the declaration's only binding, so the declaration IS the
+//     import: rewrite its module specifier in place. The narrowest edit, and the
+//     only one the rule used to make.
+//  2. The specifier has siblings and a declaration from the correct source
+//     already exists: cut the specifier out and append it there, which is the
+//     merge the rule's description promises and upstream's `appendImports`
+//     performs.
+//  3. The specifier has siblings and no such declaration exists: cut it out and
+//     synthesize one directly above the declaration it left.
+//
+// Returning nil for every shape but the first is what made the rule report the
+// most ordinary import in a Solid file — `import { createEffect, render } from
+// "solid-js"` — with a message and no fix.
+func solidImportSourceEdits(
+  file *shimast.SourceFile,
+  clause *shimast.ImportClause,
+  named *shimast.NamedImports,
+  moduleSpecifier *shimast.Node,
+  correct string,
+  specNode *shimast.Node,
+  destination *shimast.NamedImports,
+) []TextEdit {
+  if clause == nil || named == nil || named.Elements == nil || file == nil {
+    return nil
+  }
+  // "Alone" means alone among the NAMED bindings. A default binding beside them
+  // does not make the specifier a sibling of anything, but it does decide how
+  // much has to be cut, which is why the two are tracked apart.
+  alone := len(named.Elements.Nodes) == 1
+  bare := clause.Name() == nil
+  // The destination is consulted BEFORE the in-place rewrite, or the rewrite
+  // wins on a file that already imports from the correct module and leaves two
+  // declarations of it — the duplicate the rule's own description promises to
+  // avoid.
+  if destination != nil {
+    insert, ok := solidAppendPoint(file, destination)
+    if !ok {
+      return nil
+    }
+    cut, text, ok := solidBindingCut(file, clause, named, specNode)
+    if !ok {
+      return nil
+    }
+    // Disjoint: the cut lies in this declaration and the append in another.
+    return []TextEdit{cut, {Pos: insert, End: insert, Text: ", " + text}}
+  }
+  if alone && bare {
+    // The declaration IS the import, so retarget it where it stands. The
+    // narrowest edit available, and the only one the rule used to make.
+    pos, end, ok := solidQuotedTextRange(file, moduleSpecifier)
+    if !ok {
+      return nil
+    }
+    return []TextEdit{{Pos: pos, End: end, Text: correct}}
+  }
+  cut, text, ok := solidBindingCut(file, clause, named, specNode)
+  if !ok {
+    return nil
+  }
+  declaration, ok := solidDeclarationStart(file, clause)
+  if !ok {
+    return nil
+  }
+  quote := solidQuoteCharacter(file, moduleSpecifier)
+  // A type-only declaration synthesizes a type-only one. Dropping the keyword
+  // emits a runtime import under `verbatimModuleSyntax` for a symbol that has
+  // no runtime existence.
+  keyword := "import "
+  if clause.IsTypeOnly() {
+    keyword = "import type "
+  }
+  line := keyword + "{ " + text + " } from " + quote + correct + quote + ";\n"
+  return []TextEdit{{Pos: declaration, End: declaration, Text: line}, cut}
+}
+
+// solidBindingCut removes the misrouted specifier from its declaration and
+// reports the text removed, in whichever of three shapes the declaration is.
+//
+// With named siblings it takes the specifier and one comma. Alone beside a
+// DEFAULT binding it takes the braces too, because `import Solid, {} from` is
+// not what anyone meant. Alone with no default the specifier IS the whole
+// declaration, so the declaration goes — leaving `import {} from "solid-js";`
+// behind would be a statement importing nothing.
+func solidBindingCut(
+  file *shimast.SourceFile,
+  clause *shimast.ImportClause,
+  named *shimast.NamedImports,
+  specNode *shimast.Node,
+) (TextEdit, string, bool) {
+  if len(named.Elements.Nodes) > 1 {
+    return solidSpecifierCut(file, named, specNode)
+  }
+  pos, end := tokenRange(file, specNode)
+  if pos < 0 || end < pos || end > len(file.Text()) {
+    return TextEdit{}, "", false
+  }
+  text := file.Text()[pos:end]
+  if name := clause.Name(); name != nil {
+    from := name.End()
+    to := named.AsNode().End()
+    if from < 0 || to > len(file.Text()) || from >= to {
+      return TextEdit{}, "", false
+    }
+    return TextEdit{Pos: from, End: to}, text, true
+  }
+  from, to, ok := solidDeclarationRange(file, clause)
+  if !ok {
+    return TextEdit{}, "", false
+  }
+  return TextEdit{Pos: from, End: to}, text, true
+}
+
+// solidDeclarationRange bounds the whole import declaration owning `clause`,
+// including the line break after it so removing the declaration does not leave
+// a blank line where it stood.
+func solidDeclarationRange(file *shimast.SourceFile, clause *shimast.ImportClause) (int, int, bool) {
+  node := clause.AsNode()
+  if node == nil || node.Parent == nil {
+    return 0, 0, false
+  }
+  text := file.Text()
+  pos := shimscanner.SkipTrivia(text, node.Parent.Pos())
+  end := node.Parent.End()
+  if pos < 0 || end < pos || end > len(text) {
+    return 0, 0, false
+  }
+  if end < len(text) && text[end] == '\r' {
+    end++
+  }
+  if end < len(text) && text[end] == '\n' {
+    end++
+  }
+  return pos, end, true
+}
+
+// solidSpecifierCut removes one specifier from a named-import list along with
+// the comma that joined it, and reports the text it removed so a caller can put
+// it somewhere else.
+//
+// The comma taken is the one BEFORE the specifier when it has a predecessor,
+// and the one after when it is first. Taking the wrong side leaves either a
+// leading or a doubled comma, both of which are parse errors rather than
+// cosmetic damage.
+func solidSpecifierCut(
+  file *shimast.SourceFile,
+  named *shimast.NamedImports,
+  specNode *shimast.Node,
+) (TextEdit, string, bool) {
+  nodes := named.Elements.Nodes
+  index := -1
+  for i, node := range nodes {
+    if node == specNode {
+      index = i
+      break
+    }
+  }
+  if index < 0 || len(nodes) < 2 {
+    return TextEdit{}, "", false
+  }
+  pos, end := tokenRange(file, specNode)
+  if pos < 0 || end < pos {
+    return TextEdit{}, "", false
+  }
+  text := file.Text()[pos:end]
+  src := file.Text()
+  if index > 0 {
+    previousEnd := nodes[index-1].End()
+    if previousEnd < 0 || previousEnd > pos {
+      return TextEdit{}, "", false
+    }
+    return TextEdit{Pos: previousEnd, End: end}, text, true
+  }
+  nextPos := shimscanner.SkipTrivia(src, nodes[index+1].Pos())
+  if nextPos < end || nextPos > len(src) {
+    return TextEdit{}, "", false
+  }
+  return TextEdit{Pos: pos, End: nextPos}, text, true
+}
+
+// solidAppendPoint returns the offset just past a named-import list's last
+// specifier, where a relocated one is appended.
+func solidAppendPoint(file *shimast.SourceFile, named *shimast.NamedImports) (int, bool) {
+  nodes := named.Elements.Nodes
+  if len(nodes) == 0 {
+    return 0, false
   }
+  end := nodes[len(nodes)-1].End()
+  if end < 0 || end > len(file.Text()) {
+    return 0, false
+  }
+  return end, true
+}
+
+// solidDeclarationStart returns the offset of the `import` keyword owning
+// `clause`, which is where a synthesized declaration is inserted so it lands on
+// its own line directly above.
+func solidDeclarationStart(file *shimast.SourceFile, clause *shimast.ImportClause) (int, bool) {
+  node := clause.AsNode()
+  if node == nil || node.Parent == nil {
+    return 0, false
+  }
+  pos := shimscanner.SkipTrivia(file.Text(), node.Parent.Pos())
+  if pos < 0 || pos > len(file.Text()) {
+    return 0, false
+  }
+  return pos, true
+}
+
+// solidQuoteCharacter returns the quote the file already used for this module
+// specifier, so a synthesized import matches the surrounding style instead of
+// fighting `format/quotes`.
+func solidQuoteCharacter(file *shimast.SourceFile, moduleSpecifier *shimast.Node) string {
+  pos, end := tokenRange(file, moduleSpecifier)
+  if pos < 0 || end-pos < 2 {
+    return "\""
+  }
+  if quote := file.Text()[pos]; quote == '\'' || quote == '"' {
+    return string(quote)
+  }
+  return "\""
+}
+
+// solidQuotedTextRange returns the byte range of the text inside a string
+// literal's quotes, so a rewrite replaces the contents and leaves the
+// surrounding quote characters exactly as the author wrote them. Reports false
+// for anything that is not a plainly quoted literal, such as a
+// parse-recovered node with no closing quote.
+func solidQuotedTextRange(file *shimast.SourceFile, node *shimast.Node) (int, int, bool) {
+  pos, end := tokenRange(file, node)
+  if pos < 0 || end-pos < 2 {
+    return 0, 0, false
+  }
+  src := file.Text()
+  quote := src[pos]
+  if quote != '"' && quote != '\'' {
+    return 0, 0, false
+  }
+  if src[end-1] != quote {
+    return 0, 0, false
+  }
+  return pos + 1, end - 1, true
 }
 
 func (s *solidState) reportNoDestructure(ctx *Context) {
@@ -386,15 +733,49 @@ func (s *solidState) reportReactSpecificProps(ctx *Context) {
     }
     switch solidJSXAttrName(attr) {
     case "className":
-      ctx.Report(attr, "Use Solid's `class` prop instead of `className`.")
+      ctx.ReportFix(
+        attr,
+        "Use Solid's `class` prop instead of `className`.",
+        solidAttrRenameEdits(ctx.File, attr, "class")...,
+      )
     case "htmlFor":
-      ctx.Report(attr, "Use Solid's `for` prop instead of `htmlFor`.")
+      ctx.ReportFix(
+        attr,
+        "Use Solid's `for` prop instead of `htmlFor`.",
+        solidAttrRenameEdits(ctx.File, attr, "for")...,
+      )
     case "key":
       ctx.Report(attr, "DOM elements in Solid do not need React-style `key` props.")
     }
   }
 }
 
+// solidAttrRenameEdits rewrites a JSX attribute's name token and nothing else.
+//
+// `className` and `class` mean the same thing to a Solid DOM element, as do
+// `htmlFor` and `for`, so the rename is a pure 1:1 substitution and safe to
+// impose. Leaving the value untouched is what makes it safe for every value
+// shape at once: a string, an expression container, and a shorthand boolean
+// attribute all keep whatever follows the name.
+//
+// The `key` arm has no counterpart here on purpose. Solid DOM elements do not
+// consume `key` at all, so the resolution is deletion, not a rename, and the
+// deletion has to take the surrounding whitespace with it to leave valid JSX.
+//
+// Returns nil when the name token cannot be located, which downgrades the
+// caller to a plain diagnostic.
+func solidAttrRenameEdits(file *shimast.SourceFile, attrNode *shimast.Node, name string) []TextEdit {
+  attr := attrNode.AsJsxAttribute()
+  if attr == nil {
+    return nil
+  }
+  pos, end := tokenRange(file, attr.Name())
+  if pos < 0 {
+    return nil
+  }
+  return []TextEdit{{Pos: pos, End: end, Text: name}}
+}
+
 func (s *solidState) reportUnknownNamespaces(ctx *Context) {
   for _, attr := range s.jsxAttrs {
     name := solidJSXAttrName(attr)
@@ -419,7 +800,7 @@ func (s *solidState) reportReactDeps(ctx *Context) {
     if call == nil || call.Arguments == nil || len(call.Arguments.Nodes) != 2 {
       continue
     }
-    name := s.callName(call)
+    name := s.solidTrackedCallName(ctx, call)
     if name != "createEffect" && name != "createMemo" {
       continue
     }
@@ -431,6 +812,41 @@ func (s *solidState) reportReactDeps(ctx *Context) {
   }
 }
 
+// solidTrackedCallName returns the canonical Solid name only when the call is
+// proven to come from a Solid module binding. The rule carries an
+// `Unnecessary` tag, so a same-named local helper cannot be treated as a Solid
+// primitive merely because the file imports some other Solid symbol.
+func (s *solidState) solidTrackedCallName(ctx *Context, call *shimast.CallExpression) string {
+  if ctx == nil || call == nil {
+    return ""
+  }
+  expr := stripParens(call.Expression)
+  if expr == nil {
+    return ""
+  }
+  if name := identifierText(expr); name != "" {
+    if s.solidSymbols[name] == nil || canonicalValueSymbol(ctx, expr) != s.solidSymbols[name] {
+      return ""
+    }
+    return s.solidImport[name]
+  }
+  if expr.Kind != shimast.KindPropertyAccessExpression {
+    return ""
+  }
+  access := expr.AsPropertyAccessExpression()
+  if access == nil {
+    return ""
+  }
+  object := stripParens(access.Expression)
+  local := identifierText(object)
+  if !isSolidModuleSource(s.importedFrom[local]) ||
+    s.solidSymbols[local] == nil ||
+    canonicalValueSymbol(ctx, object) != s.solidSymbols[local] {
+    return ""
+  }
+  return identifierText(access.Name())
+}
+
 func (s *solidState) reportProxyAPIs(ctx *Context) {
   for _, node := range s.imports {
     decl := node.AsImportDeclaration()
@@ -1036,6 +1452,10 @@ func isSolidSource(source string) bool {
   return source == "solid-js" || source == "solid-js/web" || source == "solid-js/store"
 }
 
+func isSolidModuleSource(source string) bool {
+  return source == "solid-js" || strings.HasPrefix(source, "solid-js/")
+}
+
 func solidIsDOMTag(name string) bool {
   if name == "" {
     return false