typescript 4.8.0-dev.20220615 → 4.8.0-dev.20220616

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.20220615";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220616";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -5642,9 +5642,11 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", undefined, true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
-        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
+        This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."),
+        Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -28778,9 +28780,10 @@ var ts;
             }
             nextToken();
             var typeArguments = parseDelimitedList(20, parseType);
-            if (!parseExpected(31)) {
+            if (reScanGreaterToken() !== 31) {
                 return undefined;
             }
+            nextToken();
             return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined;
         }
         function canFollowTypeArgumentsInExpression() {
@@ -43220,6 +43223,9 @@ var ts;
             if (symbol && symbol.flags & 262144 && meaning & 788968) {
                 return { accessibility: 0 };
             }
+            if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, false)), firstIdentifier, meaning, false).accessibility === 0) {
+                return { accessibility: 0 };
+            }
             return (symbol && hasVisibleDeclarations(symbol, true)) || {
                 accessibility: 1,
                 errorSymbolName: ts.getTextOfNode(firstIdentifier),
@@ -54610,8 +54616,13 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864))) {
-                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                if (source.flags & 262144 && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) {
+                    var syntheticParam = cloneTypeParameter(source);
+                    syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam));
+                    if (hasNonCircularBaseConstraint(syntheticParam)) {
+                        var targetConstraintString = typeToString(target, source.symbol.declarations[0]);
+                        associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
+                    }
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {

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.20220615";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220616";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8483,9 +8483,11 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
-        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
+        This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."),
+        Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -35787,10 +35789,11 @@ var ts;
             }
             nextToken();
             var typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
-            if (!parseExpected(31 /* GreaterThanToken */)) {
+            if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
+            nextToken();
             // We successfully parsed a type argument list. The next token determines whether we want to
             // treat it as such. If the type argument list is followed by `(` or a template literal, as in
             // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
@@ -52540,6 +52543,9 @@ var ts;
             if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
                 return { accessibility: 0 /* Accessible */ };
             }
+            if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false)), firstIdentifier, meaning, /*computeAliases*/ false).accessibility === 0 /* Accessible */) {
+                return { accessibility: 0 /* Accessible */ };
+            }
             // Verify if the symbol is accessible
             return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || {
                 accessibility: 1 /* NotAccessible */,
@@ -65500,8 +65506,13 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
-                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                if (source.flags & 262144 /* TypeParameter */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) {
+                    var syntheticParam = cloneTypeParameter(source);
+                    syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam));
+                    if (hasNonCircularBaseConstraint(syntheticParam)) {
+                        var targetConstraintString = typeToString(target, source.symbol.declarations[0]);
+                        associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
+                    }
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
@@ -145216,7 +145227,7 @@ var ts;
                 return type.symbol && (type.symbol.flags & 1536 /* Module */);
             }
             function visitVariableLikeDeclaration(decl) {
-                if (!decl.initializer || ts.isBindingPattern(decl.name)) {
+                if (!decl.initializer || ts.isBindingPattern(decl.name) || ts.isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
                     return;
                 }
                 var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(decl);
@@ -145344,6 +145355,9 @@ var ts;
                 }
                 for (var i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
                     var param = node.parameters[i];
+                    if (!isHintableDeclaration(param)) {
+                        continue;
+                    }
                     var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(param);
                     if (effectiveTypeAnnotation) {
                         continue;
@@ -145385,6 +145399,13 @@ var ts;
             function isUndefined(name) {
                 return name === "undefined";
             }
+            function isHintableDeclaration(node) {
+                if ((ts.isParameterDeclaration(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) {
+                    var initializer = ts.skipParentheses(node.initializer);
+                    return !(isHintableLiteral(initializer) || ts.isNewExpression(initializer) || ts.isObjectLiteralExpression(initializer) || ts.isAssertionExpression(initializer));
+                }
+                return true;
+            }
         }
         InlayHints.provideInlayHints = provideInlayHints;
     })(InlayHints = ts.InlayHints || (ts.InlayHints = {}));
@@ -154823,6 +154844,77 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "addMissingConstraint";
+        var errorCodes = [
+            // We want errors this could be attached to:
+            // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint
+            ts.Diagnostics.Type_0_is_not_comparable_to_type_1.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code,
+            ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Property_0_is_incompatible_with_index_signature.code,
+            ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code,
+            ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code,
+        ];
+        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) {
+                    return;
+                }
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                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);
+            }); },
+        });
+        function getDiagnosticRelatedInfo(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)
+                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)
+                return;
+            return related;
+        }
+        function addMissingConstraint(changes, related) {
+            var decl = findAncestorMatchingSpan(related.file, related);
+            if (!decl)
+                return;
+            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
+                decl = decl.parent;
+            }
+            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, related.start + related.length, " extends " + newConstraintText);
+        }
+        function findAncestorMatchingSpan(sourceFile, span) {
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
+            var end = ts.textSpanEnd(span);
+            while (token.end < end) {
+                token = token.parent;
+            }
+            return token;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {

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.20220615";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220616";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8677,9 +8677,11 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
-        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
+        This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."),
+        Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -35981,10 +35983,11 @@ var ts;
             }
             nextToken();
             var typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
-            if (!parseExpected(31 /* GreaterThanToken */)) {
+            if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
+            nextToken();
             // We successfully parsed a type argument list. The next token determines whether we want to
             // treat it as such. If the type argument list is followed by `(` or a template literal, as in
             // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
@@ -52734,6 +52737,9 @@ var ts;
             if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
                 return { accessibility: 0 /* Accessible */ };
             }
+            if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false)), firstIdentifier, meaning, /*computeAliases*/ false).accessibility === 0 /* Accessible */) {
+                return { accessibility: 0 /* Accessible */ };
+            }
             // Verify if the symbol is accessible
             return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || {
                 accessibility: 1 /* NotAccessible */,
@@ -65694,8 +65700,13 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
-                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                if (source.flags & 262144 /* TypeParameter */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) {
+                    var syntheticParam = cloneTypeParameter(source);
+                    syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam));
+                    if (hasNonCircularBaseConstraint(syntheticParam)) {
+                        var targetConstraintString = typeToString(target, source.symbol.declarations[0]);
+                        associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
+                    }
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
@@ -145829,7 +145840,7 @@ var ts;
                 return type.symbol && (type.symbol.flags & 1536 /* Module */);
             }
             function visitVariableLikeDeclaration(decl) {
-                if (!decl.initializer || ts.isBindingPattern(decl.name)) {
+                if (!decl.initializer || ts.isBindingPattern(decl.name) || ts.isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
                     return;
                 }
                 var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(decl);
@@ -145957,6 +145968,9 @@ var ts;
                 }
                 for (var i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
                     var param = node.parameters[i];
+                    if (!isHintableDeclaration(param)) {
+                        continue;
+                    }
                     var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(param);
                     if (effectiveTypeAnnotation) {
                         continue;
@@ -145998,6 +146012,13 @@ var ts;
             function isUndefined(name) {
                 return name === "undefined";
             }
+            function isHintableDeclaration(node) {
+                if ((ts.isParameterDeclaration(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) {
+                    var initializer = ts.skipParentheses(node.initializer);
+                    return !(isHintableLiteral(initializer) || ts.isNewExpression(initializer) || ts.isObjectLiteralExpression(initializer) || ts.isAssertionExpression(initializer));
+                }
+                return true;
+            }
         }
         InlayHints.provideInlayHints = provideInlayHints;
     })(InlayHints = ts.InlayHints || (ts.InlayHints = {}));
@@ -155436,6 +155457,77 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "addMissingConstraint";
+        var errorCodes = [
+            // We want errors this could be attached to:
+            // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint
+            ts.Diagnostics.Type_0_is_not_comparable_to_type_1.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code,
+            ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Property_0_is_incompatible_with_index_signature.code,
+            ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code,
+            ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code,
+        ];
+        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) {
+                    return;
+                }
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                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);
+            }); },
+        });
+        function getDiagnosticRelatedInfo(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)
+                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)
+                return;
+            return related;
+        }
+        function addMissingConstraint(changes, related) {
+            var decl = findAncestorMatchingSpan(related.file, related);
+            if (!decl)
+                return;
+            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
+                decl = decl.parent;
+            }
+            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, related.start + related.length, " extends " + newConstraintText);
+        }
+        function findAncestorMatchingSpan(sourceFile, span) {
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
+            var end = ts.textSpanEnd(span);
+            while (token.end < end) {
+                token = token.parent;
+            }
+            return token;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {

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.20220615";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220616";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8668,9 +8668,11 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
-        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
+        This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."),
+        Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -35972,10 +35974,11 @@ var ts;
             }
             nextToken();
             var typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
-            if (!parseExpected(31 /* GreaterThanToken */)) {
+            if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
+            nextToken();
             // We successfully parsed a type argument list. The next token determines whether we want to
             // treat it as such. If the type argument list is followed by `(` or a template literal, as in
             // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
@@ -52725,6 +52728,9 @@ var ts;
             if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
                 return { accessibility: 0 /* Accessible */ };
             }
+            if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false)), firstIdentifier, meaning, /*computeAliases*/ false).accessibility === 0 /* Accessible */) {
+                return { accessibility: 0 /* Accessible */ };
+            }
             // Verify if the symbol is accessible
             return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || {
                 accessibility: 1 /* NotAccessible */,
@@ -65685,8 +65691,13 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
-                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                if (source.flags & 262144 /* TypeParameter */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) {
+                    var syntheticParam = cloneTypeParameter(source);
+                    syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam));
+                    if (hasNonCircularBaseConstraint(syntheticParam)) {
+                        var targetConstraintString = typeToString(target, source.symbol.declarations[0]);
+                        associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
+                    }
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
@@ -145820,7 +145831,7 @@ var ts;
                 return type.symbol && (type.symbol.flags & 1536 /* Module */);
             }
             function visitVariableLikeDeclaration(decl) {
-                if (!decl.initializer || ts.isBindingPattern(decl.name)) {
+                if (!decl.initializer || ts.isBindingPattern(decl.name) || ts.isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
                     return;
                 }
                 var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(decl);
@@ -145948,6 +145959,9 @@ var ts;
                 }
                 for (var i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
                     var param = node.parameters[i];
+                    if (!isHintableDeclaration(param)) {
+                        continue;
+                    }
                     var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(param);
                     if (effectiveTypeAnnotation) {
                         continue;
@@ -145989,6 +146003,13 @@ var ts;
             function isUndefined(name) {
                 return name === "undefined";
             }
+            function isHintableDeclaration(node) {
+                if ((ts.isParameterDeclaration(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) {
+                    var initializer = ts.skipParentheses(node.initializer);
+                    return !(isHintableLiteral(initializer) || ts.isNewExpression(initializer) || ts.isObjectLiteralExpression(initializer) || ts.isAssertionExpression(initializer));
+                }
+                return true;
+            }
         }
         InlayHints.provideInlayHints = provideInlayHints;
     })(InlayHints = ts.InlayHints || (ts.InlayHints = {}));
@@ -155427,6 +155448,77 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "addMissingConstraint";
+        var errorCodes = [
+            // We want errors this could be attached to:
+            // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint
+            ts.Diagnostics.Type_0_is_not_comparable_to_type_1.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code,
+            ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Property_0_is_incompatible_with_index_signature.code,
+            ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code,
+            ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code,
+        ];
+        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) {
+                    return;
+                }
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                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);
+            }); },
+        });
+        function getDiagnosticRelatedInfo(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)
+                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)
+                return;
+            return related;
+        }
+        function addMissingConstraint(changes, related) {
+            var decl = findAncestorMatchingSpan(related.file, related);
+            if (!decl)
+                return;
+            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
+                decl = decl.parent;
+            }
+            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, related.start + related.length, " extends " + newConstraintText);
+        }
+        function findAncestorMatchingSpan(sourceFile, span) {
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
+            var end = ts.textSpanEnd(span);
+            while (token.end < end) {
+                token = token.parent;
+            }
+            return token;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {

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.20220615";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220616";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8668,9 +8668,11 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
-        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
+        This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."),
+        Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -35972,10 +35974,11 @@ var ts;
             }
             nextToken();
             var typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
-            if (!parseExpected(31 /* GreaterThanToken */)) {
+            if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
+            nextToken();
             // We successfully parsed a type argument list. The next token determines whether we want to
             // treat it as such. If the type argument list is followed by `(` or a template literal, as in
             // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
@@ -52725,6 +52728,9 @@ var ts;
             if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
                 return { accessibility: 0 /* Accessible */ };
             }
+            if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false)), firstIdentifier, meaning, /*computeAliases*/ false).accessibility === 0 /* Accessible */) {
+                return { accessibility: 0 /* Accessible */ };
+            }
             // Verify if the symbol is accessible
             return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || {
                 accessibility: 1 /* NotAccessible */,
@@ -65685,8 +65691,13 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
-                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                if (source.flags & 262144 /* TypeParameter */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) {
+                    var syntheticParam = cloneTypeParameter(source);
+                    syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam));
+                    if (hasNonCircularBaseConstraint(syntheticParam)) {
+                        var targetConstraintString = typeToString(target, source.symbol.declarations[0]);
+                        associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
+                    }
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
@@ -145820,7 +145831,7 @@ var ts;
                 return type.symbol && (type.symbol.flags & 1536 /* Module */);
             }
             function visitVariableLikeDeclaration(decl) {
-                if (!decl.initializer || ts.isBindingPattern(decl.name)) {
+                if (!decl.initializer || ts.isBindingPattern(decl.name) || ts.isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
                     return;
                 }
                 var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(decl);
@@ -145948,6 +145959,9 @@ var ts;
                 }
                 for (var i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
                     var param = node.parameters[i];
+                    if (!isHintableDeclaration(param)) {
+                        continue;
+                    }
                     var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(param);
                     if (effectiveTypeAnnotation) {
                         continue;
@@ -145989,6 +146003,13 @@ var ts;
             function isUndefined(name) {
                 return name === "undefined";
             }
+            function isHintableDeclaration(node) {
+                if ((ts.isParameterDeclaration(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) {
+                    var initializer = ts.skipParentheses(node.initializer);
+                    return !(isHintableLiteral(initializer) || ts.isNewExpression(initializer) || ts.isObjectLiteralExpression(initializer) || ts.isAssertionExpression(initializer));
+                }
+                return true;
+            }
         }
         InlayHints.provideInlayHints = provideInlayHints;
     })(InlayHints = ts.InlayHints || (ts.InlayHints = {}));
@@ -155427,6 +155448,77 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "addMissingConstraint";
+        var errorCodes = [
+            // We want errors this could be attached to:
+            // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint
+            ts.Diagnostics.Type_0_is_not_comparable_to_type_1.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code,
+            ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Property_0_is_incompatible_with_index_signature.code,
+            ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code,
+            ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code,
+        ];
+        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) {
+                    return;
+                }
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                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);
+            }); },
+        });
+        function getDiagnosticRelatedInfo(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)
+                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)
+                return;
+            return related;
+        }
+        function addMissingConstraint(changes, related) {
+            var decl = findAncestorMatchingSpan(related.file, related);
+            if (!decl)
+                return;
+            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
+                decl = decl.parent;
+            }
+            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, related.start + related.length, " extends " + newConstraintText);
+        }
+        function findAncestorMatchingSpan(sourceFile, span) {
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
+            var end = ts.textSpanEnd(span);
+            while (token.end < end) {
+                token = token.parent;
+            }
+            return token;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {

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.20220615";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220616";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8463,9 +8463,11 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
-        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
+        This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."),
+        Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -35767,10 +35769,11 @@ var ts;
             }
             nextToken();
             var typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
-            if (!parseExpected(31 /* GreaterThanToken */)) {
+            if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
+            nextToken();
             // We successfully parsed a type argument list. The next token determines whether we want to
             // treat it as such. If the type argument list is followed by `(` or a template literal, as in
             // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
@@ -52520,6 +52523,9 @@ var ts;
             if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
                 return { accessibility: 0 /* Accessible */ };
             }
+            if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false)), firstIdentifier, meaning, /*computeAliases*/ false).accessibility === 0 /* Accessible */) {
+                return { accessibility: 0 /* Accessible */ };
+            }
             // Verify if the symbol is accessible
             return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || {
                 accessibility: 1 /* NotAccessible */,
@@ -65480,8 +65486,13 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
-                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                if (source.flags & 262144 /* TypeParameter */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) {
+                    var syntheticParam = cloneTypeParameter(source);
+                    syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam));
+                    if (hasNonCircularBaseConstraint(syntheticParam)) {
+                        var targetConstraintString = typeToString(target, source.symbol.declarations[0]);
+                        associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
+                    }
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {

package/package.json

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