@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/analyzer/typeEvaluatorTypes.ts

@@ -0,0 +1,452 @@
+/*
+ * typeEvaluatorTypes.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Abstract interface and other helper types for type evaluator module.
+ *
+ */
+
+import { CancellationToken } from 'vscode-languageserver-protocol';
+
+import { DiagnosticLevel } from '../common/configOptions';
+import { Diagnostic, DiagnosticAddendum } from '../common/diagnostic';
+import { TextRange } from '../common/textRange';
+import {
+    ArgumentCategory,
+    ArgumentNode,
+    CallNode,
+    CaseNode,
+    ClassNode,
+    ExpressionNode,
+    FunctionNode,
+    MatchNode,
+    NameNode,
+    ParameterCategory,
+    ParameterNode,
+    ParseNode,
+    RaiseNode,
+    StringNode,
+} from '../parser/parseNodes';
+import * as DeclarationUtils from './aliasDeclarationUtils';
+import { AnalyzerFileInfo } from './analyzerFileInfo';
+import { Declaration } from './declaration';
+import { SymbolWithScope } from './scope';
+import { Symbol } from './symbol';
+import {
+    ClassType,
+    FunctionParameter,
+    FunctionType,
+    OverloadedFunctionType,
+    Type,
+    TypeCondition,
+    TypeVarType,
+} from './types';
+import { AssignTypeFlags, ClassMember } from './typeUtils';
+import { TypeVarContext } from './typeVarContext';
+
+// Maximum number of unioned subtypes for an inferred type (e.g.
+// a list) before the type is considered an "Any".
+export const maxSubtypesForInferredType = 64;
+
+export const enum EvaluatorFlags {
+    None = 0,
+
+    // Interpret an ellipsis type annotation to mean "Any".
+    ConvertEllipsisToAny = 1 << 0,
+
+    // Normally a generic named type is specialized with "Any"
+    // types. This flag indicates that specialization shouldn't take
+    // place.
+    DoNotSpecialize = 1 << 1,
+
+    // Allow forward references. Don't report unbound errors.
+    AllowForwardReferences = 1 << 2,
+
+    // Treat string literal as a type.
+    EvaluateStringLiteralAsType = 1 << 3,
+
+    // 'Final' is not allowed in this context.
+    FinalDisallowed = 1 << 4,
+
+    // A ParamSpec isn't allowed in this context.
+    ParamSpecDisallowed = 1 << 5,
+
+    // Expression is expected to be a type (class) rather
+    // than an instance (object)
+    ExpectingType = 1 << 6,
+
+    // A TypeVarTuple isn't allowed in this context.
+    TypeVarTupleDisallowed = 1 << 7,
+
+    // Interpret an ellipsis type annotation to mean "Unknown".
+    ConvertEllipsisToUnknown = 1 << 8,
+
+    // The Generic class type is allowed in this context. It is
+    // normally not allowed if ExpectingType is set.
+    AllowGenericClassType = 1 << 9,
+
+    // A type annotation restricts the types of expressions that are
+    // allowed. If this flag is set, illegal type expressions are
+    // flagged as errors.
+    ExpectingTypeAnnotation = 1 << 10,
+
+    // TypeVars within this expression must not refer to type vars
+    // used in an outer scope that.
+    DisallowTypeVarsWithScopeId = 1 << 11,
+
+    // TypeVars within this expression must refer to type vars
+    // used in an outer scope that.
+    DisallowTypeVarsWithoutScopeId = 1 << 12,
+
+    // TypeVars within this expression that are otherwise not
+    // associated with an outer scope should be associated with
+    // the containing function's scope.
+    AssociateTypeVarsWithCurrentScope = 1 << 13,
+
+    // Used for PEP 526-style variable type annotations
+    VariableTypeAnnotation = 1 << 15,
+
+    // Emit an error if an incomplete recursive type alias is
+    // used in this context.
+    DisallowRecursiveTypeAliasPlaceholder = 1 << 16,
+
+    // 'ClassVar' is not allowed in this context.
+    ClassVarDisallowed = 1 << 17,
+
+    // 'Generic' cannot be used without type arguments in this context.
+    DisallowNakedGeneric = 1 << 18,
+
+    // The node is not parsed by the interpreter because it is within
+    // a comment or a string literal.
+    NotParsedByInterpreter = 1 << 19,
+
+    // Required and NotRequired are allowed in this context.
+    RequiredAllowed = 1 << 20,
+
+    // Allow Unpack annotation for a tuple or TypeVarTuple.
+    AllowUnpackedTupleOrTypeVarTuple = 1 << 21,
+
+    // Even though an expression is enclosed in a string literal,
+    // the interpreter (within a source file, not a stub) still
+    // parses the expression and generates parse errors.
+    InterpreterParsesStringLiteral = 1 << 22,
+
+    // Allow Unpack annotation for TypedDict.
+    AllowUnpackedTypedDict = 1 << 23,
+}
+
+export interface SimpleTypeResult {
+    type: Type;
+
+    // Is the type incomplete (i.e. not fully evaluated) because
+    // some of the paths involve cyclical dependencies?
+    isIncomplete?: boolean | undefined;
+}
+
+export interface TypeResult extends SimpleTypeResult {
+    node: ParseNode;
+
+    // Type consistency errors detected when evaluating this type.
+    typeErrors?: boolean | undefined;
+
+    // Variadic type arguments allow the shorthand "()" to
+    // represent an empty tuple (i.e. Tuple[()]).
+    isEmptyTupleShorthand?: boolean | undefined;
+
+    unpackedType?: Type | undefined;
+    typeList?: TypeResult[] | undefined;
+    expectedTypeDiagAddendum?: DiagnosticAddendum | undefined;
+
+    // Used for the output of "super" calls used on the LHS of
+    // a member access. Normally the type of the LHS is the same
+    // as the class or object used to bind the member, but the
+    // "super" call can specify a different class or object to
+    // bind.
+    bindToType?: ClassType | TypeVarType | undefined;
+
+    // Indicates that the type comes from a super() call.
+    isSuperCall?: boolean;
+
+    // Is member a descriptor object that is asymmetric with respect
+    // to __get__ and __set__ types?
+    isAsymmetricDescriptor?: boolean;
+
+    // Is the type wrapped in a "Required" or "NotRequired" class?
+    isRequired?: boolean;
+    isNotRequired?: boolean;
+}
+
+export interface EvaluatorUsage {
+    method: 'get' | 'set' | 'del';
+
+    // Used only for set methods
+    setType?: Type | undefined;
+    setErrorNode?: ExpressionNode | undefined;
+    setExpectedTypeDiag?: DiagnosticAddendum | undefined;
+}
+
+export interface ClassTypeResult {
+    classType: ClassType;
+    decoratedType: Type;
+}
+
+export interface FunctionTypeResult {
+    functionType: FunctionType;
+    decoratedType: Type;
+}
+
+export interface CallSignature {
+    type: FunctionType;
+    activeParam?: FunctionParameter | undefined;
+}
+
+export interface CallSignatureInfo {
+    signatures: CallSignature[];
+    callNode: CallNode;
+}
+
+// Used to determine whether an abstract method has been
+// overridden by a non-abstract method.
+export interface AbstractMethod {
+    symbol: Symbol;
+    symbolName: string;
+    classType: Type;
+    isAbstract: boolean;
+}
+
+export interface FunctionArgumentBase {
+    argumentCategory: ArgumentCategory;
+    node?: ArgumentNode | undefined;
+    name?: NameNode | undefined;
+    type?: Type | undefined;
+    valueExpression?: ExpressionNode | undefined;
+    active?: boolean | undefined;
+}
+
+export interface FunctionArgumentWithType extends FunctionArgumentBase {
+    type: Type;
+}
+
+export interface FunctionArgumentWithExpression extends FunctionArgumentBase {
+    valueExpression: ExpressionNode;
+}
+
+export type FunctionArgument = FunctionArgumentWithType | FunctionArgumentWithExpression;
+
+export interface EffectiveTypeResult {
+    type: Type;
+    isIncomplete: boolean;
+    includesVariableDecl: boolean;
+    includesIllegalTypeAliasDecl: boolean;
+    isRecursiveDefinition: boolean;
+}
+
+export interface ValidateArgTypeParams {
+    paramCategory: ParameterCategory;
+    paramType: Type;
+    requiresTypeVarMatching: boolean;
+    argument: FunctionArgument;
+    argType?: Type | undefined;
+    errorNode: ExpressionNode;
+    paramName?: string | undefined;
+    isParamNameSynthesized?: boolean;
+    mapsToVarArgList?: boolean | undefined;
+    expectingType?: boolean;
+}
+
+export interface AnnotationTypeOptions {
+    isVariableAnnotation?: boolean;
+    allowFinal?: boolean;
+    allowClassVar?: boolean;
+    associateTypeVarsWithScope?: boolean;
+    allowTypeVarTuple?: boolean;
+    allowParamSpec?: boolean;
+    disallowRecursiveTypeAlias?: boolean;
+    allowUnpackedTypedDict?: boolean;
+    allowUnpackedTuple?: boolean;
+    notParsedByInterpreter?: boolean;
+}
+
+export interface ExpectedTypeResult {
+    type: Type;
+    node: ParseNode;
+}
+
+export interface FunctionResult {
+    returnType: Type;
+    argumentErrors: boolean;
+    isTypeIncomplete: boolean;
+}
+
+export interface TypeEvaluator {
+    runWithCancellationToken<T>(token: CancellationToken, callback: () => T): T;
+
+    getType: (node: ExpressionNode) => Type | undefined;
+    getTypeOfExpression: (node: ExpressionNode, flags?: EvaluatorFlags, expectedType?: Type) => TypeResult;
+    getTypeOfAnnotation: (node: ExpressionNode, options?: AnnotationTypeOptions) => Type;
+    getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
+    getTypeOfFunction: (node: FunctionNode) => FunctionTypeResult | undefined;
+    getTypeOfExpressionExpectingType: (
+        node: ExpressionNode,
+        allowFinal?: boolean,
+        allowRequired?: boolean
+    ) => TypeResult;
+    evaluateTypeForSubnode: (subnode: ParseNode, callback: () => void) => TypeResult | undefined;
+    evaluateTypesForStatement: (node: ParseNode) => void;
+    evaluateTypesForMatchStatement: (node: MatchNode) => void;
+    evaluateTypesForCaseStatement: (node: CaseNode) => void;
+    evaluateTypeOfParameter: (node: ParameterNode) => void;
+
+    canBeTruthy: (type: Type) => boolean;
+    canBeFalsy: (type: Type) => boolean;
+    removeTruthinessFromType: (type: Type) => Type;
+    removeFalsinessFromType: (type: Type) => Type;
+
+    getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
+    verifyRaiseExceptionType: (node: RaiseNode) => void;
+    verifyDeleteExpression: (node: ExpressionNode) => void;
+
+    isAfterNodeReachable: (node: ParseNode) => boolean;
+    isNodeReachable: (node: ParseNode, sourceNode: ParseNode | undefined) => boolean;
+    isAsymmetricDescriptorAssignment: (node: ParseNode) => boolean;
+    suppressDiagnostics: (node: ParseNode, callback: () => void) => void;
+
+    getDeclarationsForStringNode: (node: StringNode) => Declaration[] | undefined;
+    getDeclarationsForNameNode: (node: NameNode, skipUnreachableCode?: boolean) => Declaration[] | undefined;
+    getTypeForDeclaration: (declaration: Declaration) => Type | undefined;
+    resolveAliasDeclaration: (
+        declaration: Declaration,
+        resolveLocalNames: boolean,
+        allowExternallyHiddenAccess?: boolean
+    ) => Declaration | undefined;
+    resolveAliasDeclarationWithInfo: (
+        declaration: Declaration,
+        resolveLocalNames: boolean,
+        allowExternallyHiddenAccess?: boolean
+    ) => DeclarationUtils.ResolvedAliasInfo | undefined;
+    getTypeOfIterable: (type: Type, isAsync: boolean, errorNode: ParseNode | undefined) => Type | undefined;
+    getTypeOfIterator: (type: Type, isAsync: boolean, errorNode: ParseNode | undefined) => Type | undefined;
+    getGetterTypeFromProperty: (propertyClass: ClassType, inferTypeIfNeeded: boolean) => Type | undefined;
+    getTypeOfArgument: (arg: FunctionArgument) => SimpleTypeResult;
+    markNamesAccessed: (node: ParseNode, names: string[]) => void;
+    getScopeIdForNode: (node: ParseNode) => string;
+    makeTopLevelTypeVarsConcrete: (type: Type) => Type;
+    mapSubtypesExpandTypeVars: (
+        type: Type,
+        conditionFilter: TypeCondition[] | undefined,
+        callback: (expandedSubtype: Type, unexpandedSubtype: Type) => Type | undefined
+    ) => Type;
+    lookUpSymbolRecursive: (node: ParseNode, name: string, honorCodeFlow: boolean) => SymbolWithScope | undefined;
+    getDeclaredTypeOfSymbol: (symbol: Symbol) => Type | undefined;
+    getEffectiveTypeOfSymbol: (symbol: Symbol) => Type;
+    getEffectiveTypeOfSymbolForUsage: (
+        symbol: Symbol,
+        usageNode?: NameNode,
+        useLastDecl?: boolean
+    ) => EffectiveTypeResult;
+    getInferredTypeOfDeclaration: (symbol: Symbol, decl: Declaration) => Type | undefined;
+    getDeclaredTypeForExpression: (expression: ExpressionNode, usage?: EvaluatorUsage) => Type | undefined;
+    getFunctionDeclaredReturnType: (node: FunctionNode) => Type | undefined;
+    getFunctionInferredReturnType: (type: FunctionType, args?: ValidateArgTypeParams[]) => Type;
+    getBestOverloadForArguments: (
+        errorNode: ExpressionNode,
+        type: OverloadedFunctionType,
+        argList: FunctionArgument[]
+    ) => FunctionType | undefined;
+    getBuiltInType: (node: ParseNode, name: string) => Type;
+    getTypeOfMember: (member: ClassMember) => Type;
+    getTypeOfObjectMember(errorNode: ExpressionNode, objectType: ClassType, memberName: string): TypeResult | undefined;
+    getBoundMethod: (
+        classType: ClassType,
+        memberName: string,
+        recursionCount?: number,
+        treatConstructorAsClassMember?: boolean
+    ) => FunctionType | OverloadedFunctionType | undefined;
+    getTypeOfMagicMethodReturn: (
+        objType: Type,
+        args: Type[],
+        magicMethodName: string,
+        errorNode: ExpressionNode,
+        expectedType: Type | undefined
+    ) => Type | undefined;
+    bindFunctionToClassOrObject: (
+        baseType: ClassType | undefined,
+        memberType: FunctionType | OverloadedFunctionType,
+        memberClass?: ClassType,
+        errorNode?: ParseNode,
+        recursionCount?: number,
+        treatConstructorAsClassMember?: boolean,
+        firstParamType?: ClassType | TypeVarType
+    ) => FunctionType | OverloadedFunctionType | undefined;
+    getCallSignatureInfo: (node: CallNode, activeIndex: number, activeOrFake: boolean) => CallSignatureInfo | undefined;
+    getAbstractMethods: (classType: ClassType) => AbstractMethod[];
+    narrowConstrainedTypeVar: (node: ParseNode, typeVar: TypeVarType) => Type | undefined;
+
+    assignType: (
+        destType: Type,
+        srcType: Type,
+        diag?: DiagnosticAddendum,
+        destTypeVarContext?: TypeVarContext,
+        srcTypeVarContext?: TypeVarContext,
+        flags?: AssignTypeFlags,
+        recursionCount?: number
+    ) => boolean;
+    validateOverrideMethod: (
+        baseMethod: Type,
+        overrideMethod: FunctionType,
+        diag: DiagnosticAddendum,
+        enforceParamNames?: boolean
+    ) => boolean;
+    assignTypeToExpression: (
+        target: ExpressionNode,
+        type: Type,
+        isTypeIncomplete: boolean,
+        srcExpr: ExpressionNode
+    ) => void;
+    getBuiltInObject: (node: ParseNode, name: string, typeArguments?: Type[]) => Type;
+    getTypedDictClassType: () => Type | undefined;
+    getTupleClassType: () => Type | undefined;
+    getObjectType: () => Type | undefined;
+    getTypingType: (node: ParseNode, symbolName: string) => Type | undefined;
+    inferReturnTypeIfNecessary: (type: Type) => void;
+    verifyTypeArgumentsAssignable: (
+        destType: ClassType,
+        srcType: ClassType,
+        diag: DiagnosticAddendum | undefined,
+        destTypeVarContext: TypeVarContext | undefined,
+        srcTypeVarContext: TypeVarContext | undefined,
+        flags: AssignTypeFlags,
+        recursionCount: number
+    ) => boolean;
+    addError: (message: string, node: ParseNode) => Diagnostic | undefined;
+    addWarning: (message: string, node: ParseNode) => Diagnostic | undefined;
+    addInformation: (message: string, node: ParseNode) => Diagnostic | undefined;
+    addUnusedCode: (node: ParseNode, textRange: TextRange) => void;
+    addDeprecated: (message: string, node: ParseNode) => void;
+
+    addDiagnostic: (
+        diagLevel: DiagnosticLevel,
+        rule: string,
+        message: string,
+        node: ParseNode
+    ) => Diagnostic | undefined;
+    addDiagnosticForTextRange: (
+        fileInfo: AnalyzerFileInfo,
+        diagLevel: DiagnosticLevel,
+        rule: string,
+        message: string,
+        range: TextRange
+    ) => Diagnostic | undefined;
+
+    printType: (type: Type, expandTypeAlias?: boolean) => string;
+    printFunctionParts: (type: FunctionType) => [string[], string];
+
+    getTypeCacheEntryCount: () => number;
+    disposeEvaluator: () => void;
+    useSpeculativeMode: <T>(speculativeNode: ParseNode, callback: () => T) => T;
+    setTypeForNode: (node: ParseNode, type?: Type, flags?: EvaluatorFlags) => void;
+
+    checkForCancellation: () => void;
+}

package/src/analyzer/typeEvaluatorWithTracker.ts

@@ -0,0 +1,161 @@
+/*
+ * typeEvaluatorWithTracker.ts
+ *
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * This wraps real type evaluator to track performance information such
+ * as which type inferring takes most of time, what files are read most of times
+ * and etc.
+ */
+
+import { isDebugMode } from '../common/core';
+import { LogTracker } from '../common/logTracker';
+import { timingStats } from '../common/timing';
+import { ImportLookup } from './analyzerFileInfo';
+import { PrintableType, TracePrinter } from './tracePrinter';
+import { createTypeEvaluator, EvaluatorOptions } from './typeEvaluator';
+import { TypeEvaluator } from './typeEvaluatorTypes';
+
+// We don't want to track calls from the type evaluator itself, but only entry points.
+export function createTypeEvaluatorWithTracker(
+    importLookup: ImportLookup,
+    evaluatorOptions: EvaluatorOptions,
+    logger: LogTracker,
+    printer?: TracePrinter
+) {
+    if (!evaluatorOptions.logCalls && isDebugMode()) {
+        return createTypeEvaluator(importLookup, evaluatorOptions);
+    }
+
+    function run<T>(title: string, callback: () => T, value?: PrintableType): T {
+        return evaluatorOptions.logCalls
+            ? logger.log(
+                  title,
+                  (s) => {
+                      s.add(printer?.print(value));
+                      return timingStats.typeEvaluationTime.timeOperation(callback);
+                  },
+                  evaluatorOptions.minimumLoggingThreshold,
+                  true
+              )
+            : timingStats.typeEvaluationTime.timeOperation(callback);
+    }
+
+    const lookup: ImportLookup = evaluatorOptions.logCalls
+        ? (filePath) =>
+              logger.log(
+                  'import lookup',
+                  (s) => {
+                      s.add(printer?.printFileOrModuleName(filePath));
+                      return importLookup(filePath);
+                  },
+                  evaluatorOptions.minimumLoggingThreshold,
+                  true
+              )
+        : importLookup;
+
+    const typeEvaluator = createTypeEvaluator(lookup, evaluatorOptions);
+
+    const withTracker: TypeEvaluator = {
+        runWithCancellationToken: typeEvaluator.runWithCancellationToken,
+        getType: (n) => run('getType', () => typeEvaluator.getType(n), n),
+        getTypeOfExpression: (n, f, e) =>
+            run('getTypeOfExpression', () => typeEvaluator.getTypeOfExpression(n, f, e), n),
+        getTypeOfAnnotation: typeEvaluator.getTypeOfAnnotation,
+        getTypeOfClass: (n) => run('getTypeOfClass', () => typeEvaluator.getTypeOfClass(n), n),
+        getTypeOfFunction: (n) => run('getTypeOfFunction', () => typeEvaluator.getTypeOfFunction(n), n),
+        getTypeOfExpressionExpectingType: typeEvaluator.getTypeOfExpressionExpectingType,
+        evaluateTypeForSubnode: typeEvaluator.evaluateTypeForSubnode,
+        evaluateTypesForStatement: (n) =>
+            run('evaluateTypesForStatement', () => typeEvaluator.evaluateTypesForStatement(n), n),
+        evaluateTypesForMatchStatement: typeEvaluator.evaluateTypesForMatchStatement,
+        evaluateTypesForCaseStatement: typeEvaluator.evaluateTypesForCaseStatement,
+        evaluateTypeOfParameter: typeEvaluator.evaluateTypeOfParameter,
+        canBeTruthy: typeEvaluator.canBeTruthy,
+        canBeFalsy: typeEvaluator.canBeFalsy,
+        removeTruthinessFromType: typeEvaluator.removeTruthinessFromType,
+        removeFalsinessFromType: typeEvaluator.removeFalsinessFromType,
+        getExpectedType: (n) => run('getExpectedType', () => typeEvaluator.getExpectedType(n), n),
+        verifyRaiseExceptionType: (n) =>
+            run('verifyRaiseExceptionType', () => typeEvaluator.verifyRaiseExceptionType(n), n),
+        verifyDeleteExpression: (n) => run('verifyDeleteExpression', () => typeEvaluator.verifyDeleteExpression(n), n),
+        isAfterNodeReachable: (n) => run('isAfterNodeReachable', () => typeEvaluator.isAfterNodeReachable(n), n),
+        isNodeReachable: (n, s) => run('isNodeReachable', () => typeEvaluator.isNodeReachable(n, s), n),
+        isAsymmetricDescriptorAssignment: typeEvaluator.isAsymmetricDescriptorAssignment,
+        suppressDiagnostics: (node, callback) =>
+            run('suppressDiagnostics', () => typeEvaluator.suppressDiagnostics(node, callback)),
+        getDeclarationsForStringNode: (n) =>
+            run('getDeclarationsForStringNode', () => typeEvaluator.getDeclarationsForStringNode(n), n),
+        getDeclarationsForNameNode: (n, s) =>
+            run('getDeclarationsForNameNode', () => typeEvaluator.getDeclarationsForNameNode(n, s), n),
+        getTypeForDeclaration: (n) => run('getTypeForDeclaration', () => typeEvaluator.getTypeForDeclaration(n), n),
+        resolveAliasDeclaration: (d, l, h) =>
+            run('resolveAliasDeclaration', () => typeEvaluator.resolveAliasDeclaration(d, l, h), d),
+        resolveAliasDeclarationWithInfo: (d, l, h) =>
+            run('resolveAliasDeclarationWithInfo', () => typeEvaluator.resolveAliasDeclarationWithInfo(d, l, h), d),
+        getTypeOfIterable: (t, a, e) => run('getTypeOfIterable', () => typeEvaluator.getTypeOfIterable(t, a, e), t),
+        getTypeOfIterator: (t, a, e) => run('getTypeOfIterator', () => typeEvaluator.getTypeOfIterator(t, a, e), t),
+        getGetterTypeFromProperty: (p, i) =>
+            run('getGetterTypeFromProperty', () => typeEvaluator.getGetterTypeFromProperty(p, i), p),
+        getTypeOfArgument: typeEvaluator.getTypeOfArgument,
+        markNamesAccessed: (n, a) => run('markNamesAccessed', () => typeEvaluator.markNamesAccessed(n, a), n),
+        getScopeIdForNode: typeEvaluator.getScopeIdForNode,
+        makeTopLevelTypeVarsConcrete: (t) =>
+            run('makeTopLevelTypeVarsConcrete', () => typeEvaluator.makeTopLevelTypeVarsConcrete(t), t),
+        mapSubtypesExpandTypeVars: typeEvaluator.mapSubtypesExpandTypeVars,
+        lookUpSymbolRecursive: typeEvaluator.lookUpSymbolRecursive,
+        getDeclaredTypeOfSymbol: typeEvaluator.getDeclaredTypeOfSymbol,
+        getEffectiveTypeOfSymbol: (s) =>
+            run('getEffectiveTypeOfSymbol', () => typeEvaluator.getEffectiveTypeOfSymbol(s), s),
+        getEffectiveTypeOfSymbolForUsage: (s, u, d) =>
+            run('getEffectiveTypeOfSymbolForUsage', () => typeEvaluator.getEffectiveTypeOfSymbolForUsage(s, u, d), s),
+        getInferredTypeOfDeclaration: typeEvaluator.getInferredTypeOfDeclaration,
+        getDeclaredTypeForExpression: typeEvaluator.getDeclaredTypeForExpression,
+        getFunctionDeclaredReturnType: (n) =>
+            run('getFunctionDeclaredReturnType', () => typeEvaluator.getFunctionDeclaredReturnType(n), n),
+        getFunctionInferredReturnType: (t, a) =>
+            run('getFunctionInferredReturnType', () => typeEvaluator.getFunctionInferredReturnType(t, a), t),
+        getBestOverloadForArguments: (e, t, a) => typeEvaluator.getBestOverloadForArguments(e, t, a),
+        getBuiltInType: (n, b) => run('getBuiltInType', () => typeEvaluator.getBuiltInType(n, b), n),
+        getTypeOfMember: (m) => run('getTypeOfMember', () => typeEvaluator.getTypeOfMember(m), m.symbol),
+        getTypeOfObjectMember: typeEvaluator.getTypeOfObjectMember,
+        getBoundMethod: typeEvaluator.getBoundMethod,
+        getTypeOfMagicMethodReturn: typeEvaluator.getTypeOfMagicMethodReturn,
+        bindFunctionToClassOrObject: typeEvaluator.bindFunctionToClassOrObject,
+        getCallSignatureInfo: (n, i, a) =>
+            run('getCallSignatureInfo', () => typeEvaluator.getCallSignatureInfo(n, i, a), n),
+        getAbstractMethods: (c) => run('getAbstractMethods', () => typeEvaluator.getAbstractMethods(c), c),
+        narrowConstrainedTypeVar: typeEvaluator.narrowConstrainedTypeVar,
+        assignType: (d, s, a, dc, sc, f, r) =>
+            run('assignType', () => typeEvaluator.assignType(d, s, a, dc, sc, f, r), d),
+        validateOverrideMethod: (b, o, d, e) =>
+            run('validateOverrideMethod', () => typeEvaluator.validateOverrideMethod(b, o, d, e), o),
+        assignTypeToExpression: typeEvaluator.assignTypeToExpression,
+        getBuiltInObject: typeEvaluator.getBuiltInObject,
+        getTypedDictClassType: typeEvaluator.getTypedDictClassType,
+        getTupleClassType: typeEvaluator.getTupleClassType,
+        getObjectType: typeEvaluator.getObjectType,
+        getTypingType: typeEvaluator.getTypingType,
+        inferReturnTypeIfNecessary: typeEvaluator.inferReturnTypeIfNecessary,
+        verifyTypeArgumentsAssignable: typeEvaluator.verifyTypeArgumentsAssignable,
+        addError: (m, n) => run('addError', () => typeEvaluator.addError(m, n), n),
+        addWarning: (m, n) => run('addWarning', () => typeEvaluator.addWarning(m, n), n),
+        addInformation: (m, n) => run('addInformation', () => typeEvaluator.addInformation(m, n), n),
+        addUnusedCode: (n, t) => run('addUnusedCode', () => typeEvaluator.addUnusedCode(n, t), n),
+        addDeprecated: (m, n) => run('addDeprecated', () => typeEvaluator.addDeprecated(m, n), n),
+        addDiagnostic: (d, r, m, n) => run('addDiagnostic', () => typeEvaluator.addDiagnostic(d, r, m, n), n),
+        addDiagnosticForTextRange: (f, d, r, m, g) =>
+            run('addDiagnosticForTextRange', () => typeEvaluator.addDiagnosticForTextRange(f, d, r, m, g)),
+        printType: (t, e) => run('printType', () => typeEvaluator.printType(t, e), t),
+        printFunctionParts: (t) => run('printFunctionParts', () => typeEvaluator.printFunctionParts(t), t),
+        getTypeCacheEntryCount: typeEvaluator.getTypeCacheEntryCount,
+        disposeEvaluator: typeEvaluator.disposeEvaluator,
+        useSpeculativeMode: typeEvaluator.useSpeculativeMode,
+        setTypeForNode: typeEvaluator.setTypeForNode,
+        checkForCancellation: typeEvaluator.checkForCancellation,
+    };
+
+    return withTracker;
+}