Better name for deferred mapped type:ReverseMapped

sandersn · sandersn · commit f8c86552bcd8 · 2018-01-05T15:44:38.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -339,7 +339,7 @@ namespace ts {
         const jsObjectLiteralIndexInfo = createIndexInfo(anyType, /*isReadonly*/ false);
 
         const globals = createSymbolTable();
-        const deferredInferenceCache = createMap<Type | undefined>();
+        const reverseMappedCache = createMap<Type | undefined>();
         let ambientModulesCache: Symbol[] | undefined;
         /**
          * List of every ambient module with a "*" wildcard.
@@ -2861,7 +2861,7 @@ namespace ts {
                         typeElements.push(<ConstructSignatureDeclaration>signatureToSignatureDeclarationHelper(signature, SyntaxKind.ConstructSignature, context));
                     }
                     if (resolvedType.stringIndexInfo) {
-                        const indexInfo = resolvedType.objectFlags & ObjectFlags.Deferred ?
+                        const indexInfo = resolvedType.objectFlags & ObjectFlags.ReverseMapped ?
                             createIndexInfo(anyType, resolvedType.stringIndexInfo.isReadonly, resolvedType.stringIndexInfo.declaration) :
                             resolvedType.stringIndexInfo;
                         typeElements.push(indexInfoToIndexSignatureDeclarationHelper(indexInfo, IndexKind.String, context));
@@ -2876,7 +2876,7 @@ namespace ts {
                     }
 
                     for (const propertySymbol of properties) {
-                        const propertyType = getCheckFlags(propertySymbol) & CheckFlags.Deferred ? anyType : getTypeOfSymbol(propertySymbol);
+                        const propertyType = getCheckFlags(propertySymbol) & CheckFlags.ReverseMapped ? anyType : getTypeOfSymbol(propertySymbol);
                         const saveEnclosingDeclaration = context.enclosingDeclaration;
                         context.enclosingDeclaration = undefined;
                         const propertyName = symbolToName(propertySymbol, context, SymbolFlags.Value, /*expectsIdentifier*/ true);
@@ -3685,7 +3685,7 @@ namespace ts {
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
-                    const stringIndexInfo = resolved.objectFlags & ObjectFlags.Deferred && resolved.stringIndexInfo ?
+                    const stringIndexInfo = resolved.objectFlags & ObjectFlags.ReverseMapped && resolved.stringIndexInfo ?
                         createIndexInfo(anyType, resolved.stringIndexInfo.isReadonly, resolved.stringIndexInfo.declaration) :
                         resolved.stringIndexInfo;
                     buildIndexSignatureDisplay(stringIndexInfo, writer, IndexKind.String, enclosingDeclaration, globalFlags, symbolStack);
@@ -3699,7 +3699,7 @@ namespace ts {
                                 writer.reportPrivateInBaseOfClassExpression(symbolName(p));
                             }
                         }
-                        const t = getCheckFlags(p) & CheckFlags.Deferred ? anyType : getTypeOfSymbol(p);
+                        const t = getCheckFlags(p) & CheckFlags.ReverseMapped ? anyType : getTypeOfSymbol(p);
                         if (p.flags & (SymbolFlags.Function | SymbolFlags.Method) && !getPropertiesOfObjectType(t).length) {
                             const signatures = getSignaturesOfType(t, SignatureKind.Call);
                             for (const signature of signatures) {
@@ -4907,8 +4907,8 @@ namespace ts {
             if (getCheckFlags(symbol) & CheckFlags.Instantiated) {
                 return getTypeOfInstantiatedSymbol(symbol);
             }
-            if (getCheckFlags(symbol) & CheckFlags.Deferred) {
-                return inferDeferredMappedType((symbol as DeferredTransientSymbol).propertyType, (symbol as DeferredTransientSymbol).mappedType);
+            if (getCheckFlags(symbol) & CheckFlags.ReverseMapped) {
+                return getTypeOfReverseMappedSymbol(symbol as ReverseMappedSymbol);
             }
             if (symbol.flags & (SymbolFlags.Variable | SymbolFlags.Property)) {
                 return getTypeOfVariableOrParameterOrProperty(symbol);
@@ -6120,15 +6120,15 @@ namespace ts {
             }
         }
 
-        function resolveDeferredMappedTypeMembers(type: DeferredMappedType) {
+        function resolveReverseMappedTypeMembers(type: ReverseMappedType) {
             const indexInfo = getIndexInfoOfType(type.source, IndexKind.String);
             const readonlyMask = type.mappedType.declaration.readonlyToken ? false : true;
             const optionalMask = type.mappedType.declaration.questionToken ? 0 : SymbolFlags.Optional;
-            const stringIndexInfo = indexInfo && createIndexInfo(inferDeferredMappedType(indexInfo.type, type.mappedType), readonlyMask && indexInfo.isReadonly);
+            const stringIndexInfo = indexInfo && createIndexInfo(inferReverseMappedType(indexInfo.type, type.mappedType), readonlyMask && indexInfo.isReadonly);
             const members = createSymbolTable();
             for (const prop of getPropertiesOfType(type.source)) {
-                const checkFlags = CheckFlags.Deferred | (readonlyMask && isReadonlySymbol(prop) ? CheckFlags.Readonly : 0);
-                const inferredProp = createSymbol(SymbolFlags.Property | prop.flags & optionalMask, prop.escapedName, checkFlags) as DeferredTransientSymbol;
+                const checkFlags = CheckFlags.ReverseMapped | (readonlyMask && isReadonlySymbol(prop) ? CheckFlags.Readonly : 0);
+                const inferredProp = createSymbol(SymbolFlags.Property | prop.flags & optionalMask, prop.escapedName, checkFlags) as ReverseMappedSymbol;
                 inferredProp.declarations = prop.declarations;
                 inferredProp.propertyType = getTypeOfSymbol(prop);
                 inferredProp.mappedType = type.mappedType;
@@ -6276,8 +6276,8 @@ namespace ts {
                     else if ((<ObjectType>type).objectFlags & ObjectFlags.ClassOrInterface) {
                         resolveClassOrInterfaceMembers(<InterfaceType>type);
                     }
-                    else if ((<DeferredMappedType>type).objectFlags & ObjectFlags.Deferred) {
-                        resolveDeferredMappedTypeMembers(type as DeferredMappedType);
+                    else if ((<ReverseMappedType>type).objectFlags & ObjectFlags.ReverseMapped) {
+                        resolveReverseMappedTypeMembers(type as ReverseMappedType);
                     }
                     else if ((<ObjectType>type).objectFlags & ObjectFlags.Anonymous) {
                         resolveAnonymousTypeMembers(<AnonymousType>type);
@@ -11307,16 +11307,16 @@ namespace ts {
          */
         function inferTypeForHomomorphicMappedType(source: Type, target: MappedType): Type {
             const key = source.id + "," + target.id;
-            if (deferredInferenceCache.has(key)) {
-                return deferredInferenceCache.get(key);
+            if (reverseMappedCache.has(key)) {
+                return reverseMappedCache.get(key);
             }
-            deferredInferenceCache.set(key, undefined);
-            const type = createDeferredMappedType(source, target);
-            deferredInferenceCache.set(key, type);
+            reverseMappedCache.set(key, undefined);
+            const type = createReverseMappedType(source, target);
+            reverseMappedCache.set(key, type);
             return type;
         }
 
-        function createDeferredMappedType(source: Type, target: MappedType) {
+        function createReverseMappedType(source: Type, target: MappedType) {
             const properties = getPropertiesOfType(source);
             if (properties.length === 0 && !getIndexInfoOfType(source, IndexKind.String)) {
                 return undefined;
@@ -11328,13 +11328,17 @@ namespace ts {
                     return undefined;
                 }
             }
-            const deferred = createObjectType(ObjectFlags.Deferred | ObjectFlags.Anonymous, /*symbol*/ undefined) as DeferredMappedType;
-            deferred.source = source;
-            deferred.mappedType = target;
-            return deferred;
+            const reversed = createObjectType(ObjectFlags.ReverseMapped | ObjectFlags.Anonymous, /*symbol*/ undefined) as ReverseMappedType;
+            reversed.source = source;
+            reversed.mappedType = target;
+            return reversed;
         }
 
-        function inferDeferredMappedType(sourceType: Type, target: MappedType): Type {
+        function getTypeOfReverseMappedSymbol(symbol: ReverseMappedSymbol) {
+            return inferReverseMappedType(symbol.propertyType, symbol.mappedType);
+        }
+
+        function inferReverseMappedType(sourceType: Type, target: MappedType): Type {
             const typeParameter = <TypeParameter>getIndexedAccessType((<IndexType>getConstraintTypeFromMappedType(target)).type, getTypeParameterFromMappedType(target));
             const templateType = getTemplateTypeFromMappedType(target);
             const inference = createInferenceInfo(typeParameter);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -3251,7 +3251,7 @@ namespace ts {
         ContainsPrivate   = 1 << 8,         // Synthetic property with private constituent(s)
         ContainsStatic    = 1 << 9,         // Synthetic property with static constituent(s)
         Late              = 1 << 10,        // Late-bound symbol for a computed property with a dynamic name
-        Deferred          = 1 << 11,        // Deferred inferred property of homomorphic mapped type.
+        ReverseMapped     = 1 << 11,        // property of reverse-inferred homomorphic mapped type.
         Synthetic = SyntheticProperty | SyntheticMethod
     }
 
@@ -3262,7 +3262,7 @@ namespace ts {
     }
 
     /* @internal */
-    export interface DeferredTransientSymbol extends TransientSymbol {
+    export interface ReverseMappedSymbol extends TransientSymbol {
         propertyType: Type;
         mappedType: MappedType;
     }
@@ -3501,7 +3501,7 @@ namespace ts {
         EvolvingArray    = 1 << 8,  // Evolving array type
         ObjectLiteralPatternWithComputedProperties = 1 << 9,  // Object literal pattern with computed properties
         ContainsSpread   = 1 << 10, // Object literal contains spread operation
-        Deferred = 1 << 11, // Object contains a deferred inferred property
+        ReverseMapped = 1 << 11,    // Object contains a property from a reverse-mapped type
         ClassOrInterface = Class | Interface
     }
 
@@ -3610,7 +3610,7 @@ namespace ts {
     }
 
     /* @internal */
-    export interface DeferredMappedType extends ObjectType {
+    export interface ReverseMappedType extends ObjectType {
         source: Type;
         mappedType: MappedType;
     }
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2066,7 +2066,7 @@ declare namespace ts {
         EvolvingArray = 256,
         ObjectLiteralPatternWithComputedProperties = 512,
         ContainsSpread = 1024,
-        Deferred = 2048,
+        ReverseMapped = 2048,
         ClassOrInterface = 3,
     }
     interface ObjectType extends Type {
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -2066,7 +2066,7 @@ declare namespace ts {
         EvolvingArray = 256,
         ObjectLiteralPatternWithComputedProperties = 512,
         ContainsSpread = 1024,
-        Deferred = 2048,
+        ReverseMapped = 2048,
         ClassOrInterface = 3,
     }
     interface ObjectType extends Type {

Original file line number	Diff line number	Diff line change
`@@ -3251,7 +3251,7 @@ namespace ts {`
`3251`	`3251`	`ContainsPrivate = 1 << 8, // Synthetic property with private constituent(s)`
`3252`	`3252`	`ContainsStatic = 1 << 9, // Synthetic property with static constituent(s)`
`3253`	`3253`	`Late = 1 << 10, // Late-bound symbol for a computed property with a dynamic name`
`3254`		`- Deferred = 1 << 11, // Deferred inferred property of homomorphic mapped type.`
	`3254`	`+ ReverseMapped = 1 << 11, // property of reverse-inferred homomorphic mapped type.`
`3255`	`3255`	`Synthetic = SyntheticProperty \| SyntheticMethod`
`3256`	`3256`	`}`
`3257`	`3257`
`@@ -3262,7 +3262,7 @@ namespace ts {`
`3262`	`3262`	`}`
`3263`	`3263`
`3264`	`3264`	`/* @internal */`
`3265`		`- export interface DeferredTransientSymbol extends TransientSymbol {`
	`3265`	`+ export interface ReverseMappedSymbol extends TransientSymbol {`
`3266`	`3266`	`propertyType: Type;`
`3267`	`3267`	`mappedType: MappedType;`
`3268`	`3268`	`}`
`@@ -3501,7 +3501,7 @@ namespace ts {`
`3501`	`3501`	`EvolvingArray = 1 << 8, // Evolving array type`
`3502`	`3502`	`ObjectLiteralPatternWithComputedProperties = 1 << 9, // Object literal pattern with computed properties`
`3503`	`3503`	`ContainsSpread = 1 << 10, // Object literal contains spread operation`
`3504`		`- Deferred = 1 << 11, // Object contains a deferred inferred property`
	`3504`	`+ ReverseMapped = 1 << 11, // Object contains a property from a reverse-mapped type`
`3505`	`3505`	`ClassOrInterface = Class \| Interface`
`3506`	`3506`	`}`
`3507`	`3507`
`@@ -3610,7 +3610,7 @@ namespace ts {`
`3610`	`3610`	`}`
`3611`	`3611`
`3612`	`3612`	`/* @internal */`
`3613`		`- export interface DeferredMappedType extends ObjectType {`
	`3613`	`+ export interface ReverseMappedType extends ObjectType {`
`3614`	`3614`	`source: Type;`
`3615`	`3615`	`mappedType: MappedType;`
`3616`	`3616`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2066,7 +2066,7 @@ declare namespace ts {`
`2066`	`2066`	`EvolvingArray = 256,`
`2067`	`2067`	`ObjectLiteralPatternWithComputedProperties = 512,`
`2068`	`2068`	`ContainsSpread = 1024,`
`2069`		`- Deferred = 2048,`
	`2069`	`+ ReverseMapped = 2048,`
`2070`	`2070`	`ClassOrInterface = 3,`
`2071`	`2071`	`}`
`2072`	`2072`	`interface ObjectType extends Type {`