typescript 4.6.0-dev.20211206 → 4.6.0-dev.20211210

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211206";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211210";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7937,7 +7937,7 @@ var ts;
         Duplicate_label_0: diag(1114, ts.DiagnosticCategory.Error, "Duplicate_label_0_1114", "Duplicate label '{0}'."),
         A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: diag(1115, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", "A 'continue' statement can only jump to a label of an enclosing iteration statement."),
         A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: diag(1116, ts.DiagnosticCategory.Error, "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", "A 'break' statement can only jump to a label of an enclosing statement."),
-        An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: diag(1117, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode_1117", "An object literal cannot have multiple properties with the same name in strict mode."),
+        An_object_literal_cannot_have_multiple_properties_with_the_same_name: diag(1117, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_1117", "An object literal cannot have multiple properties with the same name."),
         An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: diag(1118, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."),
         An_object_literal_cannot_have_property_and_accessor_with_the_same_name: diag(1119, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."),
         An_export_assignment_cannot_have_modifiers: diag(1120, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."),
@@ -8889,6 +8889,7 @@ var ts;
         DIRECTORY: diag(6038, ts.DiagnosticCategory.Message, "DIRECTORY_6038", "DIRECTORY"),
         STRATEGY: diag(6039, ts.DiagnosticCategory.Message, "STRATEGY_6039", "STRATEGY"),
         FILE_OR_DIRECTORY: diag(6040, ts.DiagnosticCategory.Message, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"),
+        Errors_Files: diag(6041, ts.DiagnosticCategory.Message, "Errors_Files_6041", "Errors  Files"),
         Generates_corresponding_map_file: diag(6043, ts.DiagnosticCategory.Message, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."),
         Compiler_option_0_expects_an_argument: diag(6044, ts.DiagnosticCategory.Error, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."),
         Unterminated_quoted_string_in_response_file_0: diag(6045, ts.DiagnosticCategory.Error, "Unterminated_quoted_string_in_response_file_0_6045", "Unterminated quoted string in response file '{0}'."),
@@ -9082,6 +9083,9 @@ var ts;
         Output_Formatting: diag(6256, ts.DiagnosticCategory.Message, "Output_Formatting_6256", "Output Formatting"),
         Completeness: diag(6257, ts.DiagnosticCategory.Message, "Completeness_6257", "Completeness"),
         _0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: diag(6258, ts.DiagnosticCategory.Error, "_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file_6258", "'{0}' should be set inside the 'compilerOptions' object of the config json file"),
+        Found_1_error_in_1: diag(6259, ts.DiagnosticCategory.Message, "Found_1_error_in_1_6259", "Found 1 error in {1}"),
+        Found_0_errors_in_1_file: diag(6260, ts.DiagnosticCategory.Message, "Found_0_errors_in_1_file_6260", "Found {0} errors in 1 file."),
+        Found_0_errors_in_1_files: diag(6261, ts.DiagnosticCategory.Message, "Found_0_errors_in_1_files_6261", "Found {0} errors in {1} files."),
         Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, ts.DiagnosticCategory.Message, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
         Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, ts.DiagnosticCategory.Message, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
         Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, ts.DiagnosticCategory.Message, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
@@ -24434,7 +24438,7 @@ var ts;
         // @api
         function createAssertClause(elements, multiLine) {
             var node = createBaseNode(292 /* AssertClause */);
-            node.elements = elements;
+            node.elements = createNodeArray(elements);
             node.multiLine = multiLine;
             node.transformFlags |= 4 /* ContainsESNext */;
             return node;
@@ -33620,10 +33624,14 @@ var ts;
             //  - "(x,y)" is a comma expression parsed as a signature with two parameters.
             //  - "a ? (b): c" will have "(b):" parsed as a signature with a return type annotation.
             //  - "a ? (b): function() {}" will too, since function() is a valid JSDoc function type.
-            //  - "a ? (b): (function() {})" as well, but inside of a parenthesized type.
+            //  - "a ? (b): (function() {})" as well, but inside of a parenthesized type with an arbitrary amount of nesting.
             //
             // So we need just a bit of lookahead to ensure that it can only be a signature.
-            var hasJSDocFunctionType = type && (ts.isJSDocFunctionType(type) || ts.isParenthesizedTypeNode(type) && ts.isJSDocFunctionType(type.type));
+            var unwrappedType = type;
+            while ((unwrappedType === null || unwrappedType === void 0 ? void 0 : unwrappedType.kind) === 190 /* ParenthesizedType */) {
+                unwrappedType = unwrappedType.type; // Skip parens if need be
+            }
+            var hasJSDocFunctionType = unwrappedType && ts.isJSDocFunctionType(unwrappedType);
             if (!allowAmbiguity && token() !== 38 /* EqualsGreaterThanToken */ && (hasJSDocFunctionType || token() !== 18 /* OpenBraceToken */)) {
                 // Returning undefined here will cause our caller to rewind to where we started from.
                 return undefined;
@@ -44954,10 +44962,6 @@ var ts;
                         seen.set(identifier.escapedText, currentKind);
                         continue;
                     }
-                    if (currentKind === 1 /* Property */ && existingKind === 1 /* Property */) {
-                        var span = ts.getErrorSpanForNode(file, identifier);
-                        file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode));
-                    }
                 }
             }
             return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object" /* Object */);
@@ -45191,7 +45195,7 @@ var ts;
             }
         }
         function checkStrictModeNumericLiteral(node) {
-            if (inStrictMode && node.numericLiteralFlags & 32 /* Octal */) {
+            if (languageVersion < 1 /* ES5 */ && inStrictMode && node.numericLiteralFlags & 32 /* Octal */) {
                 file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
             }
         }
@@ -48796,10 +48800,12 @@ var ts;
         }
         /* Starting from 'initial' node walk up the parent chain until 'stopAt' node is reached.
          * If at any point current node is equal to 'parent' node - return true.
+         * If current node is an IIFE, continue walking up.
          * Return false if 'stopAt' node is reached or isFunctionLike(current) === true.
          */
         function isSameScopeDescendentOf(initial, parent, stopAt) {
-            return !!parent && !!ts.findAncestor(initial, function (n) { return n === stopAt || ts.isFunctionLike(n) ? "quit" : n === parent; });
+            return !!parent && !!ts.findAncestor(initial, function (n) { return n === parent
+                || (n === stopAt || ts.isFunctionLike(n) && !ts.getImmediatelyInvokedFunctionExpression(n) ? "quit" : false); });
         }
         function getAnyImportSyntax(node) {
             switch (node.kind) {
@@ -54053,7 +54059,27 @@ var ts;
                 return mapType(source, function (t) { return getRestType(t, properties, symbol); });
             }
             var omitKeyType = getUnionType(ts.map(properties, getLiteralTypeFromPropertyName));
+            var spreadableProperties = [];
+            var unspreadableToRestKeys = [];
+            for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
+                var prop = _a[_i];
+                var literalTypeFromProperty = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
+                if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType)
+                    && !(ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */))
+                    && isSpreadableProperty(prop)) {
+                    spreadableProperties.push(prop);
+                }
+                else {
+                    unspreadableToRestKeys.push(literalTypeFromProperty);
+                }
+            }
             if (isGenericObjectType(source) || isGenericIndexType(omitKeyType)) {
+                if (unspreadableToRestKeys.length) {
+                    // If the type we're spreading from has properties that cannot
+                    // be spread into the rest type (e.g. getters, methods), ensure
+                    // they are explicitly omitted, as they would in the non-generic case.
+                    omitKeyType = getUnionType(__spreadArray([omitKeyType], unspreadableToRestKeys, true));
+                }
                 if (omitKeyType.flags & 131072 /* Never */) {
                     return source;
                 }
@@ -54064,13 +54090,9 @@ var ts;
                 return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
             }
             var members = ts.createSymbolTable();
-            for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) {
-                var prop = _a[_i];
-                if (!isTypeAssignableTo(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), omitKeyType)
-                    && !(ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */))
-                    && isSpreadableProperty(prop)) {
-                    members.set(prop.escapedName, getSpreadSymbol(prop, /*readonly*/ false));
-                }
+            for (var _b = 0, spreadableProperties_1 = spreadableProperties; _b < spreadableProperties_1.length; _b++) {
+                var prop = spreadableProperties_1[_b];
+                members.set(prop.escapedName, getSpreadSymbol(prop, /*readonly*/ false));
             }
             var result = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfosOfType(source));
             result.objectFlags |= 8388608 /* ObjectRestType */;
@@ -65581,7 +65603,7 @@ var ts;
         }
         function getBaseTypeOfLiteralType(type) {
             return type.flags & 1024 /* EnumLiteral */ ? getBaseTypeOfEnumLiteralType(type) :
-                type.flags & 128 /* StringLiteral */ ? stringType :
+                type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType :
                     type.flags & 256 /* NumberLiteral */ ? numberType :
                         type.flags & 2048 /* BigIntLiteral */ ? bigintType :
                             type.flags & 512 /* BooleanLiteral */ ? booleanType :
@@ -74337,7 +74359,7 @@ var ts;
                 typeArguments.pop();
             }
             while (typeArguments.length < typeParameters.length) {
-                typeArguments.push(getConstraintOfTypeParameter(typeParameters[typeArguments.length]) || getDefaultTypeArgumentType(isJs));
+                typeArguments.push(getDefaultFromTypeParameter(typeParameters[typeArguments.length]) || getConstraintOfTypeParameter(typeParameters[typeArguments.length]) || getDefaultTypeArgumentType(isJs));
             }
             return typeArguments;
         }
@@ -74993,8 +75015,7 @@ var ts;
          */
         function checkCallExpression(node, checkMode) {
             var _a;
-            if (!checkGrammarTypeArguments(node, node.typeArguments))
-                checkGrammarArguments(node.arguments);
+            checkGrammarTypeArguments(node, node.typeArguments);
             var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);
             if (signature === resolvingSignature) {
                 // CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that
@@ -75099,8 +75120,7 @@ var ts;
         }
         function checkImportCallExpression(node) {
             // Check grammar of dynamic import
-            if (!checkGrammarArguments(node.arguments))
-                checkGrammarImportCallExpression(node);
+            checkGrammarImportCallExpression(node);
             if (node.arguments.length === 0) {
                 return createPromiseReturnType(node, anyType);
             }
@@ -85761,20 +85781,6 @@ var ts;
             }
             return false;
         }
-        function checkGrammarForOmittedArgument(args) {
-            if (args) {
-                for (var _i = 0, args_4 = args; _i < args_4.length; _i++) {
-                    var arg = args_4[_i];
-                    if (arg.kind === 226 /* OmittedExpression */) {
-                        return grammarErrorAtPos(arg, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
-                    }
-                }
-            }
-            return false;
-        }
-        function checkGrammarArguments(args) {
-            return checkGrammarForOmittedArgument(args);
-        }
         function checkGrammarHeritageClause(node) {
             var types = node.types;
             if (checkGrammarForDisallowedTrailingComma(types)) {
@@ -85949,9 +85955,12 @@ var ts;
                         seen.set(effectiveName, currentKind);
                     }
                     else {
-                        if ((currentKind & 12 /* PropertyAssignmentOrMethod */) && (existingKind & 12 /* PropertyAssignmentOrMethod */)) {
+                        if ((currentKind & 8 /* Method */) && (existingKind & 8 /* Method */)) {
                             grammarErrorOnNode(name, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(name));
                         }
+                        else if ((currentKind & 4 /* PropertyAssignment */) && (existingKind & 4 /* PropertyAssignment */)) {
+                            grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name, ts.getTextOfNode(name));
+                        }
                         else if ((currentKind & 3 /* GetOrSetAccessor */) && (existingKind & 3 /* GetOrSetAccessor */)) {
                             if (existingKind !== 3 /* GetOrSetAccessor */ && currentKind !== existingKind) {
                                 seen.set(effectiveName, currentKind | existingKind);
@@ -103019,7 +103028,7 @@ var ts;
             if (ts.isIdentifier(node.expression)) {
                 var expression = substituteExpressionIdentifier(node.expression);
                 noSubstitution[ts.getNodeId(expression)] = true;
-                if (!ts.isIdentifier(expression)) {
+                if (!ts.isIdentifier(expression) && !(ts.getEmitFlags(node.expression) & 4096 /* HelperName */)) {
                     return ts.addEmitFlags(factory.updateCallExpression(node, expression, 
                     /*typeArguments*/ undefined, node.arguments), 536870912 /* IndirectCall */);
                 }
@@ -103030,7 +103039,7 @@ var ts;
             if (ts.isIdentifier(node.tag)) {
                 var tag = substituteExpressionIdentifier(node.tag);
                 noSubstitution[ts.getNodeId(tag)] = true;
-                if (!ts.isIdentifier(tag)) {
+                if (!ts.isIdentifier(tag) && !(ts.getEmitFlags(node.tag) & 4096 /* HelperName */)) {
                     return ts.addEmitFlags(factory.updateTaggedTemplateExpression(node, tag, 
                     /*typeArguments*/ undefined, node.template), 536870912 /* IndirectCall */);
                 }
@@ -113656,6 +113665,7 @@ var ts;
     ts.getImpliedNodeFormatForFile = getImpliedNodeFormatForFile;
     /** @internal */
     ts.plainJSErrors = new ts.Set([
+        // binder errors
         ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0.code,
         ts.Diagnostics.A_module_cannot_have_multiple_default_exports.code,
         ts.Diagnostics.Another_export_default_is_here.code,
@@ -113671,6 +113681,81 @@ var ts;
         ts.Diagnostics.A_label_is_not_allowed_here.code,
         ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code,
         ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode.code,
+        // grammar errors
+        ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement.code,
+        ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement.code,
+        ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name.code,
+        ts.Diagnostics.A_class_member_cannot_have_the_0_keyword.code,
+        ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name.code,
+        ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement.code,
+        ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code,
+        ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code,
+        ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement.code,
+        ts.Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration.code,
+        ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context.code,
+        ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer.code,
+        ts.Diagnostics.A_get_accessor_cannot_have_parameters.code,
+        ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern.code,
+        ts.Diagnostics.A_rest_element_cannot_have_a_property_name.code,
+        ts.Diagnostics.A_rest_element_cannot_have_an_initializer.code,
+        ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern.code,
+        ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer.code,
+        ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list.code,
+        ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code,
+        ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body.code,
+        ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
+        ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
+        ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
+        ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module.code,
+        ts.Diagnostics.An_export_declaration_cannot_have_modifiers.code,
+        ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module.code,
+        ts.Diagnostics.An_import_declaration_cannot_have_modifiers.code,
+        ts.Diagnostics.An_object_member_cannot_be_declared_optional.code,
+        ts.Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element.code,
+        ts.Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable.code,
+        ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause.code,
+        ts.Diagnostics.Catch_clause_variable_cannot_have_an_initializer.code,
+        ts.Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator.code,
+        ts.Diagnostics.Classes_can_only_extend_a_single_class.code,
+        ts.Diagnostics.Classes_may_not_have_a_field_named_constructor.code,
+        ts.Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code,
+        ts.Diagnostics.Duplicate_label_0.code,
+        ts.Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments.code,
+        ts.Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block.code,
+        ts.Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression.code,
+        ts.Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name.code,
+        ts.Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array.code,
+        ts.Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names.code,
+        ts.Diagnostics.Jump_target_cannot_cross_function_boundary.code,
+        ts.Diagnostics.Line_terminator_not_permitted_before_arrow.code,
+        ts.Diagnostics.Modifiers_cannot_appear_here.code,
+        ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement.code,
+        ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement.code,
+        ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies.code,
+        ts.Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code,
+        ts.Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier.code,
+        ts.Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain.code,
+        ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async.code,
+        ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer.code,
+        ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer.code,
+        ts.Diagnostics.Trailing_comma_not_allowed.code,
+        ts.Diagnostics.Variable_declaration_list_cannot_be_empty.code,
+        ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses.code,
+        ts.Diagnostics._0_expected.code,
+        ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2.code,
+        ts.Diagnostics._0_list_cannot_be_empty.code,
+        ts.Diagnostics._0_modifier_already_seen.code,
+        ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration.code,
+        ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element.code,
+        ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter.code,
+        ts.Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind.code,
+        ts.Diagnostics._0_modifier_cannot_be_used_here.code,
+        ts.Diagnostics._0_modifier_must_precede_1_modifier.code,
+        ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block.code,
+        ts.Diagnostics.const_declarations_must_be_initialized.code,
+        ts.Diagnostics.extends_clause_already_seen.code,
+        ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block.code,
+        ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code,
     ]);
     /**
      * Determine if source file needs to be re-created even if its text hasn't changed
@@ -114700,9 +114785,10 @@ var ts;
                 var includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === 3 /* TS */ || sourceFile.scriptKind === 4 /* TSX */
                     || sourceFile.scriptKind === 5 /* External */ || isPlainJs || isCheckJs || sourceFile.scriptKind === 7 /* Deferred */);
                 var bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : ts.emptyArray;
-                var checkDiagnostics = includeBindAndCheckDiagnostics && !isPlainJs ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : ts.emptyArray;
+                var checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : ts.emptyArray;
                 if (isPlainJs) {
                     bindDiagnostics = ts.filter(bindDiagnostics, function (d) { return ts.plainJSErrors.has(d.code); });
+                    checkDiagnostics = ts.filter(checkDiagnostics, function (d) { return ts.plainJSErrors.has(d.code); });
                 }
                 // skip ts-expect-error errors in plain JS files, and skip JSDoc errors except in checked JS
                 return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics && !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined);
@@ -119720,7 +119806,7 @@ var ts;
         getCanonicalFileName: ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)
     } : undefined;
     /**
-     * Create a function that reports error by writing to the system and handles the formating of the diagnostic
+     * Create a function that reports error by writing to the system and handles the formatting of the diagnostic
      */
     function createDiagnosticReporter(system, pretty) {
         var host = system === ts.sys && sysFormatDiagnosticsHost ? sysFormatDiagnosticsHost : {
@@ -119806,19 +119892,74 @@ var ts;
         return ts.countWhere(diagnostics, function (diagnostic) { return diagnostic.category === ts.DiagnosticCategory.Error; });
     }
     ts.getErrorCountForSummary = getErrorCountForSummary;
+    function getFilesInErrorForSummary(diagnostics) {
+        var filesInError = ts.filter(diagnostics, function (diagnostic) { return diagnostic.category === ts.DiagnosticCategory.Error; })
+            .map(function (errorDiagnostic) {
+            if (errorDiagnostic.file === undefined)
+                return;
+            return "" + errorDiagnostic.file.fileName;
+        });
+        return filesInError.map(function (fileName) {
+            var diagnosticForFileName = ts.find(diagnostics, function (diagnostic) {
+                return diagnostic.file !== undefined && diagnostic.file.fileName === fileName;
+            });
+            if (diagnosticForFileName !== undefined) {
+                var line = ts.getLineAndCharacterOfPosition(diagnosticForFileName.file, diagnosticForFileName.start).line;
+                return {
+                    fileName: fileName,
+                    line: line + 1,
+                };
+            }
+        });
+    }
+    ts.getFilesInErrorForSummary = getFilesInErrorForSummary;
     function getWatchErrorSummaryDiagnosticMessage(errorCount) {
         return errorCount === 1 ?
             ts.Diagnostics.Found_1_error_Watching_for_file_changes :
             ts.Diagnostics.Found_0_errors_Watching_for_file_changes;
     }
     ts.getWatchErrorSummaryDiagnosticMessage = getWatchErrorSummaryDiagnosticMessage;
-    function getErrorSummaryText(errorCount, newLine) {
+    function getErrorSummaryText(errorCount, filesInError, newLine) {
         if (errorCount === 0)
             return "";
-        var d = ts.createCompilerDiagnostic(errorCount === 1 ? ts.Diagnostics.Found_1_error : ts.Diagnostics.Found_0_errors, errorCount);
-        return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine;
+        var nonNilFiles = filesInError.filter(function (fileInError) { return fileInError !== undefined; });
+        var distinctFileNamesWithLines = nonNilFiles.map(function (fileInError) { return fileInError.fileName + ":" + fileInError.line; })
+            .filter(function (value, index, self) { return self.indexOf(value) === index; });
+        var d = errorCount === 1 ?
+            ts.createCompilerDiagnostic(filesInError[0] !== undefined ?
+                ts.Diagnostics.Found_1_error_in_1 :
+                ts.Diagnostics.Found_1_error, errorCount, distinctFileNamesWithLines[0]) :
+            ts.createCompilerDiagnostic(distinctFileNamesWithLines.length === 0 ?
+                ts.Diagnostics.Found_0_errors :
+                distinctFileNamesWithLines.length === 1 ?
+                    ts.Diagnostics.Found_0_errors_in_1_file :
+                    ts.Diagnostics.Found_0_errors_in_1_files, errorCount, distinctFileNamesWithLines.length);
+        return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine + (errorCount > 1 ? createTabularErrorsDisplay(nonNilFiles) : "");
     }
     ts.getErrorSummaryText = getErrorSummaryText;
+    function createTabularErrorsDisplay(filesInError) {
+        var distinctFiles = filesInError.filter(function (value, index, self) { return index === self.findIndex(function (file) { return (file === null || file === void 0 ? void 0 : file.fileName) === (value === null || value === void 0 ? void 0 : value.fileName); }); });
+        if (distinctFiles.length === 0)
+            return "";
+        var numberLength = function (num) { return Math.log(num) * Math.LOG10E + 1; };
+        var fileToErrorCount = distinctFiles.map(function (file) { return [file, ts.countWhere(filesInError, function (fileInError) { return fileInError.fileName === file.fileName; })]; });
+        var maxErrors = fileToErrorCount.reduce(function (acc, value) { return Math.max(acc, value[1] || 0); }, 0);
+        var headerRow = ts.Diagnostics.Errors_Files.message;
+        var leftColumnHeadingLength = headerRow.split(" ")[0].length;
+        var leftPaddingGoal = Math.max(leftColumnHeadingLength, numberLength(maxErrors));
+        var headerPadding = Math.max(numberLength(maxErrors) - leftColumnHeadingLength, 0);
+        var tabularData = "";
+        tabularData += " ".repeat(headerPadding) + headerRow + "\n";
+        fileToErrorCount.forEach(function (row) {
+            var file = row[0], errorCount = row[1];
+            var errorCountDigitsLength = Math.log(errorCount) * Math.LOG10E + 1 | 0;
+            var leftPadding = errorCountDigitsLength < leftPaddingGoal ?
+                " ".repeat(leftPaddingGoal - errorCountDigitsLength)
+                : "";
+            tabularData += "" + leftPadding + errorCount + "  " + file.fileName + ":" + file.line + "\n";
+        });
+        return tabularData;
+    }
     function isBuilderProgram(program) {
         return !!program.getState;
     }
@@ -120022,7 +120163,7 @@ var ts;
             listFiles(program, write);
         }
         if (reportSummary) {
-            reportSummary(getErrorCountForSummary(diagnostics));
+            reportSummary(getErrorCountForSummary(diagnostics), getFilesInErrorForSummary(diagnostics));
         }
         return {
             emitResult: emitResult,
@@ -120233,7 +120374,7 @@ var ts;
         var system = input.system || ts.sys;
         var host = input.host || (input.host = ts.createIncrementalCompilerHost(input.options, system));
         var builderProgram = ts.createIncrementalProgram(input);
-        var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount) { return system.write(getErrorSummaryText(errorCount, system.newLine)); } : undefined);
+        var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount, filesInError) { return system.write(getErrorSummaryText(errorCount, filesInError, system.newLine)); } : undefined);
         if (input.afterProgramEmitAndDiagnostics)
             input.afterProgramEmitAndDiagnostics(builderProgram);
         return exitStatus;
@@ -122452,11 +122593,14 @@ var ts;
         var canReportSummary = state.watch || !!state.host.reportErrorSummary;
         var diagnostics = state.diagnostics;
         var totalErrors = 0;
+        var filesInError = [];
         if (isCircularBuildOrder(buildOrder)) {
             reportBuildQueue(state, buildOrder.buildOrder);
             reportErrors(state, buildOrder.circularDiagnostics);
             if (canReportSummary)
                 totalErrors += ts.getErrorCountForSummary(buildOrder.circularDiagnostics);
+            if (canReportSummary)
+                filesInError = __spreadArray(__spreadArray([], filesInError, true), ts.getFilesInErrorForSummary(buildOrder.circularDiagnostics), true);
         }
         else {
             // Report errors from the other projects
@@ -122468,12 +122612,14 @@ var ts;
             });
             if (canReportSummary)
                 diagnostics.forEach(function (singleProjectErrors) { return totalErrors += ts.getErrorCountForSummary(singleProjectErrors); });
+            if (canReportSummary)
+                diagnostics.forEach(function (singleProjectErrors) { return __spreadArray(__spreadArray([], filesInError, true), ts.getFilesInErrorForSummary(singleProjectErrors), true); });
         }
         if (state.watch) {
             reportWatchStatus(state, ts.getWatchErrorSummaryDiagnosticMessage(totalErrors), totalErrors);
         }
         else if (state.host.reportErrorSummary) {
-            state.host.reportErrorSummary(totalErrors);
+            state.host.reportErrorSummary(totalErrors, filesInError);
         }
     }
     /**
@@ -127330,6 +127476,9 @@ var ts;
                             }
                             return;
                     }
+                    if (ts.isConstTypeReference(token.parent)) {
+                        return 3 /* keyword */;
+                    }
                 }
                 return 2 /* identifier */;
             }
@@ -131150,8 +131299,10 @@ var ts;
         }
         /** Get the corresponding JSDocTag node if the position is in a jsDoc comment */
         function getJsDocTagAtPosition(node, position) {
-            var jsdoc = ts.findAncestor(node, ts.isJSDoc);
-            return jsdoc && jsdoc.tags && (ts.rangeContainsPosition(jsdoc, position) ? ts.findLast(jsdoc.tags, function (tag) { return tag.pos < position; }) : undefined);
+            return ts.findAncestor(node, function (n) {
+                return ts.isJSDocTag(n) && ts.rangeContainsPosition(n, position) ? true :
+                    ts.isJSDoc(n) ? "quit" : false;
+            });
         }
         function getPropertiesForObjectExpression(contextualType, completionsType, obj, checker) {
             var hasCompletionsType = completionsType && completionsType !== contextualType;
@@ -140907,7 +141058,7 @@ var ts;
                 displayParts.push(ts.spacePart());
                 displayParts.push(ts.operatorPart(63 /* EqualsToken */));
                 displayParts.push(ts.spacePart());
-                ts.addRange(displayParts, ts.typeToDisplayParts(typeChecker, typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
+                ts.addRange(displayParts, ts.typeToDisplayParts(typeChecker, ts.isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
             }
             if (symbolFlags & 384 /* Enum */) {
                 prefixNextMeaning();

package/lib/tsserverlibrary.d.ts

@@ -5352,7 +5352,11 @@ declare namespace ts {
         traceResolution?: boolean;
         [option: string]: CompilerOptionsValue | undefined;
     }
-    type ReportEmitErrorSummary = (errorCount: number) => void;
+    type ReportEmitErrorSummary = (errorCount: number, filesInError: (ReportFileInError | undefined)[]) => void;
+    interface ReportFileInError {
+        fileName: string;
+        line: number;
+    }
     interface SolutionBuilderHostBase<T extends BuilderProgram> extends ProgramHost<T> {
         createDirectory?(path: string): void;
         /**