typescript 4.8.0-dev.20220720 → 4.8.0-dev.20220723

package/lib/lib.dom.d.ts

@@ -13848,11 +13848,11 @@ declare var SubmitEvent: {
  * Available only in secure contexts.
  */
 interface SubtleCrypto {
-    decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
+    decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
     deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
     deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
     digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer>;
-    encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
+    encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
     exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
     exportKey(format: Exclude<KeyFormat, "jwk">, key: CryptoKey): Promise<ArrayBuffer>;
     generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKeyPair>;

package/lib/lib.webworker.d.ts

@@ -3008,11 +3008,11 @@ declare var StorageManager: {
  * Available only in secure contexts.
  */
 interface SubtleCrypto {
-    decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
+    decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
     deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
     deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
     digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer>;
-    encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<any>;
+    encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
     exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
     exportKey(format: Exclude<KeyFormat, "jwk">, key: CryptoKey): Promise<ArrayBuffer>;
     generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKeyPair>;

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.20220720";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220723";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -4317,8 +4317,10 @@ var ts;
                 watchPresentFileSystemEntry();
             return {
                 close: function () {
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -41385,7 +41387,7 @@ var ts;
                 }
             }
             function checkAndReportErrorForInvalidInitializer() {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 && useDefineForClassFields)) {
+                if (propertyWithInvalidInitializer && !(useDefineForClassFields && ts.getEmitScriptTarget(compilerOptions) >= 9)) {
                     error(errorLocation, errorLocation && propertyWithInvalidInitializer.type && ts.textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos)
                         ? ts.Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor
                         : ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyWithInvalidInitializer.name), diagnosticName(nameArg));
@@ -66741,7 +66743,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 || operator === 56 || operator === 60) {
                         if (operator === 55) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 || parent.operatorToken.kind === 56)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -76304,13 +76310,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -76373,7 +76379,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -78644,7 +78650,8 @@ var ts;
             else {
                 statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
             }
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
+            var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), true);
             ts.setTextRange(block, body);

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.20220720";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220723";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -6857,8 +6857,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -50437,7 +50439,7 @@ var ts;
             // 1. When result is undefined, after checking for a missing "this."
             // 2. When result is defined
             function checkAndReportErrorForInvalidInitializer() {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                if (propertyWithInvalidInitializer && !(useDefineForClassFields && ts.getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */)) {
                     // We have a match, but the reference occurred within a property initializer and the identifier also binds
                     // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
                     // with ESNext+useDefineForClassFields because the scope semantics are different.
@@ -79638,7 +79640,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90560,13 +90566,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90631,7 +90637,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -93512,7 +93518,8 @@ var ts;
                 statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
             }
             // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
+            var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -141758,8 +141765,12 @@ var ts;
                 return undefined;
             }
             var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters, hasReturn = commentOwnerInfo.hasReturn;
-            var commentOwnerJSDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? ts.lastOrUndefined(commentOwner.jsDoc) : undefined;
-            if (commentOwner.getStart(sourceFile) < position || commentOwnerJSDoc && commentOwnerJSDoc !== existingDocComment) {
+            var commentOwnerJsDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? commentOwner.jsDoc : undefined;
+            var lastJsDoc = ts.lastOrUndefined(commentOwnerJsDoc);
+            if (commentOwner.getStart(sourceFile) < position
+                || lastJsDoc
+                    && existingDocComment
+                    && lastJsDoc !== existingDocComment) {
                 return undefined;
             }
             var indentationStr = getIndentationStringAtPosition(sourceFile, position);
@@ -141776,7 +141787,9 @@ var ts;
             // * if the caret was directly in front of the object, then we add an extra line and indentation.
             var openComment = "/**";
             var closeComment = " */";
-            if (tags) {
+            // If any of the existing jsDoc has tags, ignore adding new ones.
+            var hasTag = (commentOwnerJsDoc || []).some(function (jsDoc) { return !!jsDoc.tags; });
+            if (tags && !hasTag) {
                 var preamble = openComment + newLine + indentationStr + " * ";
                 var endLine = tokenStart === position ? newLine + indentationStr : "";
                 var result = preamble + newLine + tags + indentationStr + closeComment + endLine;
@@ -148838,6 +148851,7 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    ts.Debug.assert(!ts.nodeIsSynthesized(child));
                     if (ts.nodeIsMissing(child)) {
                         return inheritedIndentation;
                     }
@@ -148904,6 +148918,7 @@ var ts;
                 }
                 function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
                     ts.Debug.assert(ts.isNodeArray(nodes));
+                    ts.Debug.assert(!ts.nodeIsSynthesized(nodes));
                     var listStartToken = getOpenTokenForList(parent, nodes);
                     var listDynamicIndentation = parentDynamicIndentation;
                     var startLine = parentStartLine;
@@ -155363,54 +155378,91 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
-                if (!related) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
                     return;
-                }
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
-                if (!info)
-                    return;
-                return addMissingConstraint(changes, info);
-            }); },
+            getAllCodeActions: function (context) {
+                var program = context.program, preferences = context.preferences, host = context.host;
+                var seen = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                        if (info) {
+                            var id = ts.getNodeId(info.declaration) + "#" + info.token.getText();
+                            if (ts.addToSeen(seen, id)) {
+                                return addMissingConstraint(changes, program, preferences, host, diag.file, info);
+                            }
+                        }
+                        return undefined;
+                    });
+                }));
+            }
         });
-        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+        function getInfo(program, sourceFile, span) {
             var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
-            if (!diag || !diag.relatedInformation)
+            if (diag === undefined || diag.relatedInformation === undefined)
                 return;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
-            if (!related)
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            return related;
-        }
-        function addMissingConstraint(changes, related) {
-            var decl = findAncestorMatchingSpan(related.file, related);
-            if (!decl)
+            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (declaration === undefined)
                 return;
-            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
-                decl = decl.parent;
+            if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
+                declaration = declaration.parent;
+            }
+            if (ts.isTypeParameterDeclaration(declaration)) {
+                // should only issue fix on type parameters written using `extends`
+                if (ts.isMappedTypeNode(declaration.parent))
+                    return;
+                var token = ts.getTokenAtPosition(sourceFile, span.start);
+                var checker = program.getTypeChecker();
+                var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
+                return { constraint: constraint, declaration: declaration, token: token };
+            }
+            return undefined;
+        }
+        function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
+            var declaration = info.declaration, constraint = info.constraint;
+            var checker = program.getTypeChecker();
+            if (ts.isString(constraint)) {
+                changes.insertText(sourceFile, declaration.name.end, " extends " + constraint);
+            }
+            else {
+                var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host });
+                var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
+                var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker);
+                if (typeNode) {
+                    changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default));
+                    importAdder.writeFixes(changes);
+                }
             }
-            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
-                return; // should only issue fix on type parameters written using `extends`
-            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
-            if (!newConstraint)
-                return;
-            var newConstraintText = newConstraint[1];
-            changes.insertText(related.file, decl.name.end, " extends " + newConstraintText);
         }
         function findAncestorMatchingSpan(sourceFile, span) {
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
             var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
             while (token.end < end) {
                 token = token.parent;
             }
             return token;
         }
+        function tryGetConstraintFromDiagnosticMessage(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
+            return constraint;
+        }
+        function tryGetConstraintType(checker, node) {
+            if (ts.isTypeNode(node.parent)) {
+                return checker.getTypeArgumentConstraint(node.parent);
+            }
+            var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined;
+            return contextualType || checker.getTypeAtLocation(node);
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */

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.20220720";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220723";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7051,8 +7051,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -50631,7 +50633,7 @@ var ts;
             // 1. When result is undefined, after checking for a missing "this."
             // 2. When result is defined
             function checkAndReportErrorForInvalidInitializer() {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                if (propertyWithInvalidInitializer && !(useDefineForClassFields && ts.getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */)) {
                     // We have a match, but the reference occurred within a property initializer and the identifier also binds
                     // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
                     // with ESNext+useDefineForClassFields because the scope semantics are different.
@@ -79832,7 +79834,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90754,13 +90760,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90825,7 +90831,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -93706,7 +93712,8 @@ var ts;
                 statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
             }
             // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
+            var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -142371,8 +142378,12 @@ var ts;
                 return undefined;
             }
             var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters, hasReturn = commentOwnerInfo.hasReturn;
-            var commentOwnerJSDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? ts.lastOrUndefined(commentOwner.jsDoc) : undefined;
-            if (commentOwner.getStart(sourceFile) < position || commentOwnerJSDoc && commentOwnerJSDoc !== existingDocComment) {
+            var commentOwnerJsDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? commentOwner.jsDoc : undefined;
+            var lastJsDoc = ts.lastOrUndefined(commentOwnerJsDoc);
+            if (commentOwner.getStart(sourceFile) < position
+                || lastJsDoc
+                    && existingDocComment
+                    && lastJsDoc !== existingDocComment) {
                 return undefined;
             }
             var indentationStr = getIndentationStringAtPosition(sourceFile, position);
@@ -142389,7 +142400,9 @@ var ts;
             // * if the caret was directly in front of the object, then we add an extra line and indentation.
             var openComment = "/**";
             var closeComment = " */";
-            if (tags) {
+            // If any of the existing jsDoc has tags, ignore adding new ones.
+            var hasTag = (commentOwnerJsDoc || []).some(function (jsDoc) { return !!jsDoc.tags; });
+            if (tags && !hasTag) {
                 var preamble = openComment + newLine + indentationStr + " * ";
                 var endLine = tokenStart === position ? newLine + indentationStr : "";
                 var result = preamble + newLine + tags + indentationStr + closeComment + endLine;
@@ -149451,6 +149464,7 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    ts.Debug.assert(!ts.nodeIsSynthesized(child));
                     if (ts.nodeIsMissing(child)) {
                         return inheritedIndentation;
                     }
@@ -149517,6 +149531,7 @@ var ts;
                 }
                 function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
                     ts.Debug.assert(ts.isNodeArray(nodes));
+                    ts.Debug.assert(!ts.nodeIsSynthesized(nodes));
                     var listStartToken = getOpenTokenForList(parent, nodes);
                     var listDynamicIndentation = parentDynamicIndentation;
                     var startLine = parentStartLine;
@@ -155976,54 +155991,91 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
-                if (!related) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
                     return;
-                }
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
-                if (!info)
-                    return;
-                return addMissingConstraint(changes, info);
-            }); },
+            getAllCodeActions: function (context) {
+                var program = context.program, preferences = context.preferences, host = context.host;
+                var seen = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                        if (info) {
+                            var id = ts.getNodeId(info.declaration) + "#" + info.token.getText();
+                            if (ts.addToSeen(seen, id)) {
+                                return addMissingConstraint(changes, program, preferences, host, diag.file, info);
+                            }
+                        }
+                        return undefined;
+                    });
+                }));
+            }
         });
-        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+        function getInfo(program, sourceFile, span) {
             var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
-            if (!diag || !diag.relatedInformation)
+            if (diag === undefined || diag.relatedInformation === undefined)
                 return;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
-            if (!related)
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            return related;
-        }
-        function addMissingConstraint(changes, related) {
-            var decl = findAncestorMatchingSpan(related.file, related);
-            if (!decl)
+            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (declaration === undefined)
                 return;
-            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
-                decl = decl.parent;
+            if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
+                declaration = declaration.parent;
+            }
+            if (ts.isTypeParameterDeclaration(declaration)) {
+                // should only issue fix on type parameters written using `extends`
+                if (ts.isMappedTypeNode(declaration.parent))
+                    return;
+                var token = ts.getTokenAtPosition(sourceFile, span.start);
+                var checker = program.getTypeChecker();
+                var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
+                return { constraint: constraint, declaration: declaration, token: token };
+            }
+            return undefined;
+        }
+        function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
+            var declaration = info.declaration, constraint = info.constraint;
+            var checker = program.getTypeChecker();
+            if (ts.isString(constraint)) {
+                changes.insertText(sourceFile, declaration.name.end, " extends " + constraint);
+            }
+            else {
+                var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host });
+                var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
+                var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker);
+                if (typeNode) {
+                    changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default));
+                    importAdder.writeFixes(changes);
+                }
             }
-            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
-                return; // should only issue fix on type parameters written using `extends`
-            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
-            if (!newConstraint)
-                return;
-            var newConstraintText = newConstraint[1];
-            changes.insertText(related.file, decl.name.end, " extends " + newConstraintText);
         }
         function findAncestorMatchingSpan(sourceFile, span) {
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
             var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
             while (token.end < end) {
                 token = token.parent;
             }
             return token;
         }
+        function tryGetConstraintFromDiagnosticMessage(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
+            return constraint;
+        }
+        function tryGetConstraintType(checker, node) {
+            if (ts.isTypeNode(node.parent)) {
+                return checker.getTypeArgumentConstraint(node.parent);
+            }
+            var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined;
+            return contextualType || checker.getTypeAtLocation(node);
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */

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.20220720";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220723";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7042,8 +7042,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -50622,7 +50624,7 @@ var ts;
             // 1. When result is undefined, after checking for a missing "this."
             // 2. When result is defined
             function checkAndReportErrorForInvalidInitializer() {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                if (propertyWithInvalidInitializer && !(useDefineForClassFields && ts.getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */)) {
                     // We have a match, but the reference occurred within a property initializer and the identifier also binds
                     // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
                     // with ESNext+useDefineForClassFields because the scope semantics are different.
@@ -79823,7 +79825,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90745,13 +90751,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90816,7 +90822,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -93697,7 +93703,8 @@ var ts;
                 statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
             }
             // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
+            var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -142362,8 +142369,12 @@ var ts;
                 return undefined;
             }
             var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters, hasReturn = commentOwnerInfo.hasReturn;
-            var commentOwnerJSDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? ts.lastOrUndefined(commentOwner.jsDoc) : undefined;
-            if (commentOwner.getStart(sourceFile) < position || commentOwnerJSDoc && commentOwnerJSDoc !== existingDocComment) {
+            var commentOwnerJsDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? commentOwner.jsDoc : undefined;
+            var lastJsDoc = ts.lastOrUndefined(commentOwnerJsDoc);
+            if (commentOwner.getStart(sourceFile) < position
+                || lastJsDoc
+                    && existingDocComment
+                    && lastJsDoc !== existingDocComment) {
                 return undefined;
             }
             var indentationStr = getIndentationStringAtPosition(sourceFile, position);
@@ -142380,7 +142391,9 @@ var ts;
             // * if the caret was directly in front of the object, then we add an extra line and indentation.
             var openComment = "/**";
             var closeComment = " */";
-            if (tags) {
+            // If any of the existing jsDoc has tags, ignore adding new ones.
+            var hasTag = (commentOwnerJsDoc || []).some(function (jsDoc) { return !!jsDoc.tags; });
+            if (tags && !hasTag) {
                 var preamble = openComment + newLine + indentationStr + " * ";
                 var endLine = tokenStart === position ? newLine + indentationStr : "";
                 var result = preamble + newLine + tags + indentationStr + closeComment + endLine;
@@ -149442,6 +149455,7 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    ts.Debug.assert(!ts.nodeIsSynthesized(child));
                     if (ts.nodeIsMissing(child)) {
                         return inheritedIndentation;
                     }
@@ -149508,6 +149522,7 @@ var ts;
                 }
                 function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
                     ts.Debug.assert(ts.isNodeArray(nodes));
+                    ts.Debug.assert(!ts.nodeIsSynthesized(nodes));
                     var listStartToken = getOpenTokenForList(parent, nodes);
                     var listDynamicIndentation = parentDynamicIndentation;
                     var startLine = parentStartLine;
@@ -155967,54 +155982,91 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
-                if (!related) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
                     return;
-                }
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
-                if (!info)
-                    return;
-                return addMissingConstraint(changes, info);
-            }); },
+            getAllCodeActions: function (context) {
+                var program = context.program, preferences = context.preferences, host = context.host;
+                var seen = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                        if (info) {
+                            var id = ts.getNodeId(info.declaration) + "#" + info.token.getText();
+                            if (ts.addToSeen(seen, id)) {
+                                return addMissingConstraint(changes, program, preferences, host, diag.file, info);
+                            }
+                        }
+                        return undefined;
+                    });
+                }));
+            }
         });
-        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+        function getInfo(program, sourceFile, span) {
             var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
-            if (!diag || !diag.relatedInformation)
+            if (diag === undefined || diag.relatedInformation === undefined)
                 return;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
-            if (!related)
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            return related;
-        }
-        function addMissingConstraint(changes, related) {
-            var decl = findAncestorMatchingSpan(related.file, related);
-            if (!decl)
+            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (declaration === undefined)
                 return;
-            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
-                decl = decl.parent;
+            if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
+                declaration = declaration.parent;
+            }
+            if (ts.isTypeParameterDeclaration(declaration)) {
+                // should only issue fix on type parameters written using `extends`
+                if (ts.isMappedTypeNode(declaration.parent))
+                    return;
+                var token = ts.getTokenAtPosition(sourceFile, span.start);
+                var checker = program.getTypeChecker();
+                var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
+                return { constraint: constraint, declaration: declaration, token: token };
+            }
+            return undefined;
+        }
+        function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
+            var declaration = info.declaration, constraint = info.constraint;
+            var checker = program.getTypeChecker();
+            if (ts.isString(constraint)) {
+                changes.insertText(sourceFile, declaration.name.end, " extends " + constraint);
+            }
+            else {
+                var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host });
+                var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
+                var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker);
+                if (typeNode) {
+                    changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default));
+                    importAdder.writeFixes(changes);
+                }
             }
-            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
-                return; // should only issue fix on type parameters written using `extends`
-            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
-            if (!newConstraint)
-                return;
-            var newConstraintText = newConstraint[1];
-            changes.insertText(related.file, decl.name.end, " extends " + newConstraintText);
         }
         function findAncestorMatchingSpan(sourceFile, span) {
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
             var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
             while (token.end < end) {
                 token = token.parent;
             }
             return token;
         }
+        function tryGetConstraintFromDiagnosticMessage(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
+            return constraint;
+        }
+        function tryGetConstraintType(checker, node) {
+            if (ts.isTypeNode(node.parent)) {
+                return checker.getTypeArgumentConstraint(node.parent);
+            }
+            var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined;
+            return contextualType || checker.getTypeAtLocation(node);
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */

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.20220720";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220723";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7042,8 +7042,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -50622,7 +50624,7 @@ var ts;
             // 1. When result is undefined, after checking for a missing "this."
             // 2. When result is defined
             function checkAndReportErrorForInvalidInitializer() {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                if (propertyWithInvalidInitializer && !(useDefineForClassFields && ts.getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */)) {
                     // We have a match, but the reference occurred within a property initializer and the identifier also binds
                     // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
                     // with ESNext+useDefineForClassFields because the scope semantics are different.
@@ -79823,7 +79825,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90745,13 +90751,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90816,7 +90822,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -93697,7 +93703,8 @@ var ts;
                 statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
             }
             // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
+            var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -142362,8 +142369,12 @@ var ts;
                 return undefined;
             }
             var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters, hasReturn = commentOwnerInfo.hasReturn;
-            var commentOwnerJSDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? ts.lastOrUndefined(commentOwner.jsDoc) : undefined;
-            if (commentOwner.getStart(sourceFile) < position || commentOwnerJSDoc && commentOwnerJSDoc !== existingDocComment) {
+            var commentOwnerJsDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? commentOwner.jsDoc : undefined;
+            var lastJsDoc = ts.lastOrUndefined(commentOwnerJsDoc);
+            if (commentOwner.getStart(sourceFile) < position
+                || lastJsDoc
+                    && existingDocComment
+                    && lastJsDoc !== existingDocComment) {
                 return undefined;
             }
             var indentationStr = getIndentationStringAtPosition(sourceFile, position);
@@ -142380,7 +142391,9 @@ var ts;
             // * if the caret was directly in front of the object, then we add an extra line and indentation.
             var openComment = "/**";
             var closeComment = " */";
-            if (tags) {
+            // If any of the existing jsDoc has tags, ignore adding new ones.
+            var hasTag = (commentOwnerJsDoc || []).some(function (jsDoc) { return !!jsDoc.tags; });
+            if (tags && !hasTag) {
                 var preamble = openComment + newLine + indentationStr + " * ";
                 var endLine = tokenStart === position ? newLine + indentationStr : "";
                 var result = preamble + newLine + tags + indentationStr + closeComment + endLine;
@@ -149442,6 +149455,7 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    ts.Debug.assert(!ts.nodeIsSynthesized(child));
                     if (ts.nodeIsMissing(child)) {
                         return inheritedIndentation;
                     }
@@ -149508,6 +149522,7 @@ var ts;
                 }
                 function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
                     ts.Debug.assert(ts.isNodeArray(nodes));
+                    ts.Debug.assert(!ts.nodeIsSynthesized(nodes));
                     var listStartToken = getOpenTokenForList(parent, nodes);
                     var listDynamicIndentation = parentDynamicIndentation;
                     var startLine = parentStartLine;
@@ -155967,54 +155982,91 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
-                if (!related) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
                     return;
-                }
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
-                if (!info)
-                    return;
-                return addMissingConstraint(changes, info);
-            }); },
+            getAllCodeActions: function (context) {
+                var program = context.program, preferences = context.preferences, host = context.host;
+                var seen = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                        if (info) {
+                            var id = ts.getNodeId(info.declaration) + "#" + info.token.getText();
+                            if (ts.addToSeen(seen, id)) {
+                                return addMissingConstraint(changes, program, preferences, host, diag.file, info);
+                            }
+                        }
+                        return undefined;
+                    });
+                }));
+            }
         });
-        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+        function getInfo(program, sourceFile, span) {
             var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
-            if (!diag || !diag.relatedInformation)
+            if (diag === undefined || diag.relatedInformation === undefined)
                 return;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
-            if (!related)
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            return related;
-        }
-        function addMissingConstraint(changes, related) {
-            var decl = findAncestorMatchingSpan(related.file, related);
-            if (!decl)
+            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (declaration === undefined)
                 return;
-            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
-                decl = decl.parent;
+            if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
+                declaration = declaration.parent;
+            }
+            if (ts.isTypeParameterDeclaration(declaration)) {
+                // should only issue fix on type parameters written using `extends`
+                if (ts.isMappedTypeNode(declaration.parent))
+                    return;
+                var token = ts.getTokenAtPosition(sourceFile, span.start);
+                var checker = program.getTypeChecker();
+                var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
+                return { constraint: constraint, declaration: declaration, token: token };
+            }
+            return undefined;
+        }
+        function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
+            var declaration = info.declaration, constraint = info.constraint;
+            var checker = program.getTypeChecker();
+            if (ts.isString(constraint)) {
+                changes.insertText(sourceFile, declaration.name.end, " extends " + constraint);
+            }
+            else {
+                var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host });
+                var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
+                var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker);
+                if (typeNode) {
+                    changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default));
+                    importAdder.writeFixes(changes);
+                }
             }
-            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
-                return; // should only issue fix on type parameters written using `extends`
-            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
-            if (!newConstraint)
-                return;
-            var newConstraintText = newConstraint[1];
-            changes.insertText(related.file, decl.name.end, " extends " + newConstraintText);
         }
         function findAncestorMatchingSpan(sourceFile, span) {
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
             var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
             while (token.end < end) {
                 token = token.parent;
             }
             return token;
         }
+        function tryGetConstraintFromDiagnosticMessage(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
+            return constraint;
+        }
+        function tryGetConstraintType(checker, node) {
+            if (ts.isTypeNode(node.parent)) {
+                return checker.getTypeArgumentConstraint(node.parent);
+            }
+            var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined;
+            return contextualType || checker.getTypeAtLocation(node);
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */

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.20220720";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220723";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -6837,8 +6837,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -50417,7 +50419,7 @@ var ts;
             // 1. When result is undefined, after checking for a missing "this."
             // 2. When result is defined
             function checkAndReportErrorForInvalidInitializer() {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                if (propertyWithInvalidInitializer && !(useDefineForClassFields && ts.getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */)) {
                     // We have a match, but the reference occurred within a property initializer and the identifier also binds
                     // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
                     // with ESNext+useDefineForClassFields because the scope semantics are different.
@@ -79618,7 +79620,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90540,13 +90546,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90611,7 +90617,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -93492,7 +93498,8 @@ var ts;
                 statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
             }
             // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
+            var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);

package/package.json

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