@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

package/src/analyzer/typeEvaluatorTypes.ts

@@ -1,452 +0,0 @@
-/*
- * 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

@@ -1,161 +0,0 @@
-/*
- * 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;
-}