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

package/dist/localization/package.nls.it.json

@@ -293,7 +293,7 @@
         "noOverload": "Nessun overload per \"{name}\" corrisponde agli argomenti specificati",
         "noReturnContainsReturn": "La funzione con tipo restituito dichiarato \"NoReturn\" non può includere un'istruzione return",
         "noReturnContainsYield": "La funzione con il tipo restituito dichiarato \"NoReturn\" non può includere un'istruzione yield",
-        "noReturnReturnsNone": "La funzione con tipo dichiarato \"NoReturn\" non può restituire \"None\"",
+        "noReturnReturnsNone": "La funzione con tipo restituito dichiarato \"NoReturn\" non può restituire \"None\"",
         "nonDefaultAfterDefault": "L'argomento non predefinito segue l'argomento predefinito",
         "nonLocalInModule": "Dichiarazione non locale non consentita a livello di modulo",
         "nonLocalNoBinding": "Non è stata trovata alcuna associazione per \"{name}\" non locale",
@@ -383,7 +383,7 @@
         "requiredArgCount": "Previsto un singolo argomento tipo dopo \"Obbligatorio\"",
         "requiredNotInTypedDict": "\"Required\" non è consentito in questo contesto",
         "returnInAsyncGenerator": "L’istruzione return con valore non è consentita nel generatore asincrono",
-        "returnMissing": "La funzione con tipo dichiarato \"{returnType}\" deve restituire un valore in tutti i percorsi di codice",
+        "returnMissing": "La funzione con tipo restituito dichiarato \"{returnType}\" deve restituire un valore in tutti i percorsi di codice",
         "returnOutsideFunction": "\"return\" può essere usata solo all'interno di una funzione.",
         "returnTypeContravariant": "Non è possibile usare la variabile di tipo controvariante nel tipo restituito",
         "returnTypeMismatch": "Non è possibile assegnare l'espressione di tipo \"{exprType}\" al tipo restituito \"{returnType}\"",
@@ -429,6 +429,7 @@
         "tupleIndexOutOfRange": "L'indice {index} non è compreso nell'intervallo per il tipo {type}",
         "typeAliasIllegalExpressionForm": "Modulo di espressione non valido per la definizione dell'alias di tipo",
         "typeAliasIsRecursiveDirect": "L'alias di tipo \"{name}\" non può usare se stesso nella relativa definizione",
+        "typeAliasNotAllowed": "L'alias di tipo \"{name}\" non può essere usato in questo contesto",
         "typeAliasNotInModuleOrClass": "TypeAlias può essere definito solo all'interno di un modulo o di una classe",
         "typeAliasRedeclared": "\"{name}\" è dichiarato come TypeAlias e può essere assegnato una sola volta",
         "typeAliasStatementIllegal": "L'istruzione alias di tipo richiede Python 3.12 o versione successiva",

package/dist/localization/package.nls.ja.json

@@ -293,7 +293,7 @@
         "noOverload": "指定された引数に一致する \"{name}\" のオーバーロードがありません",
         "noReturnContainsReturn": "戻り値の型が \"NoReturn\" として宣言されている関数に return ステートメントを含めることはできません",
         "noReturnContainsYield": "戻り値の型 \"NoReturn\" を宣言した関数に yield ステートメントを含めることはできません",
-        "noReturnReturnsNone": "宣言された型が \"NoReturn\" の関数は \"None\" を返すことができません",
+        "noReturnReturnsNone": "戻り値の型が \"NoReturn\" として宣言されている関数は \"None\" を返すことができません",
         "nonDefaultAfterDefault": "既定以外の引数は既定の引数の後に続きます",
         "nonLocalInModule": "モジュール レベルでは非ローカル宣言は許可されません",
         "nonLocalNoBinding": "非ローカル \"{name}\" のバインドが見つかりません",
@@ -383,7 +383,7 @@
         "requiredArgCount": "\"Required\" の後に 1 つの型引数が必要です",
         "requiredNotInTypedDict": "このコンテキストでは\"必須\" は許可されていません",
         "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 として宣言されており、1 回だけ割り当てることができます",
         "typeAliasStatementIllegal": "型エイリアス ステートメントには Python 3.12 以降が必要です",

package/dist/localization/package.nls.ko.json

@@ -293,7 +293,7 @@
         "noOverload": "제공된 인수와 일치하는 \"{name}\"에 대한 오버로드가 없습니다.",
         "noReturnContainsReturn": "선언된 반환 형식이 \"NoReturn\"인 함수는 return 문을 포함할 수 없습니다.",
         "noReturnContainsYield": "선언된 반환 형식이 \"NoReturn\"인 함수는 yield 문을 포함할 수 없습니다.",
-        "noReturnReturnsNone": "선언된 형식이 \"NoReturn\"인 함수는 \"None\"을 반환할 수 없습니다.",
+        "noReturnReturnsNone": "선언된 반환 형식이 \"NoReturn\"인 함수는 \"None\"을 반환할 수 없습니다.",
         "nonDefaultAfterDefault": "기본값이 아닌 인수가 기본 인수를 따릅니다.",
         "nonLocalInModule": "모듈 수준에서는 비로컬 선언을 사용할 수 없습니다.",
         "nonLocalNoBinding": "비로컬 \"{name}\"에 대한 바인딩을 찾을 수 없습니다.",
@@ -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 이상이 필요합니다.",

package/dist/localization/package.nls.pl.json

@@ -293,7 +293,7 @@
         "noOverload": "Żadne przeciążenia dla nazwy „{name}” nie pasują do podanych argumentów",
         "noReturnContainsReturn": "Funkcja z zadeklarowanym zwracanym typem „NoReturn” nie może zawierać instrukcji Return",
         "noReturnContainsYield": "Funkcja z zadeklarowanym zwracanym typem „NoReturn” nie może zawierać instrukcji Yield",
-        "noReturnReturnsNone": "Funkcja o zadeklarowanym typie „NoReturn” nie może zwrócić wartości „Brak”",
+        "noReturnReturnsNone": "Funkcja z zadeklarowanym typem zwracanym „NoReturn” nie może zwracać wartości „None”",
         "nonDefaultAfterDefault": "Argument inny niż domyślny następuje po argumencie domyślnym",
         "nonLocalInModule": "Deklaracja nielokalna nie jest dozwolona na poziomie modułu",
         "nonLocalNoBinding": "Nie znaleziono powiązania dla nielokalnej nazwy „{name}”.",
@@ -383,7 +383,7 @@
         "requiredArgCount": "Oczekiwano jednego argumentu typu po wartości „Required”",
         "requiredNotInTypedDict": "Element „Required” jest niedozwolony w tym kontekście",
         "returnInAsyncGenerator": "Instrukcja „return” z wartością jest niedozwolona w generatorze asynchronicznym",
-        "returnMissing": "Funkcja z zadeklarowanym typem „{returnType}” musi zwracać wartość we wszystkich ścieżkach kodu",
+        "returnMissing": "Funkcja z zadeklarowanym typem zwracanym „{returnType}” musi zwracać wartość we wszystkich ścieżkach kodu",
         "returnOutsideFunction": "Instrukcja „return” może być używana tylko w ramach funkcji",
         "returnTypeContravariant": "Kontrawariantna zmienna typu nie może być używana w zwracanym typie",
         "returnTypeMismatch": "Wyrażenia typu „{exprType}” nie można przypisać do zwracanego typu „{returnType}”",
@@ -429,6 +429,7 @@
         "tupleIndexOutOfRange": "Indeks {index} jest poza zakresem dla typu {type}",
         "typeAliasIllegalExpressionForm": "Nieprawidłowy formularz wyrażenia dla definicji aliasu typu",
         "typeAliasIsRecursiveDirect": "Alias typu „{name}” nie może używać samego siebie w swojej definicji",
+        "typeAliasNotAllowed": "Alias typu „{name}” nie może być używany w tym kontekście",
         "typeAliasNotInModuleOrClass": "Typ TypeAlias można zdefiniować tylko w zakresie modułu lub klasy",
         "typeAliasRedeclared": "Nazwa „{name}” jest zadeklarowana jako TypeAlias i może być przypisana tylko raz",
         "typeAliasStatementIllegal": "Instrukcja typu alias wymaga języka Python w wersji 3.12 lub nowszej",

package/dist/localization/package.nls.pt-br.json

@@ -293,7 +293,7 @@
         "noOverload": "Nenhuma sobrecarga para \"{name}\" corresponde aos argumentos fornecidos",
         "noReturnContainsReturn": "A função com o tipo de retorno declarado \"NoReturn\" não pode incluir uma instrução return",
         "noReturnContainsYield": "A função com o tipo de retorno declarado \"NoReturn\" não pode incluir uma instrução yield",
-        "noReturnReturnsNone": "A função com o tipo declarado de \"NoReturn\" não pode retornar \"None\"",
+        "noReturnReturnsNone": "Função com tipo de retorno declarado \"NoReturn\" não pode retornar \"None\"",
         "nonDefaultAfterDefault": "O argumento não padrão segue o argumento padrão",
         "nonLocalInModule": "Declaração não local não permitida no nível do módulo",
         "nonLocalNoBinding": "Nenhuma associação para \"{name}\" não local encontrada",
@@ -383,7 +383,7 @@
         "requiredArgCount": "Argumento de tipo único esperado após \"Obrigatório\"",
         "requiredNotInTypedDict": "\"Obrigatório\" não é permitido neste contexto",
         "returnInAsyncGenerator": "A instrução return com valor não é permitida no gerador assíncrono",
-        "returnMissing": "A função com o tipo declarado de \"{returnType}\" deve retornar o valor em todos os caminhos de código",
+        "returnMissing": "Função com tipo de retorno declarado \"{returnType}\" deve retornar valor em todos os caminhos de código",
         "returnOutsideFunction": "\"return\" só pode ser usado dentro de uma função",
         "returnTypeContravariant": "A variável de tipo contravariante não pode ser usada no tipo de retorno",
         "returnTypeMismatch": "A expressão do tipo \"{exprType}\" não pode ser atribuída ao tipo de retorno \"{returnType}\"",
@@ -429,6 +429,7 @@
         "tupleIndexOutOfRange": "O índice {index} está fora do intervalo para o tipo {type}",
         "typeAliasIllegalExpressionForm": "Formulário de expressão inválido para definição de alias de tipo",
         "typeAliasIsRecursiveDirect": "O alias de tipo \"{name}\" não pode usar a si mesmo em sua definição",
+        "typeAliasNotAllowed": "O alias de tipo \"{name}\" não pode ser usado neste contexto",
         "typeAliasNotInModuleOrClass": "Um TypeAlias só pode ser definido dentro de um módulo ou escopo de classe",
         "typeAliasRedeclared": "\"{name}\" é declarado como um TypeAlias e só pode ser atribuído uma vez",
         "typeAliasStatementIllegal": "A instrução de alias de tipo requer o Python 3.12 ou mais recente",

package/dist/localization/package.nls.qps-ploc.json

@@ -293,7 +293,7 @@
         "noOverload": "[IcBNQ][นั้Ñø øvërløæðs før \"{ñæmë}\" mætçh thë prøvïðëð ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]",
         "noReturnContainsReturn": "[nBLDq][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"ÑøRëtµrñ\" çæññøt ïñçlµðë æ rëtµrñ stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "noReturnContainsYield": "[V3G36][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"ÑøRëtµrñ\" çæññøt ïñçlµðë æ ÿïëlð stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]",
-        "noReturnReturnsNone": "[O3XA6][นั้Fµñçtïøñ wïth ðëçlærëð tÿpë øf \"ÑøRëtµrñ\" çæññøt rëtµrñ \"Ñøñë\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
+        "noReturnReturnsNone": "[O3XA6][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"ÑøRëtµrñ\" çæññøt rëtµrñ \"Ñøñë\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "nonDefaultAfterDefault": "[mFFgP][นั้Ñøñ-ðëfæµlt ærgµmëñt følløws ðëfæµlt ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "nonLocalInModule": "[kmLlv][นั้Ñøñløçæl ðëçlærætïøñ ñøt ælløwëð æt møðµlë lëvëlẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
         "nonLocalNoBinding": "[WTA2d][นั้Ñø þïñðïñg før ñøñløçæl \"{ñæmë}\" føµñðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]",
@@ -383,7 +383,7 @@
         "requiredArgCount": "[aZX4z][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Rëqµïrëð\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
         "requiredNotInTypedDict": "[TArW6][นั้\"Rëqµïrëð\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]",
         "returnInAsyncGenerator": "[qb5pt][นั้Rëtµrñ stætëmëñt wïth vælµë ïs ñøt ælløwëð ïñ æsÿñç gëñërætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]",
-        "returnMissing": "[kPevK][นั้Fµñçtïøñ wïth ðëçlærëð tÿpë øf \"{rëtµrñTÿpë}\" mµst rëtµrñ vælµë øñ æll çøðë pæthsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
+        "returnMissing": "[kPevK][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"{rëtµrñTÿpë}\" mµst rëtµrñ vælµë øñ æll çøðë pæthsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
         "returnOutsideFunction": "[O4SJp][นั้\"rëtµrñ\" çæñ þë µsëð øñlÿ wïthïñ æ fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]",
         "returnTypeContravariant": "[KkMhh][นั้Çøñtræværïæñt tÿpë værïæþlë çæññøt þë µsëð ïñ rëtµrñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]",
         "returnTypeMismatch": "[QYqHy][นั้Ëxprëssïøñ øf tÿpë \"{ëxprTÿpë}\" çæññøt þë æssïgñëð tø rëtµrñ tÿpë \"{rëtµrñTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
@@ -429,6 +429,7 @@
         "tupleIndexOutOfRange": "[aNqDv][นั้Ïñðëx {ïñðëx} ïs øµt øf ræñgë før tÿpë {tÿpë}Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "typeAliasIllegalExpressionForm": "[4u4ay][นั้Ïñvælïð ëxprëssïøñ førm før tÿpë ælïæs ðëfïñïtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
         "typeAliasIsRecursiveDirect": "[r8PyZ][นั้Tÿpë ælïæs \"{ñæmë}\" çæññøt µsë ïtsëlf ïñ ïts ðëfïñïtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]",
+        "typeAliasNotAllowed": "[a8iha][นั้Tÿpë ælïæs \"{ñæmë}\" çæññøt þë µsëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
         "typeAliasNotInModuleOrClass": "[iQpDJ][นั้Æ TÿpëÆlïæs çæñ þë ðëfïñëð øñlÿ wïthïñ æ møðµlë ør çlæss sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "typeAliasRedeclared": "[P036x][นั้\"{ñæmë}\" ïs ðëçlærëð æs æ TÿpëÆlïæs æñð çæñ þë æssïgñëð øñlÿ øñçëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "typeAliasStatementIllegal": "[2EW0Q][นั้Tÿpë ælïæs stætëmëñt rëqµïrës Pÿthøñ 3.12 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",

package/dist/localization/package.nls.ru.json

@@ -293,7 +293,7 @@
         "noOverload": "Не существует перегрузок для \"{name}\", соответствующих указанным аргументам",
         "noReturnContainsReturn": "Функция с объявленным типом возвращаемого значения \"NoReturn\" не может содержать оператор return",
         "noReturnContainsYield": "Функция с объявленным типом возвращаемого значения \"NoReturn\" не может содержать инструкцию yield",
-        "noReturnReturnsNone": "Функция с объявленным типом \"NoReturn\" не может возвращать \"None\"",
+        "noReturnReturnsNone": "Функция с объявленным типом возвращаемого значения \"NoReturn\" не может возвращать \"None\"",
         "nonDefaultAfterDefault": "Аргумент, отличный от аргумента по умолчанию, следует за аргументом по умолчанию",
         "nonLocalInModule": "Нелокальные объявления на уровне модулей не разрешены",
         "nonLocalNoBinding": "Привязка для нелокального элемента \"{name}\" не найдена",
@@ -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",

package/dist/localization/package.nls.tr.json

@@ -293,7 +293,7 @@
         "noOverload": "\"{name}\" için aşırı yüklemelerin hiçbiri sağlanan bağımsız değişkenlerle eşleşmiyor",
         "noReturnContainsReturn": "Bildirilen dönüş türü \"NoReturn\" olan işlev bir return deyimi içeremez",
         "noReturnContainsYield": "Bildirilen dönüş türü \"NoReturn\" olan işlev bir yield deyimi içeremez",
-        "noReturnReturnsNone": "Bildirilen \"NoReturn\" türüne sahip işlev \"None\" döndüremez",
+        "noReturnReturnsNone": "Bildirilen \"NoReturn\" döndürme türüne sahip işlev \"None\" döndüremez",
         "nonDefaultAfterDefault": "Varsayılan olmayan bağımsız değişken varsayılan bağımsız değişkeni izler",
         "nonLocalInModule": "Modül düzeyinde yerel olmayan bildirim kullanılamaz",
         "nonLocalNoBinding": "Yerel olmayan \"{name}\" öğesi için bağlama bulunamadı",
@@ -383,7 +383,7 @@
         "requiredArgCount": "\"Required\" sonrasında tek bir tür bağımsız değişken bekleniyordu",
         "requiredNotInTypedDict": "Bu bağlamda \"Required\" kullanımına izin verilmiyor",
         "returnInAsyncGenerator": "Zaman uyumsuz oluşturucuda değer içeren dönüş deyimine izin verilmez",
-        "returnMissing": "Bildirilen \"{returnType}\" türüne sahip işlev, tüm kod yollarında değer döndürmelidir",
+        "returnMissing": "Bildirilen \"{returnType}\" döndürme türüne sahip işlev, tüm kod yollarında değer döndürmelidir",
         "returnOutsideFunction": "\"return\" yalnızca bir işlev içinde kullanılabilir",
         "returnTypeContravariant": "Değişken karşıtı tür değişkeni dönüş türünde kullanılamaz",
         "returnTypeMismatch": "\"{exprType}\" türündeki ifade \"{returnType}\" dönüş türüne atanamaz",
@@ -429,6 +429,7 @@
         "tupleIndexOutOfRange": "{index} dizini {type} türü için aralık dışında",
         "typeAliasIllegalExpressionForm": "Tür diğer ad tanımı için geçersiz ifade form",
         "typeAliasIsRecursiveDirect": "Tür diğer adı \"{name}\", tanımında kendisini kullanamaz",
+        "typeAliasNotAllowed": "\"{name}\" tür adı bu bağlamda kullanılamaz",
         "typeAliasNotInModuleOrClass": "TypeAlias yalnızca bir modül veya sınıf kapsamında tanımlanabilir",
         "typeAliasRedeclared": "\"{name}\" bir TypeAlias olarak bildirilmiş ve yalnızca bir kez atanabilir",
         "typeAliasStatementIllegal": "Tür diğer adı deyimi için Python 3.12 veya daha yeni bir sürümü gerekiyor",

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

@@ -293,7 +293,7 @@
         "noOverload": "“{name}”的重载与提供的参数不匹配",
         "noReturnContainsReturn": "声明返回类型为“NoReturn”的函数不能包含 return 语句",
         "noReturnContainsYield": "声明的返回类型为 “NoReturn” 的函数不能包含 yield 语句",
-        "noReturnReturnsNone": "声明类型为“NoReturn”的函数无法返回“None”",
+        "noReturnReturnsNone": "所声明的返回类型为 \"NoReturn\" 的函数无法返回 \"None\"",
         "nonDefaultAfterDefault": "非默认参数遵循默认参数",
         "nonLocalInModule": "模块级别不允许使用非本地声明",
         "nonLocalNoBinding": "找不到非本地“{name}”的绑定",
@@ -383,7 +383,7 @@
         "requiredArgCount": "\"Required\"后应为单个类型参数",
         "requiredNotInTypedDict": "此上下文中不允许使用\"Required\"",
         "returnInAsyncGenerator": "异步生成器中不允许返回值为值的语句",
-        "returnMissing": "声明类型为“{returnType}”的函数必须在所有代码路径上返回值",
+        "returnMissing": "所声明的返回类型为“{returnType}”的函数必须在所有代码路径上返回值",
         "returnOutsideFunction": "“return”只能在函数中使用",
         "returnTypeContravariant": "逆变类型变量不能用于返回类型",
         "returnTypeMismatch": "无法将类型“{exprType}”的表达式分配给返回类型“{returnType}”",
@@ -429,6 +429,7 @@
         "tupleIndexOutOfRange": "类型 {type} 的索引 {index} 超出范围",
         "typeAliasIllegalExpressionForm": "类型别名定义的表达式形式无效",
         "typeAliasIsRecursiveDirect": "类型别名“{name}”不能在其定义中使用自身",
+        "typeAliasNotAllowed": "类型别名“{name}”不能在此上下文中使用",
         "typeAliasNotInModuleOrClass": "TypeAlias 只能在模块或类范围内定义",
         "typeAliasRedeclared": "“{name}”声明为 TypeAlias，只能分配一次",
         "typeAliasStatementIllegal": "类型别名语句需要 Python 3.12 或更高版本",

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

@@ -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 或更新版本",

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

@@ -486,6 +486,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 +509,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 +639,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]