@zzzen/pyright-internal 1.2.0-dev.20240721 → 1.2.0-dev.20240804

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -3,17 +3,17 @@ import { ConsoleInterface } from '../common/console';
 import { Diagnostic, DiagnosticAddendum } from '../common/diagnostic';
 import { DiagnosticRule } from '../common/diagnosticRules';
 import { TextRange } from '../common/textRange';
-import { ArgumentCategory, ArgumentNode, CallNode, CaseNode, ClassNode, DecoratorNode, ExpressionNode, FunctionNode, MatchNode, NameNode, ParameterCategory, ParameterNode, ParseNode, RaiseNode, StringNode } from '../parser/parseNodes';
+import { ArgCategory, ArgumentNode, CallNode, CaseNode, ClassNode, DecoratorNode, ExpressionNode, FunctionNode, MatchNode, NameNode, ParamCategory, ParameterNode, ParseNode, RaiseNode, StringNode } from '../parser/parseNodes';
 import { AnalyzerFileInfo } from './analyzerFileInfo';
 import { CodeFlowReferenceExpressionNode, FlowNode } from './codeFlowTypes';
+import { ConstraintTracker } from './constraintTracker';
 import { Declaration } from './declaration';
 import * as DeclarationUtils from './declarationUtils';
 import { SymbolWithScope } from './scope';
 import { Symbol } from './symbol';
 import { PrintTypeFlags } from './typePrinter';
+import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedFunctionType, Type, TypeCondition, TypeVarScopeId, TypeVarType, UnknownType, Variance } from './types';
 import { AssignTypeFlags, ClassMember, InferenceContext, MemberAccessFlags } from './typeUtils';
-import { TypeVarContext } from './typeVarContext';
-import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedFunctionType, Type, TypeCondition, TypeVarType, UnknownType, Variance } from './types';
 export declare const maxSubtypesForInferredType = 64;
 export declare const enum EvalFlags {
     None = 0,
@@ -68,6 +68,7 @@ export interface TypeResult<T extends Type = Type> {
     isReadOnly?: boolean;
     overloadsUsedForCall?: FunctionType[];
     memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
+    magicMethodDeprecationInfo?: MagicMethodDeprecationInfo;
 }
 export interface TypeResultWithNode extends TypeResult {
     node: ParseNode;
@@ -75,7 +76,12 @@ export interface TypeResultWithNode extends TypeResult {
 export interface MemberAccessDeprecationInfo {
     accessType: 'property' | 'descriptor';
     accessMethod: 'get' | 'set' | 'del';
-    deprecationMessage: string;
+    deprecatedMessage: string;
+}
+export interface MagicMethodDeprecationInfo {
+    className: string;
+    methodName: string;
+    deprecatedMessage: string;
 }
 export interface EvaluatorUsage {
     method: 'get' | 'set' | 'del';
@@ -105,21 +111,21 @@ export interface AbstractSymbol {
     classType: Type;
     hasImplementation: boolean;
 }
-export interface FunctionArgumentBase {
-    argumentCategory: ArgumentCategory;
+export interface ArgBase {
+    argCategory: ArgCategory;
     node?: ArgumentNode | undefined;
     name?: NameNode | undefined;
     typeResult?: TypeResult | undefined;
     valueExpression?: ExpressionNode | undefined;
     active?: boolean | undefined;
 }
-export interface FunctionArgumentWithType extends FunctionArgumentBase {
+export interface ArgWithType extends ArgBase {
     typeResult: TypeResult;
 }
-export interface FunctionArgumentWithExpression extends FunctionArgumentBase {
+export interface ArgWithExpression extends ArgBase {
     valueExpression: ExpressionNode;
 }
-export type FunctionArgument = FunctionArgumentWithType | FunctionArgumentWithExpression;
+export type Arg = ArgWithType | ArgWithExpression;
 export interface EffectiveTypeResult {
     type: Type;
     isIncomplete: boolean;
@@ -130,10 +136,10 @@ export interface EffectiveTypeResult {
     evaluationAttempts?: number;
 }
 export interface ValidateArgTypeParams {
-    paramCategory: ParameterCategory;
+    paramCategory: ParamCategory;
     paramType: Type;
     requiresTypeVarMatching: boolean;
-    argument: FunctionArgument;
+    argument: Arg;
     isDefaultArg?: boolean;
     argType?: Type | undefined;
     errorNode: ExpressionNode;
@@ -142,28 +148,23 @@ export interface ValidateArgTypeParams {
     mapsToVarArgList?: boolean | undefined;
     isinstanceParam?: boolean;
 }
-export interface AnnotationTypeOptions {
-    isVariableAnnotation?: boolean;
-    allowFinal?: boolean;
-    allowClassVar?: boolean;
-    associateTypeVarsWithScope?: boolean;
-    allowTypeVarTuple?: boolean;
-    allowParamSpec?: boolean;
-    allowRequired?: boolean;
-    allowUnpackedTypedDict?: boolean;
-    allowUnpackedTuple?: boolean;
-    notParsedByInterpreter?: boolean;
-    enforceClassTypeVarScope?: boolean;
-}
 export interface ExpectedTypeOptions {
     allowFinal?: boolean;
     allowRequired?: boolean;
     allowUnpackedTuple?: boolean;
+    allowUnpackedTypedDict?: boolean;
     allowParamSpec?: boolean;
-    allowForwardReference?: boolean;
+    allowClassVar?: boolean;
+    varTypeAnnotation?: boolean;
+    typeVarGetsCurScope?: boolean;
     allowTypeVarsWithoutScopeId?: boolean;
-    enforceTypeAnnotationRules?: boolean;
-    disallowProtocolAndTypedDict?: boolean;
+    enforceClassTypeVarScope?: boolean;
+    parsesStringLiteral?: boolean;
+    notParsed?: boolean;
+    noNonTypeSpecialForms?: boolean;
+    forwardRefs?: boolean;
+    typeExpression?: boolean;
+    convertEllipsisToAny?: boolean;
 }
 export interface ExpectedTypeResult {
     type: Type;
@@ -186,7 +187,7 @@ export interface CallResult {
     returnType?: Type | undefined;
     isTypeIncomplete?: boolean | undefined;
     argumentErrors?: boolean;
-    anyOrUnknownArgument?: UnknownType | AnyType;
+    anyOrUnknownArg?: UnknownType | AnyType;
     activeParam?: FunctionParam | undefined;
     specializedInitSelfType?: Type | undefined;
     overloadsUsedForCall?: FunctionType[];
@@ -204,6 +205,25 @@ export interface ClassMemberLookup {
     narrowedTypeForSet?: Type;
     memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
 }
+export interface SolveConstraintsOptions {
+    applyUnificationVars?: boolean;
+    useLowerBoundOnly?: boolean;
+}
+export interface ApplyTypeVarOptions {
+    typeClassType?: ClassType;
+    replaceUnsolved?: {
+        scopeIds: TypeVarScopeId[];
+        tupleClassType: ClassType | undefined;
+        unsolvedExemptTypeVars?: TypeVarType[];
+        useUnknown?: boolean;
+        eliminateUnsolvedInUnions?: boolean;
+    };
+}
+export declare enum Reachability {
+    Reachable = 0,
+    UnreachableAlways = 1,
+    UnreachableByAnalysis = 2
+}
 export interface PrintTypeOptions {
     expandTypeAlias?: boolean;
     enforcePythonSyntax?: boolean;
@@ -211,7 +231,7 @@ export interface PrintTypeOptions {
     useTypingUnpack?: boolean;
     printUnknownWithAny?: boolean;
     printTypeVarVariance?: boolean;
-    omitTypeArgumentsIfUnknown?: boolean;
+    omitTypeArgsIfUnknown?: boolean;
 }
 export interface DeclaredSymbolTypeInfo {
     type: Type | undefined;
@@ -223,7 +243,7 @@ export interface ResolveAliasOptions {
 }
 export interface ValidateTypeArgsOptions {
     allowEmptyTuple?: boolean;
-    allowVariadicTypeVar?: boolean;
+    allowTypeVarTuple?: boolean;
     allowParamSpec?: boolean;
     allowTypeArgList?: boolean;
     allowUnpackedTuples?: boolean;
@@ -244,27 +264,32 @@ export interface TypeEvaluator {
     getTypeResultForDecorator: (node: DecoratorNode) => TypeResult | undefined;
     getCachedType: (node: ExpressionNode) => Type | undefined;
     getTypeOfExpression: (node: ExpressionNode, flags?: EvalFlags, context?: InferenceContext) => TypeResult;
-    getTypeOfAnnotation: (node: ExpressionNode, options?: AnnotationTypeOptions) => Type;
+    getTypeOfAnnotation: (node: ExpressionNode, options?: ExpectedTypeOptions) => Type;
     getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
+    createSubclass: (errorNode: ExpressionNode, type1: ClassType, type2: ClassType) => ClassType;
     getTypeOfFunction: (node: FunctionNode) => FunctionTypeResult | undefined;
     getTypeOfExpressionExpectingType: (node: ExpressionNode, options?: ExpectedTypeOptions) => TypeResult;
     evaluateTypeForSubnode: (subnode: ParseNode, callback: () => void) => TypeResult | undefined;
     evaluateTypesForStatement: (node: ParseNode) => void;
     evaluateTypesForMatchStatement: (node: MatchNode) => void;
     evaluateTypesForCaseStatement: (node: CaseNode) => void;
-    evaluateTypeOfParameter: (node: ParameterNode) => void;
+    evaluateTypeOfParam: (node: ParameterNode) => void;
     canBeTruthy: (type: Type) => boolean;
     canBeFalsy: (type: Type) => boolean;
     stripLiteralValue: (type: Type) => Type;
     removeTruthinessFromType: (type: Type) => Type;
     removeFalsinessFromType: (type: Type) => Type;
+    stripTypeGuard: (type: Type) => Type;
+    solveAndApplyConstraints: (type: Type, constraints: ConstraintTracker, applyOptions?: ApplyTypeVarOptions, solveOptions?: SolveConstraintsOptions) => Type;
     getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
     verifyRaiseExceptionType: (node: RaiseNode) => void;
     verifyDeleteExpression: (node: ExpressionNode) => void;
-    validateOverloadedArgTypes: (errorNode: ExpressionNode, argList: FunctionArgument[], typeResult: TypeResult<OverloadedFunctionType>, typeVarContext: TypeVarContext | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
+    validateOverloadedArgTypes: (errorNode: ExpressionNode, argList: Arg[], typeResult: TypeResult<OverloadedFunctionType>, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
     validateInitSubclassArgs: (node: ClassNode, classType: ClassType) => void;
-    isAfterNodeReachable: (node: ParseNode) => boolean;
     isNodeReachable: (node: ParseNode, sourceNode?: ParseNode | undefined) => boolean;
+    isAfterNodeReachable: (node: ParseNode) => boolean;
+    getNodeReachability: (node: ParseNode, sourceNode?: ParseNode | undefined) => Reachability;
+    getAfterNodeReachability: (node: ParseNode) => Reachability;
     isAsymmetricAccessorAssignment: (node: ParseNode) => boolean;
     suppressDiagnostics: (node: ParseNode, callback: () => void) => void;
     isSpecialFormClass: (classType: ClassType, flags: AssignTypeFlags) => boolean;
@@ -276,7 +301,7 @@ export interface TypeEvaluator {
     getTypeOfIterable: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode, emitNotIterableError?: boolean) => TypeResult | undefined;
     getTypeOfIterator: (typeResult: TypeResult, isAsync: boolean, errorNode: ExpressionNode, emitNotIterableError?: boolean) => TypeResult | undefined;
     getGetterTypeFromProperty: (propertyClass: ClassType, inferTypeIfNeeded: boolean) => Type | undefined;
-    getTypeOfArgument: (arg: FunctionArgument, inferenceContext: InferenceContext | undefined) => TypeResult;
+    getTypeOfArg: (arg: Arg, inferenceContext: InferenceContext | undefined) => TypeResult;
     markNamesAccessed: (node: ParseNode, names: string[]) => void;
     expandPromotionTypes: (node: ParseNode, type: Type) => Type;
     makeTopLevelTypeVarsConcrete: (type: Type, makeParamSpecsConcrete?: boolean) => Type;
@@ -290,23 +315,23 @@ export interface TypeEvaluator {
     getDeclaredTypeForExpression: (expression: ExpressionNode, usage?: EvaluatorUsage) => Type | undefined;
     getFunctionDeclaredReturnType: (node: FunctionNode) => Type | undefined;
     getFunctionInferredReturnType: (type: FunctionType, callSiteInfo?: CallSiteEvaluationInfo) => Type;
-    getBestOverloadForArguments: (errorNode: ExpressionNode, typeResult: TypeResult<OverloadedFunctionType>, argList: FunctionArgument[]) => FunctionType | undefined;
+    getBestOverloadForArgs: (errorNode: ExpressionNode, typeResult: TypeResult<OverloadedFunctionType>, argList: Arg[]) => FunctionType | undefined;
     getBuiltInType: (node: ParseNode, name: string) => Type;
     getTypeOfMember: (member: ClassMember) => Type;
     getTypeOfBoundMember(errorNode: ExpressionNode, objectType: ClassType, memberName: string, usage?: EvaluatorUsage, diag?: DiagnosticAddendum | undefined, flags?: MemberAccessFlags, selfType?: ClassType | TypeVarType): TypeResult | undefined;
     getBoundMagicMethod: (classType: ClassType, memberName: string, selfType?: ClassType | TypeVarType | undefined, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedFunctionType | undefined;
-    getTypeOfMagicMethodCall: (objType: Type, methodName: string, argList: TypeResult[], errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => Type | undefined;
+    getTypeOfMagicMethodCall: (objType: Type, methodName: string, argList: TypeResult[], errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => TypeResult | undefined;
     bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedFunctionType, memberClass?: ClassType, treatConstructorAsClassMethod?: boolean, selfType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedFunctionType | undefined;
     getCallSignatureInfo: (node: CallNode, activeIndex: number, activeOrFake: boolean) => CallSignatureInfo | undefined;
     getAbstractSymbols: (classType: ClassType) => AbstractSymbol[];
     narrowConstrainedTypeVar: (node: ParseNode, typeVar: TypeVarType) => Type | undefined;
-    assignType: (destType: Type, srcType: Type, diag?: DiagnosticAddendum, destTypeVarContext?: TypeVarContext, srcTypeVarContext?: TypeVarContext, flags?: AssignTypeFlags, recursionCount?: number) => boolean;
+    assignType: (destType: Type, srcType: Type, diag?: DiagnosticAddendum, destConstraints?: ConstraintTracker, srcConstraints?: ConstraintTracker, flags?: AssignTypeFlags, recursionCount?: number) => boolean;
     validateOverrideMethod: (baseMethod: Type, overrideMethod: FunctionType | OverloadedFunctionType, baseClass: ClassType | undefined, diag: DiagnosticAddendum, enforceParamNames?: boolean) => boolean;
-    validateCallArguments: (errorNode: ExpressionNode, argList: FunctionArgument[], callTypeResult: TypeResult, typeVarContext: TypeVarContext | undefined, skipUnknownArgCheck: boolean | undefined, inferenceContext: InferenceContext | undefined) => CallResult;
+    validateCallArgs: (errorNode: ExpressionNode, argList: Arg[], callTypeResult: TypeResult, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean | undefined, inferenceContext: InferenceContext | undefined) => CallResult;
     validateTypeArg: (argResult: TypeResultWithNode, options?: ValidateTypeArgsOptions) => boolean;
     assignTypeToExpression: (target: ExpressionNode, typeResult: TypeResult, srcExpr: ExpressionNode) => void;
     assignClassToSelf: (destType: ClassType, srcType: ClassType, assumedVariance: Variance) => boolean;
-    getBuiltInObject: (node: ParseNode, name: string, typeArguments?: Type[]) => Type;
+    getBuiltInObject: (node: ParseNode, name: string, typeArgs?: Type[]) => Type;
     getTypedDictClassType: () => ClassType | undefined;
     getTupleClassType: () => ClassType | undefined;
     getObjectType: () => Type;
@@ -315,15 +340,15 @@ export interface TypeEvaluator {
     getTypeClassType(): ClassType | undefined;
     getTypingType: (node: ParseNode, symbolName: string) => Type | undefined;
     inferReturnTypeIfNecessary: (type: Type) => void;
-    inferTypeParameterVarianceForClass: (type: ClassType) => void;
-    assignTypeArguments: (destType: ClassType, srcType: ClassType, diag: DiagnosticAddendum | undefined, destTypeVarContext: TypeVarContext | undefined, srcTypeVarContext: TypeVarContext | undefined, flags: AssignTypeFlags, recursionCount: number) => boolean;
-    reportMissingTypeArguments: (node: ExpressionNode, type: Type, flags: EvalFlags) => Type;
+    inferVarianceForClass: (type: ClassType) => void;
+    assignTypeArgs: (destType: ClassType, srcType: ClassType, diag: DiagnosticAddendum | undefined, destConstraints: ConstraintTracker | undefined, srcConstraints: ConstraintTracker | undefined, flags: AssignTypeFlags, recursionCount: number) => boolean;
+    reportMissingTypeArgs: (node: ExpressionNode, type: Type, flags: EvalFlags) => Type;
     isFinalVariable: (symbol: Symbol) => boolean;
     isFinalVariableDeclaration: (decl: Declaration) => boolean;
     isExplicitTypeAliasDeclaration: (decl: Declaration) => boolean;
     addInformation: (message: string, node: ParseNode, range?: TextRange) => Diagnostic | undefined;
     addUnusedCode: (node: ParseNode, textRange: TextRange) => void;
-    addUnreachableCode: (node: ParseNode, textRange: TextRange) => void;
+    addUnreachableCode: (node: ParseNode, reachability: Reachability, textRange: TextRange) => void;
     addDeprecated: (message: string, node: ParseNode) => void;
     addDiagnostic: (rule: DiagnosticRule, message: string, node: ParseNode, range?: TextRange) => Diagnostic | undefined;
     addDiagnosticForTextRange: (fileInfo: AnalyzerFileInfo, rule: DiagnosticRule, message: string, range: TextRange) => Diagnostic | undefined;
@@ -340,5 +365,4 @@ export interface TypeEvaluator {
     setTypeResultForNode: (node: ParseNode, typeResult: TypeResult, flags?: EvalFlags) => void;
     checkForCancellation: () => void;
     printControlFlowGraph: (flowNode: FlowNode, reference: CodeFlowReferenceExpressionNode | undefined, callName: string, logger: ConsoleInterface) => void;
-    printTypeVarContext: (typeVarContext: TypeVarContext) => void;
 }

package/dist/analyzer/typeEvaluatorTypes.js

@@ -8,7 +8,7 @@
  * Abstract interface and other helper types for type evaluator module.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvalFlags = exports.maxSubtypesForInferredType = void 0;
+exports.Reachability = exports.EvalFlags = exports.maxSubtypesForInferredType = void 0;
 // Maximum number of unioned subtypes for an inferred type (e.g.
 // a list) before the type is considered an "Any".
 exports.maxSubtypesForInferredType = 64;
@@ -103,4 +103,10 @@ var EvalFlags;
     // or 'issubclass' call.
     EvalFlags[EvalFlags["IsInstanceArgDefaults"] = 536871546] = "IsInstanceArgDefaults";
 })(EvalFlags || (exports.EvalFlags = EvalFlags = {}));
+var Reachability;
+(function (Reachability) {
+    Reachability[Reachability["Reachable"] = 0] = "Reachable";
+    Reachability[Reachability["UnreachableAlways"] = 1] = "UnreachableAlways";
+    Reachability[Reachability["UnreachableByAnalysis"] = 2] = "UnreachableByAnalysis";
+})(Reachability || (exports.Reachability = Reachability = {}));
 //# sourceMappingURL=typeEvaluatorTypes.js.map

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA+CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,SAgIjB;AAhID,WAAkB,SAAS;IACvB,yCAAQ,CAAA;IAER,uDAAuD;IACvD,yEAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yDAAqB,CAAA;IAErB,yDAAyD;IACzD,uDAAoB,CAAA;IAEpB,kCAAkC;IAClC,iEAAyB,CAAA;IAEzB,0CAA0C;IAC1C,gDAAgB,CAAA;IAEhB,6CAA6C;IAC7C,wDAAoB,CAAA;IAEpB,gDAAgD;IAChD,8DAAuB,CAAA;IAEvB,2DAA2D;IAC3D,4BAA4B;IAC5B,mEAAyB,CAAA;IAEzB,kEAAkE;IAClE,gEAAgE;IAChE,qBAAqB;IACrB,+DAAuB,CAAA;IAEvB,qEAAqE;IACrE,2EAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,4DAAsB,CAAA;IAEtB,8DAA8D;IAC9D,0BAA0B;IAC1B,4EAA8B,CAAA;IAE9B,oEAAoE;IACpE,0BAA0B;IAC1B,wFAAoC,CAAA;IAEpC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,0EAA6B,CAAA;IAE7B,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,yFAAoC,CAAA;IAEpC,mDAAmD;IACnD,uEAA2B,CAAA;IAE3B,6CAA6C;IAC7C,0DAAoB,CAAA;IAEpB,mEAAmE;IACnE,kEAAwB,CAAA;IAExB,iEAAiE;IACjE,iCAAiC;IACjC,wDAAmB,CAAA;IAEnB,wDAAwD;IACxD,iEAAuB,CAAA;IAEvB,uDAAuD;IACvD,2EAA4B,CAAA;IAE5B,yCAAyC;IACzC,mFAAgC,CAAA;IAEhC,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6EAA6B,CAAA;IAE7B,8DAA8D;IAC9D,iDAAiD;IACjD,gFAA8B,CAAA;IAE9B,oEAAoE;IACpE,mBAAmB;IACnB,kFAA+B,CAAA;IAE/B,6CAA6C;IAC7C,yEAA0B,CAAA;IAE1B,2EAA2E;IAC3E,4BAA4B;IAC5B,6EAA4B,CAAA;IAE5B,sEAAsE;IACtE,+DAA+D;IAC/D,mEAAuB,CAAA;IAEvB,yEAAyE;IACzE,8CAA8C;IAC9C,0FAAkC,CAAA;IAElC,6DAA6D;IAC7D,iEAA+B,CAAA;IAE/B,sEAAsE;IACtE,mEAAgC,CAAA;IAEhC,sEAAsE;IACtE,iFAAuC,CAAA;IAEvC,sEAAsE;IACtE,wBAAwB;IACxB,mFAMiB,CAAA;AACrB,CAAC,EAhIiB,SAAS,yBAAT,SAAS,QAgI1B"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAgDH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,SAgIjB;AAhID,WAAkB,SAAS;IACvB,yCAAQ,CAAA;IAER,uDAAuD;IACvD,yEAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yDAAqB,CAAA;IAErB,yDAAyD;IACzD,uDAAoB,CAAA;IAEpB,kCAAkC;IAClC,iEAAyB,CAAA;IAEzB,0CAA0C;IAC1C,gDAAgB,CAAA;IAEhB,6CAA6C;IAC7C,wDAAoB,CAAA;IAEpB,gDAAgD;IAChD,8DAAuB,CAAA;IAEvB,2DAA2D;IAC3D,4BAA4B;IAC5B,mEAAyB,CAAA;IAEzB,kEAAkE;IAClE,gEAAgE;IAChE,qBAAqB;IACrB,+DAAuB,CAAA;IAEvB,qEAAqE;IACrE,2EAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,4DAAsB,CAAA;IAEtB,8DAA8D;IAC9D,0BAA0B;IAC1B,4EAA8B,CAAA;IAE9B,oEAAoE;IACpE,0BAA0B;IAC1B,wFAAoC,CAAA;IAEpC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,0EAA6B,CAAA;IAE7B,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,yFAAoC,CAAA;IAEpC,mDAAmD;IACnD,uEAA2B,CAAA;IAE3B,6CAA6C;IAC7C,0DAAoB,CAAA;IAEpB,mEAAmE;IACnE,kEAAwB,CAAA;IAExB,iEAAiE;IACjE,iCAAiC;IACjC,wDAAmB,CAAA;IAEnB,wDAAwD;IACxD,iEAAuB,CAAA;IAEvB,uDAAuD;IACvD,2EAA4B,CAAA;IAE5B,yCAAyC;IACzC,mFAAgC,CAAA;IAEhC,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6EAA6B,CAAA;IAE7B,8DAA8D;IAC9D,iDAAiD;IACjD,gFAA8B,CAAA;IAE9B,oEAAoE;IACpE,mBAAmB;IACnB,kFAA+B,CAAA;IAE/B,6CAA6C;IAC7C,yEAA0B,CAAA;IAE1B,2EAA2E;IAC3E,4BAA4B;IAC5B,6EAA4B,CAAA;IAE5B,sEAAsE;IACtE,+DAA+D;IAC/D,mEAAuB,CAAA;IAEvB,yEAAyE;IACzE,8CAA8C;IAC9C,0FAAkC,CAAA;IAElC,6DAA6D;IAC7D,iEAA+B,CAAA;IAE/B,sEAAsE;IACtE,mEAAgC,CAAA;IAEhC,sEAAsE;IACtE,iFAAuC,CAAA;IAEvC,sEAAsE;IACtE,wBAAwB;IACxB,mFAMiB,CAAA;AACrB,CAAC,EAhIiB,SAAS,yBAAT,SAAS,QAgI1B;AAuRD,IAAY,YAIX;AAJD,WAAY,YAAY;IACpB,yDAAS,CAAA;IACT,yEAAiB,CAAA;IACjB,iFAAqB,CAAA;AACzB,CAAC,EAJW,YAAY,4BAAZ,YAAY,QAIvB"}