Extract node type printer

src/compiler/types.ts

@@ -5379,7 +5379,6 @@ export const enum NodeBuilderFlags {
     AllowUniqueESSymbolType                 = 1 << 20,
     AllowEmptyIndexInfoType                 = 1 << 21,
     /** @internal */ WriteComputedProps      = 1 << 30, // { [E.A]: 1 }
-    /** @internal */ NoSyntacticPrinter     = 1 << 31,
     // Errors (cont.)
     AllowNodeModulesRelativePaths           = 1 << 26,
     /** @internal */ DoNotIncludeSymbolChain = 1 << 27,    // Skip looking up and printing an accessible symbol chain
@@ -5726,9 +5725,9 @@ export interface EmitResolver {
     requiresAddingImplicitUndefined(node: ParameterDeclaration): boolean;
     isExpandoFunctionDeclaration(node: FunctionDeclaration | VariableDeclaration): boolean;
     getPropertiesOfContainerFunction(node: Declaration): Symbol[];
-    createTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression | ElementAccessExpression | BinaryExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
+    createTypeOfDeclaration(declaration: HasInferredType, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
     createReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
-    createTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
+    createTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker, addUndefined?: boolean): TypeNode | undefined;
     createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker): Expression;
     isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags | undefined, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
     isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
@@ -10252,6 +10251,7 @@ export interface EvaluationResolver {
 /** @internal */
 export type HasInferredType =
     | PropertyAssignment
+    | ShorthandPropertyAssignment
     | PropertyAccessExpression
     | BinaryExpression
     | ElementAccessExpression
@@ -10260,20 +10260,53 @@ export type HasInferredType =
     | BindingElement
     | PropertyDeclaration
     | PropertySignature
-    | ExportAssignment;
+    | ExportAssignment
+    | JSDocPropertyTag
+    | JSDocParameterTag;
 
 /** @internal */
 export interface SyntacticTypeNodeBuilderContext {
+    flags: NodeBuilderFlags;
     tracker: Required<Pick<SymbolTracker, "reportInferenceFallback">>;
+    enclosingFile: SourceFile | undefined;
     enclosingDeclaration: Node | undefined;
+    approximateLength: number;
+    noInferenceFallback?: boolean;
 }
 
 /** @internal */
 export interface SyntacticTypeNodeBuilderResolver {
+    isOptionalParameter(p: ParameterDeclaration): boolean;
     isUndefinedIdentifierExpression(name: Identifier): boolean;
     isExpandoFunctionDeclaration(name: FunctionDeclaration | VariableDeclaration): boolean;
     getAllAccessorDeclarations(declaration: AccessorDeclaration): AllAccessorDeclarations;
-    isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node, shouldComputeAliasToMakeVisible?: boolean): SymbolVisibilityResult;
     requiresAddingImplicitUndefined(parameter: ParameterDeclaration | JSDocParameterTag): boolean;
     isDefinitelyReferenceToGlobalSymbolObject(node: Node): boolean;
-}
+    isEntityNameVisible(context: SyntacticTypeNodeBuilderContext, entityName: EntityNameOrEntityNameExpression, shouldComputeAliasToMakeVisible?: boolean): SymbolVisibilityResult;
+    serializeExistingTypeNode(context: SyntacticTypeNodeBuilderContext, node: TypeNode, addUndefined?: boolean): TypeNode | undefined;
+    serializeReturnTypeForSignature(context: SyntacticTypeNodeBuilderContext, signatureDeclaration: SignatureDeclaration | JSDocSignature): TypeNode | undefined;
+    serializeTypeOfExpression(context: SyntacticTypeNodeBuilderContext, expr: Expression): TypeNode;
+    serializeTypeOfDeclaration(context: SyntacticTypeNodeBuilderContext, node: HasInferredType): TypeNode | undefined;
+    serializeNameOfParameter(context: SyntacticTypeNodeBuilderContext, parameter: ParameterDeclaration): BindingName | string;
+    serializeTypeName(context: SyntacticTypeNodeBuilderContext, node: EntityName, isTypeOf?: boolean, typeArguments?: readonly TypeNode[]): TypeNode | undefined;
+    serializeEntityName(context: SyntacticTypeNodeBuilderContext, node: EntityNameExpression): Expression | undefined;
+    getJsDocPropertyOverride(context: SyntacticTypeNodeBuilderContext, jsDocTypeLiteral: JSDocTypeLiteral, jsDocProperty: JSDocPropertyLikeTag): TypeNode | undefined;
+    enterNewScope(context: SyntacticTypeNodeBuilderContext, node: IntroducesNewScopeNode | ConditionalTypeNode): () => void;
+    markNodeReuse<T extends Node>(context: SyntacticTypeNodeBuilderContext, range: T, location: Node | undefined): T;
+    trackExistingEntityName<T extends EntityNameOrEntityNameExpression>(context: SyntacticTypeNodeBuilderContext, node: T): { introducesError: boolean; node: T; };
+    trackComputedName(context: SyntacticTypeNodeBuilderContext, accessExpression: EntityNameOrEntityNameExpression): void;
+    evaluateEntityNameExpression(expression: EntityNameExpression): EvaluatorResult;
+    getModuleSpecifierOverride(context: SyntacticTypeNodeBuilderContext, parent: ImportTypeNode, lit: StringLiteral): string | undefined;
+    canReuseTypeNode(context: SyntacticTypeNodeBuilderContext, existing: TypeNode): boolean;
+    shouldRemoveDeclaration(context: SyntacticTypeNodeBuilderContext, node: DynamicNamedDeclaration): boolean;
+    hasLateBindableName(node: Declaration): node is LateBoundDeclaration | LateBoundBinaryExpressionDeclaration;
+    createRecoveryBoundary(context: SyntacticTypeNodeBuilderContext): {
+        startRecoveryScope(): () => void;
+        finalizeBoundary(): boolean;
+        markError(): void;
+        hadError(): boolean;
+    };
+}
+
+/** @internal */
+export type IntroducesNewScopeNode = SignatureDeclaration | JSDocSignature | MappedTypeNode;

src/compiler/utilities.ts

@@ -242,6 +242,7 @@ import {
     InterfaceDeclaration,
     InternalEmitFlags,
     InternalSymbolName,
+    IntroducesNewScopeNode,
     isAccessor,
     isAnyDirectorySeparator,
     isArray,
@@ -315,6 +316,7 @@ import {
     isLeftHandSideExpression,
     isLineBreak,
     isLiteralTypeNode,
+    isMappedTypeNode,
     isMemberName,
     isMetaProperty,
     isMethodDeclaration,
@@ -2804,11 +2806,6 @@ export function isVariableLike(node: Node): node is VariableLikeDeclaration {
     return false;
 }
 
-/** @internal */
-export function isVariableLikeOrAccessor(node: Node): node is AccessorDeclaration | VariableLikeDeclaration {
-    return isVariableLike(node) || isAccessor(node);
-}
-
 /** @internal */
 export function isVariableDeclarationInVariableStatement(node: VariableDeclaration) {
     return node.parent.kind === SyntaxKind.VariableDeclarationList
@@ -11680,9 +11677,18 @@ export function hasInferredType(node: Node): node is HasInferredType {
         case SyntaxKind.VariableDeclaration:
         case SyntaxKind.ExportAssignment:
         case SyntaxKind.PropertyAssignment:
+        case SyntaxKind.ShorthandPropertyAssignment:
+        case SyntaxKind.JSDocParameterTag:
+        case SyntaxKind.JSDocPropertyTag:
             return true;
         default:
             assertType<never>(node);
             return false;
     }
 }
+/** @internal */
+export function isNewScopeNode(node: Node): node is IntroducesNewScopeNode {
+    return isFunctionLike(node)
+        || isJSDocSignature(node)
+        || isMappedTypeNode(node);
+}

tests/baselines/reference/ambientConstLiterals.js

@@ -74,5 +74,5 @@ declare const c9: {
 declare const c10: number[];
 declare const c11: string;
 declare const c12: number;
-declare const c13: string;
-declare const c14: number;
+declare const c13: "abc" | "def";
+declare const c14: 123 | 456;

tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.types

@@ -21,9 +21,9 @@ var a = () => <Error>{ name: "foo", message: "bar" };
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : () => Error
->  : ^^^^^^^^^^^
+>  : ^^^^^^     
 >() => (<Error>{ name: "foo", message: "bar" }) : () => Error
->                                               : ^^^^^^^^^^^
+>                                               : ^^^^^^     
 >(<Error>{ name: "foo", message: "bar" }) : Error
 >                                         : ^^^^^
 ><Error>{ name: "foo", message: "bar" } : Error
@@ -59,9 +59,9 @@ var c = () => ({ name: "foo", message: "bar" });
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : () => Error
->  : ^^^^^^^^^^^
+>  : ^^^^^^     
 >() => ((<Error>({ name: "foo", message: "bar" }))) : () => Error
->                                                   : ^^^^^^^^^^^
+>                                                   : ^^^^^^     
 >((<Error>({ name: "foo", message: "bar" }))) : Error
 >                                             : ^^^^^
 >(<Error>({ name: "foo", message: "bar" })) : Error

tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.types

@@ -21,9 +21,9 @@ var a = () => <Error>{ name: "foo", message: "bar" };
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : () => Error
->  : ^^^^^^^^^^^
+>  : ^^^^^^     
 >() => (<Error>{ name: "foo", message: "bar" }) : () => Error
->                                               : ^^^^^^^^^^^
+>                                               : ^^^^^^     
 >(<Error>{ name: "foo", message: "bar" }) : Error
 >                                         : ^^^^^
 ><Error>{ name: "foo", message: "bar" } : Error
@@ -59,9 +59,9 @@ var c = () => ({ name: "foo", message: "bar" });
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : () => Error
->  : ^^^^^^^^^^^
+>  : ^^^^^^     
 >() => ((<Error>({ name: "foo", message: "bar" }))) : () => Error
->                                                   : ^^^^^^^^^^^
+>                                                   : ^^^^^^     
 >((<Error>({ name: "foo", message: "bar" }))) : Error
 >                                             : ^^^^^
 >(<Error>({ name: "foo", message: "bar" })) : Error

tests/baselines/reference/assignmentCompatWithCallSignatures3.errors.txt

@@ -42,12 +42,12 @@ assignmentCompatWithCallSignatures3.ts(77,1): error TS2322: Type '(x: { foo: str
   Types of parameters 'y' and 'y' are incompatible.
     Type 'T' is not assignable to type '{ foo: string; bar: string; }'.
       Property 'bar' is missing in type 'Base' but required in type '{ foo: string; bar: string; }'.
-assignmentCompatWithCallSignatures3.ts(80,1): error TS2322: Type '(x: Base[], y: Derived2[]) => Derived[]' is not assignable to type '<T extends Array<Base>>(x: Base[], y: T) => Derived[]'.
+assignmentCompatWithCallSignatures3.ts(80,1): error TS2322: Type '(x: Array<Base>, y: Array<Derived2>) => Array<Derived>' is not assignable to type '<T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>'.
   Types of parameters 'y' and 'y' are incompatible.
     Type 'T' is not assignable to type 'Derived2[]'.
       Type 'Base[]' is not assignable to type 'Derived2[]'.
         Type 'Base' is missing the following properties from type 'Derived2': baz, bar
-assignmentCompatWithCallSignatures3.ts(83,1): error TS2322: Type '(x: Base[], y: Derived[]) => Derived[]' is not assignable to type '<T extends Array<Derived>>(x: Base[], y: T) => T'.
+assignmentCompatWithCallSignatures3.ts(83,1): error TS2322: Type '(x: Array<Base>, y: Array<Derived>) => Array<Derived>' is not assignable to type '<T extends Array<Derived>>(x: Array<Base>, y: T) => T'.
   Type 'Derived[]' is not assignable to type 'T'.
     'Derived[]' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Derived[]'.
 assignmentCompatWithCallSignatures3.ts(85,1): error TS2322: Type '<T>(x: { a: T; b: T; }) => T' is not assignable to type '(x: { a: string; b: number; }) => Object'.
@@ -204,7 +204,7 @@ assignmentCompatWithCallSignatures3.ts(86,1): error TS2322: Type '(x: { a: strin
     a12 = b12; // ok
     b12 = a12; // ok
     ~~~
-!!! error TS2322: Type '(x: Base[], y: Derived2[]) => Derived[]' is not assignable to type '<T extends Array<Base>>(x: Base[], y: T) => Derived[]'.
+!!! error TS2322: Type '(x: Array<Base>, y: Array<Derived2>) => Array<Derived>' is not assignable to type '<T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>'.
 !!! error TS2322:   Types of parameters 'y' and 'y' are incompatible.
 !!! error TS2322:     Type 'T' is not assignable to type 'Derived2[]'.
 !!! error TS2322:       Type 'Base[]' is not assignable to type 'Derived2[]'.
@@ -213,7 +213,7 @@ assignmentCompatWithCallSignatures3.ts(86,1): error TS2322: Type '(x: { a: strin
     a13 = b13; // ok
     b13 = a13; // ok
     ~~~
-!!! error TS2322: Type '(x: Base[], y: Derived[]) => Derived[]' is not assignable to type '<T extends Array<Derived>>(x: Base[], y: T) => T'.
+!!! error TS2322: Type '(x: Array<Base>, y: Array<Derived>) => Array<Derived>' is not assignable to type '<T extends Array<Derived>>(x: Array<Base>, y: T) => T'.
 !!! error TS2322:   Type 'Derived[]' is not assignable to type 'T'.
 !!! error TS2322:     'Derived[]' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Derived[]'.
     var b14: <T>(x: { a: T; b: T }) => T; 

tests/baselines/reference/assignmentCompatWithCallSignatures4.errors.txt

@@ -23,7 +23,7 @@ assignmentCompatWithCallSignatures4.ts(58,9): error TS2322: Type '(...x: Base[])
 assignmentCompatWithCallSignatures4.ts(62,9): error TS2322: Type '(x: { foo: string; }, y: { foo: string; bar: string; }) => Base' is not assignable to type '<T extends Derived>(x: T, y: T) => T'.
   Type 'Base' is not assignable to type 'T'.
     'T' could be instantiated with an arbitrary type which could be unrelated to 'Base'.
-assignmentCompatWithCallSignatures4.ts(66,9): error TS2322: Type '(x: Base[], y: Derived2[]) => Derived[]' is not assignable to type '<T extends Array<Derived2>>(x: Base[], y: Base[]) => T'.
+assignmentCompatWithCallSignatures4.ts(66,9): error TS2322: Type '(x: Array<Base>, y: Array<Derived2>) => Array<Derived>' is not assignable to type '<T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T'.
   Type 'Derived[]' is not assignable to type 'T'.
     'T' could be instantiated with an arbitrary type which could be unrelated to 'Derived[]'.
 assignmentCompatWithCallSignatures4.ts(69,9): error TS2322: Type '<T>(x: { a: T; b: T; }) => T' is not assignable to type '(x: { a: string; b: number; }) => number'.
@@ -163,7 +163,7 @@ assignmentCompatWithCallSignatures4.ts(96,9): error TS2322: Type '<T>(x: T) => s
             a12 = b12;
             b12 = a12;
             ~~~
-!!! error TS2322: Type '(x: Base[], y: Derived2[]) => Derived[]' is not assignable to type '<T extends Array<Derived2>>(x: Base[], y: Base[]) => T'.
+!!! error TS2322: Type '(x: Array<Base>, y: Array<Derived2>) => Array<Derived>' is not assignable to type '<T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T'.
 !!! error TS2322:   Type 'Derived[]' is not assignable to type 'T'.
 !!! error TS2322:     'T' could be instantiated with an arbitrary type which could be unrelated to 'Derived[]'.
 

tests/baselines/reference/assignmentCompatWithConstructSignatures3.errors.txt

@@ -42,12 +42,12 @@ assignmentCompatWithConstructSignatures3.ts(77,1): error TS2322: Type 'new (x: {
   Types of parameters 'y' and 'y' are incompatible.
     Type 'T' is not assignable to type '{ foo: string; bar: string; }'.
       Property 'bar' is missing in type 'Base' but required in type '{ foo: string; bar: string; }'.
-assignmentCompatWithConstructSignatures3.ts(80,1): error TS2322: Type 'new (x: Base[], y: Derived2[]) => Derived[]' is not assignable to type 'new <T extends Array<Base>>(x: Base[], y: T) => Derived[]'.
+assignmentCompatWithConstructSignatures3.ts(80,1): error TS2322: Type 'new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>' is not assignable to type 'new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>'.
   Types of parameters 'y' and 'y' are incompatible.
     Type 'T' is not assignable to type 'Derived2[]'.
       Type 'Base[]' is not assignable to type 'Derived2[]'.
         Type 'Base' is missing the following properties from type 'Derived2': baz, bar
-assignmentCompatWithConstructSignatures3.ts(83,1): error TS2322: Type 'new (x: Base[], y: Derived[]) => Derived[]' is not assignable to type 'new <T extends Array<Derived>>(x: Base[], y: T) => T'.
+assignmentCompatWithConstructSignatures3.ts(83,1): error TS2322: Type 'new (x: Array<Base>, y: Array<Derived>) => Array<Derived>' is not assignable to type 'new <T extends Array<Derived>>(x: Array<Base>, y: T) => T'.
   Type 'Derived[]' is not assignable to type 'T'.
     'Derived[]' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Derived[]'.
 assignmentCompatWithConstructSignatures3.ts(85,1): error TS2322: Type 'new <T>(x: { a: T; b: T; }) => T' is not assignable to type 'new (x: { a: string; b: number; }) => Object'.
@@ -204,7 +204,7 @@ assignmentCompatWithConstructSignatures3.ts(86,1): error TS2322: Type 'new (x: {
     a12 = b12; // ok
     b12 = a12; // ok
     ~~~
-!!! error TS2322: Type 'new (x: Base[], y: Derived2[]) => Derived[]' is not assignable to type 'new <T extends Array<Base>>(x: Base[], y: T) => Derived[]'.
+!!! error TS2322: Type 'new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>' is not assignable to type 'new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>'.
 !!! error TS2322:   Types of parameters 'y' and 'y' are incompatible.
 !!! error TS2322:     Type 'T' is not assignable to type 'Derived2[]'.
 !!! error TS2322:       Type 'Base[]' is not assignable to type 'Derived2[]'.
@@ -213,7 +213,7 @@ assignmentCompatWithConstructSignatures3.ts(86,1): error TS2322: Type 'new (x: {
     a13 = b13; // ok
     b13 = a13; // ok
     ~~~
-!!! error TS2322: Type 'new (x: Base[], y: Derived[]) => Derived[]' is not assignable to type 'new <T extends Array<Derived>>(x: Base[], y: T) => T'.
+!!! error TS2322: Type 'new (x: Array<Base>, y: Array<Derived>) => Array<Derived>' is not assignable to type 'new <T extends Array<Derived>>(x: Array<Base>, y: T) => T'.
 !!! error TS2322:   Type 'Derived[]' is not assignable to type 'T'.
 !!! error TS2322:     'Derived[]' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'Derived[]'.
     var b14: new <T>(x: { a: T; b: T }) => T;