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

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 以降が必要です",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "型パラメーター リストは、TypeVar、TypeVarTuple、または ParamSpec のみを含むタプルである必要があります",
         "typeAnnotationCall": "型式では呼び出し式を使用できません",
         "typeAnnotationVariable": "型式では変数を使用できません",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "\"type\" の型引数はクラスである必要があります。呼び出し可能関数はサポートされていません",
         "typeArgListExpected": "ParamSpec、省略記号、または型の一覧が必要です",
         "typeArgListNotAllowed": "この型引数にはリスト式を使用できません",
         "typeArgsExpectingNone": "クラス \"{name}\" に型引数が必要ありません",

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 이상이 필요합니다.",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "형식 매개 변수 목록은 TypeVar, TypeVarTuple 또는 ParamSpec만 포함하는 튜플이어야 합니다.",
         "typeAnnotationCall": "형식 식에는 호출 식을 사용할 수 없습니다.",
         "typeAnnotationVariable": "형식 식에는 변수를 사용할 수 없습니다.",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "\"type\"에 대한 형식 인수는 클래스여야 합니다. 콜러블은 지원되지 않습니다.",
         "typeArgListExpected": "ParamSpec, 줄임표 또는 형식 목록이 필요합니다.",
         "typeArgListNotAllowed": "이 형식 인수에는 목록 식을 사용할 수 없습니다.",
         "typeArgsExpectingNone": "클래스 \"{name}\"에 형식 인수가 필요하지 않습니다.",

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",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "Lista parametrów typu musi być krotką zawierającą tylko parametry TypeVar, TypeVarTuple lub ParamSpec",
         "typeAnnotationCall": "Wyrażenie wywołania jest niedozwolone w wyrażeniu typu",
         "typeAnnotationVariable": "Zmienna niedozwolona w wyrażeniu typu",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "Argument typu „type” musi być klasą; elementy wywoływane nie są obsługiwane",
         "typeArgListExpected": "Oczekiwano parametru ParamSpec, wielokropka lub listy typów",
         "typeArgListNotAllowed": "Wyrażenie listy jest niedozwolone dla tego argumentu typu",
         "typeArgsExpectingNone": "Oczekiwano braku argumentów typu dla klasy „{name}”",

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",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "A lista de parâmetros de tipo deve ser uma tupla contendo apenas TypeVar, TypeVarTuple ou ParamSpec",
         "typeAnnotationCall": "Expressão de chamada não permitida na expressão de tipo",
         "typeAnnotationVariable": "Variável não permitida na expressão de tipo",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "O argumento de tipo para \"type\" deve ser uma classe; não há suporte para callables",
         "typeArgListExpected": "ParamSpec, reticências ou lista de tipos esperados",
         "typeArgListNotAllowed": "Expressão de lista não permitida para este argumento de tipo",
         "typeArgsExpectingNone": "Nenhum argumento de tipo era esperado para a classe \"{name}\"",

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",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "Список параметров типа должен быть кортежем, содержащим только TypeVar, TypeVarTuple или ParamSpec",
         "typeAnnotationCall": "Выражение вызова не разрешено в выражении типа",
         "typeAnnotationVariable": "Переменная не разрешена в выражении типа",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "Аргумент типа для \"type\" должен быть классом. Вызываемые объекты не поддерживаются",
         "typeArgListExpected": "Ожидается ParamSpec, многоточие или список типов",
         "typeArgListNotAllowed": "Выражение списка не разрешено для аргумента этого типа",
         "typeArgsExpectingNone": "Для класса \"{name}\" не ожидается аргументов типа",

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",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "Tür parametresi listesi yalnızca TypeVar, TypeVarTuple veya ParamSpec içeren bir demet olmalıdır",
         "typeAnnotationCall": "Tür ifadesinde çağrı ifadesine izin verilmiyor",
         "typeAnnotationVariable": "Tür ifadesinde değişkene izin verilmiyor",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "“Tür” için tür bağımsız değişkeni bir sınıf olmalıdır; çağrılabilir öğeler desteklenmiyor",
         "typeArgListExpected": "ParamSpec, üç nokta veya tür listesi bekleniyordu",
         "typeArgListNotAllowed": "Bu tür bağımsız değişkeni için liste ifadesine izin verilmiyor",
         "typeArgsExpectingNone": "\"{name}\" sınıfı için tür bağımsız değişkeni beklenmiyordu",

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 或更高版本",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "类型参数列表必须是仅包含 TypeVar、TypeVarTuple 或 ParamSpec 的元组",
         "typeAnnotationCall": "类型表达式中不允许使用调用表达式",
         "typeAnnotationVariable": "类型表达式中不允许使用变量",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "“type”的类型参数必须为类; 不支持可调用项",
         "typeArgListExpected": "应为 ParamSpec、省略号或类型列表",
         "typeArgListNotAllowed": "不允许此类型参数使用列表表达式",
         "typeArgsExpectingNone": "类“{name}”不应有类型参数",

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 或更新版本",
@@ -438,7 +439,7 @@
         "typeAliasTypeParamInvalid": "型別參數清單必須是只包含 TypeVar、TypeVarTuple 或 ParamSpec 的元組",
         "typeAnnotationCall": "型別運算式中不允許呼叫運算式",
         "typeAnnotationVariable": "型別運算式中不允許變數",
-        "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported",
+        "typeAnnotationWithCallable": "\"type\" 的類型引數必須是類別; 不支援可呼叫項目",
         "typeArgListExpected": "預期為 ParamSpec、省略符號或類型清單",
         "typeArgListNotAllowed": "此型別引數不允許清單運算式",
         "typeArgsExpectingNone": "預期類別 \"{name}\" 沒有類型引數",

package/dist/nodeMain.js

@@ -9,11 +9,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = void 0;
 const backgroundAnalysis_1 = require("./backgroundAnalysis");
+const serviceProvider_1 = require("./common/serviceProvider");
 const nodeServer_1 = require("./nodeServer");
 const server_1 = require("./server");
 function main() {
     (0, nodeServer_1.run)((conn) => new server_1.PyrightServer(conn), () => {
-        const runner = new backgroundAnalysis_1.BackgroundAnalysisRunner();
+        const runner = new backgroundAnalysis_1.BackgroundAnalysisRunner(new serviceProvider_1.ServiceProvider());
         runner.start();
     });
 }

package/dist/nodeMain.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodeMain.js","sourceRoot":"","sources":["../../src/nodeMain.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,6DAAgE;AAChE,6CAAmC;AACnC,qCAAyC;AAEzC,SAAgB,IAAI;IAChB,IAAA,gBAAG,EACC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,sBAAa,CAAC,IAAI,CAAC,EACjC,GAAG,EAAE;QACD,MAAM,MAAM,GAAG,IAAI,6CAAwB,EAAE,CAAC;QAC9C,MAAM,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC,CACJ,CAAC;AACN,CAAC;AARD,oBAQC"}
+{"version":3,"file":"nodeMain.js","sourceRoot":"","sources":["../../src/nodeMain.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,6DAAgE;AAChE,8DAA2D;AAC3D,6CAAmC;AACnC,qCAAyC;AAEzC,SAAgB,IAAI;IAChB,IAAA,gBAAG,EACC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,sBAAa,CAAC,IAAI,CAAC,EACjC,GAAG,EAAE;QACD,MAAM,MAAM,GAAG,IAAI,6CAAwB,CAAC,IAAI,iCAAe,EAAE,CAAC,CAAC;QACnE,MAAM,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC,CACJ,CAAC;AACN,CAAC;AARD,oBAQC"}

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]
@@ -2178,12 +2238,12 @@ class Parser {
             if (this._getLanguageVersion() < pythonVersion_1.PythonVersion.V3_3) {
                 this._addError(localize_1.Localizer.Diagnostic.yieldFromIllegal(), nextToken);
             }
-            return parseNodes_1.YieldFromNode.create(yieldToken, this._parseTestExpression(/* allowAssignmentExpression */ true));
+            return parseNodes_1.YieldFromNode.create(yieldToken, this._parseTestExpression(/* allowAssignmentExpression */ false));
         }
         let exprList;
         if (!this._isNextTokenNeverExpression()) {
             exprList = this._parseTestOrStarListAsExpression(
-            /* allowAssignmentExpression */ true, 
+            /* allowAssignmentExpression */ false, 
             /* allowMultipleUnpack */ true, 2 /* MissingExpression */, () => localize_1.Localizer.Diagnostic.expectedYieldExpr());
             this._reportConditionalErrorForStarTupleElement(exprList);
         }