Fix whitespace differentials, type arg list printback in diags, overl…

…oad printback

internal/checker/checker.go

@@ -824,6 +824,7 @@ type Checker struct {
 	markNodeAssignments                        func(*ast.Node) bool
 	emitResolver                               *emitResolver
 	emitResolverOnce                           sync.Once
+	diagnosticConstructionContext              *printer.EmitContext
 	nodeBuilder                                NodeBuilderInterface
 	_jsxNamespace                              string
 	_jsxFactoryEntity                          *ast.Node
@@ -1032,8 +1033,8 @@ func NewChecker(program Program) *Checker {
 	c.getGlobalClassAccessorDecoratorTargetType = c.getGlobalTypeResolver("ClassAccessorDecoratorTarget", 2 /*arity*/, true /*reportErrors*/)
 	c.getGlobalClassAccessorDecoratorResultType = c.getGlobalTypeResolver("ClassAccessorDecoratorResult", 2 /*arity*/, true /*reportErrors*/)
 	c.getGlobalClassFieldDecoratorContextType = c.getGlobalTypeResolver("ClassFieldDecoratorContext", 2 /*arity*/, true /*reportErrors*/)
-	diagnosticConstructionContext := printer.NewEmitContext()
-	c.nodeBuilder = NewNodeBuilderAPI(c, diagnosticConstructionContext)
+	c.diagnosticConstructionContext = printer.NewEmitContext()
+	c.nodeBuilder = NewNodeBuilderAPI(c, c.diagnosticConstructionContext)
 	c.initializeClosures()
 	c.initializeIterationResolvers()
 	c.initializeChecker()

internal/checker/nodebuilder.go

@@ -76,7 +76,7 @@ type NodeBuilderContext struct {
 	typeParameterNames                    map[TypeId]*ast.Identifier
 	typeParameterNamesByText              map[string]struct{}
 	typeParameterNamesByTextNextNameCount map[string]int
-	typeParameterSymbolList               map[int]struct{}
+	typeParameterSymbolList               map[ast.SymbolId]struct{}
 }
 
 type NodeBuilder struct {
@@ -375,8 +375,7 @@ func (b *NodeBuilder) symbolToName(symbol *ast.Symbol, meaning ast.SymbolFlags,
 }
 
 func (b *NodeBuilder) createEntityNameFromSymbolChain(chain []*ast.Symbol, index int) *ast.Node {
-	// !!! TODO: smuggle type arguments out
-	// typeParameterNodes := lookupTypeParameterNodes(chain, index, context);
+	// typeParameterNodes := b.lookupTypeParameterNodes(chain, index)
 	symbol := chain[index]
 
 	if index == 0 {
@@ -421,9 +420,12 @@ func (b *NodeBuilder) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFlags,
 		// module is root, must use `ImportTypeNode`
 		var nonRootParts *ast.Node
 		if len(chain) > 1 {
-			nonRootParts = b.createAccessFromSymbolChain(chain, len(chain)-1, 1)
+			nonRootParts = b.createAccessFromSymbolChain(chain, len(chain)-1, 1, typeArguments)
+		}
+		typeParameterNodes := typeArguments
+		if typeParameterNodes == nil {
+			typeParameterNodes = b.lookupTypeParameterNodes(chain, 0)
 		}
-		typeParameterNodes := typeArguments                                                  /*|| lookupTypeParameterNodes(chain, 0, context);*/ // !!! TODO: type argument smuggling
 		contextFile := ast.GetSourceFileOfNode(b.e.MostOriginal(b.ctx.enclosingDeclaration)) // TODO: Just use b.ctx.enclosingFile ? Or is the delayed lookup important for context moves?
 		targetFile := getSourceFileOfModule(chain[0])
 		var specifier string
@@ -497,18 +499,19 @@ func (b *NodeBuilder) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFlags,
 
 	}
 
-	entityName := b.createAccessFromSymbolChain(chain, len(chain)-1, 0)
+	entityName := b.createAccessFromSymbolChain(chain, len(chain)-1, 0, typeArguments)
 	if ast.IsIndexedAccessTypeNode(entityName) {
 		return entityName // Indexed accesses can never be `typeof`
 	}
 	if isTypeOf {
 		return b.f.NewTypeQueryNode(entityName, nil)
 	}
 	// !!! TODO: smuggle type arguments out
+	// Move type arguments from last identifier on chain to type reference
 	// const lastId = isIdentifier(entityName) ? entityName : entityName.right;
 	// const lastTypeArgs = getIdentifierTypeArguments(lastId);
 	// setIdentifierTypeArguments(lastId, /*typeArguments*/ undefined);
-	return b.f.NewTypeReferenceNode(entityName, nil)
+	return b.f.NewTypeReferenceNode(entityName, typeArguments)
 }
 
 func getTopmostIndexedAccessType(node *ast.IndexedAccessTypeNode) *ast.IndexedAccessTypeNode {
@@ -518,9 +521,12 @@ func getTopmostIndexedAccessType(node *ast.IndexedAccessTypeNode) *ast.IndexedAc
 	return node
 }
 
-func (b *NodeBuilder) createAccessFromSymbolChain(chain []*ast.Symbol, index int, stopper int) *ast.Node {
+func (b *NodeBuilder) createAccessFromSymbolChain(chain []*ast.Symbol, index int, stopper int, overrideTypeArguments *ast.NodeList) *ast.Node {
 	// !!! TODO: smuggle type arguments out
-	// const typeParameterNodes = index === (chain.length - 1) ? overrideTypeArguments : lookupTypeParameterNodes(chain, index, context);
+	typeParameterNodes := overrideTypeArguments
+	if index != (len(chain) - 1) {
+		typeParameterNodes = b.lookupTypeParameterNodes(chain, index)
+	}
 	symbol := chain[index]
 	var parent *ast.Symbol
 	if index > 0 {
@@ -557,7 +563,7 @@ func (b *NodeBuilder) createAccessFromSymbolChain(chain []*ast.Symbol, index int
 			}
 		}
 		if name != nil && ast.IsComputedPropertyName(name) && ast.IsEntityName(name.AsComputedPropertyName().Expression) {
-			lhs := b.createAccessFromSymbolChain(chain, index-1, stopper)
+			lhs := b.createAccessFromSymbolChain(chain, index-1, stopper, overrideTypeArguments)
 			if ast.IsEntityName(lhs) {
 				return b.f.NewIndexedAccessTypeNode(
 					b.f.NewParenthesizedTypeNode(b.f.NewTypeQueryNode(lhs, nil)),
@@ -573,15 +579,15 @@ func (b *NodeBuilder) createAccessFromSymbolChain(chain []*ast.Symbol, index int
 		b.ch.getMembersOfSymbol(parent) != nil && b.ch.getMembersOfSymbol(parent)[symbol.Name] != nil &&
 		b.ch.getSymbolIfSameReference(b.ch.getMembersOfSymbol(parent)[symbol.Name], symbol) != nil {
 		// Should use an indexed access
-		lhs := b.createAccessFromSymbolChain(chain, index-1, stopper)
+		lhs := b.createAccessFromSymbolChain(chain, index-1, stopper, overrideTypeArguments)
 		if ast.IsIndexedAccessTypeNode(lhs) {
 			return b.f.NewIndexedAccessTypeNode(
 				lhs,
 				b.f.NewLiteralTypeNode(b.f.NewStringLiteral(symbolName)),
 			)
 		}
 		return b.f.NewIndexedAccessTypeNode(
-			b.f.NewTypeReferenceNode(lhs /*!!! todo: type args*/, nil),
+			b.f.NewTypeReferenceNode(lhs, typeParameterNodes),
 			b.f.NewLiteralTypeNode(b.f.NewStringLiteral(symbolName)),
 		)
 	}
@@ -593,7 +599,7 @@ func (b *NodeBuilder) createAccessFromSymbolChain(chain []*ast.Symbol, index int
 	// identifier.symbol = symbol;
 
 	if index > stopper {
-		lhs := b.createAccessFromSymbolChain(chain, index-1, stopper)
+		lhs := b.createAccessFromSymbolChain(chain, index-1, stopper, overrideTypeArguments)
 		if !ast.IsEntityName(lhs) {
 			panic("Impossible construct - an export of an indexed access cannot be reachable")
 		}
@@ -609,7 +615,6 @@ func (b *NodeBuilder) symbolToExpression(symbol *ast.Symbol, mask ast.SymbolFlag
 }
 
 func (b *NodeBuilder) createExpressionFromSymbolChain(chain []*ast.Symbol, index int) *ast.Expression {
-	// !!! TODO: smuggle type arguments out
 	// typeParameterNodes := b.lookupTypeParameterNodes(chain, index)
 	symbol := chain[index]
 
@@ -801,8 +806,54 @@ func (b *NodeBuilder) getNameOfSymbolAsWritten(symbol *ast.Symbol) string {
 	return symbol.Name
 }
 
+// The full set of type parameters for a generic class or interface type consists of its outer type parameters plus
+// its locally declared type parameters.
+func (b *NodeBuilder) getTypeParametersOfClassOrInterface(symbol *ast.Symbol) []*Type {
+	result := make([]*Type, 0)
+	result = append(result, b.ch.getOuterTypeParametersOfClassOrInterface(symbol)...)
+	result = append(result, b.ch.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)...)
+	return result
+}
+
 func (b *NodeBuilder) lookupTypeParameterNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList {
-	return nil // !!! TODO: nested reference type parameter synthesis
+	// Debug.assert(chain && 0 <= index && index < chain.length); // !!!
+	symbol := chain[index]
+	symbolId := ast.GetSymbolId(symbol)
+	if !b.ctx.hasCreatedTypeParameterSymbolList {
+		b.ctx.hasCreatedTypeParameterSymbolList = true
+		b.ctx.typeParameterSymbolList = make(map[ast.SymbolId]struct{})
+	}
+	_, ok := b.ctx.typeParameterSymbolList[symbolId]
+	if ok {
+		return nil
+	}
+	b.ctx.typeParameterSymbolList[symbolId] = struct{}{}
+
+	if b.ctx.flags&nodebuilder.FlagsWriteTypeParametersInQualifiedName != 0 && index < (len(chain)-1) {
+		parentSymbol := symbol
+		nextSymbol := chain[index+1]
+
+		if nextSymbol.CheckFlags&ast.CheckFlagsInstantiated != 0 {
+			targetSymbol := parentSymbol
+			if parentSymbol.Flags&ast.SymbolFlagsAlias != 0 {
+				targetSymbol = b.ch.resolveAlias(parentSymbol)
+			}
+			params := b.getTypeParametersOfClassOrInterface(targetSymbol)
+			targetMapper := b.ch.valueSymbolLinks.Get(nextSymbol).mapper
+			if targetMapper != nil {
+				params = core.Map(params, targetMapper.Map)
+			}
+			return b.mapToTypeNodes(params)
+		} else {
+			typeParameterNodes := b.typeParametersToTypeParameterDeclarations(symbol)
+			if len(typeParameterNodes) > 0 {
+				return b.f.NewNodeList(typeParameterNodes)
+			}
+			return nil
+		}
+	}
+
+	return nil
 }
 
 // TODO: move `lookupSymbolChain` and co to `symbolaccessibility.go` (but getSpecifierForModuleSymbol uses much context which makes that hard?)
@@ -2203,7 +2254,7 @@ func (b *NodeBuilder) createTypeNodeFromObjectType(t *Type) *ast.TypeNode {
 	abstractSignatures := core.Filter(ctorSigs, func(signature *Signature) bool {
 		return signature.flags&SignatureFlagsAbstract != 0
 	})
-	if len(callSigs) > 0 {
+	if len(abstractSignatures) > 0 {
 		types := core.Map(abstractSignatures, func(s *Signature) *Type {
 			return b.ch.getOrCreateTypeFromSignature(s, nil)
 		})

internal/checker/printer.go

@@ -12,22 +12,22 @@ import (
 )
 
 // TODO: Memoize once per checker to retain threadsafety
-func createPrinterWithDefaults() *printer.Printer {
-	return printer.NewPrinter(printer.PrinterOptions{}, printer.PrintHandlers{}, nil)
+func createPrinterWithDefaults(emitContext *printer.EmitContext) *printer.Printer {
+	return printer.NewPrinter(printer.PrinterOptions{}, printer.PrintHandlers{}, emitContext)
 }
 
-func createPrinterWithRemoveComments() *printer.Printer {
-	return printer.NewPrinter(printer.PrinterOptions{RemoveComments: true}, printer.PrintHandlers{}, nil)
+func createPrinterWithRemoveComments(emitContext *printer.EmitContext) *printer.Printer {
+	return printer.NewPrinter(printer.PrinterOptions{RemoveComments: true}, printer.PrintHandlers{}, emitContext)
 }
 
-func createPrinterWithRemoveCommentsOmitTrailingSemicolon() *printer.Printer {
+func createPrinterWithRemoveCommentsOmitTrailingSemicolon(emitContext *printer.EmitContext) *printer.Printer {
 	// TODO: OmitTrailingSemicolon support
-	return printer.NewPrinter(printer.PrinterOptions{RemoveComments: true}, printer.PrintHandlers{}, nil)
+	return printer.NewPrinter(printer.PrinterOptions{RemoveComments: true}, printer.PrintHandlers{}, emitContext)
 }
 
-func createPrinterWithRemoveCommentsNeverAsciiEscape() *printer.Printer {
+func createPrinterWithRemoveCommentsNeverAsciiEscape(emitContext *printer.EmitContext) *printer.Printer {
 	// TODO: NeverAsciiEscape support
-	return printer.NewPrinter(printer.PrinterOptions{RemoveComments: true}, printer.PrintHandlers{}, nil)
+	return printer.NewPrinter(printer.PrinterOptions{RemoveComments: true}, printer.PrintHandlers{}, emitContext)
 }
 
 func getTrailingSemicolonDeferringWriter(writer printer.EmitTextWriter) printer.EmitTextWriter {
@@ -60,9 +60,9 @@ func (c *Checker) typeToStringEx(type_ *Type, enclosingDeclaration *ast.Node, fl
 	// Otherwise, we always strip comments out.
 	var printer *printer.Printer
 	if type_ == c.unresolvedType {
-		printer = createPrinterWithDefaults()
+		printer = createPrinterWithDefaults(c.diagnosticConstructionContext)
 	} else {
-		printer = createPrinterWithRemoveComments()
+		printer = createPrinterWithRemoveComments(c.diagnosticConstructionContext)
 	}
 	var sourceFile *ast.SourceFile
 	if enclosingDeclaration != nil {
@@ -126,9 +126,9 @@ func (c *Checker) symbolToStringEx(symbol *ast.Symbol, enclosingDeclaration *ast
 	}
 	var printer_ *printer.Printer
 	if enclosingDeclaration != nil && enclosingDeclaration.Kind == ast.KindSourceFile {
-		printer_ = createPrinterWithRemoveCommentsNeverAsciiEscape()
+		printer_ = createPrinterWithRemoveCommentsNeverAsciiEscape(c.diagnosticConstructionContext)
 	} else {
-		printer_ = createPrinterWithRemoveComments()
+		printer_ = createPrinterWithRemoveComments(c.diagnosticConstructionContext)
 	}
 
 	var builder func(symbol *ast.Symbol, meaning ast.SymbolFlags, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, internalFlags nodebuilder.InternalFlags, tracker nodebuilder.SymbolTracker) *ast.Node
@@ -166,7 +166,7 @@ func (c *Checker) signatureToStringEx(signature *Signature, enclosingDeclaration
 	}
 	combinedFlags := toNodeBuilderFlags(flags) | nodebuilder.FlagsIgnoreErrors | nodebuilder.FlagsWriteTypeParametersInQualifiedName
 	sig := c.nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, combinedFlags, nodebuilder.InternalFlagsNone, nil)
-	printer_ := createPrinterWithRemoveCommentsOmitTrailingSemicolon()
+	printer_ := createPrinterWithRemoveCommentsOmitTrailingSemicolon(c.diagnosticConstructionContext)
 	var sourceFile *ast.SourceFile
 	if enclosingDeclaration != nil {
 		sourceFile = ast.GetSourceFileOfNode(enclosingDeclaration)
@@ -193,7 +193,7 @@ func (c *Checker) typePredicateToStringEx(typePredicate *TypePredicate, enclosin
 	}
 	combinedFlags := toNodeBuilderFlags(flags) | nodebuilder.FlagsIgnoreErrors | nodebuilder.FlagsWriteTypeParametersInQualifiedName
 	predicate := c.nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, combinedFlags, nodebuilder.InternalFlagsNone, nil) // TODO: GH#18217
-	printer_ := createPrinterWithRemoveComments()
+	printer_ := createPrinterWithRemoveComments(c.diagnosticConstructionContext)
 	var sourceFile *ast.SourceFile
 	if enclosingDeclaration != nil {
 		sourceFile = ast.GetSourceFileOfNode(enclosingDeclaration)