Merge commit '3fe946df78c270817192c9eb7a22e7111c8a592a' into named-ty…

…pe-arguments-beta

src/compiler/checker.ts

@@ -3779,9 +3779,21 @@ namespace ts {
                 const isTypeOf = meaning === SymbolFlags.Value;
                 if (ambientModuleSymbolRegex.test(rootName)) {
                     // module is root, must use `ImportTypeNode`
-                    const nonRootParts = chain.length > 1 ? createEntityNameFromSymbolChain(chain, chain.length - 1, 1) : undefined;
-                    const { typeArgumentNodes } = lookupTypeParameterNodes(chain, 0, context);
-                    return createImportTypeNode(createLiteralTypeNode(createLiteral(rootName.substring(1, rootName.length - 1))), nonRootParts, typeArgumentNodes, isTypeOf);
+                    const nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : undefined;
+                    const typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context).typeArgumentNodes;
+                    const lit = createLiteralTypeNode(createLiteral(rootName.substring(1, rootName.length - 1)));
+                    if (!nonRootParts || isEntityName(nonRootParts)) {
+                        if (nonRootParts) {
+                            const lastId = isIdentifier(nonRootParts) ? nonRootParts : (nonRootParts as QualifiedName).right;
+                            lastId.typeArguments = undefined;
+                        }
+                        return createImportTypeNode(lit, nonRootParts as EntityName, typeParameterNodes as ReadonlyArray<TypeNode>, isTypeOf);
+                    }
+                    else {
+                        const splitNode = getTopmostIndexedAccessType(nonRootParts);
+                        const qualifier = (splitNode.objectType as TypeReferenceNode).typeName;
+                        return createIndexedAccessTypeNode(createImportTypeNode(lit, qualifier, typeParameterNodes as ReadonlyArray<TypeNode>, isTypeOf), splitNode.indexType);
+                    }
                 }
 
                 const entityName = createAccessFromSymbolChain(chain, chain.length - 1, 0);
@@ -3798,8 +3810,8 @@ namespace ts {
                     return createTypeReferenceNode(entityName, lastTypeArgs as NodeArray<TypeNode>);
                 }
 
-                function createEntityNameFromSymbolChain(chain: Symbol[], index: number, stopper: number): EntityName {
-                    const { typeArgumentNodes, typeParameterNodes } = lookupTypeParameterNodes(chain, index, context);
+                function createAccessFromSymbolChain(chain: Symbol[], index: number, stopper: number): EntityName | IndexedAccessTypeNode {
+                    const { typeArgumentNodes, typeParameterNodes } = index === (chain.length - 1) ? { typeArgumentNodes: overrideTypeArguments, typeParameterNodes: undefined } : lookupTypeParameterNodes(chain, index, context);
                     const symbol = chain[index];
 
                     if (index === 0) {
@@ -3809,6 +3821,19 @@ namespace ts {
                     if (index === 0) {
                         context.flags ^= NodeBuilderFlags.InInitialEntityName;
                     }
+
+                    const parent = chain[index - 1];
+                    if (!(context.flags & NodeBuilderFlags.ForbidIndexedAccessSymbolReferences) && parent && getMembersOfSymbol(parent) && getMembersOfSymbol(parent).get(symbol.escapedName) === symbol) {
+                        // Should use an indexed access
+                        const LHS = createAccessFromSymbolChain(chain, index - 1, stopper);
+                        if (isIndexedAccessTypeNode(LHS)) {
+                            return createIndexedAccessTypeNode(LHS, createLiteralTypeNode(createLiteral(symbolName)));
+                        }
+                        else {
+                            return createIndexedAccessTypeNode(createTypeReferenceNode(LHS, typeArgumentNodes as ReadonlyArray<TypeArgument>), createLiteralTypeNode(createLiteral(symbolName)));
+                        }
+                    }
+
                     const identifier = setEmitFlags(createIdentifier(symbolName, typeArgumentNodes, typeParameterNodes), EmitFlags.NoAsciiEscaping);
                     identifier.symbol = symbol;
 
@@ -15621,8 +15646,18 @@ namespace ts {
                 }
             }
 
-            if (context.typeArguments) {
-                signatures = mapDefined(signatures, s => getJsxSignatureTypeArgumentInstantiation(s, context, isJs, /*performPartialInference*/ false));
+            const links = getNodeLinks(context);
+            if (!links.resolvedSignatures) {
+                links.resolvedSignatures = createMap();
+            }
+            const cacheKey = "" + getTypeId(valueType);
+            const cachedResolved = links.resolvedSignatures.get(cacheKey);
+            if (cachedResolved && cachedResolved !== resolvingSignaturesArray) {
+                signatures = cachedResolved;
+            }
+            else if (!cachedResolved) {
+                    links.resolvedSignatures.set(cacheKey, resolvingSignaturesArray);
+                    links.resolvedSignatures.set(cacheKey, signatures = instantiateJsxSignatures(context, signatures));
             }
 
             return getUnionType(map(signatures, ctor ? t => getJsxPropsTypeFromClassType(t, isJs, context, /*reportErrors*/ false) : t => getJsxPropsTypeFromCallSignature(t, context)), UnionReduction.None);
@@ -16395,7 +16430,7 @@ namespace ts {
             const isJavascript = isInJavaScriptFile(node);
             for (const signature of signatures) {
                 if (signature.typeParameters) {
-                    const typeArgumentInstantiated = getJsxSignatureTypeArgumentInstantiation(signature, node, isJavascript, /*performPartialInference*/ true);
+                    const typeArgumentInstantiated = getJsxSignatureTypeArgumentInstantiation(signature, node, isJavascript);
                     if (typeArgumentInstantiated) {
                         hasTypeArgumentError = false;
                         instantiatedSignatures.push(typeArgumentInstantiated);
@@ -16429,16 +16464,14 @@ namespace ts {
             }
         }
 
-        function getJsxSignatureTypeArgumentInstantiation(signature: Signature, node: JsxOpeningLikeElement, isJavascript: boolean, performPartialInference: boolean) {
+        function getJsxSignatureTypeArgumentInstantiation(signature: Signature, node: JsxOpeningLikeElement, isJavascript: boolean) {
             if (!node.typeArguments) {
                 return;
             }
             if (!hasCorrectTypeArgumentArity(signature, node.typeArguments) || !hasMatchesForAllNamedTypeArguments(signature.typeParameters, node.typeArguments)) {
                 return;
             }
-            const args = performPartialInference
-                ? checkTypeArgumentsWithPartialInference(signature, node.typeArguments, isJavascript, performJsxInferenceHandler, /*reportErrors*/ false)
-                : checkTypeArguments(signature, node.typeArguments, /*reportErrors*/ false);
+            const args = checkTypeArgumentsWithPartialInference(signature, node.typeArguments, isJavascript, performJsxInferenceHandler, /*reportErrors*/ false);
             if (!args) {
                 return;
             }