typescript 4.5.0-dev.20211028 → 4.5.0-dev.20211029

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.20211028";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211029";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2540,6 +2540,10 @@ var ts;
             return formatEnum(kind, ts.SyntaxKind, /*isFlags*/ false);
         }
         Debug.formatSyntaxKind = formatSyntaxKind;
+        function formatSnippetKind(kind) {
+            return formatEnum(kind, ts.SnippetKind, /*isFlags*/ false);
+        }
+        Debug.formatSnippetKind = formatSnippetKind;
         function formatNodeFlags(flags) {
             return formatEnum(flags, ts.NodeFlags, /*isFlags*/ true);
         }
@@ -4456,6 +4460,13 @@ var ts;
         ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkupped"] = 4] = "ProjectReferenceCycle_OutputsSkupped";
     })(ExitStatus = ts.ExitStatus || (ts.ExitStatus = {}));
     /* @internal */
+    var MemberOverrideStatus;
+    (function (MemberOverrideStatus) {
+        MemberOverrideStatus[MemberOverrideStatus["Ok"] = 0] = "Ok";
+        MemberOverrideStatus[MemberOverrideStatus["NeedsOverride"] = 1] = "NeedsOverride";
+        MemberOverrideStatus[MemberOverrideStatus["HasInvalidOverride"] = 2] = "HasInvalidOverride";
+    })(MemberOverrideStatus = ts.MemberOverrideStatus || (ts.MemberOverrideStatus = {}));
+    /* @internal */
     var UnionReduction;
     (function (UnionReduction) {
         UnionReduction[UnionReduction["None"] = 0] = "None";
@@ -5437,6 +5448,15 @@ var ts;
         // Masks
         // - Additional bitmasks
     })(TransformFlags = ts.TransformFlags || (ts.TransformFlags = {}));
+    // Reference: https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax
+    /* @internal */
+    var SnippetKind;
+    (function (SnippetKind) {
+        SnippetKind[SnippetKind["TabStop"] = 0] = "TabStop";
+        SnippetKind[SnippetKind["Placeholder"] = 1] = "Placeholder";
+        SnippetKind[SnippetKind["Choice"] = 2] = "Choice";
+        SnippetKind[SnippetKind["Variable"] = 3] = "Variable";
+    })(SnippetKind = ts.SnippetKind || (ts.SnippetKind = {}));
     var EmitFlags;
     (function (EmitFlags) {
         EmitFlags[EmitFlags["None"] = 0] = "None";
@@ -20742,6 +20762,10 @@ var ts;
         return node.kind === 212 /* FunctionExpression */ || node.kind === 213 /* ArrowFunction */;
     }
     ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction;
+    function escapeSnippetText(text) {
+        return text.replace(/\$/gm, "\\$");
+    }
+    ts.escapeSnippetText = escapeSnippetText;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -26945,6 +26969,25 @@ var ts;
         }
     }
     ts.moveEmitHelpers = moveEmitHelpers;
+    /**
+     * Gets the SnippetElement of a node.
+     */
+    /* @internal */
+    function getSnippetElement(node) {
+        var _a;
+        return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.snippetElement;
+    }
+    ts.getSnippetElement = getSnippetElement;
+    /**
+     * Sets the SnippetElement of a node.
+     */
+    /* @internal */
+    function setSnippetElement(node, snippet) {
+        var emitNode = getOrCreateEmitNode(node);
+        emitNode.snippetElement = snippet;
+        return node;
+    }
+    ts.setSnippetElement = setSnippetElement;
     /* @internal */
     function ignoreSourceNewlines(node) {
         getOrCreateEmitNode(node).flags |= 134217728 /* IgnoreSourceNewlines */;
@@ -47070,6 +47113,7 @@ var ts;
             isDeclarationVisible: isDeclarationVisible,
             isPropertyAccessible: isPropertyAccessible,
             getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
+            getMemberOverrideModifierStatus: getMemberOverrideModifierStatus,
         };
         function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -81645,7 +81689,7 @@ var ts;
                     checkKindsOfPropertyMemberOverrides(type, baseType_1);
                 }
             }
-            checkMembersForMissingOverrideModifier(node, type, typeWithThis, staticType);
+            checkMembersForOverrideModifier(node, type, typeWithThis, staticType);
             var implementedTypeNodes = ts.getEffectiveImplementsTypeNodes(node);
             if (implementedTypeNodes) {
                 for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
@@ -81680,8 +81724,7 @@ var ts;
                 checkPropertyInitialization(node);
             }
         }
-        function checkMembersForMissingOverrideModifier(node, type, typeWithThis, staticType) {
-            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+        function checkMembersForOverrideModifier(node, type, typeWithThis, staticType) {
             var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
@@ -81693,46 +81736,71 @@ var ts;
                 if (ts.isConstructorDeclaration(member)) {
                     ts.forEach(member.parameters, function (param) {
                         if (ts.isParameterPropertyDeclaration(param, member)) {
-                            checkClassMember(param, /*memberIsParameterProperty*/ true);
+                            checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, param, 
+                            /* memberIsParameterProperty */ true);
                         }
                     });
                 }
-                checkClassMember(member);
+                checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, 
+                /* memberIsParameterProperty */ false);
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
                 _loop_29(member);
             }
-            function checkClassMember(member, memberIsParameterProperty) {
-                var hasOverride = ts.hasOverrideModifier(member);
-                var hasStatic = ts.isStatic(member);
-                var isJs = ts.isInJSFile(member);
-                if (baseWithThis && (hasOverride || compilerOptions.noImplicitOverride)) {
-                    var declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
-                    if (!declaredProp) {
-                        return;
-                    }
-                    var thisType = hasStatic ? staticType : typeWithThis;
-                    var baseType = hasStatic ? baseStaticType : baseWithThis;
-                    var prop = getPropertyOfType(thisType, declaredProp.escapedName);
-                    var baseProp = getPropertyOfType(baseType, declaredProp.escapedName);
-                    var baseClassName = typeToString(baseWithThis);
-                    if (prop && !baseProp && hasOverride) {
-                        var suggestion = getSuggestedSymbolForNonexistentClassMember(ts.symbolName(declaredProp), baseType);
+        }
+        /**
+         * @param member Existing member node to be checked.
+         * Note: `member` cannot be a synthetic node.
+         */
+        function checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, memberIsParameterProperty, reportErrors) {
+            if (reportErrors === void 0) { reportErrors = true; }
+            var declaredProp = member.name
+                && getSymbolAtLocation(member.name)
+                || getSymbolAtLocation(member);
+            if (!declaredProp) {
+                return 0 /* Ok */;
+            }
+            return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, ts.hasOverrideModifier(member), ts.hasAbstractModifier(member), ts.isStatic(member), memberIsParameterProperty, ts.symbolName(declaredProp), reportErrors ? member : undefined);
+        }
+        /**
+         * Checks a class member declaration for either a missing or an invalid `override` modifier.
+         * Note: this function can be used for speculative checking,
+         * i.e. checking a member that does not yet exist in the program.
+         * An example of that would be to call this function in a completions scenario,
+         * when offering a method declaration as completion.
+         * @param errorNode The node where we should report an error, or undefined if we should not report errors.
+         */
+        function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, memberName, errorNode) {
+            var isJs = ts.isInJSFile(node);
+            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+            if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) {
+                var memberEscapedName = ts.escapeLeadingUnderscores(memberName);
+                var thisType = memberIsStatic ? staticType : typeWithThis;
+                var baseType = memberIsStatic ? baseStaticType : baseWithThis;
+                var prop = getPropertyOfType(thisType, memberEscapedName);
+                var baseProp = getPropertyOfType(baseType, memberEscapedName);
+                var baseClassName = typeToString(baseWithThis);
+                if (prop && !baseProp && memberHasOverrideModifier) {
+                    if (errorNode) {
+                        var suggestion = getSuggestedSymbolForNonexistentClassMember(memberName, baseType); // Again, using symbol name: note that's different from `symbol.escapedName`
                         suggestion ?
-                            error(member, isJs ?
+                            error(errorNode, isJs ?
                                 ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 :
                                 ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1, baseClassName, symbolToString(suggestion)) :
-                            error(member, isJs ?
+                            error(errorNode, isJs ?
                                 ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 :
                                 ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0, baseClassName);
                     }
-                    else if (prop && (baseProp === null || baseProp === void 0 ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
-                        var baseHasAbstract = ts.some(baseProp.declarations, ts.hasAbstractModifier);
-                        if (hasOverride) {
-                            return;
-                        }
-                        if (!baseHasAbstract) {
+                    return 2 /* HasInvalidOverride */;
+                }
+                else if (prop && (baseProp === null || baseProp === void 0 ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
+                    var baseHasAbstract = ts.some(baseProp.declarations, ts.hasAbstractModifier);
+                    if (memberHasOverrideModifier) {
+                        return 0 /* Ok */;
+                    }
+                    if (!baseHasAbstract) {
+                        if (errorNode) {
                             var diag = memberIsParameterProperty ?
                                 isJs ?
                                     ts.Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 :
@@ -81740,20 +81808,28 @@ var ts;
                                 isJs ?
                                     ts.Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 :
                                     ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0;
-                            error(member, diag, baseClassName);
+                            error(errorNode, diag, baseClassName);
                         }
-                        else if (ts.hasAbstractModifier(member) && baseHasAbstract) {
-                            error(member, ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName);
+                        return 1 /* NeedsOverride */;
+                    }
+                    else if (memberHasAbstractModifier && baseHasAbstract) {
+                        if (errorNode) {
+                            error(errorNode, ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName);
                         }
+                        return 1 /* NeedsOverride */;
                     }
                 }
-                else if (hasOverride) {
+            }
+            else if (memberHasOverrideModifier) {
+                if (errorNode) {
                     var className = typeToString(type);
-                    error(member, isJs ?
+                    error(errorNode, isJs ?
                         ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class :
                         ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class, className);
                 }
+                return 2 /* HasInvalidOverride */;
             }
+            return 0 /* Ok */;
         }
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
@@ -81796,6 +81872,31 @@ var ts;
                 }
             }
         }
+        /**
+         * Checks a member declaration node to see if has a missing or invalid `override` modifier.
+         * @param node Class-like node where the member is declared.
+         * @param member Member declaration node.
+         * Note: `member` can be a synthetic node without a parent.
+         */
+        function getMemberOverrideModifierStatus(node, member) {
+            if (!member.name) {
+                return 0 /* Ok */;
+            }
+            var symbol = getSymbolOfNode(node);
+            var type = getDeclaredTypeOfSymbol(symbol);
+            var typeWithThis = getTypeWithThisArgument(type);
+            var staticType = getTypeOfSymbol(symbol);
+            var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
+            var baseTypes = baseTypeNode && getBaseTypes(type);
+            var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
+            var baseStaticType = getBaseConstructorTypeOfClass(type);
+            var memberHasOverrideModifier = member.parent
+                ? ts.hasOverrideModifier(member)
+                : ts.hasSyntacticModifier(member, 16384 /* Override */);
+            var memberName = ts.unescapeLeadingUnderscores(ts.getTextOfPropertyName(member.name));
+            return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, ts.hasAbstractModifier(member), ts.isStatic(member), 
+            /* memberIsParameterProperty */ false, memberName);
+        }
         function getTargetSymbol(s) {
             // if symbol is instantiated its flags are not copied from the 'target'
             // so we'll need to get back original 'target' symbol to work with correct set of flags
@@ -108100,7 +108201,14 @@ var ts;
             // clear the parenthesizer rule as we ascend
             currentParenthesizerRule = undefined;
         }
-        function pipelineEmitWithHintWorker(hint, node) {
+        function pipelineEmitWithHintWorker(hint, node, allowSnippets) {
+            if (allowSnippets === void 0) { allowSnippets = true; }
+            if (allowSnippets) {
+                var snippet = ts.getSnippetElement(node);
+                if (snippet) {
+                    return emitSnippetNode(hint, node, snippet);
+                }
+            }
             if (hint === 0 /* SourceFile */)
                 return emitSourceFile(ts.cast(node, ts.isSourceFile));
             if (hint === 2 /* IdentifierName */)
@@ -108709,6 +108817,28 @@ var ts;
             }
         }
         //
+        // Snippet Elements
+        //
+        function emitSnippetNode(hint, node, snippet) {
+            switch (snippet.kind) {
+                case 1 /* Placeholder */:
+                    emitPlaceholder(hint, node, snippet);
+                    break;
+                case 0 /* TabStop */:
+                    emitTabStop(snippet);
+                    break;
+            }
+        }
+        function emitPlaceholder(hint, node, snippet) {
+            nonEscapingWrite("${" + snippet.order + ":"); // `${2:`
+            pipelineEmitWithHintWorker(hint, node, /*allowSnippets*/ false); // `...`
+            nonEscapingWrite("}"); // `}`
+            // `${2:...}`
+        }
+        function emitTabStop(snippet) {
+            nonEscapingWrite("$" + snippet.order);
+        }
+        //
         // Identifiers
         //
         function emitIdentifier(node) {
@@ -110947,6 +111077,15 @@ var ts;
         function writeProperty(s) {
             writer.writeProperty(s);
         }
+        function nonEscapingWrite(s) {
+            // This should be defined in a snippet-escaping text writer.
+            if (writer.nonEscapingWrite) {
+                writer.nonEscapingWrite(s);
+            }
+            else {
+                writer.write(s);
+            }
+        }
         function writeLine(count) {
             if (count === void 0) { count = 1; }
             for (var i = 0; i < count; i++) {

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

@@ -839,6 +839,7 @@
   "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021": "JSDoc '@typedef' 標記應具有類型註解，或者其後接著 '@property' 或 '@member' 標記。",
   "JSDoc_types_can_only_be_used_inside_documentation_comments_8020": "JSDoc 類型只能在文件註解中使用。",
   "JSDoc_types_may_be_moved_to_TypeScript_types_80004": "JSDoc 類型可移為 TypeScript 類型。",
+  "JSON_imports_are_experimental_in_ES_module_mode_imports_7062": "JSON 匯入在 ES 模組模式匯入中為實驗性。",
   "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000": "只能將非空白的 'expression' 指派給 JSX 屬性。",
   "JSX_element_0_has_no_corresponding_closing_tag_17008": "JSX 元素 '{0}' 沒有對應的結尾標記。",
   "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607": "因為 JSX 項目類別沒有 '{0}' 屬性 (property)，所以不支援屬性 (attribute)。",

package/package.json

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