typescript 4.8.0-dev.20220722 → 4.8.0-dev.20220725

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.20220722";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220725";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7042,8 +7042,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -68131,37 +68133,33 @@ var ts;
             var commonBaseType;
             for (var _i = 0, types_13 = types; _i < types_13.length; _i++) {
                 var t = types_13[_i];
-                var baseType = getBaseTypeOfLiteralType(t);
-                if (!commonBaseType) {
-                    commonBaseType = baseType;
-                }
-                if (baseType === t || baseType !== commonBaseType) {
-                    return false;
+                if (!(t.flags & 131072 /* Never */)) {
+                    var baseType = getBaseTypeOfLiteralType(t);
+                    commonBaseType !== null && commonBaseType !== void 0 ? commonBaseType : (commonBaseType = baseType);
+                    if (baseType === t || baseType !== commonBaseType) {
+                        return false;
+                    }
                 }
             }
             return true;
         }
-        // When the candidate types are all literal types with the same base type, return a union
-        // of those literal types. Otherwise, return the leftmost type for which no type to the
-        // right is a supertype.
-        function getSupertypeOrUnion(types) {
-            if (types.length === 1) {
-                return types[0];
-            }
-            return literalTypesWithSameBaseType(types) ?
-                getUnionType(types) :
-                ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+        function getCombinedTypeFlags(types) {
+            return ts.reduceLeft(types, function (flags, t) { return flags | (t.flags & 1048576 /* Union */ ? getCombinedTypeFlags(t.types) : t.flags); }, 0);
         }
         function getCommonSupertype(types) {
-            if (!strictNullChecks) {
-                return getSupertypeOrUnion(types);
-            }
-            var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
-            if (primaryTypes.length) {
-                var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
-                return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
+            if (types.length === 1) {
+                return types[0];
             }
-            return getUnionType(types, 2 /* Subtype */);
+            // Remove nullable types from each of the candidates.
+            var primaryTypes = strictNullChecks ? ts.sameMap(types, function (t) { return filterType(t, function (u) { return !(u.flags & 98304 /* Nullable */); }); }) : types;
+            // When the candidate types are all literal types with the same base type, return a union
+            // of those literal types. Otherwise, return the leftmost type for which no type to the
+            // right is a supertype.
+            var superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ?
+                getUnionType(primaryTypes) :
+                ts.reduceLeft(primaryTypes, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+            // Add any nullable types that occurred in the candidates back to the result.
+            return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* Nullable */);
         }
         // Return the leftmost type for which no type to the right is a subtype.
         function getCommonSubtype(types) {
@@ -79823,7 +79821,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90745,13 +90747,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90816,7 +90818,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -149449,6 +149451,7 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    ts.Debug.assert(!ts.nodeIsSynthesized(child));
                     if (ts.nodeIsMissing(child)) {
                         return inheritedIndentation;
                     }
@@ -149515,6 +149518,7 @@ var ts;
                 }
                 function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
                     ts.Debug.assert(ts.isNodeArray(nodes));
+                    ts.Debug.assert(!ts.nodeIsSynthesized(nodes));
                     var listStartToken = getOpenTokenForList(parent, nodes);
                     var listDynamicIndentation = parentDynamicIndentation;
                     var startLine = parentStartLine;
@@ -155974,54 +155978,91 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
-                if (!related) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
                     return;
-                }
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
-                if (!info)
-                    return;
-                return addMissingConstraint(changes, info);
-            }); },
+            getAllCodeActions: function (context) {
+                var program = context.program, preferences = context.preferences, host = context.host;
+                var seen = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                        if (info) {
+                            var id = ts.getNodeId(info.declaration) + "#" + info.token.getText();
+                            if (ts.addToSeen(seen, id)) {
+                                return addMissingConstraint(changes, program, preferences, host, diag.file, info);
+                            }
+                        }
+                        return undefined;
+                    });
+                }));
+            }
         });
-        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+        function getInfo(program, sourceFile, span) {
             var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
-            if (!diag || !diag.relatedInformation)
+            if (diag === undefined || diag.relatedInformation === undefined)
                 return;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
-            if (!related)
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            return related;
-        }
-        function addMissingConstraint(changes, related) {
-            var decl = findAncestorMatchingSpan(related.file, related);
-            if (!decl)
+            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (declaration === undefined)
                 return;
-            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
-                decl = decl.parent;
+            if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
+                declaration = declaration.parent;
+            }
+            if (ts.isTypeParameterDeclaration(declaration)) {
+                // should only issue fix on type parameters written using `extends`
+                if (ts.isMappedTypeNode(declaration.parent))
+                    return;
+                var token = ts.getTokenAtPosition(sourceFile, span.start);
+                var checker = program.getTypeChecker();
+                var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
+                return { constraint: constraint, declaration: declaration, token: token };
+            }
+            return undefined;
+        }
+        function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
+            var declaration = info.declaration, constraint = info.constraint;
+            var checker = program.getTypeChecker();
+            if (ts.isString(constraint)) {
+                changes.insertText(sourceFile, declaration.name.end, " extends " + constraint);
+            }
+            else {
+                var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host });
+                var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
+                var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker);
+                if (typeNode) {
+                    changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default));
+                    importAdder.writeFixes(changes);
+                }
             }
-            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
-                return; // should only issue fix on type parameters written using `extends`
-            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
-            if (!newConstraint)
-                return;
-            var newConstraintText = newConstraint[1];
-            changes.insertText(related.file, decl.name.end, " extends " + newConstraintText);
         }
         function findAncestorMatchingSpan(sourceFile, span) {
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
             var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
             while (token.end < end) {
                 token = token.parent;
             }
             return token;
         }
+        function tryGetConstraintFromDiagnosticMessage(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
+            return constraint;
+        }
+        function tryGetConstraintType(checker, node) {
+            if (ts.isTypeNode(node.parent)) {
+                return checker.getTypeArgumentConstraint(node.parent);
+            }
+            var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined;
+            return contextualType || checker.getTypeAtLocation(node);
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220722";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220725";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -6837,8 +6837,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -67926,37 +67928,33 @@ var ts;
             var commonBaseType;
             for (var _i = 0, types_13 = types; _i < types_13.length; _i++) {
                 var t = types_13[_i];
-                var baseType = getBaseTypeOfLiteralType(t);
-                if (!commonBaseType) {
-                    commonBaseType = baseType;
-                }
-                if (baseType === t || baseType !== commonBaseType) {
-                    return false;
+                if (!(t.flags & 131072 /* Never */)) {
+                    var baseType = getBaseTypeOfLiteralType(t);
+                    commonBaseType !== null && commonBaseType !== void 0 ? commonBaseType : (commonBaseType = baseType);
+                    if (baseType === t || baseType !== commonBaseType) {
+                        return false;
+                    }
                 }
             }
             return true;
         }
-        // When the candidate types are all literal types with the same base type, return a union
-        // of those literal types. Otherwise, return the leftmost type for which no type to the
-        // right is a supertype.
-        function getSupertypeOrUnion(types) {
-            if (types.length === 1) {
-                return types[0];
-            }
-            return literalTypesWithSameBaseType(types) ?
-                getUnionType(types) :
-                ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+        function getCombinedTypeFlags(types) {
+            return ts.reduceLeft(types, function (flags, t) { return flags | (t.flags & 1048576 /* Union */ ? getCombinedTypeFlags(t.types) : t.flags); }, 0);
         }
         function getCommonSupertype(types) {
-            if (!strictNullChecks) {
-                return getSupertypeOrUnion(types);
-            }
-            var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
-            if (primaryTypes.length) {
-                var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
-                return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
+            if (types.length === 1) {
+                return types[0];
             }
-            return getUnionType(types, 2 /* Subtype */);
+            // Remove nullable types from each of the candidates.
+            var primaryTypes = strictNullChecks ? ts.sameMap(types, function (t) { return filterType(t, function (u) { return !(u.flags & 98304 /* Nullable */); }); }) : types;
+            // When the candidate types are all literal types with the same base type, return a union
+            // of those literal types. Otherwise, return the leftmost type for which no type to the
+            // right is a supertype.
+            var superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ?
+                getUnionType(primaryTypes) :
+                ts.reduceLeft(primaryTypes, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+            // Add any nullable types that occurred in the candidates back to the result.
+            return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* Nullable */);
         }
         // Return the leftmost type for which no type to the right is a subtype.
         function getCommonSubtype(types) {
@@ -79618,7 +79616,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90540,13 +90542,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90611,7 +90613,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));

package/lib/zh-cn/diagnosticMessages.generated.json

@@ -226,6 +226,7 @@
   "An_index_signature_parameter_must_have_a_type_annotation_1022": "索引签名参数必须具有类型批注。",
   "An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_o_1337": "索引签名参数类型不能为文本类型或泛型类型。请考虑改用映射的对象类型。",
   "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268": "索引签名参数类型必须是 “string”、“number”、“symbol”或模板文本类型。",
+  "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477": "实例化表达式不能后跟属性访问。",
   "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499": "接口只能扩展具有可选类型参数的标识符/限定名称。",
   "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312": "接口只能扩展使用静态已知成员的对象类型或对象类型的交集。",
   "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840": "接口无法扩展基元类型，如“{0}”；接口只能扩展命名类型和类",
@@ -1561,6 +1562,7 @@
   "Type_library_referenced_via_0_from_file_1_with_packageId_2_1403": "通过 \"{0}\" 从具有 packageId \"{2}\" 的文件 \"{1}\" 引用了库类型",
   "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320": "\"await\" 操作数的类型必须是有效承诺，或不得包含可调用的 \"then\" 成员。",
   "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418": "计算属性类型的值为 \"{0}\"，该值不能赋给 \"{1}\" 类型。",
+  "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844": "实例成员变量“{0}”的类型不能引用构造函数中声明的标识符“{1}”。",
   "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322": "\"yield*\" 操作数的迭代元素的类型必须是有效承诺，或不得包含可调用的 \"then\" 成员。",
   "Type_of_property_0_circularly_references_itself_in_mapped_type_1_2615": "属性“{0}”的类型在已映射的类型“{1}”中循环引用其自身。",
   "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321": "异步生成器中 \"yield\" 操作数的类型必须是有效承诺，或不得包含可调用的 \"then\" 成员。",

package/lib/zh-tw/diagnosticMessages.generated.json

@@ -226,6 +226,7 @@
   "An_index_signature_parameter_must_have_a_type_annotation_1022": "索引簽章參數必須有類型註釋。",
   "An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_o_1337": "索引簽章參數類型不能是常值型別或泛型型別。請考慮改用對應的物件類型。",
   "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268": "索引簽章參數類型必須是 'string'、'number'、'symbol' 或範本文字類型。",
+  "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477": "具現化運算式後面不能接著屬性存取。",
   "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499": "介面只能擴充具有選擇性型別引數的識別碼/限定名稱。",
   "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312": "介面只能延伸物件類型或具有靜態已知成員的物件類型交集。",
   "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840": "介面無法延伸基本類型，例如 '{0}'；介面只能延伸命名類型和類別",
@@ -1561,6 +1562,7 @@
   "Type_library_referenced_via_0_from_file_1_with_packageId_2_1403": "透過 '{0}' 從檔案 '{1}' (packageId 為 '{2}') 參考的型別程式庫",
   "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320": "'await' 運算元類型必須是有效的 Promise，或不得包含可呼叫的 'then' 成員。",
   "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418": "已計算屬性值的類型為 '{0}'，其無法指派給類型 '{1}'。",
+  "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844": "執行個體成員變數 '{0}' 的類型不得參考建構函式中所宣告的識別碼 '{1}'。",
   "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322": "'yield*' 運算元的反覆項目類型必須是有效的 Promise，或不得包含可呼叫的 'then' 成員。",
   "Type_of_property_0_circularly_references_itself_in_mapped_type_1_2615": "屬性 '{0}' 的類型在對應的類型 '{1}' 中會循環參考自己。",
   "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321": "非同步產生器中的 'yield' 運算元類型必須是有效的 Promise，或不得包含可呼叫的 'then' 成員。",

package/package.json

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