Parse '[P in K]' part of mapped type as a type parameter declaration

microsoft · ahejlsberg · Nov 13, 2016 · Nov 3, 2016 · Nov 3, 2016 · Nov 4, 2016
commit d1a8af532092378b07e3d441838070e5b5360466
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -1302,6 +1302,7 @@ namespace ts {
                 case SyntaxKind.JSDocFunctionType:
                 case SyntaxKind.ModuleDeclaration:
                 case SyntaxKind.TypeAliasDeclaration:
+                case SyntaxKind.MappedType:
                     return ContainerFlags.IsContainer | ContainerFlags.HasLocals;
 
                 case SyntaxKind.SourceFile:
@@ -1421,6 +1422,7 @@ namespace ts {
                 case SyntaxKind.ArrowFunction:
                 case SyntaxKind.JSDocFunctionType:
                 case SyntaxKind.TypeAliasDeclaration:
+                case SyntaxKind.MappedType:
                     // All the children of these container types are never visible through another
                     // symbol (i.e. through another symbol's 'exports' or 'members').  Instead,
                     // they're only accessed 'lexically' (i.e. from code that exists underneath

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -5834,6 +5834,18 @@ namespace ts {
             return links.resolvedType;
         }
 
+        function getTypeFromMappedTypeNode(node: MappedTypeNode) {
+            const links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                getTypeFromTypeNode(node.typeParameter.constraint);
+                if (node.type) {
+                    getTypeFromTypeNode(node.type);
+                }
+                links.resolvedType = unknownType;
+            }
+            return links.resolvedType;
+        }
+
         function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node: Node, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
@@ -6003,7 +6015,7 @@ namespace ts {
                 case SyntaxKind.IndexedAccessType:
                     return getTypeFromIndexedAccessTypeNode(<IndexedAccessTypeNode>node);
                 case SyntaxKind.MappedType:
-                    return unknownType;  // !!!
+                    return getTypeFromMappedTypeNode(<MappedTypeNode>node);
                 // This function assumes that an identifier or qualified name is a type expression
                 // Callers should first ensure this by calling isTypeNode
                 case SyntaxKind.Identifier:
@@ -15075,7 +15087,7 @@ namespace ts {
         }
 
         function checkMappedType(node: MappedTypeNode) {
-            node; // !!!
+            getTypeFromMappedTypeNode(node);
         }
 
         function isPrivateWithinAmbient(node: Node): boolean {
@@ -18318,7 +18330,7 @@ namespace ts {
                     return checkSourceElement((<ParenthesizedTypeNode | TypeOperatorNode>node).type);
                 case SyntaxKind.IndexedAccessType:
                     return checkIndexedAccessType(<IndexedAccessTypeNode>node);
-                case SyntaxKind.IndexedAccessType:
+                case SyntaxKind.MappedType:
                     return checkMappedType(<MappedTypeNode>node);
                 case SyntaxKind.FunctionDeclaration:
                     return checkFunctionDeclaration(<FunctionDeclaration>node);

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -140,8 +140,7 @@ namespace ts {
                 return visitNode(cbNode, (<IndexedAccessTypeNode>node).objectType) ||
                     visitNode(cbNode, (<IndexedAccessTypeNode>node).indexType);
             case SyntaxKind.MappedType:
-                return visitNode(cbNode, (<MappedTypeNode>node).iterationTypeName) ||
-                    visitNode(cbNode, (<MappedTypeNode>node).indexType) ||
+                return visitNode(cbNode, (<MappedTypeNode>node).typeParameter) ||
                     visitNode(cbNode, (<MappedTypeNode>node).type);
             case SyntaxKind.LiteralType:
                 return visitNode(cbNode, (<LiteralTypeNode>node).literal);
@@ -2411,14 +2410,20 @@ namespace ts {
             return token() === SyntaxKind.OpenBracketToken && nextTokenIsIdentifier() && nextToken() === SyntaxKind.InKeyword;
         }
 
+        function parseMappedTypeParameter() {
+            const node = <TypeParameterDeclaration>createNode(SyntaxKind.TypeParameter);
+            node.name = parseIdentifier();
+            parseExpected(SyntaxKind.InKeyword);
+            node.constraint = parseType();
+            return finishNode(node);
+        }
+
         function parseMappedType() {
             const node = <MappedTypeNode>createNode(SyntaxKind.MappedType);
             parseExpected(SyntaxKind.OpenBraceToken);
             node.readonlyToken = parseOptionalToken(SyntaxKind.ReadonlyKeyword);
             parseExpected(SyntaxKind.OpenBracketToken);
-            node.iterationTypeName = parseIdentifier();
-            parseExpected(SyntaxKind.InKeyword);
-            node.indexType = parseType();
+            node.typeParameter = parseMappedTypeParameter();
             parseExpected(SyntaxKind.CloseBracketToken);
             node.questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
             node.type = parseTypeAnnotation();

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -902,8 +902,7 @@ namespace ts {
     export interface MappedTypeNode extends TypeNode {
         kind: SyntaxKind.MappedType;
         readonlyToken?: ReadonlyToken;
-        iterationTypeName: Identifier;
-        indexType: TypeNode;
+        typeParameter: TypeParameterDeclaration;
         questionToken?: QuestionToken;
         type?: TypeNode;
     }