typescript 4.8.0-dev.20220628 → 4.8.0-dev.20220629

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.8";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220628";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220629";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -61329,8 +61329,8 @@ var ts;
             var conditional = node.parent;
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
         }
-        function getContextualTypeForChildJsxExpression(node, child) {
-            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
+        function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
+            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
             var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
             if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
                 return undefined;
@@ -61347,24 +61347,24 @@ var ts;
                 }
             }, true));
         }
-        function getContextualTypeForJsxExpression(node) {
+        function getContextualTypeForJsxExpression(node, contextFlags) {
             var exprParent = node.parent;
             return ts.isJsxAttributeLike(exprParent)
-                ? getContextualType(node)
+                ? getContextualType(node, contextFlags)
                 : ts.isJsxElement(exprParent)
-                    ? getContextualTypeForChildJsxExpression(exprParent, node)
+                    ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags)
                     : undefined;
         }
-        function getContextualTypeForJsxAttribute(attribute) {
+        function getContextualTypeForJsxAttribute(attribute, contextFlags) {
             if (ts.isJsxAttribute(attribute)) {
-                var attributesType = getApparentTypeOfContextualType(attribute.parent);
+                var attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
                 if (!attributesType || isTypeAny(attributesType)) {
                     return undefined;
                 }
                 return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
             }
             else {
-                return getContextualType(attribute.parent);
+                return getContextualType(attribute.parent, contextFlags);
             }
         }
         function isPossiblyDiscriminantValue(node) {
@@ -61488,10 +61488,10 @@ var ts;
                 case 271:
                     return tryGetTypeFromEffectiveTypeNode(parent);
                 case 288:
-                    return getContextualTypeForJsxExpression(parent);
+                    return getContextualTypeForJsxExpression(parent, contextFlags);
                 case 285:
                 case 287:
-                    return getContextualTypeForJsxAttribute(parent);
+                    return getContextualTypeForJsxAttribute(parent, contextFlags);
                 case 280:
                 case 279:
                     return getContextualJsxElementAttributesType(parent, contextFlags);
@@ -98803,7 +98803,7 @@ var ts;
             }
         }
         function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
             processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }

package/lib/tsserver.js

@@ -109,7 +109,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.20220628";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220629";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -73377,8 +73377,8 @@ var ts;
             var conditional = node.parent;
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
         }
-        function getContextualTypeForChildJsxExpression(node, child) {
-            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
+        function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
+            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
             // JSX expression is in children of JSX Element, we will look for an "children" attribute (we get the name from JSX.ElementAttributesProperty)
             var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
             if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
@@ -73396,27 +73396,27 @@ var ts;
                 }
             }, /*noReductions*/ true));
         }
-        function getContextualTypeForJsxExpression(node) {
+        function getContextualTypeForJsxExpression(node, contextFlags) {
             var exprParent = node.parent;
             return ts.isJsxAttributeLike(exprParent)
-                ? getContextualType(node)
+                ? getContextualType(node, contextFlags)
                 : ts.isJsxElement(exprParent)
-                    ? getContextualTypeForChildJsxExpression(exprParent, node)
+                    ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags)
                     : undefined;
         }
-        function getContextualTypeForJsxAttribute(attribute) {
+        function getContextualTypeForJsxAttribute(attribute, contextFlags) {
             // When we trying to resolve JsxOpeningLikeElement as a stateless function element, we will already give its attributes a contextual type
             // which is a type of the parameter of the signature we are trying out.
             // If there is no contextual type (e.g. we are trying to resolve stateful component), get attributes type from resolving element's tagName
             if (ts.isJsxAttribute(attribute)) {
-                var attributesType = getApparentTypeOfContextualType(attribute.parent);
+                var attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
                 if (!attributesType || isTypeAny(attributesType)) {
                     return undefined;
                 }
                 return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
             }
             else {
-                return getContextualType(attribute.parent);
+                return getContextualType(attribute.parent, contextFlags);
             }
         }
         // Return true if the given expression is possibly a discriminant value. We limit the kinds of
@@ -73577,10 +73577,10 @@ var ts;
                 case 271 /* ExportAssignment */:
                     return tryGetTypeFromEffectiveTypeNode(parent);
                 case 288 /* JsxExpression */:
-                    return getContextualTypeForJsxExpression(parent);
+                    return getContextualTypeForJsxExpression(parent, contextFlags);
                 case 285 /* JsxAttribute */:
                 case 287 /* JsxSpreadAttribute */:
-                    return getContextualTypeForJsxAttribute(parent);
+                    return getContextualTypeForJsxAttribute(parent, contextFlags);
                 case 280 /* JsxOpeningElement */:
                 case 279 /* JsxSelfClosingElement */:
                     return getContextualJsxElementAttributesType(parent, contextFlags);
@@ -119437,7 +119437,7 @@ var ts;
             }
         }
         function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
             processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }

package/lib/tsserverlibrary.js

@@ -303,7 +303,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.20220628";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220629";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -73571,8 +73571,8 @@ var ts;
             var conditional = node.parent;
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
         }
-        function getContextualTypeForChildJsxExpression(node, child) {
-            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
+        function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
+            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
             // JSX expression is in children of JSX Element, we will look for an "children" attribute (we get the name from JSX.ElementAttributesProperty)
             var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
             if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
@@ -73590,27 +73590,27 @@ var ts;
                 }
             }, /*noReductions*/ true));
         }
-        function getContextualTypeForJsxExpression(node) {
+        function getContextualTypeForJsxExpression(node, contextFlags) {
             var exprParent = node.parent;
             return ts.isJsxAttributeLike(exprParent)
-                ? getContextualType(node)
+                ? getContextualType(node, contextFlags)
                 : ts.isJsxElement(exprParent)
-                    ? getContextualTypeForChildJsxExpression(exprParent, node)
+                    ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags)
                     : undefined;
         }
-        function getContextualTypeForJsxAttribute(attribute) {
+        function getContextualTypeForJsxAttribute(attribute, contextFlags) {
             // When we trying to resolve JsxOpeningLikeElement as a stateless function element, we will already give its attributes a contextual type
             // which is a type of the parameter of the signature we are trying out.
             // If there is no contextual type (e.g. we are trying to resolve stateful component), get attributes type from resolving element's tagName
             if (ts.isJsxAttribute(attribute)) {
-                var attributesType = getApparentTypeOfContextualType(attribute.parent);
+                var attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
                 if (!attributesType || isTypeAny(attributesType)) {
                     return undefined;
                 }
                 return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
             }
             else {
-                return getContextualType(attribute.parent);
+                return getContextualType(attribute.parent, contextFlags);
             }
         }
         // Return true if the given expression is possibly a discriminant value. We limit the kinds of
@@ -73771,10 +73771,10 @@ var ts;
                 case 271 /* ExportAssignment */:
                     return tryGetTypeFromEffectiveTypeNode(parent);
                 case 288 /* JsxExpression */:
-                    return getContextualTypeForJsxExpression(parent);
+                    return getContextualTypeForJsxExpression(parent, contextFlags);
                 case 285 /* JsxAttribute */:
                 case 287 /* JsxSpreadAttribute */:
-                    return getContextualTypeForJsxAttribute(parent);
+                    return getContextualTypeForJsxAttribute(parent, contextFlags);
                 case 280 /* JsxOpeningElement */:
                 case 279 /* JsxSelfClosingElement */:
                     return getContextualJsxElementAttributesType(parent, contextFlags);
@@ -119631,7 +119631,7 @@ var ts;
             }
         }
         function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
             processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }

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.20220628";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220629";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -73562,8 +73562,8 @@ var ts;
             var conditional = node.parent;
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
         }
-        function getContextualTypeForChildJsxExpression(node, child) {
-            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
+        function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
+            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
             // JSX expression is in children of JSX Element, we will look for an "children" attribute (we get the name from JSX.ElementAttributesProperty)
             var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
             if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
@@ -73581,27 +73581,27 @@ var ts;
                 }
             }, /*noReductions*/ true));
         }
-        function getContextualTypeForJsxExpression(node) {
+        function getContextualTypeForJsxExpression(node, contextFlags) {
             var exprParent = node.parent;
             return ts.isJsxAttributeLike(exprParent)
-                ? getContextualType(node)
+                ? getContextualType(node, contextFlags)
                 : ts.isJsxElement(exprParent)
-                    ? getContextualTypeForChildJsxExpression(exprParent, node)
+                    ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags)
                     : undefined;
         }
-        function getContextualTypeForJsxAttribute(attribute) {
+        function getContextualTypeForJsxAttribute(attribute, contextFlags) {
             // When we trying to resolve JsxOpeningLikeElement as a stateless function element, we will already give its attributes a contextual type
             // which is a type of the parameter of the signature we are trying out.
             // If there is no contextual type (e.g. we are trying to resolve stateful component), get attributes type from resolving element's tagName
             if (ts.isJsxAttribute(attribute)) {
-                var attributesType = getApparentTypeOfContextualType(attribute.parent);
+                var attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
                 if (!attributesType || isTypeAny(attributesType)) {
                     return undefined;
                 }
                 return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
             }
             else {
-                return getContextualType(attribute.parent);
+                return getContextualType(attribute.parent, contextFlags);
             }
         }
         // Return true if the given expression is possibly a discriminant value. We limit the kinds of
@@ -73762,10 +73762,10 @@ var ts;
                 case 271 /* ExportAssignment */:
                     return tryGetTypeFromEffectiveTypeNode(parent);
                 case 288 /* JsxExpression */:
-                    return getContextualTypeForJsxExpression(parent);
+                    return getContextualTypeForJsxExpression(parent, contextFlags);
                 case 285 /* JsxAttribute */:
                 case 287 /* JsxSpreadAttribute */:
-                    return getContextualTypeForJsxAttribute(parent);
+                    return getContextualTypeForJsxAttribute(parent, contextFlags);
                 case 280 /* JsxOpeningElement */:
                 case 279 /* JsxSelfClosingElement */:
                     return getContextualJsxElementAttributesType(parent, contextFlags);
@@ -119622,7 +119622,7 @@ var ts;
             }
         }
         function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
             processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }

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.20220628";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220629";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -73562,8 +73562,8 @@ var ts;
             var conditional = node.parent;
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
         }
-        function getContextualTypeForChildJsxExpression(node, child) {
-            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
+        function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
+            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
             // JSX expression is in children of JSX Element, we will look for an "children" attribute (we get the name from JSX.ElementAttributesProperty)
             var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
             if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
@@ -73581,27 +73581,27 @@ var ts;
                 }
             }, /*noReductions*/ true));
         }
-        function getContextualTypeForJsxExpression(node) {
+        function getContextualTypeForJsxExpression(node, contextFlags) {
             var exprParent = node.parent;
             return ts.isJsxAttributeLike(exprParent)
-                ? getContextualType(node)
+                ? getContextualType(node, contextFlags)
                 : ts.isJsxElement(exprParent)
-                    ? getContextualTypeForChildJsxExpression(exprParent, node)
+                    ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags)
                     : undefined;
         }
-        function getContextualTypeForJsxAttribute(attribute) {
+        function getContextualTypeForJsxAttribute(attribute, contextFlags) {
             // When we trying to resolve JsxOpeningLikeElement as a stateless function element, we will already give its attributes a contextual type
             // which is a type of the parameter of the signature we are trying out.
             // If there is no contextual type (e.g. we are trying to resolve stateful component), get attributes type from resolving element's tagName
             if (ts.isJsxAttribute(attribute)) {
-                var attributesType = getApparentTypeOfContextualType(attribute.parent);
+                var attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
                 if (!attributesType || isTypeAny(attributesType)) {
                     return undefined;
                 }
                 return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
             }
             else {
-                return getContextualType(attribute.parent);
+                return getContextualType(attribute.parent, contextFlags);
             }
         }
         // Return true if the given expression is possibly a discriminant value. We limit the kinds of
@@ -73762,10 +73762,10 @@ var ts;
                 case 271 /* ExportAssignment */:
                     return tryGetTypeFromEffectiveTypeNode(parent);
                 case 288 /* JsxExpression */:
-                    return getContextualTypeForJsxExpression(parent);
+                    return getContextualTypeForJsxExpression(parent, contextFlags);
                 case 285 /* JsxAttribute */:
                 case 287 /* JsxSpreadAttribute */:
-                    return getContextualTypeForJsxAttribute(parent);
+                    return getContextualTypeForJsxAttribute(parent, contextFlags);
                 case 280 /* JsxOpeningElement */:
                 case 279 /* JsxSelfClosingElement */:
                     return getContextualJsxElementAttributesType(parent, contextFlags);
@@ -119622,7 +119622,7 @@ var ts;
             }
         }
         function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
             processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }

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.20220628";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220629";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -73357,8 +73357,8 @@ var ts;
             var conditional = node.parent;
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined;
         }
-        function getContextualTypeForChildJsxExpression(node, child) {
-            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName);
+        function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
+            var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
             // JSX expression is in children of JSX Element, we will look for an "children" attribute (we get the name from JSX.ElementAttributesProperty)
             var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
             if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
@@ -73376,27 +73376,27 @@ var ts;
                 }
             }, /*noReductions*/ true));
         }
-        function getContextualTypeForJsxExpression(node) {
+        function getContextualTypeForJsxExpression(node, contextFlags) {
             var exprParent = node.parent;
             return ts.isJsxAttributeLike(exprParent)
-                ? getContextualType(node)
+                ? getContextualType(node, contextFlags)
                 : ts.isJsxElement(exprParent)
-                    ? getContextualTypeForChildJsxExpression(exprParent, node)
+                    ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags)
                     : undefined;
         }
-        function getContextualTypeForJsxAttribute(attribute) {
+        function getContextualTypeForJsxAttribute(attribute, contextFlags) {
             // When we trying to resolve JsxOpeningLikeElement as a stateless function element, we will already give its attributes a contextual type
             // which is a type of the parameter of the signature we are trying out.
             // If there is no contextual type (e.g. we are trying to resolve stateful component), get attributes type from resolving element's tagName
             if (ts.isJsxAttribute(attribute)) {
-                var attributesType = getApparentTypeOfContextualType(attribute.parent);
+                var attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
                 if (!attributesType || isTypeAny(attributesType)) {
                     return undefined;
                 }
                 return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
             }
             else {
-                return getContextualType(attribute.parent);
+                return getContextualType(attribute.parent, contextFlags);
             }
         }
         // Return true if the given expression is possibly a discriminant value. We limit the kinds of
@@ -73557,10 +73557,10 @@ var ts;
                 case 271 /* ExportAssignment */:
                     return tryGetTypeFromEffectiveTypeNode(parent);
                 case 288 /* JsxExpression */:
-                    return getContextualTypeForJsxExpression(parent);
+                    return getContextualTypeForJsxExpression(parent, contextFlags);
                 case 285 /* JsxAttribute */:
                 case 287 /* JsxSpreadAttribute */:
-                    return getContextualTypeForJsxAttribute(parent);
+                    return getContextualTypeForJsxAttribute(parent, contextFlags);
                 case 280 /* JsxOpeningElement */:
                 case 279 /* JsxSelfClosingElement */:
                     return getContextualJsxElementAttributesType(parent, contextFlags);
@@ -119417,7 +119417,7 @@ var ts;
             }
         }
         function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
             processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }

package/package.json

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