@zzzen/pyright-internal 1.2.0-dev.20230813 → 1.2.0-dev.20230827

package/dist/localization/package.nls.zh-tw.json

@@ -78,7 +78,7 @@
         "comparisonAlwaysTrue": "條件一律會評估為 True，因為類型 \"{leftType}\" 和 \"{rightType}\" 沒有重疊",
         "comprehensionInDict": "理解不能與其他字典項目搭配使用",
         "comprehensionInSet": "Comprehension 無法與其他集合輸入項目一起使用",
-        "concatenateParamSpecMissing": "\"Concatenate\" 的最後一個類型引數必須是 ParamSpec",
+        "concatenateParamSpecMissing": "Last type argument for \"Concatenate\" must be a ParamSpec or \"...\"",
         "concatenateTypeArgsMissing": "\"Concatenate\" 至少需要兩個型別引數",
         "conditionalOperandInvalid": "型別 \"{type}\" 的條件運算元無效",
         "constantRedefinition": "\"{name}\" 是常數 (因為它是大寫) 且無法重新定義",
@@ -130,8 +130,8 @@
         "duplicateStarPattern": "模式序列中僅允許一個 \"*\" 模式",
         "duplicateStarStarPattern": "僅允許輸入一個 \"**\"",
         "duplicateUnpack": "清單中僅允許一個解除封裝作業",
-        "ellipsisContext": "此內容中不允許 \"...\"",
-        "ellipsisSecondArg": "\"...\" 只允許做為兩個引數的第二個",
+        "ellipsisContext": "\"...\" is not allowed in this context",
+        "ellipsisSecondArg": "\"...\" is allowed only as the second of two arguments",
         "enumClassOverride": "列舉類別 \"{name}\" 為 Final，且不能設為子類別",
         "exceptionGroupIncompatible": "例外群組語法 (\"except*\") 需要 Python 3.11 或更新版本",
         "exceptionTypeIncorrect": "\"{type}\" 不是衍生自 BaseException",
@@ -185,7 +185,7 @@
         "expectedTypeParameterName": "應為型別參數名稱",
         "expectedYieldExpr": "yield 陳述式中應有運算式",
         "finalClassIsAbstract": "類別 \"{type}\" 標示為 Final，且必須實作所有抽象方法",
-        "finalContext": "此內容中不允許 \"Final\"",
+        "finalContext": "\"Final\" is not allowed in this context",
         "finalMethodOverride": "方法 \"{name}\" 不能覆寫類別 \"{className}\" 中定義的 Final 方法",
         "finalReassigned": "\"{name}\" 已宣告為 Final，因此無法重新指派",
         "finalRedeclaration": "\"{name}\" 先前已宣告為 Final",
@@ -335,7 +335,7 @@
         "paramSpecArgsMissing": "ParamSpec \"{type}\" 的引數遺失",
         "paramSpecArgsUsage": "只有搭配 *args 參數使用時，ParamSpec 的 \"args\" 成員才有效",
         "paramSpecAssignedName": "ParamSpec 必須指派至名為 \"{name}\" 的變數",
-        "paramSpecContext": "此內容中不允許 ParamSpec",
+        "paramSpecContext": "ParamSpec is not allowed in this context",
         "paramSpecDefaultNotTuple": "ParamSpec 的預設值必須是省略符號、元組運算式或 ParamSpec",
         "paramSpecFirstArg": "應以 ParamSpec 的名稱作為第一個引數",
         "paramSpecKwargsUsage": "ParamSpec 的 \"kwargs\" 成員只有在與 **kwargs 參數搭配使用時有效",
@@ -383,7 +383,7 @@
         "requiredArgCount": "\"Required\" 後面應有單一型別引數",
         "requiredNotInTypedDict": "此內容中不允許 \"Required\"",
         "returnInAsyncGenerator": "非同步產生器中不允許具有值的 return 陳述式",
-        "returnMissing": "具有宣告 \"{returnType}\" 型別的函式必須在所有程式碼路徑上傳回值",
+        "returnMissing": "宣告類型為 \"{returnType}\" 的函式必須在所有程式碼路徑上傳回值",
         "returnOutsideFunction": "\"return\" 只能在函式內使用",
         "returnTypeContravariant": "逆變數型別變數不能用在傳回型別中",
         "returnTypeMismatch": "類型 \"{exprType}\" 的運算式不能指派至傳回類型 \"{returnType}\"",
@@ -429,6 +429,7 @@
         "tupleIndexOutOfRange": "索引 {index} 超過類型 {type} 的範圍",
         "typeAliasIllegalExpressionForm": "類型別名定義無效的運算式格式",
         "typeAliasIsRecursiveDirect": "型別別名 \"{name}\" 無法在其定義中使用它自己",
+        "typeAliasNotAllowed": "類型別名 \"{name}\" 無法在此內容中使用",
         "typeAliasNotInModuleOrClass": "TypeAlias 只能在模組或類別範圍內定義",
         "typeAliasRedeclared": "\"{name}\" 宣告為 TypeAlias，且只能指派一次",
         "typeAliasStatementIllegal": "類型別名陳述式需要 Python 3.12 或更新版本",
@@ -448,6 +449,7 @@
         "typeArgsTooFew": "為 \"{name}\" 提供太少類型引數; 預期為 {expected} 但收到 {received}",
         "typeArgsTooMany": "已為 \"{name}\" 提供太多型別引數; 應為 {expected} 但收到 {received}",
         "typeAssignmentMismatch": "類型 \"{sourceType}\" 的運算式不能指派至宣告的類型 \"{destType}\"",
+        "typeAssignmentMismatchWildcard": "Import symbol \"{name}\" has type \"{sourceType}\", which cannot be assigned to declared type \"{destType}\"",
         "typeCallNotAllowed": "不應在類型註釋中使用 type() 呼叫",
         "typeCommentDeprecated": "使用類型註解已取代; 請改為使用類型註釋",
         "typeExpectedClass": "預期為類型運算式，但收到 \"{type}\"",
@@ -487,7 +489,7 @@
         "typeVarPossiblyUnsolvable": "如果呼叫者未提供參數 \"{param}\" 的引數，則型別變數 \"{name}\" 可能無法解析",
         "typeVarScopedToReturnType": "型別變數 \"{name}\" 的範圍為傳回型別內的可呼叫項目，無法在函式主體中參考",
         "typeVarSingleConstraint": "TypeVar 至少必須有兩個限制類型",
-        "typeVarTupleContext": "此內容中不允許 TypeVarTuple",
+        "typeVarTupleContext": "TypeVarTuple is not allowed in this context",
         "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 預設型別必須是未封裝的元組或 TypeVarTuple",
         "typeVarTupleMustBeUnpacked": "TypeVarTuple 值需要解除封裝運算子",
         "typeVarTupleUnknownParam": "\"{name}\" 是 TypeVarTuple 的未知參數",
@@ -544,8 +546,8 @@
         "unpackInAnnotation": "類型註釋中不允許解壓縮運算子",
         "unpackInDict": "字典中不允許解壓縮作業",
         "unpackInSet": "集合內不允許將運算子解除封裝",
-        "unpackNotAllowed": "此內容中不允許解除封裝",
-        "unpackOperatorNotAllowed": "此內容中不允許解壓縮作業",
+        "unpackNotAllowed": "Unpack is not allowed in this context",
+        "unpackOperatorNotAllowed": "Unpack operation is not allowed in this context",
         "unpackTuplesIllegal": "Python 3.8 之前的 Tuple 中不允許解壓縮作業",
         "unpackedArgInTypeArgument": "解壓縮的引數不能用於類型引數清單",
         "unpackedArgWithVariadicParam": "未封裝的引數無法用於 TypeVarTuple 參數",
@@ -566,7 +568,7 @@
         "variadicTypeParamTooManyAlias": "類型別名最多只能有一個 TypeVarTuple 類型參數，但收到多個 ({names})",
         "variadicTypeParamTooManyClass": "一般類別最多只能有一個 TypeVarTuple 類型參數，但收到多個 ({names})",
         "walrusIllegal": "運算子 \":=\" 需要 Python 3.8 或更新版本",
-        "walrusNotAllowed": "此內容中不允許未使用括弧括住運算子 \":=\"",
+        "walrusNotAllowed": "Operator \":=\" is not allowed in this context without surrounding parentheses",
         "wildcardInFunction": "類別或函式內不允許萬用字元匯入",
         "wildcardLibraryImport": "不允許從程式庫匯入萬用字元",
         "wildcardPatternTypePartiallyUnknown": "萬用字元模式擷取的類型部分未知",
@@ -576,7 +578,7 @@
         "yieldOutsideFunction": "在函式或 lambda 外部不允許 \"yield\"",
         "yieldWithinListCompr": "清單理解內不允許 \"yield\"",
         "zeroCaseStatementsFound": "Match 陳述式必須至少包含一個 case 陳述式",
-        "zeroLengthTupleNotAllowed": "此內容中不允許零長度 Tuple"
+        "zeroLengthTupleNotAllowed": "Zero-length tuple is not allowed in this context"
     },
     "DiagnosticAddendum": {
         "argParam": "引數對應至參數 \"{paramName}\"",
@@ -619,6 +621,7 @@
         "memberIsInitVar": "成員 \"{name}\" 是僅限初始化的欄位",
         "memberIsInvariant": "\"{name}\" 為不變數，因為它可變動",
         "memberIsNotFinalInProtocol": "\"{name}\" 未在通訊協定中標示為 Final",
+        "memberIsWritableInProtocol": "\"{name}\" is writable in protocol",
         "memberSetClassVar": "無法透過類別執行個體指派成員 \"{name}\"，因為它是 ClassVar",
         "memberTypeMismatch": "\"{name}\" 是不相容的類型",
         "memberUnknown": "成員 \"{name}\" 未知",

package/dist/parser/parser.d.ts

@@ -77,6 +77,7 @@ export declare class Parser {
     private _parseMatchStatement;
     private _parseCaseStatement;
     private _isPatternIrrefutable;
+    private _reportDuplicatePatternCaptureTargets;
     private _getPatternTargetNames;
     private _parsePatternSequence;
     private _parsePatternAs;

package/dist/parser/parser.js

@@ -220,6 +220,8 @@ class Parser {
                 else if (peekToken.type === 9 /* Operator */) {
                     const operatorToken = peekToken;
                     if (operatorToken.operatorType !== 26 /* Multiply */ &&
+                        operatorToken.operatorType !== 0 /* Add */ &&
+                        operatorToken.operatorType !== 5 /* BitwiseInvert */ &&
                         operatorToken.operatorType !== 33 /* Subtract */) {
                         isInvalidMatchToken = true;
                     }
@@ -486,6 +488,11 @@ class Parser {
         else {
             casePattern = parseNodes_1.PatternSequenceNode.create(patternList.list[0], patternList.list);
         }
+        if (casePattern.nodeType !== 0 /* Error */) {
+            const globalNameMap = new Map();
+            const localNameMap = new Map();
+            this._reportDuplicatePatternCaptureTargets(casePattern, globalNameMap, localNameMap);
+        }
         let guardExpression;
         if (this._consumeTokenIfKeyword(20 /* If */)) {
             guardExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
@@ -504,6 +511,79 @@ class Parser {
         }
         return false;
     }
+    // Reports any situations where a capture target (a variable that receives part of a pattern)
+    // appears twice within the same pattern. This is complicated by the fact that duplicate targets
+    // are allowed in separate "or" clauses, so we need to track the targets we've seen globally
+    // as well as the targets we've seen locally within the current "or" clause.
+    _reportDuplicatePatternCaptureTargets(node, globalNameMap, localNameMap) {
+        const reportTargetIfDuplicate = (nameNode) => {
+            if (globalNameMap.has(nameNode.value) || localNameMap.has(nameNode.value)) {
+                this._addError(localize_1.Localizer.Diagnostic.duplicateCapturePatternTarget().format({
+                    name: nameNode.value,
+                }), nameNode);
+            }
+            else {
+                localNameMap.set(nameNode.value, nameNode);
+            }
+        };
+        switch (node.nodeType) {
+            case 65 /* PatternSequence */: {
+                node.entries.forEach((subpattern) => {
+                    this._reportDuplicatePatternCaptureTargets(subpattern, globalNameMap, localNameMap);
+                });
+                break;
+            }
+            case 68 /* PatternClass */: {
+                node.arguments.forEach((arg) => {
+                    this._reportDuplicatePatternCaptureTargets(arg.pattern, globalNameMap, localNameMap);
+                });
+                break;
+            }
+            case 66 /* PatternAs */: {
+                if (node.target) {
+                    reportTargetIfDuplicate(node.target);
+                }
+                const orLocalNameMaps = node.orPatterns.map((subpattern) => {
+                    const orLocalNameMap = new Map();
+                    this._reportDuplicatePatternCaptureTargets(subpattern, localNameMap, orLocalNameMap);
+                    return orLocalNameMap;
+                });
+                const combinedLocalOrNameMap = new Map();
+                orLocalNameMaps.forEach((orLocalNameMap) => {
+                    orLocalNameMap.forEach((node) => {
+                        if (!combinedLocalOrNameMap.has(node.value)) {
+                            combinedLocalOrNameMap.set(node.value, node);
+                            reportTargetIfDuplicate(node);
+                        }
+                    });
+                });
+                break;
+            }
+            case 69 /* PatternCapture */: {
+                if (!node.isWildcard) {
+                    reportTargetIfDuplicate(node.target);
+                }
+                break;
+            }
+            case 70 /* PatternMapping */: {
+                node.entries.forEach((mapEntry) => {
+                    if (mapEntry.nodeType === 72 /* PatternMappingExpandEntry */) {
+                        reportTargetIfDuplicate(mapEntry.target);
+                    }
+                    else {
+                        this._reportDuplicatePatternCaptureTargets(mapEntry.keyPattern, globalNameMap, localNameMap);
+                        this._reportDuplicatePatternCaptureTargets(mapEntry.valuePattern, globalNameMap, localNameMap);
+                    }
+                });
+                break;
+            }
+            case 67 /* PatternLiteral */:
+            case 73 /* PatternValue */:
+            case 0 /* Error */: {
+                break;
+            }
+        }
+    }
     _getPatternTargetNames(node, nameSet) {
         switch (node.nodeType) {
             case 65 /* PatternSequence */: {
@@ -561,24 +641,6 @@ class Parser {
         if (starEntries.length > 1) {
             this._addError(localize_1.Localizer.Diagnostic.duplicateStarPattern(), starEntries[1].orPatterns[0]);
         }
-        // Look for redundant capture targets.
-        const captureTargetMap = new Map();
-        patternList.list.forEach((asPattern) => {
-            asPattern.orPatterns.forEach((patternAtom) => {
-                if (patternAtom.nodeType === 69 /* PatternCapture */ &&
-                    !patternAtom.isStar &&
-                    !patternAtom.isWildcard) {
-                    if (captureTargetMap.has(patternAtom.target.value)) {
-                        this._addError(localize_1.Localizer.Diagnostic.duplicateCapturePatternTarget().format({
-                            name: patternAtom.target.value,
-                        }), patternAtom);
-                    }
-                    else {
-                        captureTargetMap.set(patternAtom.target.value, patternAtom);
-                    }
-                }
-            });
-        });
         return patternList;
     }
     // as_pattern: or_pattern ['as' NAME]