Skip to content

Commit 82109d3

Browse files
author
Arthur Ozga
committed
cleanup
1 parent a5e93c4 commit 82109d3

File tree

1 file changed

+17
-44
lines changed

1 file changed

+17
-44
lines changed

‎src/compiler/checker.ts

Lines changed: 17 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -2229,19 +2229,7 @@ namespace ts {
22292229

22302230
return result;
22312231
}
2232-
function oldTypeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
2233-
const writer = getSingleLineStringWriter();
2234-
getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
2235-
let result = writer.string();
2236-
releaseStringWriter(writer);
2237-
2238-
const maxLength = compilerOptions.noErrorTruncation || flags & TypeFormatFlags.NoTruncation ? undefined : 100;
2239-
if (maxLength && result.length >= maxLength) {
2240-
result = result.substr(0, maxLength - "...".length) + "...";
2241-
}
2242-
return result;
2243-
}
2244-
2232+
22452233
function typeFormatFlagsToNodeBuilderFlags(flags: TypeFormatFlags): NodeBuilderFlags {
22462234
let result = NodeBuilderFlags.None;
22472235
if (flags & TypeFormatFlags.WriteArrayAsGenericType) {
@@ -2282,8 +2270,6 @@ namespace ts {
22822270
}
22832271

22842272
function typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
2285-
const str = oldTypeToString(type, enclosingDeclaration, flags); str;
2286-
const str2 = oldTypeToString(type, enclosingDeclaration, flags); str2;
22872273
const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, typeFormatFlagsToNodeBuilderFlags(flags) | NodeBuilderFlags.ignoreErrors, !!(flags & TypeFormatFlags.InTypeAlias));
22882274
Debug.assert(typeNode !== undefined, "should always get typenode?");
22892275
const newLine = NewLineKind.None;
@@ -2331,11 +2317,8 @@ namespace ts {
23312317
// State
23322318
encounteredError: boolean;
23332319
inObjectTypeLiteral: boolean;
2334-
// TODO: needed for part of parens handling
23352320
InElementType: boolean; // Writing an array or union element type
2336-
// TODO: ???
2337-
InFirstTypeArgument: boolean; // Writing first type argument of the instantiated type
2338-
// TODO: ???
2321+
InFirstTypeArgument: boolean; // Writing first type argument of the instantiated type
23392322
InTypeAlias: boolean; // Writing type in type alias declaration
23402323
symbolStack: Symbol[] | undefined;
23412324
}
@@ -2354,18 +2337,15 @@ namespace ts {
23542337
}
23552338

23562339
function typeToTypeNodeHelper(type: Type, context: NodeBuilderContext): TypeNode {
2357-
const InElementType = context.InElementType;
2358-
// TODO: why doesn't tts unset the flag?
2340+
const inElementType = context.InElementType;
23592341
context.InElementType = false;
23602342
const inTypeAlias = context.InTypeAlias;
23612343
context.InTypeAlias = false;
23622344
const inFirstTypeArgument = context.InFirstTypeArgument;
23632345
context.InFirstTypeArgument = false;
23642346

2365-
// TODO: should be assert?
23662347
if (!type) {
23672348
context.encounteredError = true;
2368-
// TODO(aozgaa): should we return implict any (undefined) or explicit any (keywordtypenode)?
23692349
return undefined;
23702350
}
23712351

@@ -2382,7 +2362,7 @@ namespace ts {
23822362
return createKeywordTypeNode(SyntaxKind.BooleanKeyword);
23832363
}
23842364
if (type.flags & TypeFlags.Enum) {
2385-
const name = symbolToName(type.symbol, /*expectsIdentifier*/ false, SymbolFlags.Type, context);
2365+
const name = symbolToName(type.symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ false);
23862366
return createTypeReferenceNode(name, /*typeArguments*/ undefined);
23872367
}
23882368
if (type.flags & (TypeFlags.StringLiteral)) {
@@ -2396,7 +2376,7 @@ namespace ts {
23962376
}
23972377
if (type.flags & TypeFlags.EnumLiteral) {
23982378
const parentSymbol = getParentOfSymbol(type.symbol);
2399-
const parentName = symbolToName(parentSymbol, /*expectsIdentifier*/ false, SymbolFlags.Type, context);
2379+
const parentName = symbolToName(parentSymbol, context, SymbolFlags.Type, /*expectsIdentifier*/ false);
24002380
const name = getNameOfSymbol(type.symbol, context);
24012381
const enumLiteralName = createQualifiedName(parentName, name);
24022382
return createTypeReferenceNode(enumLiteralName, /*typeArguments*/ undefined);
@@ -2436,12 +2416,11 @@ namespace ts {
24362416
}
24372417
if (objectFlags & ObjectFlags.ClassOrInterface) {
24382418
Debug.assert(!!(type.flags & TypeFlags.Object));
2439-
const name = symbolToName(type.symbol, /*expectsIdentifier*/ false, SymbolFlags.Type, context);
2440-
// TODO(aozgaa): handle type arguments.
2419+
const name = symbolToName(type.symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ false);
24412420
return createTypeReferenceNode(name, /*typeArguments*/ undefined);
24422421
}
24432422
if (type.flags & TypeFlags.TypeParameter) {
2444-
const name = symbolToName(type.symbol, /*expectsIdentifier*/ false, SymbolFlags.Type, context);
2423+
const name = symbolToName(type.symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ false);
24452424
// Ignore constraint/default when creating a usage (as opposed to declaration) of a type parameter.
24462425
return createTypeReferenceNode(name, /*typeArguments*/ undefined);
24472426
}
@@ -2451,15 +2430,14 @@ namespace ts {
24512430
const name = symbolToTypeReferenceName(type.aliasSymbol);
24522431
const typeArgumentNodes = toTypeArgumentNodes(type.aliasTypeArguments, context);
24532432
return createTypeReferenceNode(name, typeArgumentNodes);
2454-
// return symbolToTypeReferenceIdentifier(type.aliasSymbol, type.aliasTypeArguments);
24552433
}
24562434

24572435
if (type.flags & (TypeFlags.Union | TypeFlags.Intersection)) {
24582436
const types = type.flags & TypeFlags.Union ? formatUnionTypes((<UnionType>type).types) : (<IntersectionType>type).types;
24592437
const typeNodes = types && mapToTypeNodeArray(types, context, /*addInElementTypeFlag*/ true, /*addInFirstTypeArgumentFlag*/ false);
24602438
if (typeNodes && typeNodes.length > 0) {
24612439
const unionOrIntersectionTypeNode = createUnionOrIntersectionTypeNode(type.flags & TypeFlags.Union ? SyntaxKind.UnionType : SyntaxKind.IntersectionType, typeNodes);
2462-
return InElementType ? createParenthesizedTypeNode(unionOrIntersectionTypeNode) : unionOrIntersectionTypeNode;
2440+
return inElementType ? createParenthesizedTypeNode(unionOrIntersectionTypeNode) : unionOrIntersectionTypeNode;
24632441
}
24642442
else {
24652443
if (!context.encounteredError && !(context.flags & NodeBuilderFlags.allowEmptyUnionOrIntersection)) {
@@ -2521,7 +2499,7 @@ namespace ts {
25212499
const typeAlias = getTypeAliasForTypeLiteral(type);
25222500
if (typeAlias) {
25232501
// The specified symbol flags need to be reinterpreted as type flags
2524-
const entityName = symbolToName(typeAlias, /*expectsIdentifier*/ false, SymbolFlags.Type, context);
2502+
const entityName = symbolToName(typeAlias, context, SymbolFlags.Type, /*expectsIdentifier*/ false );
25252503
return createTypeReferenceNode(entityName, /*typeArguments*/ undefined);
25262504
}
25272505
else {
@@ -2598,7 +2576,7 @@ namespace ts {
25982576
}
25992577

26002578
function shouldAddParenthesisAroundFunctionType(callSignature: Signature, context: NodeBuilderContext) {
2601-
if (InElementType) {
2579+
if (inElementType) {
26022580
return true;
26032581
}
26042582
else if (inFirstTypeArgument) {
@@ -2611,14 +2589,13 @@ namespace ts {
26112589
}
26122590

26132591
function createTypeQueryNodeFromSymbol(symbol: Symbol, symbolFlags: SymbolFlags) {
2614-
const entityName = symbolToName(symbol, /*expectsIdentifier*/ false, symbolFlags, context);
2592+
const entityName = symbolToName(symbol, context, symbolFlags, /*expectsIdentifier*/ false);
26152593
return createTypeQueryNode(entityName);
26162594
}
26172595

26182596
function symbolToTypeReferenceName(symbol: Symbol) {
26192597
// Unnamed function expressions and arrow functions have reserved names that we don't want to display
2620-
const entityName = symbol.flags & SymbolFlags.Class || !isReservedMemberName(symbol.name) ? symbolToName(symbol, /*expectsIdentifier*/ false, SymbolFlags.Type, context) : createIdentifier("");
2621-
// TODO: assert no type args?
2598+
const entityName = symbol.flags & SymbolFlags.Class || !isReservedMemberName(symbol.name) ? symbolToName(symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ false) : createIdentifier("");
26222599
return entityName;
26232600
}
26242601

@@ -2651,7 +2628,6 @@ namespace ts {
26512628
let i = 0;
26522629
let qualifiedName: QualifiedName | undefined;
26532630
if (outerTypeParameters) {
2654-
let inFirstTypeArgument = true;
26552631
const length = outerTypeParameters.length;
26562632
while (i < length) {
26572633
// Find group of type arguments for type parameters with the same declaring container.
@@ -2676,7 +2652,6 @@ namespace ts {
26762652
qualifiedName = createQualifiedName(namePart, /*right*/ undefined);
26772653
}
26782654
}
2679-
inFirstTypeArgument = false;
26802655
}
26812656
}
26822657

@@ -2745,12 +2720,11 @@ namespace ts {
27452720
return typeElements;
27462721
}
27472722

2748-
// TODO: make logic mirror that of writeObjectLiteralType
27492723
for (const propertySymbol of properties) {
27502724
const propertyType = getTypeOfSymbol(propertySymbol);
27512725
const saveEnclosingDeclaration = context.enclosingDeclaration;
27522726
context.enclosingDeclaration = undefined;
2753-
const propertyName = symbolToName(propertySymbol, /*expectsIdentifier*/ true, SymbolFlags.Value, context);
2727+
const propertyName = symbolToName(propertySymbol, context, SymbolFlags.Value, /*expectsIdentifier*/ true);
27542728
context.enclosingDeclaration = saveEnclosingDeclaration;
27552729
const optionalToken = propertySymbol.flags & SymbolFlags.Optional ? createToken(SyntaxKind.QuestionToken) : undefined;
27562730
if (propertySymbol.flags & (SymbolFlags.Function | SymbolFlags.Method) && !getPropertiesOfObjectType(propertyType).length) {
@@ -2856,7 +2830,7 @@ namespace ts {
28562830
const constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
28572831
const defaultParameter = getDefaultFromTypeParameter(type);
28582832
const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
2859-
const name = symbolToName(type.symbol, /*expectsIdentifier*/ true, SymbolFlags.Type, context);
2833+
const name = symbolToName(type.symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ true);
28602834
return createTypeParameterDeclaration(name, constraintNode, defaultParameterNode);
28612835
}
28622836

@@ -2903,10 +2877,9 @@ namespace ts {
29032877
}
29042878
}
29052879

2906-
// TODO: add SymbolFormatFlags?? Yes to add outer type parameters. Defer UseOnlyExternalAliasing until a separate symbolbuilder PR.
2907-
function symbolToName(symbol: Symbol, expectsIdentifier: true, meaning: SymbolFlags, context: NodeBuilderContext): Identifier;
2908-
function symbolToName(symbol: Symbol, expectsIdentifier: false, meaning: SymbolFlags, context: NodeBuilderContext): EntityName;
2909-
function symbolToName(symbol: Symbol, expectsIdentifier: boolean, meaning: SymbolFlags, context: NodeBuilderContext): EntityName {
2880+
function symbolToName(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, expectsIdentifier: true): Identifier;
2881+
function symbolToName(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, expectsIdentifier: false): EntityName;
2882+
function symbolToName(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, expectsIdentifier: boolean): EntityName {
29102883

29112884
// Try to get qualified name if the symbol is not a type parameter and there is an enclosing declaration.
29122885
let chain: Symbol[];

0 commit comments

Comments
 (0)