Always have host

Author: jakebailey

internal/checker/nodebuilder.go

@@ -7,9 +7,9 @@ import (
 )
 
 type NodeBuilder struct {
-	ctxStack  []*NodeBuilderContext
-	basicHost Host
-	impl      *nodeBuilderImpl
+	ctxStack []*NodeBuilderContext
+	host     Host
+	impl     *nodeBuilderImpl
 }
 
 // EmitContext implements NodeBuilderInterface.
@@ -20,6 +20,7 @@ func (b *NodeBuilder) EmitContext() *printer.EmitContext {
 func (b *NodeBuilder) enterContext(enclosingDeclaration *ast.Node, flags nodebuilder.Flags, internalFlags nodebuilder.InternalFlags, tracker nodebuilder.SymbolTracker) {
 	b.ctxStack = append(b.ctxStack, b.impl.ctx)
 	b.impl.ctx = &NodeBuilderContext{
+		host:                     b.host,
 		tracker:                  tracker,
 		flags:                    flags,
 		internalFlags:            internalFlags,
@@ -32,14 +33,7 @@ func (b *NodeBuilder) enterContext(enclosingDeclaration *ast.Node, flags nodebui
 		enclosingSymbolTypes:     make(map[ast.SymbolId]*Type),
 		remappedSymbolReferences: make(map[ast.SymbolId]*ast.Symbol),
 	}
-	// TODO: always provide this; see https://github.com/microsoft/typescript-go/pull/1588#pullrequestreview-3125218673
-	var moduleResolverHost Host
-	if tracker != nil {
-		moduleResolverHost = tracker.GetModuleSpecifierGenerationHost()
-	} else if internalFlags&nodebuilder.InternalFlagsDoNotIncludeSymbolChain != 0 {
-		moduleResolverHost = b.basicHost
-	}
-	tracker = NewSymbolTrackerImpl(b.impl.ctx, tracker, moduleResolverHost)
+	tracker = NewSymbolTrackerImpl(b.impl.ctx, tracker)
 	b.impl.ctx.tracker = tracker
 }
 
@@ -178,7 +172,7 @@ func (b *NodeBuilder) TypeToTypeNode(typ *Type, enclosingDeclaration *ast.Node,
 
 func NewNodeBuilder(ch *Checker, e *printer.EmitContext) *NodeBuilder {
 	impl := newNodeBuilderImpl(ch, e)
-	return &NodeBuilder{impl: impl, ctxStack: make([]*NodeBuilderContext, 0, 1), basicHost: ch.program}
+	return &NodeBuilder{impl: impl, ctxStack: make([]*NodeBuilderContext, 0, 1), host: ch.program}
 }
 
 func (c *Checker) getNodeBuilder() *NodeBuilder {

internal/checker/nodebuilderimpl.go

@@ -53,6 +53,7 @@ type NodeBuilderSymbolLinks struct {
 	specifierCache module.ModeAwareCache[string]
 }
 type NodeBuilderContext struct {
+	host                            Host
 	tracker                         nodebuilder.SymbolTracker
 	approximateLength               int
 	encounteredError                bool
@@ -1155,7 +1156,7 @@ func (b *nodeBuilderImpl) getSpecifierForModuleSymbol(symbol *ast.Symbol, overri
 			return stringutil.StripQuotes(symbol.Name)
 		}
 	}
-	if b.ctx.enclosingFile == nil || b.ctx.tracker.GetModuleSpecifierGenerationHost() == nil {
+	if b.ctx.enclosingFile == nil {
 		if isAmbientModuleSymbolName(symbol.Name) {
 			return stringutil.StripQuotes(symbol.Name)
 		}
@@ -1188,7 +1189,7 @@ func (b *nodeBuilderImpl) getSpecifierForModuleSymbol(symbol *ast.Symbol, overri
 	// just like how the declaration emitter does for the ambient module declarations - we can easily accomplish this
 	// using the `baseUrl` compiler option (which we would otherwise never use in declaration emit) and a non-relative
 	// specifier preference
-	host := b.ctx.tracker.GetModuleSpecifierGenerationHost()
+	host := b.ctx.host
 	specifierCompilerOptions := b.ch.compilerOptions
 	specifierPref := modulespecifiers.ImportModuleSpecifierPreferenceProjectRelative
 	endingPref := modulespecifiers.ImportModuleSpecifierEndingPreferenceNone

internal/checker/symboltracker.go

@@ -2,18 +2,16 @@ package checker
 
 import (
 	"github.com/microsoft/typescript-go/internal/ast"
-	"github.com/microsoft/typescript-go/internal/modulespecifiers"
 	"github.com/microsoft/typescript-go/internal/nodebuilder"
 )
 
 type SymbolTrackerImpl struct {
 	context            *NodeBuilderContext
 	inner              nodebuilder.SymbolTracker
 	DisableTrackSymbol bool
-	tchost             Host
 }
 
-func NewSymbolTrackerImpl(context *NodeBuilderContext, tracker nodebuilder.SymbolTracker, tchost Host) *SymbolTrackerImpl {
+func NewSymbolTrackerImpl(context *NodeBuilderContext, tracker nodebuilder.SymbolTracker) *SymbolTrackerImpl {
 	if tracker != nil {
 		for {
 			t, ok := tracker.(*SymbolTrackerImpl)
@@ -24,14 +22,7 @@ func NewSymbolTrackerImpl(context *NodeBuilderContext, tracker nodebuilder.Symbo
 		}
 	}
 
-	return &SymbolTrackerImpl{context, tracker, false, tchost}
-}
-
-func (this *SymbolTrackerImpl) GetModuleSpecifierGenerationHost() modulespecifiers.ModuleSpecifierGenerationHost {
-	if this.inner == nil {
-		return this.tchost
-	}
-	return this.inner.GetModuleSpecifierGenerationHost()
+	return &SymbolTrackerImpl{context, tracker, false}
 }
 
 func (this *SymbolTrackerImpl) TrackSymbol(symbol *ast.Symbol, enclosingDeclaration *ast.Node, meaning ast.SymbolFlags) bool {

internal/fourslash/_scripts/manualTests.txt

@@ -2,3 +2,5 @@ completionListInClosedFunction05
 completionsAtIncompleteObjectLiteralProperty
 completionsSelfDeclaring1
 completionsWithDeprecatedTag4
+moduleReexportedIntoGlobalQuickInfo
+quickInfoImportNonunicodePath

internal/fourslash/tests/gen/moduleReexportedIntoGlobalQuickInfo_test.go renamed to internal/fourslash/tests/manual/moduleReexportedIntoGlobalQuickInfo_test.go

@@ -23,5 +23,5 @@ declare global {
 // @Filename: /index.ts
 let v = new /*1*/THREE.Vector3();`
 	f := fourslash.NewFourslash(t, nil /*capabilities*/, content)
-	f.VerifyQuickInfoAt(t, "1", "const THREE: typeof import(\"/node_modules/@types/three/index\")", "")
+	f.VerifyQuickInfoAt(t, "1", "const THREE: typeof import(\"three\")", "")
 }

internal/fourslash/tests/gen/quickInfoImportNonunicodePath_test.go renamed to internal/fourslash/tests/manual/quickInfoImportNonunicodePath_test.go

@@ -16,5 +16,5 @@ export const foo = 1;
 // @Filename: /test.ts
 import { foo } from "./江南/*1*/今何在/tmp";`
 	f := fourslash.NewFourslash(t, nil /*capabilities*/, content)
-	f.VerifyQuickInfoAt(t, "1", "module \"/江南今何在/tmp\"", "")
+	f.VerifyQuickInfoAt(t, "1", "module \"./江南今何在/tmp\"", "")
 }

internal/nodebuilder/types.go

@@ -3,13 +3,10 @@ package nodebuilder
 
 import (
 	"github.com/microsoft/typescript-go/internal/ast"
-	"github.com/microsoft/typescript-go/internal/modulespecifiers"
 )
 
 // TODO: previously all symboltracker methods were optional, but now they're required.
 type SymbolTracker interface {
-	GetModuleSpecifierGenerationHost() modulespecifiers.ModuleSpecifierGenerationHost
-
 	TrackSymbol(symbol *ast.Symbol, enclosingDeclaration *ast.Node, meaning ast.SymbolFlags) bool
 	ReportInaccessibleThisError()
 	ReportPrivateInBaseOfClassExpression(propertyName string)

internal/transformers/declarations/tracker.go

@@ -5,7 +5,6 @@ import (
 	"github.com/microsoft/typescript-go/internal/checker"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/diagnostics"
-	"github.com/microsoft/typescript-go/internal/modulespecifiers"
 	"github.com/microsoft/typescript-go/internal/printer"
 	"github.com/microsoft/typescript-go/internal/scanner"
 )
@@ -17,11 +16,6 @@ type SymbolTrackerImpl struct {
 	fallbackStack []*ast.Node
 }
 
-// GetModuleSpecifierGenerationHost implements checker.SymbolTracker.
-func (s *SymbolTrackerImpl) GetModuleSpecifierGenerationHost() modulespecifiers.ModuleSpecifierGenerationHost {
-	return s.host
-}
-
 // PopErrorFallbackNode implements checker.SymbolTracker.
 func (s *SymbolTrackerImpl) PopErrorFallbackNode() {
 	s.fallbackStack = s.fallbackStack[:len(s.fallbackStack)-1]

testdata/baselines/reference/compiler/declarationEmitAugmentationUsesCorrectSourceFile.types

@@ -27,12 +27,12 @@ declare namespace Knex {
 }
 
 export = knex;
->knex : typeof import("index.ts")
+>knex : typeof import("knex")
 
 === index.ts ===
 import "knex";
 declare module "knex" {
->"knex" : typeof import("node_modules/knex/index")
+>"knex" : typeof import("knex")
 
   namespace Knex {
 >Knex : typeof Knex

testdata/baselines/reference/compiler/symbolLinkDeclarationEmitModuleNamesRootDir.types

@@ -17,9 +17,9 @@ import { BindingKey } from '@loopback/context';
 export const CONTROLLER_CLASS = BindingKey.create<ControllerClass>(null as any); // line in question
 >CONTROLLER_CLASS : BindingKey<ControllerClass>
 >BindingKey.create<ControllerClass>(null as any) : BindingKey<ControllerClass>
->BindingKey.create : <T extends import("/monorepo/context/index").Constructor<any>>(ctor: T) => BindingKey<T>
+>BindingKey.create : <T extends import("@loopback/context").Constructor<any>>(ctor: T) => BindingKey<T>
 >BindingKey : typeof BindingKey
->create : <T extends import("/monorepo/context/index").Constructor<any>>(ctor: T) => BindingKey<T>
+>create : <T extends import("@loopback/context").Constructor<any>>(ctor: T) => BindingKey<T>
 >null as any : any
 
 === /monorepo/context/src/value-promise.d.ts ===