Extract node type printer

src/compiler/diagnosticMessages.json

@@ -6979,7 +6979,7 @@
         "category": "Error",
         "code": 9008
     },
-    "At least one accessor must have an explicit return type annotation with --isolatedDeclarations.": {
+    "At least one accessor must have an explicit type annotation with --isolatedDeclarations.": {
         "category": "Error",
         "code": 9009
     },

src/compiler/factory/utilities.ts

@@ -1668,7 +1668,7 @@ export function createAccessorPropertySetRedirector(factory: NodeFactory, node:
 }
 
 /** @internal */
-export function findComputedPropertyNameCacheAssignment(name: ComputedPropertyName) {
+export function findComputedPropertyNameCacheAssignment(name: ComputedPropertyName): AssignmentExpression<EqualsToken> & { readonly left: GeneratedIdentifier; } | undefined {
     let node = name.expression;
     while (true) {
         node = skipOuterExpressions(node);

src/compiler/transformers/declarations/diagnostics.ts

@@ -625,8 +625,8 @@ export function createGetIsolatedDeclarationErrors(resolver: EmitResolver): (nod
         [SyntaxKind.ArrowFunction]: Diagnostics.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
         [SyntaxKind.MethodDeclaration]: Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
         [SyntaxKind.ConstructSignature]: Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
-        [SyntaxKind.GetAccessor]: Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
-        [SyntaxKind.SetAccessor]: Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
+        [SyntaxKind.GetAccessor]: Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
+        [SyntaxKind.SetAccessor]: Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
         [SyntaxKind.Parameter]: Diagnostics.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
         [SyntaxKind.VariableDeclaration]: Diagnostics.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
         [SyntaxKind.PropertyDeclaration]: Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations,

src/compiler/types.ts

@@ -5845,7 +5845,7 @@ export interface EmitResolver {
     requiresAddingImplicitUndefined(node: ParameterDeclaration, enclosingDeclaration: Node | undefined): boolean;
     isExpandoFunctionDeclaration(node: FunctionDeclaration | VariableDeclaration): boolean;
     getPropertiesOfContainerFunction(node: Declaration): Symbol[];
-    createTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression | ElementAccessExpression | BinaryExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
+    createTypeOfDeclaration(declaration: HasInferredType, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
     createReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
     createTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
     createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker): Expression;
@@ -10493,37 +10493,65 @@ export interface EvaluationResolver {
 
 /** @internal */
 export type HasInferredType =
-    | PropertyAssignment
+    | Exclude<VariableLikeDeclaration, JsxAttribute | EnumMember>
     | PropertyAccessExpression
-    | BinaryExpression
     | ElementAccessExpression
-    | VariableDeclaration
-    | ParameterDeclaration
-    | BindingElement
-    | PropertyDeclaration
-    | PropertySignature
+    | BinaryExpression
     | ExportAssignment;
 
 /** @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, enclosingDeclaration: Node | undefined): boolean;
+    requiresAddingImplicitUndefined(declaration: ParameterDeclaration | PropertySignature | JSDocParameterTag | JSDocPropertyTag | PropertyDeclaration, symbol: Symbol | undefined, enclosingDeclaration: Node | undefined): 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 | GetAccessorDeclaration | SetAccessorDeclaration, symbol: Symbol | undefined): 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;
+    canReuseTypeNodeAnnotation(context: SyntacticTypeNodeBuilderContext, node: Declaration, existing: TypeNode, symbol: Symbol | undefined, requiresAddingUndefined?: boolean): 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 interface SyntacticNodeBuilder {
-    typeFromExpression: (node: Expression, context: SyntacticTypeNodeBuilderContext, isConstContext?: boolean, requiresAddingUndefined?: boolean, preserveLiterals?: boolean) => boolean | undefined;
-    serializeTypeOfDeclaration: (node: HasInferredType, context: SyntacticTypeNodeBuilderContext) => boolean | undefined;
-    serializeReturnTypeForSignature: (node: SignatureDeclaration | JSDocSignature, context: SyntacticTypeNodeBuilderContext) => boolean | undefined;
-    serializeTypeOfExpression: (expr: Expression, context: SyntacticTypeNodeBuilderContext, addUndefined?: boolean, preserveLiterals?: boolean) => boolean;
+    serializeTypeOfDeclaration: (node: HasInferredType, symbol: Symbol, context: SyntacticTypeNodeBuilderContext) => TypeNode | undefined;
+    serializeReturnTypeForSignature: (signature: SignatureDeclaration | JSDocSignature, symbol: Symbol, context: SyntacticTypeNodeBuilderContext) => TypeNode | undefined;
+    serializeTypeOfExpression: (expr: Expression | JsxAttributeValue, context: SyntacticTypeNodeBuilderContext, addUndefined?: boolean, preserveLiterals?: boolean) => TypeNode;
+    tryReuseExistingTypeNode: (context: SyntacticTypeNodeBuilderContext, existing: TypeNode) => TypeNode | undefined;
+    serializeTypeOfAccessor: (accessor: AccessorDeclaration, symbol: Symbol, context: SyntacticTypeNodeBuilderContext) => TypeNode | undefined;
 }
+
+/** @internal */
+export type IntroducesNewScopeNode = SignatureDeclaration | JSDocSignature | MappedTypeNode;

src/compiler/utilities.ts

@@ -246,6 +246,7 @@ import {
     InterfaceDeclaration,
     InternalEmitFlags,
     InternalSymbolName,
+    IntroducesNewScopeNode,
     isAccessor,
     isAnyDirectorySeparator,
     isArray,
@@ -321,6 +322,7 @@ import {
     isLeftHandSideExpression,
     isLineBreak,
     isLiteralTypeNode,
+    isMappedTypeNode,
     isMemberName,
     isMetaProperty,
     isMethodDeclaration,
@@ -2853,11 +2855,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): boolean {
     return node.parent.kind === SyntaxKind.VariableDeclarationList
@@ -11846,6 +11843,9 @@ 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);
@@ -11938,3 +11938,9 @@ export const nodeCoreModules: Set<string> = new Set([
     ...unprefixedNodeCoreModulesList.map(name => `node:${name}`),
     ...exclusivelyPrefixedNodeCoreModules,
 ]);
+/** @internal */
+export function isNewScopeNode(node: Node): node is IntroducesNewScopeNode {
+    return isFunctionLike(node)
+        || isJSDocSignature(node)
+        || isMappedTypeNode(node);
+}

src/services/codefixes/fixMissingTypeAnnotationOnExports.ts

@@ -119,7 +119,7 @@ const extractExpression = "extract-expression";
 const errorCodes = [
     Diagnostics.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code,
     Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code,
-    Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code,
+    Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code,
     Diagnostics.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code,
     Diagnostics.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code,
     Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code,

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/circularAccessorAnnotations.types

@@ -2,23 +2,23 @@
 
 === circularAccessorAnnotations.ts ===
 declare const c1: {
->c1 : { readonly foo: any; }
->   : ^^^^^^^^^^^^^^^^^^^^^^
+>c1 : { readonly foo: typeof c1.foo; }
+>   : ^^^^^^^^^^^^^^^^             ^^^
 
     get foo(): typeof c1.foo;
 >foo : any
 >    : ^^^
 >c1.foo : any
 >       : ^^^
->c1 : { readonly foo: any; }
->   : ^^^^^^^^^^^^^^^^^^^^^^
+>c1 : { readonly foo: typeof c1.foo; }
+>   : ^^^^^^^^^^^^^^^^             ^^^
 >foo : any
 >    : ^^^
 }
 
 declare const c2: {
->c2 : { foo: any; }
->   : ^^^^^^^^^^^^^
+>c2 : { foo: typeof c2.foo; }
+>   : ^^^^^^^             ^^^
 
     set foo(value: typeof c2.foo);
 >foo : any
@@ -27,15 +27,15 @@ declare const c2: {
 >      : ^^^
 >c2.foo : any
 >       : ^^^
->c2 : { foo: any; }
->   : ^^^^^^^^^^^^^
+>c2 : { foo: typeof c2.foo; }
+>   : ^^^^^^^             ^^^
 >foo : any
 >    : ^^^
 }
 
 declare const c3: {
 >c3 : { foo: string; }
->   : ^^^^^^^^^^^^^^^^
+>   : ^^^^^^^      ^^^
 
     get foo(): string;
 >foo : string
@@ -49,7 +49,7 @@ declare const c3: {
 >c3.foo : string
 >       : ^^^^^^
 >c3 : { foo: string; }
->   : ^^^^^^^^^^^^^^^^
+>   : ^^^^^^^      ^^^
 >foo : string
 >    : ^^^^^^
 }

tests/baselines/reference/circularObjectLiteralAccessors.types

@@ -5,15 +5,15 @@
 
 const a = {
 >a : { b: { foo: string; }; foo: string; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^
 >{    b: {        get foo(): string {            return a.foo;        },        set foo(value: string) {            a.foo = value;        }    },    foo: ''} : { b: { foo: string; }; foo: string; }
->                                                                                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                                                                                             : ^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^
 
     b: {
 >b : { foo: string; }
->  : ^^^^^^^^^^^^^^^^
+>  : ^^^^^^^      ^^^
 >{        get foo(): string {            return a.foo;        },        set foo(value: string) {            a.foo = value;        }    } : { foo: string; }
->                                                                                                                                        : ^^^^^^^^^^^^^^^^
+>                                                                                                                                        : ^^^^^^^      ^^^
 
         get foo(): string {
 >foo : string
@@ -23,7 +23,7 @@ const a = {
 >a.foo : string
 >      : ^^^^^^
 >a : { b: { foo: string; }; foo: string; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^
 >foo : string
 >    : ^^^^^^
 
@@ -40,7 +40,7 @@ const a = {
 >a.foo : string
 >      : ^^^^^^
 >a : { b: { foo: string; }; foo: string; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^
 >foo : string
 >    : ^^^^^^
 >value : string

tests/baselines/reference/collisionArgumentsArrowFunctions.types

@@ -3,9 +3,9 @@
 === collisionArgumentsArrowFunctions.ts ===
 var f1 = (i: number, ...arguments) => { //arguments is error
 >f1 : (i: number, ...arguments: any[]) => void
->   : ^ ^^      ^^^^^         ^^     ^^^^^^^^^
+>   : ^ ^^      ^^^^^         ^^^^^^^^^^^^^^^^
 >(i: number, ...arguments) => { //arguments is error    var arguments: any[]; // no error} : (i: number, ...arguments: any[]) => void
->                                                                                          : ^ ^^      ^^^^^         ^^     ^^^^^^^^^
+>                                                                                          : ^ ^^      ^^^^^         ^^^^^^^^^^^^^^^^
 >i : number
 >  : ^^^^^^
 >arguments : any[]

tests/baselines/reference/collisionArgumentsClassMethod.types

@@ -7,7 +7,7 @@ class c1 {
 
     public foo(i: number, ...arguments) { //arguments is error
 >foo : (i: number, ...arguments: any[]) => void
->    : ^ ^^      ^^^^^         ^^     ^^^^^^^^^
+>    : ^ ^^      ^^^^^         ^^^^^^^^^^^^^^^^
 >i : number
 >  : ^^^^^^
 >arguments : any[]

tests/baselines/reference/collisionArgumentsFunction.types

@@ -18,7 +18,7 @@ function f1(arguments: number, ...restParameters) { //arguments is error
 }
 function f12(i: number, ...arguments) { //arguments is error
 >f12 : (i: number, ...arguments: any[]) => void
->    : ^ ^^      ^^^^^         ^^     ^^^^^^^^^
+>    : ^ ^^      ^^^^^         ^^^^^^^^^^^^^^^^
 >i : number
 >  : ^^^^^^
 >arguments : any[]

tests/baselines/reference/collisionArgumentsFunctionExpressions.types

@@ -21,7 +21,7 @@ function foo() {
     }
     function f12(i: number, ...arguments) { //arguments is error
 >f12 : (i: number, ...arguments: any[]) => void
->    : ^ ^^      ^^^^^         ^^     ^^^^^^^^^
+>    : ^ ^^      ^^^^^         ^^^^^^^^^^^^^^^^
 >i : number
 >  : ^^^^^^
 >arguments : any[]

tests/baselines/reference/commentsOnObjectLiteral4.types

@@ -3,9 +3,9 @@
 === commentsOnObjectLiteral4.ts ===
 var v = {
 >v : { readonly bar: number; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^^^^^^^      ^^^
 >{ /**  * @type {number}  */ get bar(): number {  return 12; }} : { readonly bar: number; }
->                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                               : ^^^^^^^^^^^^^^^^      ^^^
 
  /**
   * @type {number}