typescript 4.6.0-dev.20211214 → 4.6.0-dev.20211215

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.6";
-    ts.version = ts.versionMajorMinor + ".0-dev.20211214";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211215";
     var NativeCollections;
     (function (NativeCollections) {
         function tryGetNativeMap() {
@@ -27016,7 +27016,7 @@ var ts;
                                     return true;
                             }
                         }
-                        else if (third === 27) {
+                        else if (third === 27 || third === 63) {
                             return true;
                         }
                         return false;
@@ -47518,8 +47518,14 @@ var ts;
             }
             return type;
         }
+        function isMappedTypeGenericIndexedAccess(type) {
+            return type.flags & 8388608 && ts.getObjectFlags(type.objectType) & 32 &&
+                !isGenericMappedType(type.objectType) && isGenericIndexType(type.indexType);
+        }
         function getApparentType(type) {
-            var t = type.flags & 465829888 ? getBaseConstraintOfType(type) || unknownType : type;
+            var t = !(type.flags & 465829888) ? type :
+                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
+                    getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 ? globalStringType :
@@ -55554,12 +55560,14 @@ var ts;
                     target = getActualTypeVariable(target);
                 }
                 if (target.flags & 8650752) {
-                    if (ts.getObjectFlags(source) & 524288 || source === nonInferrableAnyType || source === silentNeverType ||
-                        (priority & 128 && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
                     if (inference) {
+                        if (ts.getObjectFlags(source) & 524288) {
+                            return;
+                        }
                         if (!inference.isFixed) {
                             if (inference.priority === undefined || priority < inference.priority) {
                                 inference.candidates = undefined;
@@ -55588,18 +55596,16 @@ var ts;
                         inferencePriority = Math.min(inferencePriority, priority);
                         return;
                     }
-                    else {
-                        var simplified = getSimplifiedType(target, false);
-                        if (simplified !== target) {
-                            invokeOnce(source, simplified, inferFromTypes);
-                        }
-                        else if (target.flags & 8388608) {
-                            var indexType = getSimplifiedType(target.indexType, false);
-                            if (indexType.flags & 465829888) {
-                                var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, false), indexType, false);
-                                if (simplified_1 && simplified_1 !== target) {
-                                    invokeOnce(source, simplified_1, inferFromTypes);
-                                }
+                    var simplified = getSimplifiedType(target, false);
+                    if (simplified !== target) {
+                        inferFromTypes(source, simplified);
+                    }
+                    else if (target.flags & 8388608) {
+                        var indexType = getSimplifiedType(target.indexType, false);
+                        if (indexType.flags & 465829888) {
+                            var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, false), indexType, false);
+                            if (simplified_1 && simplified_1 !== target) {
+                                inferFromTypes(source, simplified_1);
                             }
                         }
                     }
@@ -58116,7 +58122,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211214";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211215";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33531,7 +33531,7 @@ var ts;
                                     return true;
                             }
                         }
-                        else if (third === 27 /* CommaToken */) {
+                        else if (third === 27 /* CommaToken */ || third === 63 /* EqualsToken */) {
                             return true;
                         }
                         return false;
@@ -57425,13 +57425,23 @@ var ts;
             }
             return type;
         }
+        function isMappedTypeGenericIndexedAccess(type) {
+            return type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(type.objectType) & 32 /* Mapped */ &&
+                !isGenericMappedType(type.objectType) && isGenericIndexType(type.indexType);
+        }
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
          * type itself.
          */
         function getApparentType(type) {
-            var t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
+            // We obtain the base constraint for all instantiable types, except indexed access types of the form
+            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
+            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
+            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
+                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
+                    getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -66616,12 +66626,14 @@ var ts;
                     // not contain anyFunctionType when we come back to this argument for its second round
                     // of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard
                     // when constructing types from type parameters that had no inference candidates).
-                    if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */ || source === nonInferrableAnyType || source === silentNeverType ||
-                        (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
                     if (inference) {
+                        if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */) {
+                            return;
+                        }
                         if (!inference.isFixed) {
                             if (inference.priority === undefined || priority < inference.priority) {
                                 inference.candidates = undefined;
@@ -66652,21 +66664,19 @@ var ts;
                         inferencePriority = Math.min(inferencePriority, priority);
                         return;
                     }
-                    else {
-                        // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
-                        var simplified = getSimplifiedType(target, /*writing*/ false);
-                        if (simplified !== target) {
-                            invokeOnce(source, simplified, inferFromTypes);
-                        }
-                        else if (target.flags & 8388608 /* IndexedAccess */) {
-                            var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
-                            // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
-                            // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
-                            if (indexType.flags & 465829888 /* Instantiable */) {
-                                var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
-                                if (simplified_1 && simplified_1 !== target) {
-                                    invokeOnce(source, simplified_1, inferFromTypes);
-                                }
+                    // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
+                    var simplified = getSimplifiedType(target, /*writing*/ false);
+                    if (simplified !== target) {
+                        inferFromTypes(source, simplified);
+                    }
+                    else if (target.flags & 8388608 /* IndexedAccess */) {
+                        var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
+                        // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
+                        // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
+                        if (indexType.flags & 465829888 /* Instantiable */) {
+                            var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
+                            if (simplified_1 && simplified_1 !== target) {
+                                inferFromTypes(source, simplified_1);
                             }
                         }
                     }
@@ -69536,7 +69546,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -123110,13 +123120,6 @@ var ts;
             || ts.isImportSpecifier(parent)
             || ts.isImportClause(parent)
             || ts.isImportEqualsDeclaration(parent) && node === parent.name) {
-            var decl = parent;
-            while (decl) {
-                if (ts.isImportEqualsDeclaration(decl) || ts.isImportClause(decl) || ts.isExportDeclaration(decl)) {
-                    return decl.isTypeOnly ? 2 /* Type */ : 7 /* All */;
-                }
-                decl = decl.parent;
-            }
             return 7 /* All */;
         }
         else if (isInRightSideOfInternalImportEqualsDeclaration(node)) {

package/lib/tsserverlibrary.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211214";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211215";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33725,7 +33725,7 @@ var ts;
                                     return true;
                             }
                         }
-                        else if (third === 27 /* CommaToken */) {
+                        else if (third === 27 /* CommaToken */ || third === 63 /* EqualsToken */) {
                             return true;
                         }
                         return false;
@@ -57619,13 +57619,23 @@ var ts;
             }
             return type;
         }
+        function isMappedTypeGenericIndexedAccess(type) {
+            return type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(type.objectType) & 32 /* Mapped */ &&
+                !isGenericMappedType(type.objectType) && isGenericIndexType(type.indexType);
+        }
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
          * type itself.
          */
         function getApparentType(type) {
-            var t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
+            // We obtain the base constraint for all instantiable types, except indexed access types of the form
+            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
+            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
+            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
+                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
+                    getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -66810,12 +66820,14 @@ var ts;
                     // not contain anyFunctionType when we come back to this argument for its second round
                     // of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard
                     // when constructing types from type parameters that had no inference candidates).
-                    if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */ || source === nonInferrableAnyType || source === silentNeverType ||
-                        (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
                     if (inference) {
+                        if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */) {
+                            return;
+                        }
                         if (!inference.isFixed) {
                             if (inference.priority === undefined || priority < inference.priority) {
                                 inference.candidates = undefined;
@@ -66846,21 +66858,19 @@ var ts;
                         inferencePriority = Math.min(inferencePriority, priority);
                         return;
                     }
-                    else {
-                        // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
-                        var simplified = getSimplifiedType(target, /*writing*/ false);
-                        if (simplified !== target) {
-                            invokeOnce(source, simplified, inferFromTypes);
-                        }
-                        else if (target.flags & 8388608 /* IndexedAccess */) {
-                            var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
-                            // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
-                            // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
-                            if (indexType.flags & 465829888 /* Instantiable */) {
-                                var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
-                                if (simplified_1 && simplified_1 !== target) {
-                                    invokeOnce(source, simplified_1, inferFromTypes);
-                                }
+                    // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
+                    var simplified = getSimplifiedType(target, /*writing*/ false);
+                    if (simplified !== target) {
+                        inferFromTypes(source, simplified);
+                    }
+                    else if (target.flags & 8388608 /* IndexedAccess */) {
+                        var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
+                        // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
+                        // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
+                        if (indexType.flags & 465829888 /* Instantiable */) {
+                            var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
+                            if (simplified_1 && simplified_1 !== target) {
+                                inferFromTypes(source, simplified_1);
                             }
                         }
                     }
@@ -69730,7 +69740,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -123692,13 +123702,6 @@ var ts;
             || ts.isImportSpecifier(parent)
             || ts.isImportClause(parent)
             || ts.isImportEqualsDeclaration(parent) && node === parent.name) {
-            var decl = parent;
-            while (decl) {
-                if (ts.isImportEqualsDeclaration(decl) || ts.isImportClause(decl) || ts.isExportDeclaration(decl)) {
-                    return decl.isTypeOnly ? 2 /* Type */ : 7 /* All */;
-                }
-                decl = decl.parent;
-            }
             return 7 /* All */;
         }
         else if (isInRightSideOfInternalImportEqualsDeclaration(node)) {

package/lib/typescript.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211214";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211215";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33725,7 +33725,7 @@ var ts;
                                     return true;
                             }
                         }
-                        else if (third === 27 /* CommaToken */) {
+                        else if (third === 27 /* CommaToken */ || third === 63 /* EqualsToken */) {
                             return true;
                         }
                         return false;
@@ -57619,13 +57619,23 @@ var ts;
             }
             return type;
         }
+        function isMappedTypeGenericIndexedAccess(type) {
+            return type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(type.objectType) & 32 /* Mapped */ &&
+                !isGenericMappedType(type.objectType) && isGenericIndexType(type.indexType);
+        }
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
          * type itself.
          */
         function getApparentType(type) {
-            var t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
+            // We obtain the base constraint for all instantiable types, except indexed access types of the form
+            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
+            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
+            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
+                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
+                    getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -66810,12 +66820,14 @@ var ts;
                     // not contain anyFunctionType when we come back to this argument for its second round
                     // of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard
                     // when constructing types from type parameters that had no inference candidates).
-                    if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */ || source === nonInferrableAnyType || source === silentNeverType ||
-                        (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
                     if (inference) {
+                        if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */) {
+                            return;
+                        }
                         if (!inference.isFixed) {
                             if (inference.priority === undefined || priority < inference.priority) {
                                 inference.candidates = undefined;
@@ -66846,21 +66858,19 @@ var ts;
                         inferencePriority = Math.min(inferencePriority, priority);
                         return;
                     }
-                    else {
-                        // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
-                        var simplified = getSimplifiedType(target, /*writing*/ false);
-                        if (simplified !== target) {
-                            invokeOnce(source, simplified, inferFromTypes);
-                        }
-                        else if (target.flags & 8388608 /* IndexedAccess */) {
-                            var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
-                            // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
-                            // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
-                            if (indexType.flags & 465829888 /* Instantiable */) {
-                                var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
-                                if (simplified_1 && simplified_1 !== target) {
-                                    invokeOnce(source, simplified_1, inferFromTypes);
-                                }
+                    // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
+                    var simplified = getSimplifiedType(target, /*writing*/ false);
+                    if (simplified !== target) {
+                        inferFromTypes(source, simplified);
+                    }
+                    else if (target.flags & 8388608 /* IndexedAccess */) {
+                        var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
+                        // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
+                        // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
+                        if (indexType.flags & 465829888 /* Instantiable */) {
+                            var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
+                            if (simplified_1 && simplified_1 !== target) {
+                                inferFromTypes(source, simplified_1);
                             }
                         }
                     }
@@ -69730,7 +69740,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -123692,13 +123702,6 @@ var ts;
             || ts.isImportSpecifier(parent)
             || ts.isImportClause(parent)
             || ts.isImportEqualsDeclaration(parent) && node === parent.name) {
-            var decl = parent;
-            while (decl) {
-                if (ts.isImportEqualsDeclaration(decl) || ts.isImportClause(decl) || ts.isExportDeclaration(decl)) {
-                    return decl.isTypeOnly ? 2 /* Type */ : 7 /* All */;
-                }
-                decl = decl.parent;
-            }
             return 7 /* All */;
         }
         else if (isInRightSideOfInternalImportEqualsDeclaration(node)) {

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211214";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211215";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33725,7 +33725,7 @@ var ts;
                                     return true;
                             }
                         }
-                        else if (third === 27 /* CommaToken */) {
+                        else if (third === 27 /* CommaToken */ || third === 63 /* EqualsToken */) {
                             return true;
                         }
                         return false;
@@ -57619,13 +57619,23 @@ var ts;
             }
             return type;
         }
+        function isMappedTypeGenericIndexedAccess(type) {
+            return type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(type.objectType) & 32 /* Mapped */ &&
+                !isGenericMappedType(type.objectType) && isGenericIndexType(type.indexType);
+        }
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
          * type itself.
          */
         function getApparentType(type) {
-            var t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
+            // We obtain the base constraint for all instantiable types, except indexed access types of the form
+            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
+            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
+            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
+                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
+                    getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -66810,12 +66820,14 @@ var ts;
                     // not contain anyFunctionType when we come back to this argument for its second round
                     // of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard
                     // when constructing types from type parameters that had no inference candidates).
-                    if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */ || source === nonInferrableAnyType || source === silentNeverType ||
-                        (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
                     if (inference) {
+                        if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */) {
+                            return;
+                        }
                         if (!inference.isFixed) {
                             if (inference.priority === undefined || priority < inference.priority) {
                                 inference.candidates = undefined;
@@ -66846,21 +66858,19 @@ var ts;
                         inferencePriority = Math.min(inferencePriority, priority);
                         return;
                     }
-                    else {
-                        // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
-                        var simplified = getSimplifiedType(target, /*writing*/ false);
-                        if (simplified !== target) {
-                            invokeOnce(source, simplified, inferFromTypes);
-                        }
-                        else if (target.flags & 8388608 /* IndexedAccess */) {
-                            var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
-                            // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
-                            // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
-                            if (indexType.flags & 465829888 /* Instantiable */) {
-                                var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
-                                if (simplified_1 && simplified_1 !== target) {
-                                    invokeOnce(source, simplified_1, inferFromTypes);
-                                }
+                    // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
+                    var simplified = getSimplifiedType(target, /*writing*/ false);
+                    if (simplified !== target) {
+                        inferFromTypes(source, simplified);
+                    }
+                    else if (target.flags & 8388608 /* IndexedAccess */) {
+                        var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
+                        // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
+                        // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
+                        if (indexType.flags & 465829888 /* Instantiable */) {
+                            var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
+                            if (simplified_1 && simplified_1 !== target) {
+                                inferFromTypes(source, simplified_1);
                             }
                         }
                     }
@@ -69730,7 +69740,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -123692,13 +123702,6 @@ var ts;
             || ts.isImportSpecifier(parent)
             || ts.isImportClause(parent)
             || ts.isImportEqualsDeclaration(parent) && node === parent.name) {
-            var decl = parent;
-            while (decl) {
-                if (ts.isImportEqualsDeclaration(decl) || ts.isImportClause(decl) || ts.isExportDeclaration(decl)) {
-                    return decl.isTypeOnly ? 2 /* Type */ : 7 /* All */;
-                }
-                decl = decl.parent;
-            }
             return 7 /* All */;
         }
         else if (isInRightSideOfInternalImportEqualsDeclaration(node)) {

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211214";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211215";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33520,7 +33520,7 @@ var ts;
                                     return true;
                             }
                         }
-                        else if (third === 27 /* CommaToken */) {
+                        else if (third === 27 /* CommaToken */ || third === 63 /* EqualsToken */) {
                             return true;
                         }
                         return false;
@@ -57414,13 +57414,23 @@ var ts;
             }
             return type;
         }
+        function isMappedTypeGenericIndexedAccess(type) {
+            return type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(type.objectType) & 32 /* Mapped */ &&
+                !isGenericMappedType(type.objectType) && isGenericIndexType(type.indexType);
+        }
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
          * type itself.
          */
         function getApparentType(type) {
-            var t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
+            // We obtain the base constraint for all instantiable types, except indexed access types of the form
+            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
+            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
+            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
+                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
+                    getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -66605,12 +66615,14 @@ var ts;
                     // not contain anyFunctionType when we come back to this argument for its second round
                     // of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard
                     // when constructing types from type parameters that had no inference candidates).
-                    if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */ || source === nonInferrableAnyType || source === silentNeverType ||
-                        (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
                     if (inference) {
+                        if (ts.getObjectFlags(source) & 524288 /* NonInferrableType */) {
+                            return;
+                        }
                         if (!inference.isFixed) {
                             if (inference.priority === undefined || priority < inference.priority) {
                                 inference.candidates = undefined;
@@ -66641,21 +66653,19 @@ var ts;
                         inferencePriority = Math.min(inferencePriority, priority);
                         return;
                     }
-                    else {
-                        // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
-                        var simplified = getSimplifiedType(target, /*writing*/ false);
-                        if (simplified !== target) {
-                            invokeOnce(source, simplified, inferFromTypes);
-                        }
-                        else if (target.flags & 8388608 /* IndexedAccess */) {
-                            var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
-                            // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
-                            // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
-                            if (indexType.flags & 465829888 /* Instantiable */) {
-                                var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
-                                if (simplified_1 && simplified_1 !== target) {
-                                    invokeOnce(source, simplified_1, inferFromTypes);
-                                }
+                    // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine
+                    var simplified = getSimplifiedType(target, /*writing*/ false);
+                    if (simplified !== target) {
+                        inferFromTypes(source, simplified);
+                    }
+                    else if (target.flags & 8388608 /* IndexedAccess */) {
+                        var indexType = getSimplifiedType(target.indexType, /*writing*/ false);
+                        // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider
+                        // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can.
+                        if (indexType.flags & 465829888 /* Instantiable */) {
+                            var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false);
+                            if (simplified_1 && simplified_1 !== target) {
+                                inferFromTypes(source, simplified_1);
                             }
                         }
                     }
@@ -69525,7 +69535,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.6.0-dev.20211214",
+    "version": "4.6.0-dev.20211215",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [