Merge branch 'main' into main

Author: chase

.github/workflows/create-cache.yml

@@ -20,6 +20,8 @@ defaults:
 
 jobs:
   cache:
+    if: github.repository == 'microsoft/typescript-go'
+
     strategy:
       fail-fast: false
       matrix:

.golangci.yml

@@ -22,6 +22,7 @@ linters:
     - errname
     - errorlint
     - fatcontext
+    - forbidigo
     - gocheckcompilerdirectives
     - goprintffuncname
     - govet
@@ -70,11 +71,30 @@ linters:
             - pkg: 'encoding/json$'
               desc: 'Use "github.com/go-json-experiment/json" instead.'
 
+    forbidigo:
+      analyze-types: true
+      forbid:
+        - pattern: '.*'
+          msg: tspath should likely be used instead
+          pkg: ^(path|path/filepath)$
+        - pattern: '.*'
+          msg: a host implementation should likely be used instead
+          pkg: ^os/
+        - pattern: 'GOOS'
+          msg: a host implementation should likely be used instead
+          pkg: ^runtime$
+
   exclusions:
     rules:
       - path: internal/fourslash/tests/gen/
         linters:
           - misspell
+      - path: 'internal/(repo|testutil|testrunner|vfs|pprof|execute/tsctests|bundled)|cmd/tsgo'
+        text: should likely be used instead
+      - path: '(.+)_test\.go$'
+        text: should likely be used instead
+      - path: '_tools'
+        text: should likely be used instead
 
     presets:
       - comments

_submodules/TypeScript

@@ -1,10 +1,14 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"fmt"
 	"os"
+	"os/exec"
+	"os/signal"
 	"runtime"
+	"syscall"
 
 	"github.com/microsoft/typescript-go/internal/bundled"
 	"github.com/microsoft/typescript-go/internal/core"
@@ -49,9 +53,17 @@ func runLSP(args []string) int {
 		FS:                 fs,
 		DefaultLibraryPath: defaultLibraryPath,
 		TypingsLocation:    typingsLocation,
+		NpmInstall: func(cwd string, args []string) ([]byte, error) {
+			cmd := exec.Command("npm", args...)
+			cmd.Dir = cwd
+			return cmd.Output()
+		},
 	})
 
-	if err := s.Run(); err != nil {
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	if err := s.Run(ctx); err != nil {
 		return 1
 	}
 	return 0

cmd/tsgo/lsp.go

@@ -43,7 +43,6 @@ const (
 	InternalSymbolNameClass                   = InternalSymbolNamePrefix + "class"                   // Unnamed class expression
 	InternalSymbolNameFunction                = InternalSymbolNamePrefix + "function"                // Unnamed function expression
 	InternalSymbolNameComputed                = InternalSymbolNamePrefix + "computed"                // Computed property name declaration with dynamic name
-	InternalSymbolNameResolving               = InternalSymbolNamePrefix + "resolving"               // Indicator symbol used to mark partially resolved type aliases
 	InternalSymbolNameInstantiationExpression = InternalSymbolNamePrefix + "instantiationExpression" // Instantiation expressions
 	InternalSymbolNameImportAttributes        = InternalSymbolNamePrefix + "importAttributes"
 	InternalSymbolNameExportEquals            = "export=" // Export assignment symbol

internal/ast/symbol.go

@@ -61,6 +61,7 @@ const (
 	TypeSystemPropertyNameResolvedBaseTypes
 	TypeSystemPropertyNameWriteType
 	TypeSystemPropertyNameInitializerIsUndefined
+	TypeSystemPropertyNameAliasTarget
 )
 
 type TypeResolution struct {
@@ -618,7 +619,6 @@ type Checker struct {
 	argumentsSymbol                             *ast.Symbol
 	requireSymbol                               *ast.Symbol
 	unknownSymbol                               *ast.Symbol
-	resolvingSymbol                             *ast.Symbol
 	unresolvedSymbols                           map[string]*ast.Symbol
 	errorTypes                                  map[string]*Type
 	globalThisSymbol                            *ast.Symbol
@@ -915,7 +915,6 @@ func NewChecker(program Program) *Checker {
 	c.argumentsSymbol = c.newSymbol(ast.SymbolFlagsProperty, "arguments")
 	c.requireSymbol = c.newSymbol(ast.SymbolFlagsProperty, "require")
 	c.unknownSymbol = c.newSymbol(ast.SymbolFlagsProperty, "unknown")
-	c.resolvingSymbol = c.newSymbol(ast.SymbolFlagsNone, ast.InternalSymbolNameResolving)
 	c.unresolvedSymbols = make(map[string]*ast.Symbol)
 	c.errorTypes = make(map[string]*Type)
 	c.globalThisSymbol = c.newSymbolEx(ast.SymbolFlagsModule, "globalThis", ast.CheckFlagsReadonly)
@@ -15652,29 +15651,25 @@ func (c *Checker) resolveAlias(symbol *ast.Symbol) *ast.Symbol {
 	}
 	links := c.aliasSymbolLinks.Get(symbol)
 	if links.aliasTarget == nil {
-		links.aliasTarget = c.resolvingSymbol
+		if !c.pushTypeResolution(symbol, TypeSystemPropertyNameAliasTarget) {
+			return c.unknownSymbol
+		}
 		node := c.getDeclarationOfAliasSymbol(symbol)
 		if node == nil {
 			panic("Unexpected nil in resolveAlias for symbol: " + c.symbolToString(symbol))
 		}
-		target := c.getTargetOfAliasDeclaration(node, false /*dontRecursivelyResolve*/)
-		if links.aliasTarget == c.resolvingSymbol {
-			if target == nil {
-				target = c.unknownSymbol
-			}
-			links.aliasTarget = target
-		} else {
+		links.aliasTarget = core.OrElse(c.getTargetOfAliasDeclaration(node, false /*dontRecursivelyResolve*/), c.unknownSymbol)
+		if !c.popTypeResolution() {
 			c.error(node, diagnostics.Circular_definition_of_import_alias_0, c.symbolToString(symbol))
+			links.aliasTarget = c.unknownSymbol
 		}
-	} else if links.aliasTarget == c.resolvingSymbol {
-		links.aliasTarget = c.unknownSymbol
 	}
 	return links.aliasTarget
 }
 
 func (c *Checker) tryResolveAlias(symbol *ast.Symbol) *ast.Symbol {
 	links := c.aliasSymbolLinks.Get(symbol)
-	if links.aliasTarget != c.resolvingSymbol {
+	if links.aliasTarget != nil || c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameAliasTarget) < 0 {
 		return c.resolveAlias(symbol)
 	}
 	return nil
@@ -18097,6 +18092,8 @@ func (c *Checker) typeResolutionHasProperty(r *TypeResolution) bool {
 		return c.nodeLinks.Get(r.target.(*ast.Node)).flags&NodeCheckFlagsInitializerIsUndefinedComputed != 0
 	case TypeSystemPropertyNameWriteType:
 		return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).writeType != nil
+	case TypeSystemPropertyNameAliasTarget:
+		return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget != nil
 	}
 	panic("Unhandled case in typeResolutionHasProperty")
 }

internal/checker/checker.go

@@ -16,7 +16,6 @@ TestCompletionEntryClassMembersWithInferredFunctionReturnType1
 TestCompletionEntryForArgumentConstrainedToString
 TestCompletionEntryForArrayElementConstrainedToString
 TestCompletionEntryForArrayElementConstrainedToString2
-TestCompletionEntryForClassMembers_StaticWhenBaseTypeIsNotResolved
 TestCompletionEntryForUnionProperty
 TestCompletionEntryForUnionProperty2
 TestCompletionForComputedStringProperties

internal/diagnostics/diagnostics_generated.go

@@ -1,6 +1,7 @@
 package fourslash
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"maps"
@@ -164,7 +165,7 @@ func NewFourslash(t *testing.T, capabilities *lsproto.ClientCapabilities, conten
 		defer func() {
 			outputWriter.Close()
 		}()
-		err := server.Run()
+		err := server.Run(context.TODO())
 		if err != nil {
 			t.Error("server error:", err)
 		}

internal/fourslash/_scripts/failingTests.txt

@@ -10,25 +10,9 @@ import (
 
 func TestCompletionEntryForClassMembers_StaticWhenBaseTypeIsNotResolved(t *testing.T) {
 	t.Parallel()
-	t.Skip()
+
 	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
-	const content = `// @Filename: /node_modules/@types/react/index.d.ts
-export = React;
-export as namespace React;
-declare namespace React {
-    function createElement(): any;
-    interface Component<P = {}, S = {}, SS = any> { }
-    class Component<P, S> {
-        static contextType?: any;
-        context: any;
-        constructor(props: Readonly<P>);
-        setState<K extends keyof S>(
-            state: ((prevState: Readonly<S>, props: Readonly<P>) => (Pick<S, K> | S | null)) | (Pick<S, K> | S | null),
-            callback?: () => void
-        ): void;
-    }
-}
-// @Filename: /a.ts
+	const content = `// @Filename: /a.ts
 import React from 'react'
 class Slider extends React.Component {
     static defau/**/ltProps = {