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

package/src/analyzer/docStringUtils.ts

@@ -1,112 +0,0 @@
-/*
- * docStringUtils.ts
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT license.
- * Author: Eric Traut
- *
- * Static methods that format and parse doc strings based on
- * the rules specified in PEP 257
- * (https://www.python.org/dev/peps/pep-0257/).
- */
-
-// Cleans the a docstring as inspect.cleandoc does.
-export function cleanDocString(rawString: string): string {
-    return cleanAndSplitDocString(rawString).join('\n');
-}
-
-export function cleanAndSplitDocString(rawString: string): string[] {
-    // Remove carriage returns and replace tabs.
-    const unescaped = rawString.replace(/\r/g, '').replace(/\t/g, '        ');
-
-    // Split into lines.
-    const lines = unescaped.split('\n');
-
-    // Determine the max indent amount.
-    let leftSpacesToRemove = Number.MAX_VALUE;
-    lines.forEach((line, index) => {
-        // First line is special.
-        if (lines.length <= 1 || index > 0) {
-            const trimmed = line.trimLeft();
-            if (trimmed) {
-                leftSpacesToRemove = Math.min(leftSpacesToRemove, line.length - trimmed.length);
-            }
-        }
-    });
-
-    // Handle the case where there were only empty lines.
-    if (leftSpacesToRemove >= Number.MAX_VALUE) {
-        leftSpacesToRemove = 0;
-    }
-
-    // Trim the lines.
-    const trimmedLines: string[] = [];
-    lines.forEach((line, index) => {
-        if (index === 0) {
-            trimmedLines.push(line.trim());
-        } else {
-            trimmedLines.push(line.substr(leftSpacesToRemove).trimRight());
-        }
-    });
-
-    // Strip off leading and trailing blank lines.
-    while (trimmedLines.length > 0 && trimmedLines[0].length === 0) {
-        trimmedLines.shift();
-    }
-
-    while (trimmedLines.length > 0 && trimmedLines[trimmedLines.length - 1].length === 0) {
-        trimmedLines.pop();
-    }
-
-    return trimmedLines;
-}
-
-export function extractParameterDocumentation(functionDocString: string, paramName: string): string | undefined {
-    if (!functionDocString || !paramName) {
-        return undefined;
-    }
-
-    // Python doesn't have a single standard for param documentation. There are three
-    // popular styles.
-    //
-    // 1. Epytext:
-    //      @param param1: description
-    // 2. reST:
-    //      :param param1: description
-    // 3. Google (variant 1):
-    //      Args:
-    //          param1: description
-    // 4. Google (variant 2):
-    //      Args:
-    //          param1 (type): description
-
-    const docStringLines = cleanAndSplitDocString(functionDocString);
-    for (const line of docStringLines) {
-        const trimmedLine = line.trim();
-
-        // Check for Epytext
-        let paramOffset = trimmedLine.indexOf('@param ' + paramName);
-        if (paramOffset >= 0) {
-            return trimmedLine.substr(paramOffset + 7);
-        }
-
-        // Check for reST format
-        paramOffset = trimmedLine.indexOf(':param ' + paramName);
-        if (paramOffset >= 0) {
-            return trimmedLine.substr(paramOffset + 7);
-        }
-
-        // Check for Google (variant 1) format
-        paramOffset = trimmedLine.indexOf(paramName + ': ');
-        if (paramOffset >= 0) {
-            return trimmedLine.substr(paramOffset);
-        }
-
-        // Check for Google (variant 1) format
-        paramOffset = trimmedLine.indexOf(paramName + ' (');
-        if (paramOffset >= 0) {
-            return trimmedLine.substr(paramOffset);
-        }
-    }
-
-    return undefined;
-}

package/src/analyzer/functionTransform.ts

@@ -1,137 +0,0 @@
-/*
- * functionTransform.ts
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT license.
- * Author: Eric Traut
- *
- * Code that transforms the return result of a function.
- *
- */
-
-import { DiagnosticRule } from '../common/diagnosticRules';
-import { Localizer } from '../localization/localize';
-import { ExpressionNode, ParameterCategory } from '../parser/parseNodes';
-import { getFileInfo } from './analyzerNodeInfo';
-import { Symbol, SymbolFlags } from './symbol';
-import { FunctionArgument, FunctionResult, TypeEvaluator } from './typeEvaluatorTypes';
-import {
-    ClassType,
-    FunctionParameter,
-    FunctionType,
-    isClassInstance,
-    isFunction,
-    isInstantiableClass,
-    OverloadedFunctionType,
-    Type,
-} from './types';
-import { ClassMember, ClassMemberLookupFlags, lookUpObjectMember, synthesizeTypeVarForSelfCls } from './typeUtils';
-
-export function applyFunctionTransform(
-    evaluator: TypeEvaluator,
-    errorNode: ExpressionNode,
-    argList: FunctionArgument[],
-    functionType: FunctionType | OverloadedFunctionType,
-    result: FunctionResult
-): FunctionResult {
-    if (isFunction(functionType)) {
-        if (functionType.details.fullName === 'functools.total_ordering') {
-            return applyTotalOrderingTransform(evaluator, errorNode, argList, result);
-        }
-    }
-
-    // By default, return the result unmodified.
-    return result;
-}
-
-function applyTotalOrderingTransform(
-    evaluator: TypeEvaluator,
-    errorNode: ExpressionNode,
-    argList: FunctionArgument[],
-    result: FunctionResult
-) {
-    if (argList.length !== 1) {
-        return result;
-    }
-
-    // This function is meant to apply to a concrete instantiable class.
-    const classType = argList[0].type;
-    if (!classType || !isInstantiableClass(classType) || classType.includeSubclasses) {
-        return result;
-    }
-
-    const orderingMethods = ['__lt__', '__le__', '__gt__', '__ge__'];
-    const instanceType = ClassType.cloneAsInstance(classType);
-
-    // Verify that the class has at least one of the required functions.
-    let firstMemberFound: ClassMember | undefined;
-    const missingMethods = orderingMethods.filter((methodName) => {
-        const memberInfo = lookUpObjectMember(instanceType, methodName, ClassMemberLookupFlags.SkipInstanceVariables);
-        if (memberInfo && !firstMemberFound) {
-            firstMemberFound = memberInfo;
-        }
-        return !memberInfo;
-    });
-
-    if (!firstMemberFound) {
-        evaluator.addDiagnostic(
-            getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues,
-            DiagnosticRule.reportGeneralTypeIssues,
-            Localizer.Diagnostic.totalOrderingMissingMethod(),
-            errorNode
-        );
-        return result;
-    }
-
-    // Determine what type to use for the parameter corresponding to
-    // the second operand. This will be taken from the existing method.
-    let operandType: Type | undefined;
-
-    const firstMemberType = evaluator.getTypeOfMember(firstMemberFound);
-    if (
-        isFunction(firstMemberType) &&
-        firstMemberType.details.parameters.length >= 2 &&
-        firstMemberType.details.parameters[1].hasDeclaredType
-    ) {
-        operandType = firstMemberType.details.parameters[1].type;
-    }
-
-    // If there was no provided operand type, fall back to object.
-    if (!operandType) {
-        const objectType = evaluator.getBuiltInObject(errorNode, 'object');
-        if (!objectType || !isClassInstance(objectType)) {
-            return result;
-        }
-        operandType = objectType;
-    }
-
-    const boolType = evaluator.getBuiltInObject(errorNode, 'bool');
-    if (!boolType || !isClassInstance(boolType)) {
-        return result;
-    }
-
-    const selfParam: FunctionParameter = {
-        category: ParameterCategory.Simple,
-        name: 'self',
-        type: synthesizeTypeVarForSelfCls(classType, /* isClsParam */ false),
-        hasDeclaredType: true,
-    };
-
-    const objParam: FunctionParameter = {
-        category: ParameterCategory.Simple,
-        name: '__value',
-        type: operandType,
-        hasDeclaredType: true,
-    };
-
-    // Add the missing members to the class's symbol table.
-    missingMethods.forEach((methodName) => {
-        const methodToAdd = FunctionType.createSynthesizedInstance(methodName);
-        FunctionType.addParameter(methodToAdd, selfParam);
-        FunctionType.addParameter(methodToAdd, objParam);
-        methodToAdd.details.declaredReturnType = boolType;
-
-        classType.details.fields.set(methodName, Symbol.createWithType(SymbolFlags.ClassMember, methodToAdd));
-    });
-
-    return result;
-}