@ttsc/lint 0.33.1 → 0.34.1

package/linthost/rules_ts_prefer_readonly.go

@@ -88,7 +88,7 @@ func preferReadonlyRecordTarget(ctx *Context, target *shimast.Node, written map[
   }
   record := func(symbol *shimast.Symbol) {
     if symbol != nil {
-      for _, decl := range symbol.Declarations {
+      for _, decl := range shimast.SymbolDeclarationsOf(symbol) {
         if decl != nil && decl.Kind == shimast.KindPropertyDeclaration {
           written[decl] = true
         }

package/linthost/rules_ts_switch_exhaustiveness_check.go

@@ -362,8 +362,8 @@ func switchExhaustivenessCheckTypeName(
       if name := shimchecker.Checker_symbolToValueString(checker, symbol, location); name != "" {
         return "typeof " + name
       }
-      if symbol.Name != "" {
-        return "typeof " + symbol.Name
+      if shimast.SymbolNameOf(symbol) != "" {
+        return "typeof " + shimast.SymbolNameOf(symbol)
       }
     }
   }

package/linthost/rules_ts_unbound_method.go

@@ -106,7 +106,7 @@ func unboundMethodSymbolIsClassMethod(symbol *shimast.Symbol) bool {
   if symbol == nil {
     return false
   }
-  for _, decl := range symbol.Declarations {
+  for _, decl := range shimast.SymbolDeclarationsOf(symbol) {
     if decl == nil {
       continue
     }

package/linthost/rules_unicorn_consistent_destructuring.go

@@ -612,8 +612,8 @@ func (s *unicornConsistentDestructuringState) resolveValueSymbol(
   if symbol == nil {
     return nil
   }
-  if symbol.Flags&shimast.SymbolFlagsExportValue != 0 && symbol.ExportSymbol != nil {
-    symbol = symbol.ExportSymbol
+  if shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsExportValue != 0 && shimast.SymbolExportSymbolOf(symbol) != nil {
+    symbol = shimast.SymbolExportSymbolOf(symbol)
   }
   return s.ctx.Checker.GetMergedSymbol(symbol)
 }

package/linthost/rules_unicorn_consistent_existence_index_check.go

@@ -197,10 +197,10 @@ func unicornConsistentExistenceIndexCheckIsIndexBinding(
   identifier *shimast.Node,
 ) bool {
   symbol := canonicalValueSymbol(ctx, identifier)
-  if symbol == nil || symbol.ValueDeclaration == nil {
+  if symbol == nil || shimast.SymbolValueDeclarationOf(symbol) == nil {
     return false
   }
-  declaration := symbol.ValueDeclaration
+  declaration := shimast.SymbolValueDeclarationOf(symbol)
   if declaration.Kind != shimast.KindVariableDeclaration ||
     declaration.Parent == nil ||
     declaration.Parent.Kind != shimast.KindVariableDeclarationList {

package/linthost/rules_unicorn_consistent_function_scoping.go

@@ -168,7 +168,7 @@ func unicornConsistentFunctionScopingIsImplicitArguments(
   symbol *shimast.Symbol,
 ) bool {
   return node.Kind == shimast.KindIdentifier && identifierText(node) == "arguments" &&
-    symbol.ValueDeclaration == nil && len(symbol.Declarations) == 0
+    shimast.SymbolValueDeclarationOf(symbol) == nil && len(shimast.SymbolDeclarationsOf(symbol)) == 0
 }
 
 func (analysis *unicornConsistentFunctionScopingAnalysis) isReference(node *shimast.Node) bool {
@@ -244,10 +244,10 @@ func unicornConsistentFunctionScopingIsDeclarationName(
   if node == nil || symbol == nil {
     return false
   }
-  if declaration := symbol.ValueDeclaration; declaration != nil && declaration.Name() == node {
+  if declaration := shimast.SymbolValueDeclarationOf(symbol); declaration != nil && declaration.Name() == node {
     return true
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declaration != nil && declaration.Name() == node {
       return true
     }
@@ -340,10 +340,10 @@ func unicornConsistentFunctionScopingSymbolDeclaredInside(
   if symbol == nil || function == nil {
     return false
   }
-  if symbol.ValueDeclaration != nil && noLoopFuncNodeContains(function, symbol.ValueDeclaration) {
+  if shimast.SymbolValueDeclarationOf(symbol) != nil && noLoopFuncNodeContains(function, shimast.SymbolValueDeclarationOf(symbol)) {
     return true
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declaration != nil && noLoopFuncNodeContains(function, declaration) {
       return true
     }
@@ -358,10 +358,10 @@ func unicornConsistentFunctionScopingSymbolDeclaredInScopes(
   if symbol == nil {
     return false
   }
-  if unicornConsistentFunctionScopingDeclarationPins(symbol.ValueDeclaration, scopes) {
+  if unicornConsistentFunctionScopingDeclarationPins(shimast.SymbolValueDeclarationOf(symbol), scopes) {
     return true
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if unicornConsistentFunctionScopingDeclarationPins(declaration, scopes) {
       return true
     }

package/linthost/rules_unicorn_filename_case.go

@@ -242,7 +242,7 @@ func (unicornFilenameCase) Check(ctx *Context, _ *shimast.Node) {
     caseFunctions = append(caseFunctions, unicornFilenameCaseFunction(chosen))
   }
 
-  segments := unicornFilenameCasePathSegments(ctx.CurrentDirectory, fileName)
+  segments := unicornFilenameCasePathSegments(ctx.CurrentDirectory, string(fileName))
   for _, segment := range segments {
     for _, pattern := range options.ignore {
       if pattern.MatchString(segment) {

package/linthost/rules_unicorn_isolated_functions.go

@@ -629,7 +629,7 @@ func (a *unicornIsolatedFunctionsAnalysis) checkReference(
   } else {
     symbol = canonicalValueSymbol(a.ctx, identifier)
     if symbol != nil {
-      for _, declaration := range symbol.Declarations {
+      for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
         if declaration != nil && declaration != function &&
           declaration.Pos() >= function.Pos() && declaration.End() <= function.End() {
           return
@@ -674,10 +674,10 @@ func (a *unicornIsolatedFunctionsAnalysis) checkReference(
 // top-level bindings resolve globally but are real source declarations, so
 // they stay reported like upstream's script-mode captures.
 func unicornIsolatedFunctionsIsAmbientGlobal(ctx *Context, name string, symbol *shimast.Symbol) bool {
-  if len(symbol.Declarations) == 0 {
+  if len(shimast.SymbolDeclarationsOf(symbol)) == 0 {
     return true
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declaration == nil {
       return false
     }

package/linthost/rules_unicorn_no_typeof_undefined.go

@@ -184,7 +184,7 @@ func unicornNoTypeofUndefinedIsGlobal(ctx *Context, operand *shimast.Node) bool
   if symbol == nil {
     return true
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declaration == nil {
       continue
     }

package/linthost/rules_unicorn_no_unnecessary_polyfills.go

@@ -209,7 +209,7 @@ func unicornNoUnnecessaryPolyfillsSpecifier(node *shimast.Node) *shimast.Node {
 // no targets resolve, which silences the rule like upstream's early returns
 // and catch blocks.
 func unicornNoUnnecessaryPolyfillsUnavailableSet(ctx *Context, options unicornNoUnnecessaryPolyfillsOptions) (map[string]struct{}, bool) {
-  dirname := filepath.Dir(ctx.File.FileName())
+  dirname := filepath.Dir(string(ctx.File.FileName()))
   browserslistOptions := browserslistOpts{path: dirname, env: "production"}
 
   var targets interface{}

package/linthost/rules_unicorn_no_unused_properties.go

@@ -206,7 +206,7 @@ func unusedPropertiesCollectReferences(
   names := make(map[string]struct{}, len(candidates))
   for _, candidate := range candidates {
     symbol := unusedPropertiesDeclaredSymbol(ctx, candidate)
-    if symbol == nil || len(symbol.Declarations) != 1 || bySymbol[symbol] != nil {
+    if symbol == nil || len(shimast.SymbolDeclarationsOf(symbol)) != 1 || bySymbol[symbol] != nil {
       candidate.container = nil
       continue
     }
@@ -286,8 +286,8 @@ func unusedPropertiesSymbolAtIdentifier(
   if symbol == nil {
     return nil
   }
-  if symbol.Flags&shimast.SymbolFlagsExportValue != 0 && symbol.ExportSymbol != nil {
-    symbol = symbol.ExportSymbol
+  if shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsExportValue != 0 && shimast.SymbolExportSymbolOf(symbol) != nil {
+    symbol = shimast.SymbolExportSymbolOf(symbol)
   }
   return ctx.Checker.GetMergedSymbol(symbol)
 }

package/linthost/rules_unicorn_prefer_number_properties.go

@@ -206,7 +206,7 @@ func unicornPreferNumberPropertiesResolvesGlobal(ctx *Context, node *shimast.Nod
   if resolved != global {
     return false
   }
-  for _, declaration := range resolved.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(resolved) {
     if declaration != nil &&
       shimast.GetSourceFileOfNode(declaration) == ctx.File &&
       unicornPreferNumberPropertiesDeclarationIntroducesValue(declaration) {

package/linthost/rules_unicorn_prefer_simple_condition_first.go

@@ -372,7 +372,7 @@ func unicornPreferSimpleConditionFirstIsGlobalBooleanCall(
   if resolved != global {
     return false
   }
-  for _, declaration := range resolved.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(resolved) {
     if declaration != nil && shimast.GetSourceFileOfNode(declaration) == ctx.File &&
       unicornPreferSimpleConditionFirstDeclarationIntroducesValue(declaration) {
       return false

package/linthost/rules_unicorn_prevent_abbreviations.go

@@ -572,7 +572,7 @@ func collectUnicornPreventAbbreviationsBindings(
     bindings = append(bindings, binding)
     bySymbol[symbol] = binding
     byDeclaration[node] = binding
-    for _, declaration := range symbol.Declarations {
+    for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
       byDeclaration[declaration] = binding
     }
   })
@@ -918,7 +918,7 @@ func collectUnicornPreventAbbreviationsReferences(
     }
     binding := bySymbol[symbol]
     if binding == nil {
-      for _, declaration := range symbol.Declarations {
+      for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
         if candidate := byDeclaration[declaration]; candidate != nil {
           binding = candidate
           break
@@ -1168,7 +1168,7 @@ func unicornPreventAbbreviationsCanRenameBinding(
   if binding == nil || len(binding.references) == 0 || unicornPreventAbbreviationsBindingIsExternallyVisible(ctx, binding) {
     return false
   }
-  if strings.EqualFold(filepath.Ext(ctx.File.FileName()), ".vue") {
+  if strings.EqualFold(filepath.Ext(string(ctx.File.FileName())), ".vue") {
     return false
   }
   parameter := unicornPreventAbbreviationsEnclosingParameter(binding.declaration)
@@ -1196,9 +1196,9 @@ func unicornPreventAbbreviationsBindingIsExternallyVisible(
   if ctx == nil || ctx.File == nil || binding == nil || binding.symbol == nil || ctx.File.IsDeclarationFile {
     return true
   }
-  declarations := make([]*shimast.Node, 0, len(binding.symbol.Declarations)+1)
+  declarations := make([]*shimast.Node, 0, len(shimast.SymbolDeclarationsOf(binding.symbol))+1)
   declarations = append(declarations, binding.declaration)
-  declarations = append(declarations, binding.symbol.Declarations...)
+  declarations = append(declarations, shimast.SymbolDeclarationsOf(binding.symbol)...)
   seen := make(map[*shimast.Node]struct{}, len(declarations))
   for _, declaration := range declarations {
     if declaration == nil {
@@ -1704,10 +1704,10 @@ func reportUnicornPreventAbbreviationsFilename(
   options unicornPreventAbbreviationsOptions,
 ) {
   filenameWithPath := ctx.File.FileName()
-  if filenameWithPath == "" || unicornPreventAbbreviationsIsVirtualFilename(filenameWithPath) {
+  if filenameWithPath == "" || unicornPreventAbbreviationsIsVirtualFilename(string(filenameWithPath)) {
     return
   }
-  filename := filepath.Base(filenameWithPath)
+  filename := filepath.Base(string(filenameWithPath))
   extension := unicornPreventAbbreviationsFilenameExtension(filename)
   basename := strings.TrimSuffix(filename, extension)
   replacements := getUnicornPreventAbbreviationsNameReplacements(basename, options, 3)

package/linthost/rules_var.go

@@ -970,7 +970,7 @@ func preferConstSymbolIsLocalToScope(symbol *shimast.Symbol, scope *shimast.Node
   if symbol == nil || scope == nil {
     return false
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if preferConstDeclarationScope(declaration) == scope {
       return true
     }

package/linthost/solid_helpers_test.go

@@ -61,7 +61,7 @@ func assertSolidCheckerFindings(
     t.Fatalf("user source files = %d, want 1", len(files))
   }
   wanted := filepath.ToSlash(filepath.Join("src", fileName))
-  if got := filepath.ToSlash(files[0].FileName()); !strings.HasSuffix(got, wanted) {
+  if got := filepath.ToSlash(string(files[0].FileName())); !strings.HasSuffix(got, wanted) {
     t.Fatalf("user source file = %q, want one ending in %q", got, wanted)
   }
   assertSolidExpectations(t, files[0], program.runLintCycle(engine), expected)

package/linthost/type_alias_reference_node_uses_borrowed_builder_context_test.go

@@ -48,10 +48,10 @@ func TestTypeAliasReferenceNodeUsesBorrowedBuilderContext(t *testing.T) {
     t.Fatal("Pair<string> alias metadata missing")
   }
   alias := value.Alias()
-  if alias.Symbol() == nil || alias.Symbol().Name != "Pair" || len(alias.TypeArguments()) != 1 || prog.checker.TypeToString(alias.TypeArguments()[0]) != "string" {
+  if alias.Symbol() == nil || shimast.SymbolNameOf(alias.Symbol()) != "Pair" || len(alias.TypeArguments()) != 1 || prog.checker.TypeToString(alias.TypeArguments()[0]) != "string" {
     t.Fatal("authored alias identity or argument missing")
   }
-  enclosing := classSymbol(t, prog, "Holder").Declarations[0]
+  enclosing := shimast.SymbolDeclarationsOf(classSymbol(t, prog, "Holder"))[0]
   emit := shimprinter.NewEmitContext()
   assertReference := func(node *shimast.Node) {
     t.Helper()

package/linthost/type_instantiation_mappers_reach_runtime_endpoints_test.go

@@ -189,7 +189,7 @@ func declaredClassTypeParameters(
   symbol *shimast.Symbol,
 ) []*shimchecker.Type {
   t.Helper()
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declaration == nil ||
       (declaration.Kind != shimast.KindClassDeclaration && declaration.Kind != shimast.KindClassExpression) {
       continue
@@ -202,12 +202,12 @@ func declaredClassTypeParameters(
       }
       typ := checker.GetTypeAtLocation(node)
       if typ == nil {
-        t.Fatalf("GetTypeAtLocation returned nil for a type parameter of %s", symbol.Name)
+        t.Fatalf("GetTypeAtLocation returned nil for a type parameter of %s", shimast.SymbolNameOf(symbol))
       }
       result = append(result, typ)
     }
     return result
   }
-  t.Fatalf("class declaration for %q not found", symbol.Name)
+  t.Fatalf("class declaration for %q not found", shimast.SymbolNameOf(symbol))
   return nil
 }

package/linthost/user_source_files_exclude_imported_declarations_and_javascript_test.go

@@ -52,7 +52,7 @@ func TestUserSourceFilesExcludeImportedDeclarationsAndJavaScript(t *testing.T) {
   defer prog.close()
   imported := map[string]int{"src/helper.js": 0, "src/shapes.d.ts": 0}
   for _, file := range prog.tsProgram.SourceFiles() {
-    name := filepath.ToSlash(filepath.Clean(file.FileName()))
+    name := filepath.ToSlash(filepath.Clean(string(file.FileName())))
     for expected := range imported {
       if name == filepath.ToSlash(filepath.Join(root, expected)) {
         imported[expected]++
@@ -67,7 +67,7 @@ func TestUserSourceFilesExcludeImportedDeclarationsAndJavaScript(t *testing.T) {
 
   names := make([]string, 0)
   for _, file := range prog.userSourceFiles() {
-    rel, err := filepath.Rel(root, file.FileName())
+    rel, err := filepath.Rel(root, string(file.FileName()))
     if err != nil {
       t.Fatal(err)
     }

package/linthost/user_source_files_span_program_typescript_sources_test.go

@@ -57,7 +57,7 @@ func TestUserSourceFilesSpanProgramTypeScriptSources(t *testing.T) {
 
   names := make([]string, 0)
   for _, file := range prog.userSourceFiles() {
-    rel, err := filepath.Rel(root, file.FileName())
+    rel, err := filepath.Rel(root, string(file.FileName()))
     if err != nil {
       t.Fatal(err)
     }

package/linthost/windows_project_source_selection_preserves_physical_aliases_test.go

@@ -6,6 +6,7 @@ import (
   "path/filepath"
   "testing"
 
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/samchon/ttsc/packages/ttsc/driver/windowsjunction"
 )
 
@@ -32,16 +33,16 @@ func TestWindowsProjectSourceSelectionPreservesPhysicalAliases(t *testing.T) {
     t.Fatalf("load: err=%v diagnostics=%v", err, diags)
   }
   defer prog.close()
-  configured := prog.tsProgram.GetSourceFile(filepath.ToSlash(filepath.Join(root, "owned", "main.ts")))
-  imported := prog.tsProgram.GetSourceFile(filepath.ToSlash(filepath.Join(root, "alias", "main.ts")))
+  configured := prog.tsProgram.GetSourceFile(shimtspath.RootedFilePath(filepath.ToSlash(filepath.Join(root, "owned", "main.ts"))))
+  imported := prog.tsProgram.GetSourceFile(shimtspath.RootedFilePath(filepath.ToSlash(filepath.Join(root, "alias", "main.ts"))))
   if configured == nil || imported == nil || configured == imported {
     t.Fatal("fixture must load distinct configured and imported AST spellings")
   }
   roots := prog.projectSourceFileNames()
-  if _, direct := roots[canonicalProjectPath(root, imported.FileName())]; direct {
+  if _, direct := roots[canonicalProjectPath(root, string(imported.FileName()))]; direct {
     t.Fatal("alternate spelling must exercise physical fallback, not direct lookup")
   }
-  if !prog.selectedByProject(roots, imported.FileName()) {
+  if !prog.selectedByProject(roots, string(imported.FileName())) {
     t.Error("physical alias lost selected-file ownership")
   }
   if prog.selectedByProject(roots, filepath.Join(root, "outside.ts")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.33.1",
+  "version": "0.34.1",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -38,7 +38,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.33.1"
+    "ttsc": "0.34.1"
   },
   "repository": {
     "type": "git",