typescript 4.7.0-dev.20220416 → 4.7.0-dev.20220419

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.7";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220416";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220419";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -26733,7 +26733,7 @@ var ts;
             var pos = getNodePos();
             parseExpected(112);
             var entityName = parseEntityName(true, true);
-            var typeArguments = tryParseTypeArguments();
+            var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
@@ -51418,8 +51418,11 @@ var ts;
                     return type[cache] = elementType;
                 }
             }
-            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
-                return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+            if (isGenericMappedType(objectType)) {
+                var nameType = getNameTypeFromMappedType(objectType);
+                if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
+                    return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+                }
             }
             return type[cache] = type;
         }

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.20220416";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220419";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33186,7 +33186,8 @@ var ts;
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
             var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
-            var typeArguments = tryParseTypeArguments();
+            // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
+            var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
@@ -61934,11 +61935,14 @@ var ts;
                     return type[cache] = elementType;
                 }
             }
-            // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
-            // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
-            // construct the type Box<T[X]>.
-            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
-                return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+            // If the object type is a mapped type { [P in K]: E }, where K is generic, or { [P in K as N]: E }, where
+            // K is generic and N is assignable to P, instantiate E using a mapper that substitutes the index type for P.
+            // For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the type Box<T[X]>.
+            if (isGenericMappedType(objectType)) {
+                var nameType = getNameTypeFromMappedType(objectType);
+                if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
+                    return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+                }
             }
             return type[cache] = type;
         }

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.20220416";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220419";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33380,7 +33380,8 @@ var ts;
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
             var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
-            var typeArguments = tryParseTypeArguments();
+            // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
+            var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
@@ -62128,11 +62129,14 @@ var ts;
                     return type[cache] = elementType;
                 }
             }
-            // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
-            // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
-            // construct the type Box<T[X]>.
-            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
-                return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+            // If the object type is a mapped type { [P in K]: E }, where K is generic, or { [P in K as N]: E }, where
+            // K is generic and N is assignable to P, instantiate E using a mapper that substitutes the index type for P.
+            // For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the type Box<T[X]>.
+            if (isGenericMappedType(objectType)) {
+                var nameType = getNameTypeFromMappedType(objectType);
+                if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
+                    return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+                }
             }
             return type[cache] = type;
         }

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.20220416";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220419";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33380,7 +33380,8 @@ var ts;
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
             var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
-            var typeArguments = tryParseTypeArguments();
+            // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
+            var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
@@ -62128,11 +62129,14 @@ var ts;
                     return type[cache] = elementType;
                 }
             }
-            // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
-            // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
-            // construct the type Box<T[X]>.
-            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
-                return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+            // If the object type is a mapped type { [P in K]: E }, where K is generic, or { [P in K as N]: E }, where
+            // K is generic and N is assignable to P, instantiate E using a mapper that substitutes the index type for P.
+            // For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the type Box<T[X]>.
+            if (isGenericMappedType(objectType)) {
+                var nameType = getNameTypeFromMappedType(objectType);
+                if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
+                    return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+                }
             }
             return type[cache] = type;
         }

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.20220416";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220419";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33380,7 +33380,8 @@ var ts;
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
             var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
-            var typeArguments = tryParseTypeArguments();
+            // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
+            var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
@@ -62128,11 +62129,14 @@ var ts;
                     return type[cache] = elementType;
                 }
             }
-            // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
-            // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
-            // construct the type Box<T[X]>.
-            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
-                return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+            // If the object type is a mapped type { [P in K]: E }, where K is generic, or { [P in K as N]: E }, where
+            // K is generic and N is assignable to P, instantiate E using a mapper that substitutes the index type for P.
+            // For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the type Box<T[X]>.
+            if (isGenericMappedType(objectType)) {
+                var nameType = getNameTypeFromMappedType(objectType);
+                if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
+                    return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+                }
             }
             return type[cache] = type;
         }

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.20220416";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220419";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33175,7 +33175,8 @@ var ts;
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
             var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
-            var typeArguments = tryParseTypeArguments();
+            // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
+            var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
@@ -61923,11 +61924,14 @@ var ts;
                     return type[cache] = elementType;
                 }
             }
-            // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
-            // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
-            // construct the type Box<T[X]>.
-            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
-                return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+            // If the object type is a mapped type { [P in K]: E }, where K is generic, or { [P in K as N]: E }, where
+            // K is generic and N is assignable to P, instantiate E using a mapper that substitutes the index type for P.
+            // For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the type Box<T[X]>.
+            if (isGenericMappedType(objectType)) {
+                var nameType = getNameTypeFromMappedType(objectType);
+                if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
+                    return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+                }
             }
             return type[cache] = type;
         }

package/package.json

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