microsoft/pyright
1
1
Fork 0
mirror of https://github.com/microsoft/pyright.git synced 2024-10-06 12:57:14 +03:00
Code Issues Projects Releases Wiki Activity

Modified typing data structures to increase monomorphism for performance reasons. (#8415)

Browse Source
This commit is contained in:
Eric Traut 2024-07-13 14:43:45 -07:00 committed by GitHub
parent 17bd81a7de
commit 496822d3d0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
37 changed files with 2923 additions and 2749 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

515
packages/pyright-internal/src/analyzer/checker.ts
View File

File diff suppressed because it is too large Load Diff

44
packages/pyright-internal/src/analyzer/codeFlowEngine.ts
View File

@ -1411,15 +1411,15 @@ export function getCodeFlowEngine(
// can be narrowed to one of its constrained types based on isinstance type
// guard checks.
function narrowConstrainedTypeVar(flowNode: FlowNode, typeVar: TypeVarType): ClassType | undefined {
assert(!typeVar.details.isParamSpec);
assert(!typeVar.details.isVariadic);
assert(!typeVar.details.boundType);
assert(typeVar.details.constraints.length > 0);
assert(!typeVar.shared.isParamSpec);
assert(!typeVar.shared.isVariadic);
assert(!typeVar.shared.boundType);
assert(typeVar.shared.constraints.length > 0);
const visitedFlowNodeMap = new Set<number>();
const startingConstraints: ClassType[] = [];
for (const constraint of typeVar.details.constraints) {
for (const constraint of typeVar.shared.constraints) {
if (isClassInstance(constraint)) {
startingConstraints.push(constraint);
} else {
@ -1604,8 +1604,8 @@ export function getCodeFlowEngine(
if (
!subtype.props.condition.some(
(condition) =>
condition.typeVar.details.constraints.length > 0 &&
condition.typeVar.nameWithScope === typeVar.nameWithScope
condition.typeVar.shared.constraints.length > 0 &&
condition.typeVar.priv.nameWithScope === typeVar.priv.nameWithScope
)
) {
isCompatible = false;
@ -1749,15 +1749,15 @@ export function getCodeFlowEngine(
}
function isFunctionNoReturn(functionType: FunctionType, isCallAwaited: boolean) {
const returnType = functionType.details.declaredReturnType;
const returnType = functionType.shared.declaredReturnType;
if (returnType) {
if (
isClassInstance(returnType) &&
ClassType.isBuiltIn(returnType, 'Coroutine') &&
returnType.typeArguments &&
returnType.typeArguments.length >= 3
returnType.priv.typeArguments &&
returnType.priv.typeArguments.length >= 3
) {
if (isNever(returnType.typeArguments[2]) && isCallAwaited) {
if (isNever(returnType.priv.typeArguments[2]) && isCallAwaited) {
return true;
}
}
@ -1765,19 +1765,19 @@ export function getCodeFlowEngine(
return isNever(returnType);
} else if (!inferNoReturnForUnannotatedFunctions) {
return false;
} else if (functionType.details.declaration) {
} else if (functionType.shared.declaration) {
// If the function is a generator (i.e. it has yield statements)
// then it is not a "no return" call. Also, don't infer a "no
// return" type for abstract methods.
if (
!functionType.details.declaration.isGenerator &&
!functionType.shared.declaration.isGenerator &&
!FunctionType.isAbstractMethod(functionType) &&
!FunctionType.isStubDefinition(functionType) &&
!FunctionType.isPyTypedDefinition(functionType)
) {
// Check specifically for a common idiom where the only statement
// (other than a possible docstring) is a "raise NotImplementedError".
const functionStatements = functionType.details.declaration.node.suite.statements;
const functionStatements = functionType.shared.declaration.node.suite.statements;
let foundRaiseNotImplemented = false;
for (const statement of functionStatements) {
@ -1816,11 +1816,11 @@ export function getCodeFlowEngine(
}
function isAfterNodeReachable(evaluator: TypeEvaluator, functionType: FunctionType) {
if (!functionType.details.declaration) {
if (!functionType.shared.declaration) {
return true;
}
return evaluator.isAfterNodeReachable(functionType.details.declaration.node);
return evaluator.isAfterNodeReachable(functionType.shared.declaration.node);
}
// Performs a cursory analysis to determine whether the expression
@ -1853,8 +1853,8 @@ export function getCodeFlowEngine(
const exitMethodName = isAsync ? '__aexit__' : '__exit__';
const exitType = evaluator.getBoundMagicMethod(cmType, exitMethodName);
if (exitType && isFunction(exitType) && exitType.details.declaredReturnType) {
let returnType = exitType.details.declaredReturnType;
if (exitType && isFunction(exitType) && exitType.shared.declaredReturnType) {
let returnType = exitType.shared.declaredReturnType;
// If it's an __aexit__ method, its return type will typically be wrapped
// in a Coroutine, so we need to extract the return type from the third
@ -1863,16 +1863,16 @@ export function getCodeFlowEngine(
if (
isClassInstance(returnType) &&
ClassType.isBuiltIn(returnType, 'Coroutine') &&
returnType.typeArguments &&
returnType.typeArguments.length >= 3
returnType.priv.typeArguments &&
returnType.priv.typeArguments.length >= 3
) {
returnType = returnType.typeArguments[2];
returnType = returnType.priv.typeArguments[2];
}
}
cmSwallowsExceptions = false;
if (isClassInstance(returnType) && ClassType.isBuiltIn(returnType, 'bool')) {
if (returnType.literalValue === undefined || returnType.literalValue === true) {
if (returnType.priv.literalValue === undefined || returnType.priv.literalValue === true) {
cmSwallowsExceptions = true;
}
}

124
packages/pyright-internal/src/analyzer/constraintSolver.ts
View File

@ -104,7 +104,7 @@ export function assignTypeToTypeVar(
// If the TypeVar doesn't have a scope ID, then it's being used
// outside of a valid TypeVar scope. This will be reported as a
// separate error. Just ignore this case to avoid redundant errors.
if (!destType.scopeId) {
if (!destType.priv.scopeId) {
return true;
}
@ -119,7 +119,7 @@ export function assignTypeToTypeVar(
// Verify that we are solving for the scope associated with this
// type variable.
if (!typeVarContext.hasSolveForScope(destType.scopeId)) {
if (!typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
// Handle Any as a source.
if (isAnyOrUnknown(srcType) || (isClass(srcType) && ClassType.derivesFromAnyOrUnknown(srcType))) {
return true;
@ -128,9 +128,9 @@ export function assignTypeToTypeVar(
// Handle a type[Any] as a source.
if (isClassInstance(srcType) && ClassType.isBuiltIn(srcType, 'type')) {
if (
!srcType.typeArguments ||
srcType.typeArguments.length < 1 ||
isAnyOrUnknown(srcType.typeArguments[0])
!srcType.priv.typeArguments ||
srcType.priv.typeArguments.length < 1 ||
isAnyOrUnknown(srcType.priv.typeArguments[0])
) {
if (TypeBase.isInstantiable(destType)) {
return true;
@ -140,7 +140,7 @@ export function assignTypeToTypeVar(
// Is this the equivalent of an "Unknown" for a ParamSpec?
if (
destType.details.isParamSpec &&
destType.shared.isParamSpec &&
isFunction(srcType) &&
FunctionType.isParamSpecValue(srcType) &&
FunctionType.isGradualCallableForm(srcType)
@ -164,7 +164,7 @@ export function assignTypeToTypeVar(
// Emit an error unless this is a synthesized type variable used
// for pseudo-generic classes.
if (!destType.details.isSynthesized || destType.details.isSynthesizedSelf) {
if (!destType.shared.isSynthesized || destType.shared.isSynthesizedSelf) {
diag?.addMessage(
LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(srcType, destType))
);
@ -174,7 +174,7 @@ export function assignTypeToTypeVar(
// An in-scope placeholder TypeVar can always be assigned to itself,
// but we won't record this in the typeVarContext.
if (isTypeSame(destType, srcType) && destType.isInScopePlaceholder) {
if (isTypeSame(destType, srcType) && destType.priv.isInScopePlaceholder) {
return true;
}
@ -190,11 +190,11 @@ export function assignTypeToTypeVar(
);
}
if (destType.details.isParamSpec) {
if (destType.shared.isParamSpec) {
return assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContext, recursionCount);
}
if (destType.details.isVariadic && !destType.isVariadicInUnion) {
if (destType.shared.isVariadic && !destType.priv.isVariadicInUnion) {
if (!isUnpacked(srcType)) {
const tupleClassType = evaluator.getTupleClassType();
if (tupleClassType && isInstantiableClass(tupleClassType)) {
@ -217,10 +217,10 @@ export function assignTypeToTypeVar(
// we need to treat it as a union of the unpacked TypeVarTuple.
if (
isTypeVar(srcType) &&
srcType.details.isVariadic &&
srcType.isVariadicUnpacked &&
!srcType.isVariadicInUnion &&
!destType.details.isVariadic
srcType.shared.isVariadic &&
srcType.priv.isVariadicUnpacked &&
!srcType.priv.isVariadicInUnion &&
!destType.shared.isVariadic
) {
srcType = TypeVarType.cloneForUnpacked(srcType, /* isInUnion */ true);
}
@ -229,7 +229,7 @@ export function assignTypeToTypeVar(
// because type narrowing isn't used in this case. For example, if the
// source type is "Literal[1]" and the constraint list includes the type
// "float", the resulting type is float.
if (destType.details.constraints.length > 0) {
if (destType.shared.constraints.length > 0) {
return assignTypeToConstrainedTypeVar(
evaluator,
destType,
@ -246,8 +246,8 @@ export function assignTypeToTypeVar(
const curEntry = typeVarContext.getPrimarySignature().getTypeVar(destType);
let curWideTypeBound = curEntry?.wideBound;
if (!curWideTypeBound && !destType.details.isSynthesizedSelf) {
curWideTypeBound = destType.details.boundType;
if (!curWideTypeBound && !destType.shared.isSynthesizedSelf) {
curWideTypeBound = destType.shared.boundType;
}
let curNarrowTypeBound = curEntry?.narrowBound;
let newNarrowTypeBound = curNarrowTypeBound;
@ -259,7 +259,7 @@ export function assignTypeToTypeVar(
// If the source is a class that is missing type arguments, fill
// in missing type arguments with Unknown.
if ((flags & AssignTypeFlags.AllowUnspecifiedTypeArguments) === 0) {
if (isClass(adjSrcType) && adjSrcType.includeSubclasses) {
if (isClass(adjSrcType) && adjSrcType.priv.includeSubclasses) {
adjSrcType = specializeWithDefaultTypeArgs(adjSrcType);
}
}
@ -493,8 +493,8 @@ export function assignTypeToTypeVar(
// is still a valid solution to the TypeVar.
if (
isUnion(curSolvedNarrowTypeBound) &&
curSolvedNarrowTypeBound.subtypes.length > maxSubtypesForInferredType &&
(destType as TypeVarType).details.boundType !== undefined &&
curSolvedNarrowTypeBound.priv.subtypes.length > maxSubtypesForInferredType &&
(destType as TypeVarType).shared.boundType !== undefined &&
isClassInstance(objectType)
) {
newNarrowTypeBound = combineTypes([curSolvedNarrowTypeBound, objectType], {
@ -579,7 +579,7 @@ export function assignTypeToTypeVar(
}
// If there's a bound type, make sure the source is assignable to it.
if (destType.details.boundType) {
if (destType.shared.boundType) {
const updatedType = (newNarrowTypeBound || newWideTypeBound)!;
// If the dest is a Type[T] but the source is not a valid Type,
@ -592,13 +592,13 @@ export function assignTypeToTypeVar(
// In general, bound types cannot be generic, but the "Self" type is an
// exception. In this case, we need to use the original TypeVarContext
// to solve for the generic type variable(s) in the bound type.
const effectiveTypeVarContext = destType.details.isSynthesizedSelf
const effectiveTypeVarContext = destType.shared.isSynthesizedSelf
? typeVarContext
: new TypeVarContext(destType.scopeId);
: new TypeVarContext(destType.priv.scopeId);
if (
!evaluator.assignType(
destType.details.boundType,
destType.shared.boundType,
evaluator.makeTopLevelTypeVarsConcrete(updatedType),
diag?.createAddendum(),
effectiveTypeVarContext,
@ -609,11 +609,11 @@ export function assignTypeToTypeVar(
) {
// Avoid adding a message that will confuse users if the TypeVar was
// synthesized for internal purposes.
if (!destType.details.isSynthesized) {
if (!destType.shared.isSynthesized) {
diag?.addMessage(
LocAddendum.typeBound().format({
sourceType: evaluator.printType(updatedType),
destType: evaluator.printType(destType.details.boundType),
destType: evaluator.printType(destType.shared.boundType),
name: TypeVarType.getReadableName(destType),
})
);
@ -712,7 +712,7 @@ function assignTypeToConstrainedTypeVar(
destType,
concreteSrcType,
/* diag */ undefined,
new TypeVarContext(destType.scopeId),
new TypeVarContext(destType.priv.scopeId),
/* srcTypeVarContext */ undefined,
AssignTypeFlags.Default,
recursionCount
@ -743,7 +743,7 @@ function assignTypeToConstrainedTypeVar(
}
let constraintIndexUsed: number | undefined;
destType.details.constraints.forEach((constraint, i) => {
destType.shared.constraints.forEach((constraint, i) => {
const adjustedConstraint = TypeBase.isInstantiable(destType)
? convertToInstantiable(constraint)
: constraint;
@ -810,7 +810,7 @@ function assignTypeToConstrainedTypeVar(
// If the type is a union, see if the entire union is assignable to one
// of the constraints.
if (!constrainedType && isUnion(concreteSrcType)) {
constrainedType = destType.details.constraints.find((constraint) => {
constrainedType = destType.shared.constraints.find((constraint) => {
const adjustedConstraint = TypeBase.isInstantiable(destType)
? convertToInstantiable(constraint)
: constraint;
@ -834,7 +834,7 @@ function assignTypeToConstrainedTypeVar(
diag?.addMessage(
LocAddendum.typeConstrainedTypeVar().format({
type: evaluator.printType(srcType),
name: destType.details.name,
name: destType.shared.name,
})
);
return false;
@ -911,20 +911,20 @@ function assignTypeToParamSpec(
const adjSrcType = isFunction(srcType) ? convertParamSpecValueToType(srcType) : srcType;
typeVarContext.doForEachSignature((signatureContext) => {
if (isTypeVar(adjSrcType) && adjSrcType.details.isParamSpec) {
if (isTypeVar(adjSrcType) && adjSrcType.shared.isParamSpec) {
const existingType = signatureContext.getParamSpecType(destType);
if (existingType) {
const existingTypeParamSpec = FunctionType.getParamSpecFromArgsKwargs(existingType);
const existingTypeWithoutArgsKwargs = FunctionType.cloneRemoveParamSpecArgsKwargs(existingType);
if (existingTypeWithoutArgsKwargs.details.parameters.length === 0 && existingTypeParamSpec) {
if (existingTypeWithoutArgsKwargs.shared.parameters.length === 0 && existingTypeParamSpec) {
// If there's an existing entry that matches, that's fine.
if (isTypeSame(existingTypeParamSpec, adjSrcType, {}, recursionCount)) {
return;
}
}
} else {
if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.scopeId)) {
if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
signatureContext.setTypeVarType(destType, convertTypeToParamSpecValue(adjSrcType));
}
return;
@ -983,7 +983,7 @@ function assignTypeToParamSpec(
}
if (updateContextWithNewFunction) {
if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.scopeId)) {
if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
signatureContext.setTypeVarType(destType, newFunction);
}
return;
@ -995,7 +995,7 @@ function assignTypeToParamSpec(
diag?.addMessage(
LocAddendum.typeParamSpec().format({
type: evaluator.printType(adjSrcType),
name: destType.details.name,
name: destType.shared.name,
})
);
@ -1027,14 +1027,14 @@ export function addConstraintsForExpectedType(
usageOffset: number | undefined = undefined
): boolean {
if (isAny(expectedType)) {
type.details.typeParameters.forEach((typeParam) => {
type.shared.typeParameters.forEach((typeParam) => {
updateTypeVarType(evaluator, typeVarContext, typeParam, expectedType, expectedType);
});
return true;
}
if (isTypeVar(expectedType) && expectedType.details.isSynthesizedSelf && expectedType.details.boundType) {
expectedType = expectedType.details.boundType;
if (isTypeVar(expectedType) && expectedType.shared.isSynthesizedSelf && expectedType.shared.boundType) {
expectedType = expectedType.shared.boundType;
}
if (!isClass(expectedType)) {
@ -1042,7 +1042,7 @@ export function addConstraintsForExpectedType(
}
// If the expected type is generic (but not specialized), we can't proceed.
const expectedTypeArgs = expectedType.typeArguments;
const expectedTypeArgs = expectedType.priv.typeArguments;
if (!expectedTypeArgs) {
return evaluator.assignType(
type,
@ -1108,14 +1108,14 @@ export function addConstraintsForExpectedType(
const expectedTypeScopeId = getTypeVarScopeId(expectedType);
const synthExpectedTypeArgs = ClassType.getTypeParameters(expectedType).map((typeParam, index) => {
const typeVar = TypeVarType.createInstance(`__dest${index}`);
typeVar.details.isSynthesized = true;
if (typeParam.details.isParamSpec) {
typeVar.details.isParamSpec = true;
typeVar.shared.isSynthesized = true;
if (typeParam.shared.isParamSpec) {
typeVar.shared.isParamSpec = true;
}
// Use invariance here so we set the narrow and wide values on the TypeVar.
typeVar.details.declaredVariance = Variance.Invariant;
typeVar.scopeId = expectedTypeScopeId;
typeVar.shared.declaredVariance = Variance.Invariant;
typeVar.priv.scopeId = expectedTypeScopeId;
return typeVar;
});
const genericExpectedType = ClassType.cloneForSpecialization(
@ -1127,11 +1127,11 @@ export function addConstraintsForExpectedType(
// For each type param in the target type, create a placeholder type variable.
const typeArgs = ClassType.getTypeParameters(type).map((typeParam, index) => {
const typeVar = TypeVarType.createInstance(`__source${index}`);
typeVar.details.isSynthesized = true;
typeVar.details.synthesizedIndex = index;
typeVar.details.isExemptFromBoundCheck = true;
if (typeParam.details.isParamSpec) {
typeVar.details.isParamSpec = true;
typeVar.shared.isSynthesized = true;
typeVar.shared.synthesizedIndex = index;
typeVar.shared.isExemptFromBoundCheck = true;
if (typeParam.shared.isParamSpec) {
typeVar.shared.isParamSpec = true;
}
return TypeVarType.cloneAsInScopePlaceholder(typeVar);
});
@ -1157,18 +1157,18 @@ export function addConstraintsForExpectedType(
// If the resulting type is a union, try to find a matching type var and move
// the remaining subtypes to the "otherSubtypes" array.
if (synthTypeVar) {
if (typeVar.details.isParamSpec && isFunction(synthTypeVar)) {
if (typeVar.shared.isParamSpec && isFunction(synthTypeVar)) {
synthTypeVar = convertParamSpecValueToType(synthTypeVar);
}
if (isUnion(synthTypeVar)) {
let foundSynthTypeVar: TypeVarType | undefined;
sortTypes(synthTypeVar.subtypes).forEach((subtype) => {
sortTypes(synthTypeVar.priv.subtypes).forEach((subtype) => {
if (
isTypeVar(subtype) &&
subtype.details.isSynthesized &&
subtype.details.synthesizedIndex !== undefined &&
subtype.shared.isSynthesized &&
subtype.shared.synthesizedIndex !== undefined &&
!foundSynthTypeVar
) {
foundSynthTypeVar = subtype;
@ -1188,11 +1188,11 @@ export function addConstraintsForExpectedType(
if (
synthTypeVar &&
isTypeVar(synthTypeVar) &&
synthTypeVar.details.isSynthesized &&
synthTypeVar.details.synthesizedIndex !== undefined
synthTypeVar.shared.isSynthesized &&
synthTypeVar.shared.synthesizedIndex !== undefined
) {
const targetTypeVar =
ClassType.getTypeParameters(specializedType)[synthTypeVar.details.synthesizedIndex];
ClassType.getTypeParameters(specializedType)[synthTypeVar.shared.synthesizedIndex];
if (index < expectedTypeArgs.length) {
let typeArgValue: Type | undefined = transformPossibleRecursiveTypeAlias(expectedTypeArgs[index]);
@ -1251,9 +1251,9 @@ function widenTypeForVariadicTypeVar(evaluator: TypeEvaluator, type1: Type, type
// If the two unpacked tuples are not the same length, we can't combine them.
if (
!type1.tupleTypeArguments ||
!type2.tupleTypeArguments ||
type1.tupleTypeArguments.length !== type2.tupleTypeArguments.length
!type1.priv.tupleTypeArguments ||
!type2.priv.tupleTypeArguments ||
type1.priv.tupleTypeArguments.length !== type2.priv.tupleTypeArguments.length
) {
return undefined;
}
@ -1271,12 +1271,12 @@ function widenTypeForVariadicTypeVar(evaluator: TypeEvaluator, type1: Type, type
// If the provided type is an unpacked tuple, this function strips the
// literals from types of the corresponding elements.
function stripLiteralValueForUnpackedTuple(evaluator: TypeEvaluator, type: Type): Type {
if (!isUnpackedClass(type) || !type.tupleTypeArguments) {
if (!isUnpackedClass(type) || !type.priv.tupleTypeArguments) {
return type;
}
let strippedLiteral = false;
const tupleTypeArgs: TupleTypeArgument[] = type.tupleTypeArguments.map((arg) => {
const tupleTypeArgs: TupleTypeArgument[] = type.priv.tupleTypeArguments.map((arg) => {
const strippedType = evaluator.stripLiteralValue(arg.type);
if (strippedType !== arg.type) {
@ -1317,7 +1317,7 @@ function logTypeVarSignatureContext(evaluator: TypeEvaluator, context: TypeVarSi
let loggedConstraint = false;
context.getTypeVars().forEach((entry) => {
const typeVarName = `${indent}${entry.typeVar.details.name}`;
const typeVarName = `${indent}${entry.typeVar.shared.name}`;
const narrowBound = entry.narrowBoundNoLiterals ?? entry.narrowBound;
const wideBound = entry.wideBound;

44
packages/pyright-internal/src/analyzer/constructorTransform.ts
View File

@ -46,7 +46,7 @@ import {
import { TypeVarContext } from './typeVarContext';
export function hasConstructorTransform(classType: ClassType): boolean {
if (classType.details.fullName === 'functools.partial') {
if (classType.shared.fullName === 'functools.partial') {
return true;
}
@ -61,7 +61,7 @@ export function applyConstructorTransform(
result: FunctionResult,
signatureTracker: UniqueSignatureTracker | undefined
): FunctionResult {
if (classType.details.fullName === 'functools.partial') {
if (classType.shared.fullName === 'functools.partial') {
return applyPartialTransform(evaluator, errorNode, argList, result, signatureTracker);
}
@ -78,7 +78,7 @@ function applyPartialTransform(
signatureTracker: UniqueSignatureTracker | undefined
): FunctionResult {
// We assume that the normal return result is a functools.partial class instance.
if (!isClassInstance(result.returnType) || result.returnType.details.fullName !== 'functools.partial') {
if (!isClassInstance(result.returnType) || result.returnType.shared.fullName !== 'functools.partial') {
return result;
}
@ -88,7 +88,7 @@ function applyPartialTransform(
}
const callMemberType = evaluator.getTypeOfMember(callMemberResult);
if (!isFunction(callMemberType) || callMemberType.details.parameters.length < 1) {
if (!isFunction(callMemberType) || callMemberType.shared.parameters.length < 1) {
return result;
}
@ -180,7 +180,7 @@ function applyPartialTransform(
evaluator.addDiagnostic(
DiagnosticRule.reportCallIssue,
LocMessage.noOverload().format({
name: origFunctionType.overloads[0].details.name,
name: origFunctionType.priv.overloads[0].shared.name,
}),
errorNode
);
@ -199,7 +199,7 @@ function applyPartialTransform(
synthesizedCallType = OverloadedFunctionType.create(
// Set the "overloaded" flag for each of the __call__ overloads.
applicableOverloads.map((overload) =>
FunctionType.cloneWithNewFlags(overload, overload.details.flags | FunctionTypeFlags.Overloaded)
FunctionType.cloneWithNewFlags(overload, overload.shared.flags | FunctionTypeFlags.Overloaded)
)
);
}
@ -269,7 +269,7 @@ function applyPartialTransformToFunction(
LocMessage.argAssignmentParamFunction().format({
argType: evaluator.printType(argTypeResult.type),
paramType: evaluator.printType(paramType),
functionName: origFunctionType.details.name,
functionName: origFunctionType.shared.name,
paramName: paramListDetails.params[paramListDetails.argsIndex].param.name ?? '',
}),
arg.valueExpression ?? errorNode
@ -315,7 +315,7 @@ function applyPartialTransformToFunction(
LocMessage.argAssignmentParamFunction().format({
argType: evaluator.printType(argTypeResult.type),
paramType: evaluator.printType(paramType),
functionName: origFunctionType.details.name,
functionName: origFunctionType.shared.name,
paramName,
}),
arg.valueExpression ?? errorNode
@ -364,7 +364,7 @@ function applyPartialTransformToFunction(
LocMessage.argAssignmentParamFunction().format({
argType: evaluator.printType(argTypeResult.type),
paramType: evaluator.printType(paramType),
functionName: origFunctionType.details.name,
functionName: origFunctionType.shared.name,
paramName: paramListDetails.params[paramListDetails.kwargsIndex].param.name ?? '',
}),
arg.valueExpression ?? errorNode
@ -404,7 +404,7 @@ function applyPartialTransformToFunction(
LocMessage.argAssignmentParamFunction().format({
argType: evaluator.printType(argTypeResult.type),
paramType: evaluator.printType(paramType),
functionName: origFunctionType.details.name,
functionName: origFunctionType.shared.name,
paramName,
}),
arg.valueExpression ?? errorNode
@ -426,7 +426,7 @@ function applyPartialTransformToFunction(
// Create a new parameter list that omits parameters that have been
// populated already.
const updatedParamList: FunctionParam[] = specializedFunctionType.details.parameters.map((param, index) => {
const updatedParamList: FunctionParam[] = specializedFunctionType.shared.parameters.map((param, index) => {
const specializedParam: FunctionParam = { ...param };
specializedParam.type = FunctionType.getEffectiveParameterType(specializedFunctionType, index);
@ -460,25 +460,25 @@ function applyPartialTransformToFunction(
// Create a new __call__ method that uses the remaining parameters.
const newCallMemberType = FunctionType.createInstance(
partialCallMemberType.details.name,
partialCallMemberType.details.fullName,
partialCallMemberType.details.moduleName,
partialCallMemberType.details.flags,
specializedFunctionType.details.docString
partialCallMemberType.shared.name,
partialCallMemberType.shared.fullName,
partialCallMemberType.shared.moduleName,
partialCallMemberType.shared.flags,
specializedFunctionType.shared.docString
);
if (partialCallMemberType.details.parameters.length > 0) {
FunctionType.addParameter(newCallMemberType, partialCallMemberType.details.parameters[0]);
if (partialCallMemberType.shared.parameters.length > 0) {
FunctionType.addParameter(newCallMemberType, partialCallMemberType.shared.parameters[0]);
}
newParamList.forEach((param) => {
FunctionType.addParameter(newCallMemberType, param);
});
newCallMemberType.details.declaredReturnType = specializedFunctionType.details.declaredReturnType
newCallMemberType.shared.declaredReturnType = specializedFunctionType.shared.declaredReturnType
? FunctionType.getEffectiveReturnType(specializedFunctionType)
: specializedFunctionType.inferredReturnType;
newCallMemberType.details.declaration = partialCallMemberType.details.declaration;
newCallMemberType.details.typeVarScopeId = specializedFunctionType.details.typeVarScopeId;
: specializedFunctionType.priv.inferredReturnType;
newCallMemberType.shared.declaration = partialCallMemberType.shared.declaration;
newCallMemberType.shared.typeVarScopeId = specializedFunctionType.shared.typeVarScopeId;
return { returnType: newCallMemberType, isTypeIncomplete: false, argumentErrors };
}

82
packages/pyright-internal/src/analyzer/constructors.ts
View File

@ -324,8 +324,8 @@ function validateNewAndInitMethods(
// type and rely on the __init__ method to supply the type arguments instead.
let initMethodBindToType = newMethodReturnType;
if (
initMethodBindToType.typeArguments &&
initMethodBindToType.typeArguments.some((typeArg) => isUnknown(typeArg))
initMethodBindToType.priv.typeArguments &&
initMethodBindToType.priv.typeArguments.some((typeArg) => isUnknown(typeArg))
) {
initMethodBindToType = ClassType.cloneAsInstance(type);
}
@ -479,10 +479,10 @@ function validateNewMethod(
if (newReturnType) {
// Special-case the 'tuple' type specialization to use the homogenous
// arbitrary-length form.
if (isClassInstance(newReturnType) && isTupleClass(newReturnType) && !newReturnType.tupleTypeArguments) {
if (newReturnType.typeArguments && newReturnType.typeArguments.length === 1) {
if (isClassInstance(newReturnType) && isTupleClass(newReturnType) && !newReturnType.priv.tupleTypeArguments) {
if (newReturnType.priv.typeArguments && newReturnType.priv.typeArguments.length === 1) {
newReturnType = specializeTupleClass(newReturnType, [
{ type: newReturnType.typeArguments[0], isUnbounded: true },
{ type: newReturnType.priv.typeArguments[0], isUnbounded: true },
]);
}
@ -539,7 +539,7 @@ function validateInitMethod(
if (
isClassInstance(expectedSubType) &&
ClassType.isSameGenericClass(type, expectedSubType) &&
type.typeArguments
type.priv.typeArguments
) {
return undefined;
}
@ -617,7 +617,7 @@ function validateInitMethod(
}
if (!returnType) {
const typeVarContext = type.typeArguments
const typeVarContext = type.priv.typeArguments
? buildTypeVarContextFromSpecializedClass(type)
: new TypeVarContext(getTypeVarScopeId(type));
@ -675,13 +675,13 @@ function validateFallbackConstructorCall(
if (argList.length > 0 && argList.some((arg) => arg.argumentCategory === ArgumentCategory.Simple)) {
evaluator.addDiagnostic(
DiagnosticRule.reportCallIssue,
LocMessage.constructorNoArgs().format({ type: type.aliasName || type.details.name }),
LocMessage.constructorNoArgs().format({ type: type.priv.aliasName || type.shared.name }),
errorNode
);
reportedErrors = true;
}
if (!inferenceContext && type.typeArguments) {
if (!inferenceContext && type.priv.typeArguments) {
// If there was no expected type but the type was already specialized,
// assume that we're constructing an instance of the specialized type.
return {
@ -760,7 +760,7 @@ function validateMetaclassCall(
// If the return type is unannotated, don't use the inferred return type.
const callType = metaclassCallMethodInfo.type;
if (isFunction(callType) && !callType.details.declaredReturnType) {
if (isFunction(callType) && !callType.shared.declaredReturnType) {
return undefined;
}
@ -806,7 +806,7 @@ function applyExpectedTypeForConstructor(
// If this isn't a generic type or it's a type that has already been
// explicitly specialized, the expected type isn't applicable.
if (type.details.typeParameters.length === 0 || type.typeArguments) {
if (type.shared.typeParameters.length === 0 || type.priv.typeArguments) {
return applySolvedTypeVars(ClassType.cloneAsInstance(type), typeVarContext, { applyInScopePlaceholders: true });
}
@ -822,7 +822,7 @@ function applyExpectedTypeForConstructor(
// If the expected type didn't provide TypeVar values, remaining
// unsolved TypeVars should be considered Unknown unless they were
// provided explicitly in the constructor call.
if (type.typeArguments) {
if (type.priv.typeArguments) {
unsolvedTypeVarsAreUnknown = false;
}
}
@ -843,9 +843,9 @@ function applyExpectedTypeForTupleConstructor(type: ClassType, inferenceContext:
inferenceContext &&
isClassInstance(inferenceContext.expectedType) &&
isTupleClass(inferenceContext.expectedType) &&
inferenceContext.expectedType.tupleTypeArguments
inferenceContext.expectedType.priv.tupleTypeArguments
) {
specializedType = specializeTupleClass(type, inferenceContext.expectedType.tupleTypeArguments);
specializedType = specializeTupleClass(type, inferenceContext.expectedType.priv.tupleTypeArguments);
}
return specializedType;
@ -901,7 +901,7 @@ function createFunctionFromMetaclassCall(
classType: ClassType,
recursionCount: number
): FunctionType | OverloadedFunctionType | undefined {
const metaclass = classType.details.effectiveMetaclass;
const metaclass = classType.shared.effectiveMetaclass;
if (!metaclass || !isClass(metaclass)) {
return undefined;
}
@ -943,7 +943,7 @@ function createFunctionFromMetaclassCall(
// any of them returns something other than the instance of the class being
// constructed.
doForEachSignature(boundCallType, (signature) => {
if (signature.details.declaredReturnType) {
if (signature.shared.declaredReturnType) {
const returnType = FunctionType.getEffectiveReturnType(signature);
if (returnType && shouldSkipNewAndInitEvaluation(evaluator, classType, returnType)) {
useMetaclassCall = true;
@ -978,14 +978,14 @@ function createFunctionFromNewMethod(
// If there are no parameters that include class-scoped type parameters,
// self-specialize the class because the type arguments for the class
// can't be solved if there are no parameters to supply them.
const hasParametersWithTypeVars = newSubtype.details.parameters.some((param, index) => {
const hasParametersWithTypeVars = newSubtype.shared.parameters.some((param, index) => {
if (index === 0 || !param.name) {
return false;
}
const paramType = FunctionType.getEffectiveParameterType(newSubtype, index);
const typeVars = getTypeVarArgumentsRecursive(paramType);
return typeVars.some((typeVar) => typeVar.scopeId === getTypeVarScopeId(classType));
return typeVars.some((typeVar) => typeVar.priv.scopeId === getTypeVarScopeId(classType));
});
const boundNew = evaluator.bindFunctionToClassOrObject(
@ -1003,14 +1003,14 @@ function createFunctionFromNewMethod(
}
const convertedNew = FunctionType.clone(boundNew);
convertedNew.details.typeVarScopeId = newSubtype.details.typeVarScopeId;
convertedNew.shared.typeVarScopeId = newSubtype.shared.typeVarScopeId;
if (!convertedNew.details.docString && classType.details.docString) {
convertedNew.details.docString = classType.details.docString;
if (!convertedNew.shared.docString && classType.shared.docString) {
convertedNew.shared.docString = classType.shared.docString;
}
convertedNew.details.flags &= ~(FunctionTypeFlags.StaticMethod | FunctionTypeFlags.ConstructorMethod);
convertedNew.constructorTypeVarScopeId = getTypeVarScopeId(classType);
convertedNew.shared.flags &= ~(FunctionTypeFlags.StaticMethod | FunctionTypeFlags.ConstructorMethod);
convertedNew.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
return convertedNew;
};
@ -1024,7 +1024,7 @@ function createFunctionFromNewMethod(
}
const newOverloads: FunctionType[] = [];
newType.overloads.forEach((overload) => {
newType.priv.overloads.forEach((overload) => {
const converted = convertNewToConstructor(overload);
if (converted) {
newOverloads.push(converted);
@ -1045,16 +1045,16 @@ function createFunctionFromNewMethod(
function createFunctionFromObjectNewMethod(classType: ClassType) {
// Return a fallback constructor based on the object.__new__ method.
const constructorFunction = FunctionType.createSynthesizedInstance('__new__', FunctionTypeFlags.None);
constructorFunction.details.declaredReturnType = ClassType.cloneAsInstance(classType);
constructorFunction.shared.declaredReturnType = ClassType.cloneAsInstance(classType);
// If this is type[T] or a protocol, we don't know what parameters are accepted
// by the constructor, so add the default parameters.
if (classType.includeSubclasses || ClassType.isProtocolClass(classType)) {
if (classType.priv.includeSubclasses || ClassType.isProtocolClass(classType)) {
FunctionType.addDefaultParameters(constructorFunction);
}
if (!constructorFunction.details.docString && classType.details.docString) {
constructorFunction.details.docString = classType.details.docString;
if (!constructorFunction.shared.docString && classType.shared.docString) {
constructorFunction.shared.docString = classType.shared.docString;
}
return constructorFunction;
@ -1104,14 +1104,14 @@ function createFunctionFromInitMethod(
// If this is a generic type, self-specialize the class (i.e. fill in
// its own type parameters as type arguments).
if (objectType.details.typeParameters.length > 0 && !objectType.typeArguments) {
if (objectType.shared.typeParameters.length > 0 && !objectType.priv.typeArguments) {
const typeVarContext = new TypeVarContext(getTypeVarScopeIds(objectType));
// If a TypeVar is not used in any of the parameter types, it should take
// on its default value (typically Unknown) in the resulting specialized type.
const typeVarsInParams: TypeVarType[] = [];
convertedInit.details.parameters.forEach((param, index) => {
convertedInit.shared.parameters.forEach((param, index) => {
const paramType = FunctionType.getEffectiveParameterType(convertedInit, index);
addTypeVarsToListIfUnique(typeVarsInParams, getTypeVarArgumentsRecursive(paramType));
});
@ -1131,18 +1131,18 @@ function createFunctionFromInitMethod(
}
}
convertedInit.details.declaredReturnType = boundInit.strippedFirstParamType ?? returnType;
convertedInit.shared.declaredReturnType = boundInit.priv.strippedFirstParamType ?? returnType;
if (convertedInit.specializedTypes) {
convertedInit.specializedTypes.returnType = returnType;
if (convertedInit.priv.specializedTypes) {
convertedInit.priv.specializedTypes.returnType = returnType;
}
if (!convertedInit.details.docString && classType.details.docString) {
convertedInit.details.docString = classType.details.docString;
if (!convertedInit.shared.docString && classType.shared.docString) {
convertedInit.shared.docString = classType.shared.docString;
}
convertedInit.details.flags &= ~FunctionTypeFlags.StaticMethod;
convertedInit.constructorTypeVarScopeId = getTypeVarScopeId(classType);
convertedInit.shared.flags &= ~FunctionTypeFlags.StaticMethod;
convertedInit.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
return convertedInit;
}
@ -1156,7 +1156,7 @@ function createFunctionFromInitMethod(
}
const initOverloads: FunctionType[] = [];
initType.overloads.forEach((overload) => {
initType.priv.overloads.forEach((overload) => {
const converted = convertInitToConstructor(overload);
if (converted) {
initOverloads.push(converted);
@ -1234,7 +1234,7 @@ function isDefaultNewMethod(newMethod?: Type): boolean {
return false;
}
const params = newMethod.details.parameters;
const params = newMethod.shared.parameters;
if (params.length !== 2) {
return false;
}
@ -1243,8 +1243,8 @@ function isDefaultNewMethod(newMethod?: Type): boolean {
return false;
}
const returnType = newMethod.details.declaredReturnType ?? newMethod.inferredReturnType;
if (!returnType || !isTypeVar(returnType) || !returnType.details.isSynthesizedSelf) {
const returnType = newMethod.shared.declaredReturnType ?? newMethod.priv.inferredReturnType;
if (!returnType || !isTypeVar(returnType) || !returnType.shared.isSynthesizedSelf) {
return false;
}

91
packages/pyright-internal/src/analyzer/dataClasses.ts
View File

@ -90,9 +90,9 @@ export function synthesizeDataClassMethods(
const classTypeVar = synthesizeTypeVarForSelfCls(classType, /* isClsParam */ true);
const newType = FunctionType.createSynthesizedInstance('__new__', FunctionTypeFlags.ConstructorMethod);
newType.constructorTypeVarScopeId = getTypeVarScopeId(classType);
newType.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
const initType = FunctionType.createSynthesizedInstance('__init__');
initType.constructorTypeVarScopeId = getTypeVarScopeId(classType);
initType.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
// Generate both a __new__ and an __init__ method. The parameters of the
// __new__ method are based on field definitions for NamedTuple classes,
@ -105,7 +105,7 @@ export function synthesizeDataClassMethods(
if (!isNamedTuple) {
FunctionType.addDefaultParameters(newType);
}
newType.details.declaredReturnType = convertToInstance(classTypeVar);
newType.shared.declaredReturnType = convertToInstance(classTypeVar);
const selfParam = FunctionParam.create(
ParameterCategory.Simple,
@ -117,7 +117,7 @@ export function synthesizeDataClassMethods(
if (isNamedTuple) {
FunctionType.addDefaultParameters(initType);
}
initType.details.declaredReturnType = evaluator.getNoneType();
initType.shared.declaredReturnType = evaluator.getNoneType();
// Maintain a list of all dataclass entries (including
// those from inherited classes) plus a list of only those
@ -230,7 +230,7 @@ export function synthesizeDataClassMethods(
!isNamedTuple &&
isDataclassFieldConstructor(
callType,
classType.details.dataClassBehaviors?.fieldDescriptorNames || []
classType.shared.dataClassBehaviors?.fieldDescriptorNames || []
)
) {
const initArg = statement.rightExpression.arguments.find((arg) => arg.name?.value === 'init');
@ -290,7 +290,7 @@ export function synthesizeDataClassMethods(
ClassType.isBuiltIn(valueType, 'str') &&
isLiteralType(valueType)
) {
aliasName = valueType.literalValue as string;
aliasName = valueType.priv.literalValue as string;
}
}
@ -455,7 +455,7 @@ export function synthesizeDataClassMethods(
if (
isDataclassFieldConstructor(
callType,
classType.details.dataClassBehaviors?.fieldDescriptorNames || []
classType.shared.dataClassBehaviors?.fieldDescriptorNames || []
)
) {
evaluator.addDiagnostic(
@ -469,7 +469,7 @@ export function synthesizeDataClassMethods(
});
if (!isNamedTuple) {
classType.details.dataClassEntries = localDataClassEntries;
classType.shared.dataClassEntries = localDataClassEntries;
}
// Now that the dataClassEntries field has been set with a complete list
@ -586,7 +586,7 @@ export function synthesizeDataClassMethods(
operatorMethod,
FunctionParam.create(ParameterCategory.Simple, paramType, FunctionParamFlags.TypeDeclared, 'other')
);
operatorMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'bool');
operatorMethod.shared.declaredReturnType = evaluator.getBuiltInObject(node, 'bool');
// If a method of this name already exists, don't override it.
if (!symbolTable.get(operator)) {
symbolTable.set(operator, Symbol.createWithType(SymbolFlags.ClassMember, operatorMethod));
@ -622,7 +622,7 @@ export function synthesizeDataClassMethods(
if (synthesizeHashFunction) {
const hashMethod = FunctionType.createSynthesizedInstance('__hash__');
FunctionType.addParameter(hashMethod, selfParam);
hashMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'int');
hashMethod.shared.declaredReturnType = evaluator.getBuiltInObject(node, 'int');
symbolTable.set(
'__hash__',
Symbol.createWithType(SymbolFlags.ClassMember | SymbolFlags.IgnoredForOverrideChecks, hashMethod)
@ -655,8 +655,8 @@ export function synthesizeDataClassMethods(
);
}
if (ClassType.isDataClassGenerateSlots(classType) && classType.details.localSlotsNames === undefined) {
classType.details.localSlotsNames = localDataClassEntries.map((entry) => entry.name);
if (ClassType.isDataClassGenerateSlots(classType) && classType.shared.localSlotsNames === undefined) {
classType.shared.localSlotsNames = localDataClassEntries.map((entry) => entry.name);
}
// Should we synthesize a __slots__ symbol?
@ -730,24 +730,24 @@ function getDefaultArgValueForFieldSpecifier(
}
if (callTarget) {
const initParam = callTarget.details.parameters.find((p) => p.name === paramName);
const initParam = callTarget.shared.parameters.find((p) => p.name === paramName);
if (initParam) {
// Is the parameter type a literal bool?
if (
FunctionParam.isTypeDeclared(initParam) &&
isClass(initParam.type) &&
typeof initParam.type.literalValue === 'boolean'
typeof initParam.type.priv.literalValue === 'boolean'
) {
return initParam.type.literalValue;
return initParam.type.priv.literalValue;
}
// Is the default argument value a literal bool?
if (
initParam.defaultType &&
isClass(initParam.defaultType) &&
typeof initParam.defaultType.literalValue === 'boolean'
typeof initParam.defaultType.priv.literalValue === 'boolean'
) {
return initParam.defaultType.literalValue;
return initParam.defaultType.priv.literalValue;
}
}
}
@ -775,10 +775,10 @@ function getConverterInputType(
// Create synthesized function of the form Callable[[T], fieldType] which
// will be used to check compatibility of the provided converter.
const typeVar = TypeVarType.createInstance('__converterInput');
typeVar.scopeId = getScopeIdForNode(converterNode);
typeVar.priv.scopeId = getScopeIdForNode(converterNode);
const targetFunction = FunctionType.createSynthesizedInstance('');
targetFunction.details.typeVarScopeId = typeVar.scopeId;
targetFunction.details.declaredReturnType = fieldType;
targetFunction.shared.typeVarScopeId = typeVar.priv.scopeId;
targetFunction.shared.declaredReturnType = fieldType;
FunctionType.addParameter(
targetFunction,
FunctionParam.create(
@ -808,7 +808,7 @@ function getConverterInputType(
signature = applySolvedTypeVars(signature, returnTypeVarContext) as FunctionType;
}
const inputTypeVarContext = new TypeVarContext(typeVar.scopeId);
const inputTypeVarContext = new TypeVarContext(typeVar.priv.scopeId);
if (evaluator.assignType(targetFunction, signature, diagAddendum, inputTypeVarContext)) {
const overloadSolution = applySolvedTypeVars(typeVar, inputTypeVarContext, {
@ -838,7 +838,7 @@ function getConverterInputType(
evaluator.addDiagnostic(
DiagnosticRule.reportGeneralTypeIssues,
LocMessage.dataClassConverterOverloads().format({
funcName: converterType.overloads[0].details.name || '<anonymous function>',
funcName: converterType.priv.overloads[0].shared.name || '<anonymous function>',
fieldType: evaluator.printType(fieldType),
fieldName: fieldName,
}) + diagAddendum.getString(),
@ -869,7 +869,7 @@ function getConverterAsFunction(
// choose the first of the two subtypes, which typically corresponds
// to the __init__ method (rather than the __new__ method).
if (isUnion(fromConstructor)) {
fromConstructor = fromConstructor.subtypes[0];
fromConstructor = fromConstructor.priv.subtypes[0];
}
if (isFunction(fromConstructor) || isOverloadedFunction(fromConstructor)) {
@ -908,7 +908,7 @@ function getDescriptorForConverterField(
/* declaredMetaclass */ undefined,
isInstantiableClass(typeMetaclass) ? typeMetaclass : UnknownType.create()
);
descriptorClass.details.baseClasses.push(evaluator.getBuiltInType(dataclassNode, 'object'));
descriptorClass.shared.baseClasses.push(evaluator.getBuiltInType(dataclassNode, 'object'));
computeMroLinearization(descriptorClass);
const fields = ClassType.getSymbolTable(descriptorClass);
@ -927,7 +927,7 @@ function getDescriptorForConverterField(
setFunction,
FunctionParam.create(ParameterCategory.Simple, setType, FunctionParamFlags.TypeDeclared, 'value')
);
setFunction.details.declaredReturnType = evaluator.getNoneType();
setFunction.shared.declaredReturnType = evaluator.getNoneType();
const setSymbol = Symbol.createWithType(SymbolFlags.ClassMember, setFunction);
fields.set('__set__', setSymbol);
@ -944,7 +944,7 @@ function getDescriptorForConverterField(
getFunction,
FunctionParam.create(ParameterCategory.Simple, AnyType.create(), FunctionParamFlags.TypeDeclared, 'objtype')
);
getFunction.details.declaredReturnType = getType;
getFunction.shared.declaredReturnType = getType;
const getSymbol = Symbol.createWithType(SymbolFlags.ClassMember, getFunction);
fields.set('__get__', getSymbol);
@ -1018,11 +1018,11 @@ function isDataclassFieldConstructor(type: Type, fieldDescriptorNames: string[])
let callName: string | undefined;
if (isFunction(type)) {
callName = type.details.fullName;
callName = type.shared.fullName;
} else if (isOverloadedFunction(type)) {
callName = type.overloads[0].details.fullName;
callName = type.priv.overloads[0].shared.fullName;
} else if (isInstantiableClass(type)) {
callName = type.details.fullName;
callName = type.shared.fullName;
}
if (!callName) {
@ -1153,8 +1153,8 @@ export function validateDataClassTransformDecorator(
if (
!isClassInstance(valueType) ||
!ClassType.isBuiltIn(valueType, 'tuple') ||
!valueType.tupleTypeArguments ||
valueType.tupleTypeArguments.some(
!valueType.priv.tupleTypeArguments ||
valueType.priv.tupleTypeArguments.some(
(entry) =>
!isInstantiableClass(entry.type) &&
!isFunction(entry.type) &&
@ -1171,11 +1171,11 @@ export function validateDataClassTransformDecorator(
return;
}
valueType.tupleTypeArguments.forEach((arg) => {
valueType.priv.tupleTypeArguments.forEach((arg) => {
if (isInstantiableClass(arg.type) || isFunction(arg.type)) {
behaviors.fieldDescriptorNames.push(arg.type.details.fullName);
behaviors.fieldDescriptorNames.push(arg.type.shared.fullName);
} else if (isOverloadedFunction(arg.type)) {
behaviors.fieldDescriptorNames.push(arg.type.overloads[0].details.fullName);
behaviors.fieldDescriptorNames.push(arg.type.priv.overloads[0].shared.fullName);
}
});
break;
@ -1203,19 +1203,20 @@ export function getDataclassDecoratorBehaviors(type: Type): DataClassBehaviors |
// dataclass_transform decorator. If more than one have such a decorator,
// only the first one will be honored, as per PEP 681.
functionType =
type.overloads.find((overload) => !!overload.details.decoratorDataClassBehaviors) ?? type.overloads[0];
type.priv.overloads.find((overload) => !!overload.shared.decoratorDataClassBehaviors) ??
type.priv.overloads[0];
}
if (!functionType) {
return undefined;
}
if (functionType.details.decoratorDataClassBehaviors) {
return functionType.details.decoratorDataClassBehaviors;
if (functionType.shared.decoratorDataClassBehaviors) {
return functionType.shared.decoratorDataClassBehaviors;
}
// Is this the built-in dataclass? If so, return the default behaviors.
if (functionType.details.fullName === 'dataclasses.dataclass') {
if (functionType.shared.fullName === 'dataclasses.dataclass') {
return {
fieldDescriptorNames: ['dataclasses.field', 'dataclasses.Field'],
};
@ -1267,16 +1268,16 @@ function applyDataClassBehaviorOverrideValue(
behaviors.frozen = argValue;
}
classType.details.baseClasses.forEach((baseClass) => {
classType.shared.baseClasses.forEach((baseClass) => {
if (isInstantiableClass(baseClass) && ClassType.isDataClass(baseClass)) {
if (ClassType.isDataClassFrozen(baseClass)) {
hasFrozenBaseClass = true;
} else if (
!baseClass.details.classDataClassTransform &&
!baseClass.shared.classDataClassTransform &&
!(
baseClass.details.declaredMetaclass &&
isInstantiableClass(baseClass.details.declaredMetaclass) &&
!!baseClass.details.declaredMetaclass.details.classDataClassTransform
baseClass.shared.declaredMetaclass &&
isInstantiableClass(baseClass.shared.declaredMetaclass) &&
!!baseClass.shared.declaredMetaclass.shared.classDataClassTransform
)
) {
// If this base class is unfrozen and isn't the class that directly
@ -1325,7 +1326,7 @@ function applyDataClassBehaviorOverrideValue(
if (argValue === true) {
behaviors.generateSlots = true;
if (classType.details.localSlotsNames) {
if (classType.shared.localSlotsNames) {
evaluator.addDiagnostic(
DiagnosticRule.reportGeneralTypeIssues,
LocMessage.dataClassSlotsOverwrite(),
@ -1361,7 +1362,7 @@ export function applyDataClassClassBehaviorOverrides(
// Instead, it comes from the default.
behaviors.frozen = behaviors.frozenDefault;
classType.details.dataClassBehaviors = behaviors;
classType.shared.dataClassBehaviors = behaviors;
args.forEach((arg) => {
if (arg.valueExpression && arg.name) {

62
packages/pyright-internal/src/analyzer/decorators.ts
View File

@ -123,7 +123,7 @@ export function getFunctionInfoFromDecorators(
}
} else {
if (ClassType.isBuiltIn(decoratorType, 'deprecated')) {
deprecationMessage = decoratorType.deprecatedInstanceMessage;
deprecationMessage = decoratorType.priv.deprecatedInstanceMessage;
}
}
}
@ -159,8 +159,8 @@ export function applyFunctionDecorator(
(isFunction(decoratorType) && FunctionType.isBuiltIn(decoratorType, 'overload'))
) {
if (isFunction(inputFunctionType)) {
inputFunctionType.details.flags |= FunctionTypeFlags.Overloaded;
undecoratedType.details.flags |= FunctionTypeFlags.Overloaded;
inputFunctionType.shared.flags |= FunctionTypeFlags.Overloaded;
undecoratedType.shared.flags |= FunctionTypeFlags.Overloaded;
return inputFunctionType;
}
}
@ -173,10 +173,10 @@ export function applyFunctionDecorator(
if (isFunction(decoratorCallType)) {
if (
decoratorCallType.details.name === '__dataclass_transform__' ||
decoratorCallType.shared.name === '__dataclass_transform__' ||
FunctionType.isBuiltIn(decoratorCallType, 'dataclass_transform')
) {
undecoratedType.details.decoratorDataClassBehaviors = validateDataClassTransformDecorator(
undecoratedType.shared.decoratorDataClassBehaviors = validateDataClassTransformDecorator(
evaluator,
decoratorNode.expression
);
@ -194,7 +194,7 @@ export function applyFunctionDecorator(
}
if (FunctionType.isBuiltIn(decoratorType, 'type_check_only')) {
undecoratedType.details.flags |= FunctionTypeFlags.TypeCheckOnly;
undecoratedType.shared.flags |= FunctionTypeFlags.TypeCheckOnly;
return inputFunctionType;
}
@ -226,25 +226,25 @@ export function applyFunctionDecorator(
}
} else if (isInstantiableClass(decoratorType)) {
if (ClassType.isBuiltIn(decoratorType)) {
switch (decoratorType.details.name) {
switch (decoratorType.shared.name) {
case 'classmethod':
case 'staticmethod': {
const requiredFlag =
decoratorType.details.name === 'classmethod'
decoratorType.shared.name === 'classmethod'
? FunctionTypeFlags.ClassMethod
: FunctionTypeFlags.StaticMethod;
// If the function isn't currently a class method or static method
// (which can happen if the function was wrapped in a decorator),
// add the appropriate flag.
if (isFunction(inputFunctionType) && (inputFunctionType.details.flags & requiredFlag) === 0) {
if (isFunction(inputFunctionType) && (inputFunctionType.shared.flags & requiredFlag) === 0) {
const newFunction = FunctionType.clone(inputFunctionType);
newFunction.details.flags &= ~(
newFunction.shared.flags &= ~(
FunctionTypeFlags.ConstructorMethod |
FunctionTypeFlags.StaticMethod |
FunctionTypeFlags.ClassMethod
);
newFunction.details.flags |= requiredFlag;
newFunction.shared.flags |= requiredFlag;
return newFunction;
}
@ -279,13 +279,13 @@ export function applyFunctionDecorator(
// Copy the overload flag from the input function type.
if (FunctionType.isOverloaded(inputFunctionType)) {
returnType.details.flags |= FunctionTypeFlags.Overloaded;
returnType.shared.flags |= FunctionTypeFlags.Overloaded;
}
// Copy the docstrings from the input function type if the
// decorator didn't have its own docstring.
if (!returnType.details.docString) {
returnType.details.docString = inputFunctionType.details.docString;
if (!returnType.shared.docString) {
returnType.shared.docString = inputFunctionType.shared.docString;
}
}
@ -313,10 +313,10 @@ export function applyClassDecorator(
if (isFunction(decoratorCallType)) {
if (
decoratorCallType.details.name === '__dataclass_transform__' ||
decoratorCallType.shared.name === '__dataclass_transform__' ||
FunctionType.isBuiltIn(decoratorCallType, 'dataclass_transform')
) {
originalClassType.details.classDataClassTransform = validateDataClassTransformDecorator(
originalClassType.shared.classDataClassTransform = validateDataClassTransformDecorator(
evaluator,
decoratorNode.expression
);
@ -338,7 +338,7 @@ export function applyClassDecorator(
}
} else if (isFunction(decoratorType)) {
if (FunctionType.isBuiltIn(decoratorType, 'final')) {
originalClassType.details.flags |= ClassTypeFlags.Final;
originalClassType.shared.flags |= ClassTypeFlags.Final;
// Don't call getTypeOfDecorator for final. We'll hard-code its
// behavior because its function definition results in a cyclical
@ -347,12 +347,12 @@ export function applyClassDecorator(
}
if (FunctionType.isBuiltIn(decoratorType, 'type_check_only')) {
originalClassType.details.flags |= ClassTypeFlags.TypeCheckOnly;
originalClassType.shared.flags |= ClassTypeFlags.TypeCheckOnly;
return inputClassType;
}
if (FunctionType.isBuiltIn(decoratorType, 'runtime_checkable')) {
originalClassType.details.flags |= ClassTypeFlags.RuntimeCheckable;
originalClassType.shared.flags |= ClassTypeFlags.RuntimeCheckable;
// Don't call getTypeOfDecorator for runtime_checkable. It appears
// frequently in stubs, and it's a waste of time to validate its
@ -382,7 +382,7 @@ export function applyClassDecorator(
}
} else if (isClassInstance(decoratorType)) {
if (ClassType.isBuiltIn(decoratorType, 'deprecated')) {
originalClassType.details.deprecatedMessage = decoratorType.deprecatedInstanceMessage;
originalClassType.shared.deprecatedMessage = decoratorType.priv.deprecatedInstanceMessage;
return inputClassType;
}
}
@ -438,9 +438,9 @@ function getTypeOfDecorator(evaluator: TypeEvaluator, node: DecoratorNode, funct
// If the return type is a function that has no annotations
// and just *args and **kwargs parameters, assume that it
// preserves the type of the input function.
if (isFunction(returnType) && !returnType.details.declaredReturnType) {
if (isFunction(returnType) && !returnType.shared.declaredReturnType) {
if (
!returnType.details.parameters.some((param, index) => {
!returnType.shared.parameters.some((param, index) => {
// Don't allow * or / separators or params with declared types.
if (!param.name || FunctionParam.isTypeDeclared(param)) {
return true;
@ -465,8 +465,8 @@ function getTypeOfDecorator(evaluator: TypeEvaluator, node: DecoratorNode, funct
if (isPartlyUnknown(returnType)) {
if (isFunction(decoratorTypeResult.type)) {
if (
!decoratorTypeResult.type.details.parameters.find((param) => FunctionParam.isTypeDeclared(param)) &&
decoratorTypeResult.type.details.declaredReturnType === undefined
!decoratorTypeResult.type.shared.parameters.find((param) => FunctionParam.isTypeDeclared(param)) &&
decoratorTypeResult.type.shared.declaredReturnType === undefined
) {
return functionOrClassType;
}
@ -517,7 +517,7 @@ export function addOverloadsToFunctionType(evaluator: TypeEvaluator, node: Funct
} else if (isOverloadedFunction(prevDeclDeclTypeInfo.decoratedType)) {
// If the previous declaration was itself an overloaded function,
// copy the entries from it.
appendArray(overloadedTypes, prevDeclDeclTypeInfo.decoratedType.overloads);
appendArray(overloadedTypes, prevDeclDeclTypeInfo.decoratedType.priv.overloads);
}
}
}
@ -531,10 +531,10 @@ export function addOverloadsToFunctionType(evaluator: TypeEvaluator, node: Funct
// Apply the implementation's docstring to any overloads that don't
// have their own docstrings.
const implementation = overloadedTypes.find((signature) => !FunctionType.isOverloaded(signature));
if (implementation?.details.docString) {
if (implementation?.shared.docString) {
overloadedTypes = overloadedTypes.map((overload) => {
if (FunctionType.isOverloaded(overload) && !overload.details.docString) {
return FunctionType.cloneWithDocString(overload, implementation.details.docString);
if (FunctionType.isOverloaded(overload) && !overload.shared.docString) {
return FunctionType.cloneWithDocString(overload, implementation.shared.docString);
}
return overload;
});
@ -543,12 +543,12 @@ export function addOverloadsToFunctionType(evaluator: TypeEvaluator, node: Funct
// PEP 702 indicates that if the implementation of an overloaded
// function is marked deprecated, all of the overloads should be
// treated as deprecated as well.
if (implementation && implementation.details.deprecatedMessage !== undefined) {
if (implementation && implementation.shared.deprecatedMessage !== undefined) {
overloadedTypes = overloadedTypes.map((overload) => {
if (FunctionType.isOverloaded(overload) && overload.details.deprecatedMessage === undefined) {
if (FunctionType.isOverloaded(overload) && overload.shared.deprecatedMessage === undefined) {
return FunctionType.cloneWithDeprecatedMessage(
overload,
implementation.details.deprecatedMessage
implementation.shared.deprecatedMessage
);
}
return overload;

57
packages/pyright-internal/src/analyzer/enums.ts
View File

@ -39,7 +39,7 @@ import {
// Determines whether the class is an Enum metaclass or a subclass thereof.
export function isEnumMetaclass(classType: ClassType) {
return classType.details.mro.some(
return classType.shared.mro.some(
(mroClass) => isClass(mroClass) && ClassType.isBuiltIn(mroClass, ['EnumMeta', 'EnumType'])
);
}
@ -97,9 +97,9 @@ export function createEnumType(
ClassTypeFlags.EnumClass | ClassTypeFlags.ValidTypeAliasClass,
getTypeSourceId(errorNode),
/* declaredMetaclass */ undefined,
enumClass.details.effectiveMetaclass
enumClass.shared.effectiveMetaclass
);
classType.details.baseClasses.push(enumClass);
classType.shared.baseClasses.push(enumClass);
computeMroLinearization(classType);
const classFields = ClassType.getSymbolTable(classType);
@ -152,12 +152,7 @@ export function createEnumType(
const valueType = ClassType.cloneWithLiteral(ClassType.cloneAsInstance(intClassType), index + 1);
const enumLiteral = new EnumLiteral(
classType.details.fullName,
classType.details.name,
entryName,
valueType
);
const enumLiteral = new EnumLiteral(classType.shared.fullName, classType.shared.name, entryName, valueType);
const newSymbol = Symbol.createWithType(
SymbolFlags.ClassMember,
@ -225,12 +220,7 @@ export function createEnumType(
const entryName = nameNode.strings[0].value;
const enumLiteral = new EnumLiteral(
classType.details.fullName,
classType.details.name,
entryName,
valueType
);
const enumLiteral = new EnumLiteral(classType.shared.fullName, classType.shared.name, entryName, valueType);
const newSymbol = Symbol.createWithType(
SymbolFlags.ClassMember,
@ -265,12 +255,7 @@ export function createEnumType(
}
const entryName = nameNode.strings[0].value;
const enumLiteral = new EnumLiteral(
classType.details.fullName,
classType.details.name,
entryName,
valueType
);
const enumLiteral = new EnumLiteral(classType.shared.fullName, classType.shared.name, entryName, valueType);
const newSymbol = Symbol.createWithType(
SymbolFlags.ClassMember,
@ -391,7 +376,7 @@ export function transformTypeForEnumMember(
aliasedEnumType &&
isClassInstance(aliasedEnumType) &&
ClassType.isSameGenericClass(aliasedEnumType, ClassType.cloneAsInstance(memberInfo.classType)) &&
aliasedEnumType.literalValue !== undefined
aliasedEnumType.priv.literalValue !== undefined
) {
return aliasedEnumType;
}
@ -461,10 +446,10 @@ export function transformTypeForEnumMember(
// Handle the Python 3.11 "enum.member()" and "enum.nonmember()" features.
if (assignedType && isClassInstance(assignedType) && ClassType.isBuiltIn(assignedType)) {
if (assignedType.details.fullName === 'enum.nonmember') {
if (assignedType.shared.fullName === 'enum.nonmember') {
const nonMemberType =
assignedType.typeArguments && assignedType.typeArguments.length > 0
? assignedType.typeArguments[0]
assignedType.priv.typeArguments && assignedType.priv.typeArguments.length > 0
? assignedType.priv.typeArguments[0]
: UnknownType.create();
// If the type of the nonmember is declared and the assigned value has
@ -476,10 +461,10 @@ export function transformTypeForEnumMember(
return nonMemberType;
}
if (assignedType.details.fullName === 'enum.member') {
if (assignedType.shared.fullName === 'enum.member') {
valueType =
assignedType.typeArguments && assignedType.typeArguments.length > 0
? assignedType.typeArguments[0]
assignedType.priv.typeArguments && assignedType.priv.typeArguments.length > 0
? assignedType.priv.typeArguments[0]
: UnknownType.create();
isMemberOfEnumeration = true;
}
@ -490,8 +475,8 @@ export function transformTypeForEnumMember(
}
const enumLiteral = new EnumLiteral(
memberInfo.classType.details.fullName,
memberInfo.classType.details.name,
memberInfo.classType.shared.fullName,
memberInfo.classType.shared.name,
memberName,
valueType
);
@ -562,7 +547,7 @@ export function getTypeOfEnumMember(
}
// Handle the special case of 'name' and 'value' members within an enum.
const literalValue = classType.literalValue;
const literalValue = classType.priv.literalValue;
if (memberName === 'name' || memberName === '_name_') {
// Does the class explicitly override this member? Or it it using the
@ -593,7 +578,7 @@ export function getTypeOfEnumMember(
return {
type: combineTypes(
literalValues.map((literalClass) => {
const literalValue = literalClass.literalValue;
const literalValue = literalClass.priv.literalValue;
assert(literalValue instanceof EnumLiteral);
return makeNameType(literalValue);
})
@ -620,7 +605,7 @@ export function getTypeOfEnumMember(
// This occurs, for example, in the django TextChoices class. If we
// detect a custom metaclass, we'll use the declared type of _value_
// if it is declared.
const metaclass = classType.details.effectiveMetaclass;
const metaclass = classType.shared.effectiveMetaclass;
if (metaclass && isClass(metaclass) && !ClassType.isBuiltIn(metaclass)) {
return { type: valueType ?? AnyType.create(), isIncomplete };
}
@ -664,7 +649,7 @@ export function getTypeOfEnumMember(
return {
type: combineTypes(
literalValues.map((literalClass) => {
const literalValue = literalClass.literalValue;
const literalValue = literalClass.priv.literalValue;
assert(literalValue instanceof EnumLiteral);
return literalValue.itemType;
})
@ -700,8 +685,8 @@ export function getEnumAutoValueType(evaluator: TypeEvaluator, node: ExpressionN
isClass(memberInfo.classType) &&
!ClassType.isBuiltIn(memberInfo.classType, 'Enum')
) {
if (memberInfo.type.details.declaredReturnType) {
return memberInfo.type.details.declaredReturnType;
if (memberInfo.type.shared.declaredReturnType) {
return memberInfo.type.shared.declaredReturnType;
}
}
}

12
packages/pyright-internal/src/analyzer/functionTransform.ts
View File

@ -34,7 +34,7 @@ export function applyFunctionTransform(
result: FunctionResult
): FunctionResult {
if (isFunction(functionType)) {
if (functionType.details.fullName === 'functools.total_ordering') {
if (functionType.shared.fullName === 'functools.total_ordering') {
return applyTotalOrderingTransform(evaluator, errorNode, argList, result);
}
}
@ -55,7 +55,7 @@ function applyTotalOrderingTransform(
// This function is meant to apply to a concrete instantiable class.
const classType = argList[0].typeResult?.type;
if (!classType || !isInstantiableClass(classType) || classType.includeSubclasses) {
if (!classType || !isInstantiableClass(classType) || classType.priv.includeSubclasses) {
return result;
}
@ -88,10 +88,10 @@ function applyTotalOrderingTransform(
const firstMemberType = evaluator.getTypeOfMember(firstMemberFound);
if (
isFunction(firstMemberType) &&
firstMemberType.details.parameters.length >= 2 &&
FunctionParam.isTypeDeclared(firstMemberType.details.parameters[1])
firstMemberType.shared.parameters.length >= 2 &&
FunctionParam.isTypeDeclared(firstMemberType.shared.parameters[1])
) {
operandType = firstMemberType.details.parameters[1].type;
operandType = firstMemberType.shared.parameters[1].type;
}
// If there was no provided operand type, fall back to object.
@ -127,7 +127,7 @@ function applyTotalOrderingTransform(
const methodToAdd = FunctionType.createSynthesizedInstance(methodName);
FunctionType.addParameter(methodToAdd, selfParam);
FunctionType.addParameter(methodToAdd, objParam);
methodToAdd.details.declaredReturnType = boolType;
methodToAdd.shared.declaredReturnType = boolType;
ClassType.getSymbolTable(classType).set(
methodName,

36
packages/pyright-internal/src/analyzer/namedTuples.ts
View File

@ -108,9 +108,9 @@ export function createNamedTupleType(
isClassInstance(defaultsArgType) &&
isTupleClass(defaultsArgType) &&
!isUnboundedTupleClass(defaultsArgType) &&
defaultsArgType.tupleTypeArguments
defaultsArgType.priv.tupleTypeArguments
) {
defaultArgCount = defaultsArgType.tupleTypeArguments.length;
defaultArgCount = defaultsArgType.priv.tupleTypeArguments.length;
} else {
defaultArgCount = undefined;
}
@ -126,10 +126,10 @@ export function createNamedTupleType(
ClassTypeFlags.ReadOnlyInstanceVariables | ClassTypeFlags.ValidTypeAliasClass,
ParseTreeUtils.getTypeSourceId(errorNode),
/* declaredMetaclass */ undefined,
isInstantiableClass(namedTupleType) ? namedTupleType.details.effectiveMetaclass : UnknownType.create()
isInstantiableClass(namedTupleType) ? namedTupleType.shared.effectiveMetaclass : UnknownType.create()
);
classType.details.baseClasses.push(namedTupleType);
classType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
classType.shared.baseClasses.push(namedTupleType);
classType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
const classFields = ClassType.getSymbolTable(classType);
classFields.set(
@ -139,12 +139,12 @@ export function createNamedTupleType(
const classTypeVar = synthesizeTypeVarForSelfCls(classType, /* isClsParam */ true);
const constructorType = FunctionType.createSynthesizedInstance('__new__', FunctionTypeFlags.ConstructorMethod);
constructorType.details.declaredReturnType = convertToInstance(classTypeVar);
constructorType.constructorTypeVarScopeId = getTypeVarScopeId(classType);
constructorType.shared.declaredReturnType = convertToInstance(classTypeVar);
constructorType.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
if (ParseTreeUtils.isAssignmentToDefaultsFollowingNamedTuple(errorNode)) {
constructorType.details.flags |= FunctionTypeFlags.DisableDefaultChecks;
constructorType.shared.flags |= FunctionTypeFlags.DisableDefaultChecks;
}
constructorType.details.typeVarScopeId = classType.details.typeVarScopeId;
constructorType.shared.typeVarScopeId = classType.shared.typeVarScopeId;
FunctionType.addParameter(
constructorType,
FunctionParam.create(ParameterCategory.Simple, classTypeVar, FunctionParamFlags.TypeDeclared, 'cls')
@ -275,7 +275,7 @@ export function createNamedTupleType(
ClassType.isBuiltIn(nameTypeResult.type, 'str') &&
isLiteralType(nameTypeResult.type)
) {
entryName = nameTypeResult.type.literalValue as string;
entryName = nameTypeResult.type.priv.literalValue as string;
if (!entryName) {
evaluator.addDiagnostic(
@ -366,7 +366,7 @@ export function createNamedTupleType(
}
if (addGenericGetAttribute) {
constructorType.details.parameters = [];
constructorType.shared.parameters = [];
FunctionType.addDefaultParameters(constructorType);
entryTypes.push(AnyType.create(/* isEllipsis */ false));
entryTypes.push(AnyType.create(/* isEllipsis */ true));
@ -376,20 +376,20 @@ export function createNamedTupleType(
const initType = FunctionType.createSynthesizedInstance('__init__');
FunctionType.addParameter(initType, selfParameter);
FunctionType.addDefaultParameters(initType);
initType.details.declaredReturnType = evaluator.getNoneType();
initType.constructorTypeVarScopeId = getTypeVarScopeId(classType);
initType.shared.declaredReturnType = evaluator.getNoneType();
initType.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
classFields.set('__new__', Symbol.createWithType(SymbolFlags.ClassMember, constructorType));
classFields.set('__init__', Symbol.createWithType(SymbolFlags.ClassMember, initType));
const lenType = FunctionType.createSynthesizedInstance('__len__');
lenType.details.declaredReturnType = evaluator.getBuiltInObject(errorNode, 'int');
lenType.shared.declaredReturnType = evaluator.getBuiltInObject(errorNode, 'int');
FunctionType.addParameter(lenType, selfParameter);
classFields.set('__len__', Symbol.createWithType(SymbolFlags.ClassMember, lenType));
if (addGenericGetAttribute) {
const getAttribType = FunctionType.createSynthesizedInstance('__getattribute__');
getAttribType.details.declaredReturnType = AnyType.create();
getAttribType.shared.declaredReturnType = AnyType.create();
FunctionType.addParameter(getAttribType, selfParameter);
FunctionType.addParameter(
getAttribType,
@ -435,7 +435,7 @@ export function updateNamedTupleBaseClass(
): boolean {
let isUpdateNeeded = false;
classType.details.baseClasses = classType.details.baseClasses.map((baseClass) => {
classType.shared.baseClasses = classType.shared.baseClasses.map((baseClass) => {
if (!isInstantiableClass(baseClass) || !ClassType.isBuiltIn(baseClass, 'NamedTuple')) {
return baseClass;
}
@ -459,9 +459,9 @@ export function updateNamedTupleBaseClass(
/* typeArguments */ undefined,
isTypeArgumentExplicit
);
clonedNamedTupleClass.details = { ...clonedNamedTupleClass.details };
clonedNamedTupleClass.shared = { ...clonedNamedTupleClass.shared };
clonedNamedTupleClass.details.baseClasses = clonedNamedTupleClass.details.baseClasses.map(
clonedNamedTupleClass.shared.baseClasses = clonedNamedTupleClass.shared.baseClasses.map(
(namedTupleBaseClass) => {
if (!isInstantiableClass(namedTupleBaseClass) || !ClassType.isBuiltIn(namedTupleBaseClass, 'tuple')) {
return namedTupleBaseClass;

33
packages/pyright-internal/src/analyzer/operations.ts
View File

@ -271,8 +271,8 @@ export function validateBinaryOperation(
return ClassType.cloneWithLiteral(
leftClassSubtype,
((leftClassSubtype.literalValue as string) +
rightClassSubtype.literalValue) as string
((leftClassSubtype.priv.literalValue as string) +
rightClassSubtype.priv.literalValue) as string
);
});
});
@ -293,10 +293,10 @@ export function validateBinaryOperation(
const leftClassSubtype = leftSubtype as ClassType;
const rightClassSubtype = rightSubtype as ClassType;
const leftLiteralValue = BigInt(
leftClassSubtype.literalValue as number | bigint
leftClassSubtype.priv.literalValue as number | bigint
);
const rightLiteralValue = BigInt(
rightClassSubtype.literalValue as number | bigint
rightClassSubtype.priv.literalValue as number | bigint
);
let newValue: number | bigint | undefined;
@ -371,10 +371,10 @@ export function validateBinaryOperation(
operator === OperatorType.Add &&
isClassInstance(leftSubtypeExpanded) &&
isTupleClass(leftSubtypeExpanded) &&
leftSubtypeExpanded.tupleTypeArguments &&
leftSubtypeExpanded.priv.tupleTypeArguments &&
isClassInstance(rightSubtypeExpanded) &&
isTupleClass(rightSubtypeExpanded) &&
rightSubtypeExpanded.tupleTypeArguments &&
rightSubtypeExpanded.priv.tupleTypeArguments &&
tupleClassType &&
isInstantiableClass(tupleClassType)
) {
@ -389,8 +389,8 @@ export function validateBinaryOperation(
) {
return ClassType.cloneAsInstance(
specializeTupleClass(tupleClassType, [
...leftSubtypeExpanded.tupleTypeArguments,
...rightSubtypeExpanded.tupleTypeArguments,
...leftSubtypeExpanded.priv.tupleTypeArguments,
...rightSubtypeExpanded.priv.tupleTypeArguments,
])
);
}
@ -543,8 +543,8 @@ export function getTypeOfBinaryOperation(
inferenceContext &&
isClassInstance(inferenceContext.expectedType) &&
ClassType.isBuiltIn(inferenceContext.expectedType, 'list') &&
inferenceContext.expectedType.typeArguments &&
inferenceContext.expectedType.typeArguments.length >= 1 &&
inferenceContext.expectedType.priv.typeArguments &&
inferenceContext.expectedType.priv.typeArguments.length >= 1 &&
node.leftExpression.nodeType === ParseNodeType.List
) {
expectedLeftOperandType = inferenceContext.expectedType;
@ -570,7 +570,7 @@ export function getTypeOfBinaryOperation(
return false;
}
return ClassType.isTypedDictClass(subtype) || subtype.details.typeParameters.length > 0;
return ClassType.isTypedDictClass(subtype) || subtype.shared.typeParameters.length > 0;
})
) {
expectedOperandType = leftType;
@ -684,7 +684,7 @@ export function getTypeOfBinaryOperation(
if (stringNode && otherNode && otherType) {
let isAllowed = true;
if (isClass(otherType)) {
if (!otherType.isTypeArgumentExplicit || isClassInstance(otherType)) {
if (!otherType.priv.isTypeArgumentExplicit || isClassInstance(otherType)) {
isAllowed = false;
}
}
@ -999,14 +999,17 @@ export function getTypeOfUnaryOperation(
} else if (node.operator === OperatorType.Subtract) {
type = mapSubtypes(exprType, (subtype) => {
const classSubtype = subtype as ClassType;
return ClassType.cloneWithLiteral(classSubtype, -(classSubtype.literalValue as number | bigint));
return ClassType.cloneWithLiteral(
classSubtype,
-(classSubtype.priv.literalValue as number | bigint)
);
});
}
} else if (literalClassName === 'bool') {
if (node.operator === OperatorType.Not) {
type = mapSubtypes(exprType, (subtype) => {
const classSubtype = subtype as ClassType;
return ClassType.cloneWithLiteral(classSubtype, !(classSubtype.literalValue as boolean));
return ClassType.cloneWithLiteral(classSubtype, !(classSubtype.priv.literalValue as boolean));
});
}
}
@ -1134,7 +1137,7 @@ function customMetaclassSupportsMethod(type: Type, methodName: string): boolean
return false;
}
const metaclass = type.details.effectiveMetaclass;
const metaclass = type.shared.effectiveMetaclass;
if (!metaclass || !isInstantiableClass(metaclass)) {
return false;
}

107
packages/pyright-internal/src/analyzer/packageTypeVerifier.ts
View File

@ -680,7 +680,7 @@ export class PackageTypeVerifier {
}
private _reportMissingClassDocstring(symbolInfo: SymbolInfo, type: ClassType, report: PackageTypeReport) {
if (type.details.docString) {
if (type.shared.docString) {
return;
}
@ -701,7 +701,7 @@ export class PackageTypeVerifier {
declFileUri: Uri | undefined,
report: PackageTypeReport
) {
if (type.details.parameters.find((param) => param.defaultType && isEllipsisType(param.defaultType))) {
if (type.shared.parameters.find((param) => param.defaultType && isEllipsisType(param.defaultType))) {
if (symbolInfo) {
this._addSymbolWarning(
symbolInfo,
@ -714,7 +714,7 @@ export class PackageTypeVerifier {
report.missingDefaultParamCount++;
}
if (type.details.docString) {
if (type.shared.docString) {
return;
}
@ -827,7 +827,7 @@ export class PackageTypeVerifier {
}
case TypeCategory.OverloadedFunction: {
for (const overload of type.overloads) {
for (const overload of type.priv.overloads) {
knownStatus = this._updateKnownStatusIfWorse(
knownStatus,
this._getSymbolTypeKnownStatus(
@ -844,7 +844,7 @@ export class PackageTypeVerifier {
}
case TypeCategory.Function: {
if (!this._shouldIgnoreType(report, type.details.fullName)) {
if (!this._shouldIgnoreType(report, type.shared.fullName)) {
knownStatus = this._updateKnownStatusIfWorse(
knownStatus,
this._getFunctionTypeKnownStatus(
@ -866,9 +866,9 @@ export class PackageTypeVerifier {
// Properties require special handling.
if (TypeBase.isInstance(type) && ClassType.isPropertyClass(type)) {
const propMethodInfo: [string, (c: ClassType) => FunctionType | undefined][] = [
['fget', (c) => c.fgetInfo?.methodType],
['fset', (c) => c.fsetInfo?.methodType],
['fdel', (c) => c.fdelInfo?.methodType],
['fget', (c) => c.priv.fgetInfo?.methodType],
['fset', (c) => c.priv.fsetInfo?.methodType],
['fdel', (c) => c.priv.fdelInfo?.methodType],
];
const propertyClass = type;
@ -888,7 +888,7 @@ export class PackageTypeVerifier {
// static. Otherwise we'll incorrectly report that "self" is not annotated.
accessType = FunctionType.cloneWithNewFlags(
accessType,
accessType.details.flags & ~FunctionTypeFlags.StaticMethod
accessType.shared.flags & ~FunctionTypeFlags.StaticMethod
);
}
@ -908,7 +908,7 @@ export class PackageTypeVerifier {
break;
}
if (!this._shouldIgnoreType(report, type.details.fullName)) {
if (!this._shouldIgnoreType(report, type.shared.fullName)) {
// Don't bother type-checking built-in types.
if (!ClassType.isBuiltIn(type)) {
const symbolInfo = this._getSymbolForClass(report, type, publicSymbols);
@ -917,12 +917,12 @@ export class PackageTypeVerifier {
}
// Analyze type arguments if present to make sure they are known.
if (type.typeArguments) {
type.typeArguments!.forEach((typeArg, index) => {
if (type.priv.typeArguments) {
type.priv.typeArguments!.forEach((typeArg, index) => {
if (isUnknown(typeArg)) {
this._addSymbolError(
symbolInfo,
`Type argument ${index + 1} for class "${type.details.name}" has unknown type`,
`Type argument ${index + 1} for class "${type.shared.name}" has unknown type`,
declRange,
declFileUri
);
@ -933,7 +933,7 @@ export class PackageTypeVerifier {
this._addSymbolError(
symbolInfo,
`Type argument ${index + 1} for class "${
type.details.name
type.shared.name
}" has partially unknown type` + diag.getString(),
declRange,
declFileUri
@ -947,7 +947,7 @@ export class PackageTypeVerifier {
}
case TypeCategory.Module: {
if (!this._shouldIgnoreType(report, type.moduleName)) {
if (!this._shouldIgnoreType(report, type.priv.moduleName)) {
const moduleSymbol = this._getSymbolForModule(report, type, publicSymbols);
if (moduleSymbol.typeKnownStatus !== TypeKnownStatus.Known) {
this._addSymbolError(
@ -982,11 +982,11 @@ export class PackageTypeVerifier {
let knownStatus = TypeKnownStatus.Known;
// If the file path wasn't provided, try to get it from the type.
if (type.details.declaration && !declFileUri) {
declFileUri = type.details.declaration.uri;
if (type.shared.declaration && !declFileUri) {
declFileUri = type.shared.declaration.uri;
}
type.details.parameters.forEach((param, index) => {
type.shared.parameters.forEach((param, index) => {
// Skip nameless parameters like "*" and "/".
if (param.name) {
if (!FunctionParam.isTypeDeclared(param)) {
@ -1055,8 +1055,8 @@ export class PackageTypeVerifier {
}
});
if (type.details.declaredReturnType) {
if (isUnknown(type.details.declaredReturnType)) {
if (type.shared.declaredReturnType) {
if (isUnknown(type.shared.declaredReturnType)) {
if (symbolInfo) {
this._addSymbolError(
symbolInfo,
@ -1070,15 +1070,13 @@ export class PackageTypeVerifier {
const extraInfo = new DiagnosticAddendum();
const returnTypeKnownStatus = this._getTypeKnownStatus(
report,
type.details.declaredReturnType,
type.shared.declaredReturnType,
publicSymbols,
extraInfo.createAddendum()
);
if (returnTypeKnownStatus !== TypeKnownStatus.Known) {
extraInfo.addMessage(
`Return type is "${this._program.printType(type.details.declaredReturnType)}"`
);
extraInfo.addMessage(`Return type is "${this._program.printType(type.shared.declaredReturnType)}"`);
if (symbolInfo) {
this._addSymbolError(
@ -1100,7 +1098,7 @@ export class PackageTypeVerifier {
}
} else {
// Init methods have an implied return type.
if (type.details.name !== '__init__') {
if (type.shared.name !== '__init__') {
if (symbolInfo) {
this._addSymbolError(
symbolInfo,
@ -1123,7 +1121,7 @@ export class PackageTypeVerifier {
private _getSymbolForClass(report: PackageTypeReport, type: ClassType, publicSymbols: PublicSymbolSet): SymbolInfo {
// See if this type is already analyzed.
const cachedType = report.symbols.get(type.details.fullName);
const cachedType = report.symbols.get(type.shared.fullName);
if (cachedType) {
cachedType.referenceCount++;
return cachedType;
@ -1131,10 +1129,10 @@ export class PackageTypeVerifier {
const symbolInfo: SymbolInfo = {
category: SymbolCategory.Class,
name: type.details.name,
fullName: type.details.fullName,
fileUri: type.details.fileUri,
isExported: publicSymbols.has(type.details.fullName),
name: type.shared.name,
fullName: type.shared.fullName,
fileUri: type.shared.fileUri,
isExported: publicSymbols.has(type.shared.fullName),
typeKnownStatus: TypeKnownStatus.Known,
referenceCount: 1,
diagnostics: [],
@ -1148,7 +1146,7 @@ export class PackageTypeVerifier {
const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(
report,
type.details.fullName,
type.shared.fullName,
ClassType.getSymbolTable(type),
ScopeType.Class,
publicSymbols,
@ -1157,7 +1155,7 @@ export class PackageTypeVerifier {
// see if we can find a same-named symbol in a parent class with
// a type declaration.
if (!symbol.hasTypedDeclarations()) {
for (const mroClass of type.details.mro.slice(1)) {
for (const mroClass of type.shared.mro.slice(1)) {
if (isClass(mroClass)) {
const overrideSymbol = ClassType.getSymbolTable(mroClass).get(name);
if (overrideSymbol && overrideSymbol.hasTypedDeclarations()) {
@ -1177,8 +1175,8 @@ export class PackageTypeVerifier {
);
// Add information for the metaclass.
if (type.details.effectiveMetaclass) {
if (!isInstantiableClass(type.details.effectiveMetaclass)) {
if (type.shared.effectiveMetaclass) {
if (!isInstantiableClass(type.shared.effectiveMetaclass)) {
this._addSymbolError(symbolInfo, `Type of metaclass unknown`, getEmptyRange(), Uri.empty());
symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(
symbolInfo.typeKnownStatus,
@ -1188,7 +1186,7 @@ export class PackageTypeVerifier {
const diag = new DiagnosticAddendum();
const metaclassKnownStatus = this._getTypeKnownStatus(
report,
type.details.effectiveMetaclass,
type.shared.effectiveMetaclass,
publicSymbols,
diag
);
@ -1196,8 +1194,7 @@ export class PackageTypeVerifier {
if (metaclassKnownStatus !== TypeKnownStatus.Known) {
this._addSymbolError(
symbolInfo,
`Type of metaclass "${type.details.effectiveMetaclass}" is partially unknown` +
diag.getString(),
`Type of metaclass "${type.shared.effectiveMetaclass}" is partially unknown` + diag.getString(),
getEmptyRange(),
Uri.empty()
);
@ -1210,7 +1207,7 @@ export class PackageTypeVerifier {
}
// Add information for base classes.
type.details.baseClasses.forEach((baseClass) => {
type.shared.baseClasses.forEach((baseClass) => {
if (!isInstantiableClass(baseClass)) {
this._addSymbolError(symbolInfo, `Type of base class unknown`, getEmptyRange(), Uri.empty());
symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(
@ -1230,7 +1227,7 @@ export class PackageTypeVerifier {
if (baseClassTypeStatus !== TypeKnownStatus.Known) {
this._addSymbolError(
symbolInfo,
`Type of base class "${baseClass.details.fullName}" is partially unknown` + diag.getString(),
`Type of base class "${baseClass.shared.fullName}" is partially unknown` + diag.getString(),
getEmptyRange(),
Uri.empty()
);
@ -1252,7 +1249,7 @@ export class PackageTypeVerifier {
publicSymbols: PublicSymbolSet
): SymbolInfo {
// See if this type is already analyzed.
const cachedType = report.symbols.get(type.moduleName);
const cachedType = report.symbols.get(type.priv.moduleName);
if (cachedType) {
cachedType.referenceCount++;
return cachedType;
@ -1260,10 +1257,10 @@ export class PackageTypeVerifier {
const symbolInfo: SymbolInfo = {
category: SymbolCategory.Module,
name: type.moduleName,
fullName: type.moduleName,
fileUri: type.fileUri,
isExported: publicSymbols.has(type.moduleName),
name: type.priv.moduleName,
fullName: type.priv.moduleName,
fileUri: type.priv.fileUri,
isExported: publicSymbols.has(type.priv.moduleName),
typeKnownStatus: TypeKnownStatus.Known,
referenceCount: 1,
diagnostics: [],
@ -1271,14 +1268,14 @@ export class PackageTypeVerifier {
};
// Add the symbol for the module if the name isn't relative.
if (!type.moduleName.startsWith('.')) {
if (!type.priv.moduleName.startsWith('.')) {
this._addSymbol(report, symbolInfo);
}
const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(
report,
type.moduleName,
type.fields,
type.priv.moduleName,
type.priv.fields,
ScopeType.Module,
publicSymbols
);
@ -1342,7 +1339,7 @@ export class PackageTypeVerifier {
}
case TypeCategory.OverloadedFunction: {
for (const overload of type.overloads) {
for (const overload of type.priv.overloads) {
knownStatus = this._updateKnownStatusIfWorse(
knownStatus,
this._getTypeKnownStatus(report, overload, publicSymbols, diag.createAddendum())
@ -1353,7 +1350,7 @@ export class PackageTypeVerifier {
}
case TypeCategory.Function: {
if (!this._shouldIgnoreType(report, type.details.fullName)) {
if (!this._shouldIgnoreType(report, type.shared.fullName)) {
knownStatus = this._updateKnownStatusIfWorse(
knownStatus,
this._getFunctionTypeKnownStatus(
@ -1372,7 +1369,7 @@ export class PackageTypeVerifier {
}
case TypeCategory.Class: {
if (!this._shouldIgnoreType(report, type.details.fullName)) {
if (!this._shouldIgnoreType(report, type.shared.fullName)) {
// Don't bother type-checking built-in types.
if (!ClassType.isBuiltIn(type)) {
const symbolInfo = this._getSymbolForClass(report, type, publicSymbols);
@ -1381,16 +1378,16 @@ export class PackageTypeVerifier {
}
// Analyze type arguments if present to make sure they are known.
if (type.typeArguments) {
type.typeArguments!.forEach((typeArg, index) => {
if (type.priv.typeArguments) {
type.priv.typeArguments!.forEach((typeArg, index) => {
if (isUnknown(typeArg)) {
diag.addMessage(
`Type argument ${index + 1} for class "${type.details.name}" has unknown type`
`Type argument ${index + 1} for class "${type.shared.name}" has unknown type`
);
knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
} else if (isPartlyUnknown(typeArg)) {
diag.addMessage(
`Type argument ${index + 1} for class "${type.details.name}" has partially unknown type`
`Type argument ${index + 1} for class "${type.shared.name}" has partially unknown type`
);
knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.PartiallyUnknown);
}
@ -1401,7 +1398,7 @@ export class PackageTypeVerifier {
}
case TypeCategory.Module: {
if (!this._shouldIgnoreType(report, type.moduleName)) {
if (!this._shouldIgnoreType(report, type.priv.moduleName)) {
const moduleSymbol = this._getSymbolForModule(report, type, publicSymbols);
knownStatus = this._updateKnownStatusIfWorse(knownStatus, moduleSymbol.typeKnownStatus);
}

54
packages/pyright-internal/src/analyzer/parameterUtils.ts
View File

@ -32,7 +32,7 @@ export function isTypedKwargs(param: FunctionParam): boolean {
isClassInstance(param.type) &&
isUnpackedClass(param.type) &&
ClassType.isTypedDictClass(param.type) &&
!!param.type.details.typedDictEntries
!!param.type.shared.typedDictEntries
);
}
@ -72,7 +72,7 @@ export interface ParameterListDetails {
}
export function firstParametersExcludingSelf(type: FunctionType): FunctionParam | undefined {
return type.details.parameters.find((p) => !(isTypeVar(p.type) && p.type.details.isSynthesizedSelf));
return type.shared.parameters.find((p) => !(isTypeVar(p.type) && p.type.shared.isSynthesizedSelf));
}
// Examines the input parameters within a function signature and creates a
@ -88,13 +88,13 @@ export function getParameterListDetails(type: FunctionType): ParameterListDetail
hasUnpackedTypedDict: false,
};
let positionOnlyIndex = type.details.parameters.findIndex((p) => isPositionOnlySeparator(p));
let positionOnlyIndex = type.shared.parameters.findIndex((p) => isPositionOnlySeparator(p));
// Handle the old (pre Python 3.8) way of specifying positional-only
// parameters by naming them with "__".
if (positionOnlyIndex < 0) {
for (let i = 0; i < type.details.parameters.length; i++) {
const p = type.details.parameters[i];
for (let i = 0; i < type.shared.parameters.length; i++) {
const p = type.shared.parameters[i];
if (p.category !== ParameterCategory.Simple) {
break;
}
@ -117,7 +117,7 @@ export function getParameterListDetails(type: FunctionType): ParameterListDetail
}
for (let i = 0; i < positionOnlyIndex; i++) {
if (type.details.parameters[i].defaultType) {
if (type.shared.parameters[i].defaultType) {
break;
}
@ -157,14 +157,14 @@ export function getParameterListDetails(type: FunctionType): ParameterListDetail
}
};
type.details.parameters.forEach((param, index) => {
type.shared.parameters.forEach((param, index) => {
if (param.category === ParameterCategory.ArgsList) {
// If this is an unpacked tuple, expand the entries.
const paramType = FunctionType.getEffectiveParameterType(type, index);
if (param.name && isUnpackedClass(paramType) && paramType.tupleTypeArguments) {
if (param.name && isUnpackedClass(paramType) && paramType.priv.tupleTypeArguments) {
const addToPositionalOnly = index < result.positionOnlyParamCount;
paramType.tupleTypeArguments.forEach((tupleArg, tupleIndex) => {
paramType.priv.tupleTypeArguments.forEach((tupleArg, tupleIndex) => {
const category =
isVariadicTypeVar(tupleArg.type) || tupleArg.isUnbounded
? ParameterCategory.ArgsList
@ -237,13 +237,13 @@ export function getParameterListDetails(type: FunctionType): ParameterListDetail
const paramType = FunctionType.getEffectiveParameterType(type, index);
// Is this an unpacked TypedDict? If so, expand the entries.
if (isClassInstance(paramType) && isUnpackedClass(paramType) && paramType.details.typedDictEntries) {
if (isClassInstance(paramType) && isUnpackedClass(paramType) && paramType.shared.typedDictEntries) {
if (result.firstKeywordOnlyIndex === undefined) {
result.firstKeywordOnlyIndex = result.params.length;
}
const typedDictType = paramType;
paramType.details.typedDictEntries.knownItems.forEach((entry, name) => {
paramType.shared.typedDictEntries.knownItems.forEach((entry, name) => {
const specializedParamType = partiallySpecializeType(entry.valueType, typedDictType);
addVirtualParameter(
@ -259,16 +259,16 @@ export function getParameterListDetails(type: FunctionType): ParameterListDetail
);
});
if (paramType.details.typedDictEntries.extraItems) {
if (paramType.shared.typedDictEntries.extraItems) {
addVirtualParameter(
FunctionParam.create(
ParameterCategory.KwargsDict,
paramType.details.typedDictEntries.extraItems.valueType,
paramType.shared.typedDictEntries.extraItems.valueType,
FunctionParamFlags.TypeDeclared,
'kwargs'
),
index,
paramType.details.typedDictEntries.extraItems.valueType
paramType.shared.typedDictEntries.extraItems.valueType
);
result.kwargsIndex = result.params.length - 1;
@ -296,8 +296,8 @@ export function getParameterListDetails(type: FunctionType): ParameterListDetail
param,
index,
/* typeOverride */ undefined,
type.specializedTypes?.parameterDefaultArgs
? type.specializedTypes?.parameterDefaultArgs[index]
type.priv.specializedTypes?.parameterDefaultArgs
? type.priv.specializedTypes?.parameterDefaultArgs[index]
: undefined
);
}
@ -323,7 +323,7 @@ export function isParamSpecArgsArgument(paramSpec: TypeVarType, argType: Type) {
doForEachSubtype(argType, (argSubtype) => {
if (
isParamSpec(argSubtype) &&
argSubtype.paramSpecAccess === 'args' &&
argSubtype.priv.paramSpecAccess === 'args' &&
isTypeSame(argSubtype, paramSpec, { ignoreTypeFlags: true })
) {
return;
@ -331,10 +331,10 @@ export function isParamSpecArgsArgument(paramSpec: TypeVarType, argType: Type) {
if (
isClassInstance(argSubtype) &&
argSubtype.tupleTypeArguments &&
argSubtype.tupleTypeArguments.length === 1 &&
argSubtype.tupleTypeArguments[0].isUnbounded &&
isAnyOrUnknown(argSubtype.tupleTypeArguments[0].type)
argSubtype.priv.tupleTypeArguments &&
argSubtype.priv.tupleTypeArguments.length === 1 &&
argSubtype.priv.tupleTypeArguments[0].isUnbounded &&
isAnyOrUnknown(argSubtype.priv.tupleTypeArguments[0].type)
) {
return;
}
@ -357,7 +357,7 @@ export function isParamSpecKwargsArgument(paramSpec: TypeVarType, argType: Type)
doForEachSubtype(argType, (argSubtype) => {
if (
isParamSpec(argSubtype) &&
argSubtype.paramSpecAccess === 'kwargs' &&
argSubtype.priv.paramSpecAccess === 'kwargs' &&
isTypeSame(argSubtype, paramSpec, { ignoreTypeFlags: true })
) {
return;
@ -366,11 +366,11 @@ export function isParamSpecKwargsArgument(paramSpec: TypeVarType, argType: Type)
if (
isClassInstance(argSubtype) &&
ClassType.isBuiltIn(argSubtype, 'dict') &&
argSubtype.typeArguments &&
argSubtype.typeArguments.length === 2 &&
isClassInstance(argSubtype.typeArguments[0]) &&
ClassType.isBuiltIn(argSubtype.typeArguments[0], 'str') &&
isAnyOrUnknown(argSubtype.typeArguments[1])
argSubtype.priv.typeArguments &&
argSubtype.priv.typeArguments.length === 2 &&
isClassInstance(argSubtype.priv.typeArguments[0]) &&
ClassType.isBuiltIn(argSubtype.priv.typeArguments[0], 'str') &&
isAnyOrUnknown(argSubtype.priv.typeArguments[1])
) {
return;
}

103
packages/pyright-internal/src/analyzer/patternMatching.ts
View File

@ -229,8 +229,10 @@ function narrowTypeBasedOnSequencePattern(
canNarrowTuple = false;
}
if (isClassInstance(entry.subtype) && entry.subtype.tupleTypeArguments) {
const unboundedIndex = entry.subtype.tupleTypeArguments.findIndex((typeArg) => typeArg.isUnbounded);
if (isClassInstance(entry.subtype) && entry.subtype.priv.tupleTypeArguments) {
const unboundedIndex = entry.subtype.priv.tupleTypeArguments.findIndex(
(typeArg) => typeArg.isUnbounded
);
if (unboundedIndex >= 0) {
// If the pattern includes a "star" entry that aligns exactly with
@ -270,13 +272,13 @@ function narrowTypeBasedOnSequencePattern(
if (index === pattern.starEntryIndex) {
if (
isClassInstance(narrowedEntryType) &&
narrowedEntryType.tupleTypeArguments &&
narrowedEntryType.priv.tupleTypeArguments &&
!isUnboundedTupleClass(narrowedEntryType) &&
narrowedEntryType.tupleTypeArguments
narrowedEntryType.priv.tupleTypeArguments
) {
appendArray(
narrowedEntryTypes,
narrowedEntryType.tupleTypeArguments.map((t) => t.type)
narrowedEntryType.priv.tupleTypeArguments.map((t) => t.type)
);
} else {
narrowedEntryTypes.push(narrowedEntryType);
@ -451,10 +453,14 @@ function narrowTypeBasedOnMappingPattern(
const keyType = evaluator.getTypeOfExpression(keyPattern.expression).type;
// The key type must be a str literal.
if (!isClassInstance(keyType) || !ClassType.isBuiltIn(keyType, 'str') || keyType.literalValue === undefined) {
if (
!isClassInstance(keyType) ||
!ClassType.isBuiltIn(keyType, 'str') ||
keyType.priv.literalValue === undefined
) {
return type;
}
const keyValue = keyType.literalValue as string;
const keyValue = keyType.priv.literalValue as string;
const valueTypes = valuePattern.orPatterns.map(
(orPattern) => evaluator.getTypeOfExpression((orPattern as PatternLiteralNode).expression).type
@ -475,7 +481,7 @@ function narrowTypeBasedOnMappingPattern(
(valueType) =>
isClassInstance(valueType) &&
ClassType.isSameGenericClass(valueType, memberValueType) &&
valueType.literalValue === memberValueType.literalValue
valueType.priv.literalValue === memberValueType.priv.literalValue
)
) {
return undefined;
@ -522,7 +528,7 @@ function narrowTypeBasedOnMappingPattern(
}
const tdEntries = getTypedDictMembersForClass(evaluator, mappingSubtypeInfo.typedDict!);
const valueEntry = tdEntries.knownItems.get(keySubtype.literalValue as string);
const valueEntry = tdEntries.knownItems.get(keySubtype.priv.literalValue as string);
if (valueEntry) {
const narrowedValueType = narrowTypeBasedOnPattern(
evaluator,
@ -539,9 +545,9 @@ function narrowTypeBasedOnMappingPattern(
isTypeSame(mappingSubtypeInfo.subtype, mappingSubtypeInfo.typedDict!)
) {
const newNarrowedEntriesMap = new Map<string, TypedDictEntry>(
mappingSubtypeInfo.typedDict!.typedDictNarrowedEntries ?? []
mappingSubtypeInfo.typedDict!.priv.typedDictNarrowedEntries ?? []
);
newNarrowedEntriesMap.set(keySubtype.literalValue as string, {
newNarrowedEntriesMap.set(keySubtype.priv.literalValue as string, {
valueType: valueEntry.valueType,
isReadOnly: valueEntry.isReadOnly,
isRequired: false,
@ -607,9 +613,9 @@ function getPositionalMatchArgNames(evaluator: TypeEvaluator, type: ClassType):
isClassInstance(matchArgsType) &&
isTupleClass(matchArgsType) &&
!isUnboundedTupleClass(matchArgsType) &&
matchArgsType.tupleTypeArguments
matchArgsType.priv.tupleTypeArguments
) {
const tupleArgs = matchArgsType.tupleTypeArguments;
const tupleArgs = matchArgsType.priv.tupleTypeArguments;
// Are all the args string literals?
if (
@ -618,7 +624,7 @@ function getPositionalMatchArgNames(evaluator: TypeEvaluator, type: ClassType):
isClassInstance(arg.type) && ClassType.isBuiltIn(arg.type, 'str') && isLiteralType(arg.type)
)
) {
return tupleArgs.map((arg) => (arg.type as ClassType).literalValue as string);
return tupleArgs.map((arg) => (arg.type as ClassType).priv.literalValue as string);
}
}
}
@ -657,12 +663,12 @@ function narrowTypeBasedOnLiteralPattern(
if (
isClassInstance(expandedSubtype) &&
ClassType.isBuiltIn(expandedSubtype, 'bool') &&
expandedSubtype.literalValue === undefined &&
expandedSubtype.priv.literalValue === undefined &&
isClassInstance(literalType) &&
ClassType.isBuiltIn(literalType, 'bool') &&
literalType.literalValue !== undefined
literalType.priv.literalValue !== undefined
) {
return ClassType.cloneWithLiteral(literalType, !(literalType.literalValue as boolean));
return ClassType.cloneWithLiteral(literalType, !(literalType.priv.literalValue as boolean));
}
return expandedSubtype;
@ -721,7 +727,7 @@ function narrowTypeBasedOnClassPattern(
let classType = exprType;
if (classType.details.typeParameters.length > 0) {
if (classType.shared.typeParameters.length > 0) {
classType = ClassType.cloneForSpecialization(
classType,
/* typeArguments */ undefined,
@ -741,7 +747,7 @@ function narrowTypeBasedOnClassPattern(
// Handle the case where the class pattern references type() or a subtype thereof
// and the subject type is an instantiable class itself.
if (isPatternMetaclass && isInstantiableClass(subjectSubtypeExpanded)) {
const metaclass = subjectSubtypeExpanded.details.effectiveMetaclass ?? UnknownType.create();
const metaclass = subjectSubtypeExpanded.shared.effectiveMetaclass ?? UnknownType.create();
if (isInstantiableClass(classType) && evaluator.assignType(classType, metaclass)) {
return undefined;
}
@ -865,7 +871,7 @@ function narrowTypeBasedOnClassPattern(
unknownCallable,
/* useUnknown */ isUnknown(subjectSubtypeExpanded)
);
unknownCallable.details.declaredReturnType = subjectSubtypeExpanded;
unknownCallable.shared.declaredReturnType = subjectSubtypeExpanded;
return unknownCallable;
}
@ -875,7 +881,7 @@ function narrowTypeBasedOnClassPattern(
// Handle the case where the class pattern references type() or a subtype thereof
// and the subject type is a class itself.
if (isPatternMetaclass && isInstantiableClass(subjectSubtypeExpanded)) {
const metaclass = subjectSubtypeExpanded.details.effectiveMetaclass ?? UnknownType.create();
const metaclass = subjectSubtypeExpanded.shared.effectiveMetaclass ?? UnknownType.create();
if (
evaluator.assignType(expandedSubtype, metaclass) ||
evaluator.assignType(metaclass, expandedSubtype)
@ -928,7 +934,7 @@ function narrowTypeBasedOnClassPattern(
if (isInstantiableClass(unexpandedSubtype) && isClassInstance(subjectSubtypeExpanded)) {
if (
ClassType.isSpecialBuiltIn(unexpandedSubtype) ||
unexpandedSubtype.details.typeParameters.length > 0
unexpandedSubtype.shared.typeParameters.length > 0
) {
const typeVarContext = new TypeVarContext(getTypeVarScopeId(unexpandedSubtype));
const unspecializedMatchType = ClassType.cloneForSpecialization(
@ -1002,7 +1008,7 @@ function narrowTypeBasedOnClassPattern(
// Some built-in classes are treated as special cases for the class pattern
// if a positional argument is used.
function isClassSpecialCaseForClassPattern(classType: ClassType) {
if (classPatternSpecialCases.some((className) => classType.details.fullName === className)) {
if (classPatternSpecialCases.some((className) => classType.shared.fullName === className)) {
return true;
}
@ -1013,11 +1019,8 @@ function isClassSpecialCaseForClassPattern(classType: ClassType) {
}
// If the class derives from a built-in class, it is considered a special case.
for (const mroClass of classType.details.mro) {
if (
isClass(mroClass) &&
classPatternSpecialCases.some((className) => mroClass.details.fullName === className)
) {
for (const mroClass of classType.shared.mro) {
if (isClass(mroClass) && classPatternSpecialCases.some((className) => mroClass.shared.fullName === className)) {
return true;
}
}
@ -1061,7 +1064,7 @@ function narrowTypeOfClassPatternArgument(
if (isClassSpecialCaseForClassPattern(matchType)) {
useSelfForPattern = true;
} else if (positionalArgNames.length === 0) {
matchType.details.mro.forEach((mroClass) => {
matchType.shared.mro.forEach((mroClass) => {
if (isClass(mroClass) && isClassSpecialCaseForClassPattern(mroClass)) {
selfForPatternType = mroClass;
useSelfForPattern = true;
@ -1236,7 +1239,7 @@ function getMappingPatternInfo(evaluator: TypeEvaluator, type: Type, node: Patte
// Is it a subclass of Mapping?
let mroClassToSpecialize: ClassType | undefined;
for (const mroClass of concreteSubtype.details.mro) {
for (const mroClass of concreteSubtype.shared.mro) {
if (isInstantiableClass(mroClass) && ClassType.isBuiltIn(mroClass, 'Mapping')) {
mroClassToSpecialize = mroClass;
break;
@ -1246,14 +1249,14 @@ function getMappingPatternInfo(evaluator: TypeEvaluator, type: Type, node: Patte
if (mroClassToSpecialize) {
const specializedMapping = partiallySpecializeType(mroClassToSpecialize, concreteSubtype) as ClassType;
if (specializedMapping.typeArguments && specializedMapping.typeArguments.length >= 2) {
if (specializedMapping.priv.typeArguments && specializedMapping.priv.typeArguments.length >= 2) {
mappingInfo.push({
subtype,
isDefinitelyMapping: true,
isDefinitelyNotMapping: false,
dictTypeArgs: {
key: specializedMapping.typeArguments[0],
value: specializedMapping.typeArguments[1],
key: specializedMapping.priv.typeArguments[0],
value: specializedMapping.priv.typeArguments[1],
},
});
}
@ -1307,7 +1310,7 @@ function getSequencePatternInfo(
let pushedEntry = false;
if (isClassInstance(concreteSubtype)) {
for (const mroClass of concreteSubtype.details.mro) {
for (const mroClass of concreteSubtype.shared.mro) {
if (!isInstantiableClass(mroClass)) {
break;
}
@ -1343,7 +1346,7 @@ function getSequencePatternInfo(
const specializedSequence = partiallySpecializeType(mroClassToSpecialize, concreteSubtype) as ClassType;
if (isTupleClass(specializedSequence)) {
const typeArgs = specializedSequence.tupleTypeArguments ?? [
const typeArgs = specializedSequence.priv.tupleTypeArguments ?? [
{ type: UnknownType.create(), isUnbounded: true },
];
@ -1481,8 +1484,8 @@ function getSequencePatternInfo(
sequenceInfo.push({
subtype,
entryTypes: [
specializedSequence.typeArguments && specializedSequence.typeArguments.length > 0
? specializedSequence.typeArguments[0]
specializedSequence.priv.typeArguments && specializedSequence.priv.typeArguments.length > 0
? specializedSequence.priv.typeArguments[0]
: UnknownType.create(),
],
isIndeterminateLength: true,
@ -1514,10 +1517,10 @@ function getSequencePatternInfo(
sequenceTypeVarContext
) as ClassType;
if (specializedSequence.typeArguments && specializedSequence.typeArguments.length > 0) {
if (specializedSequence.priv.typeArguments && specializedSequence.priv.typeArguments.length > 0) {
sequenceInfo.push({
subtype,
entryTypes: [specializedSequence.typeArguments[0]],
entryTypes: [specializedSequence.priv.typeArguments[0]],
isIndeterminateLength: true,
isDefiniteNoMatch: false,
isPotentialNoMatch: true,
@ -1593,7 +1596,7 @@ function getTypeOfPatternSequenceEntry(
// its type other than it's "Unknown". We could evaluate it as an
// "object", but that will cause problems given that this type will
// be wrapped in a "list" below, and lists are invariant.
if (isVariadicTypeVar(type) && !type.isVariadicInUnion) {
if (isVariadicTypeVar(type) && !type.priv.isVariadicInUnion) {
return UnknownType.create();
}
@ -1741,7 +1744,7 @@ export function assignTypeToPatternTargets(
evaluator,
mappingSubtypeInfo.typedDict!
);
const valueInfo = tdEntries.knownItems.get(keySubtype.literalValue as string);
const valueInfo = tdEntries.knownItems.get(keySubtype.priv.literalValue as string);
valueTypes.push(valueInfo ? valueInfo.valueType : UnknownType.create());
} else {
valueTypes.push(UnknownType.create());
@ -1900,8 +1903,8 @@ export function validateClassPattern(evaluator: TypeEvaluator, pattern: PatternC
if (
exprType.props?.typeAliasInfo &&
isInstantiableClass(exprType) &&
exprType.typeArguments &&
exprType.isTypeArgumentExplicit
exprType.priv.typeArguments &&
exprType.priv.isTypeArgumentExplicit
) {
evaluator.addDiagnostic(
DiagnosticRule.reportGeneralTypeIssues,
@ -1951,7 +1954,7 @@ export function validateClassPattern(evaluator: TypeEvaluator, pattern: PatternC
evaluator.addDiagnostic(
DiagnosticRule.reportGeneralTypeIssues,
LocMessage.classPatternPositionalArgCount().format({
type: exprType.details.name,
type: exprType.shared.name,
expected: expectedPatternCount,
received: positionalPatternCount,
}),
@ -1997,7 +2000,7 @@ export function getPatternSubtypeNarrowingCallback(
doForEachSubtype(narrowedSubjectType, (subtype) => {
subtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
if (isClassInstance(subtype) && subtype.literalValue !== undefined) {
if (isClassInstance(subtype) && subtype.priv.literalValue !== undefined) {
if (ClassType.isBuiltIn(indexType, 'str')) {
typesToCombine.push(
narrowTypeForDiscriminatedDictEntryComparison(
@ -2055,11 +2058,11 @@ export function getPatternSubtypeNarrowingCallback(
if (
isClassInstance(subtype) &&
ClassType.isBuiltIn(subtype, 'tuple') &&
subtype.tupleTypeArguments &&
matchingEntryIndex < subtype.tupleTypeArguments.length &&
subtype.tupleTypeArguments.every((e) => !e.isUnbounded)
subtype.priv.tupleTypeArguments &&
matchingEntryIndex < subtype.priv.tupleTypeArguments.length &&
subtype.priv.tupleTypeArguments.every((e) => !e.isUnbounded)
) {
narrowedSubtypes.push(subtype.tupleTypeArguments[matchingEntryIndex].type);
narrowedSubtypes.push(subtype.priv.tupleTypeArguments[matchingEntryIndex].type);
} else if (isNever(narrowedSubjectType)) {
narrowedSubtypes.push(narrowedSubjectType);
} else {
@ -2096,7 +2099,7 @@ export function getPatternSubtypeNarrowingCallback(
}
const resultType = mapSubtypes(narrowedSubjectType, (literalSubtype) => {
assert(isClassInstance(literalSubtype) && literalSubtype.literalValue !== undefined);
assert(isClassInstance(literalSubtype) && literalSubtype.priv.literalValue !== undefined);
return narrowTypeForDiscriminatedLiteralFieldComparison(
evaluator,

152
packages/pyright-internal/src/analyzer/properties.ts
View File

@ -60,11 +60,11 @@ export function createProperty(
const typeMetaclass = evaluator.getBuiltInType(decoratorNode, 'type');
const typeSourceId = ClassType.isBuiltIn(decoratorType, 'property')
? getTypeSourceId(decoratorNode)
: decoratorType.details.typeSourceId;
: decoratorType.shared.typeSourceId;
const propertyClass = ClassType.createInstantiable(
decoratorType.details.name,
getClassFullName(decoratorNode, fileInfo.moduleName, `__property_${fget.details.name}`),
decoratorType.shared.name,
getClassFullName(decoratorNode, fileInfo.moduleName, `__property_${fget.shared.name}`),
fileInfo.moduleName,
fileInfo.fileUri,
ClassTypeFlags.PropertyClass | ClassTypeFlags.BuiltIn,
@ -73,10 +73,10 @@ export function createProperty(
isInstantiableClass(typeMetaclass) ? typeMetaclass : UnknownType.create()
);
propertyClass.details.declaration = decoratorType.details.declaration;
propertyClass.details.typeVarScopeId = decoratorType.details.typeVarScopeId;
propertyClass.shared.declaration = decoratorType.shared.declaration;
propertyClass.shared.typeVarScopeId = decoratorType.shared.typeVarScopeId;
const objectType = evaluator.getBuiltInType(decoratorNode, 'object');
propertyClass.details.baseClasses.push(isInstantiableClass(objectType) ? objectType : UnknownType.create());
propertyClass.shared.baseClasses.push(isInstantiableClass(objectType) ? objectType : UnknownType.create());
computeMroLinearization(propertyClass);
// Clone the symbol table of the old class type.
@ -92,19 +92,19 @@ export function createProperty(
});
const propertyObject = ClassType.cloneAsInstance(propertyClass);
propertyClass.isAsymmetricDescriptor = false;
propertyClass.priv.isAsymmetricDescriptor = false;
// Update the __set__ and __delete__ methods if present.
updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
// Fill in the fget method.
propertyObject.fgetInfo = {
methodType: FunctionType.cloneWithNewFlags(fget, fget.details.flags | FunctionTypeFlags.StaticMethod),
classType: fget.details.methodClass,
propertyObject.priv.fgetInfo = {
methodType: FunctionType.cloneWithNewFlags(fget, fget.shared.flags | FunctionTypeFlags.StaticMethod),
classType: fget.shared.methodClass,
};
if (FunctionType.isClassMethod(fget)) {
propertyClass.details.flags |= ClassTypeFlags.ClassProperty;
propertyClass.shared.flags |= ClassTypeFlags.ClassProperty;
}
// Fill in the __get__ method with an overload.
@ -127,8 +127,8 @@ export function clonePropertyWithSetter(
}
const classType = prop as ClassType;
const flagsToClone = classType.details.flags;
let isAsymmetricDescriptor = !!classType.isAsymmetricDescriptor;
const flagsToClone = classType.shared.flags;
let isAsymmetricDescriptor = !!classType.priv.isAsymmetricDescriptor;
// Verify parameters for fset.
// We'll skip this test if the diagnostic rule is disabled because it
@ -164,25 +164,25 @@ export function clonePropertyWithSetter(
}
const propertyClass = ClassType.createInstantiable(
classType.details.name,
classType.details.fullName,
classType.details.moduleName,
classType.shared.name,
classType.shared.fullName,
classType.shared.moduleName,
getFileInfo(errorNode).fileUri,
flagsToClone,
classType.details.typeSourceId,
classType.details.declaredMetaclass,
classType.details.effectiveMetaclass
classType.shared.typeSourceId,
classType.shared.declaredMetaclass,
classType.shared.effectiveMetaclass
);
propertyClass.details.declaration = classType.details.declaration;
propertyClass.details.typeVarScopeId = classType.details.typeVarScopeId;
propertyClass.shared.declaration = classType.shared.declaration;
propertyClass.shared.typeVarScopeId = classType.shared.typeVarScopeId;
const objectType = evaluator.getBuiltInType(errorNode, 'object');
propertyClass.details.baseClasses.push(isInstantiableClass(objectType) ? objectType : UnknownType.create());
propertyClass.shared.baseClasses.push(isInstantiableClass(objectType) ? objectType : UnknownType.create());
computeMroLinearization(propertyClass);
propertyClass.fgetInfo = classType.fgetInfo;
propertyClass.fdelInfo = classType.fdelInfo;
propertyClass.isAsymmetricDescriptor = isAsymmetricDescriptor;
propertyClass.priv.fgetInfo = classType.priv.fgetInfo;
propertyClass.priv.fdelInfo = classType.priv.fdelInfo;
propertyClass.priv.isAsymmetricDescriptor = isAsymmetricDescriptor;
const propertyObject = ClassType.cloneAsInstance(propertyClass);
// Clone the symbol table of the old class type.
@ -197,9 +197,9 @@ export function clonePropertyWithSetter(
updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
// Fill in the new fset method.
propertyObject.fsetInfo = {
methodType: FunctionType.cloneWithNewFlags(fset, fset.details.flags | FunctionTypeFlags.StaticMethod),
classType: fset.details.methodClass,
propertyObject.priv.fsetInfo = {
methodType: FunctionType.cloneWithNewFlags(fset, fset.shared.flags | FunctionTypeFlags.StaticMethod),
classType: fset.shared.methodClass,
};
// Fill in the __set__ method.
@ -223,26 +223,26 @@ export function clonePropertyWithDeleter(
const classType = prop as ClassType;
const propertyClass = ClassType.createInstantiable(
classType.details.name,
classType.details.fullName,
classType.details.moduleName,
classType.shared.name,
classType.shared.fullName,
classType.shared.moduleName,
getFileInfo(errorNode).fileUri,
classType.details.flags,
classType.details.typeSourceId,
classType.details.declaredMetaclass,
classType.details.effectiveMetaclass
classType.shared.flags,
classType.shared.typeSourceId,
classType.shared.declaredMetaclass,
classType.shared.effectiveMetaclass
);
propertyClass.details.declaration = classType.details.declaration;
propertyClass.details.typeVarScopeId = classType.details.typeVarScopeId;
propertyClass.shared.declaration = classType.shared.declaration;
propertyClass.shared.typeVarScopeId = classType.shared.typeVarScopeId;
const objectType = evaluator.getBuiltInType(errorNode, 'object');
propertyClass.details.baseClasses.push(isInstantiableClass(objectType) ? objectType : UnknownType.create());
propertyClass.shared.baseClasses.push(isInstantiableClass(objectType) ? objectType : UnknownType.create());
computeMroLinearization(propertyClass);
propertyClass.fgetInfo = classType.fgetInfo;
propertyClass.fsetInfo = classType.fsetInfo;
propertyClass.priv.fgetInfo = classType.priv.fgetInfo;
propertyClass.priv.fsetInfo = classType.priv.fsetInfo;
const propertyObject = ClassType.cloneAsInstance(propertyClass);
propertyClass.isAsymmetricDescriptor = classType.isAsymmetricDescriptor ?? false;
propertyClass.priv.isAsymmetricDescriptor = classType.priv.isAsymmetricDescriptor ?? false;
// Clone the symbol table of the old class type.
const fields = ClassType.getSymbolTable(propertyClass);
@ -256,9 +256,9 @@ export function clonePropertyWithDeleter(
updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
// Fill in the fdel method.
propertyObject.fdelInfo = {
methodType: FunctionType.cloneWithNewFlags(fdel, fdel.details.flags | FunctionTypeFlags.StaticMethod),
classType: fdel.details.methodClass,
propertyObject.priv.fdelInfo = {
methodType: FunctionType.cloneWithNewFlags(fdel, fdel.shared.flags | FunctionTypeFlags.StaticMethod),
classType: fdel.shared.methodClass,
};
// Fill in the __delete__ method.
@ -294,15 +294,15 @@ function addGetMethodToPropertySymbolTable(evaluator: TypeEvaluator, propertyObj
AnyType.create(/* isEllipsis */ true)
)
);
getFunction1.details.declaredReturnType = FunctionType.isClassMethod(fget)
getFunction1.shared.declaredReturnType = FunctionType.isClassMethod(fget)
? FunctionType.getEffectiveReturnType(fget)
: propertyObject;
getFunction1.details.declaration = fget.details.declaration;
getFunction1.details.deprecatedMessage = fget.details.deprecatedMessage;
getFunction1.shared.declaration = fget.shared.declaration;
getFunction1.shared.deprecatedMessage = fget.shared.deprecatedMessage;
// Override the scope ID since we're using parameter types from the
// decorated function.
getFunction1.details.typeVarScopeId = getTypeVarScopeId(fget);
getFunction1.shared.typeVarScopeId = getTypeVarScopeId(fget);
// The second overload is for accesses through a class instance.
const getFunction2 = FunctionType.createSynthesizedInstance('__get__', FunctionTypeFlags.Overloaded);
@ -312,7 +312,7 @@ function addGetMethodToPropertySymbolTable(evaluator: TypeEvaluator, propertyObj
);
const objType =
fget.details.parameters.length > 0 ? FunctionType.getEffectiveParameterType(fget, 0) : AnyType.create();
fget.shared.parameters.length > 0 ? FunctionType.getEffectiveParameterType(fget, 0) : AnyType.create();
FunctionType.addParameter(
getFunction2,
@ -329,13 +329,13 @@ function addGetMethodToPropertySymbolTable(evaluator: TypeEvaluator, propertyObj
AnyType.create(/* isEllipsis */ true)
)
);
getFunction2.details.declaredReturnType = FunctionType.getEffectiveReturnType(fget);
getFunction2.details.declaration = fget.details.declaration;
getFunction2.details.deprecatedMessage = fget.details.deprecatedMessage;
getFunction2.shared.declaredReturnType = FunctionType.getEffectiveReturnType(fget);
getFunction2.shared.declaration = fget.shared.declaration;
getFunction2.shared.deprecatedMessage = fget.shared.deprecatedMessage;
// Override the scope ID since we're using parameter types from the
// decorated function.
getFunction2.details.typeVarScopeId = getTypeVarScopeId(fget);
getFunction2.shared.typeVarScopeId = getTypeVarScopeId(fget);
// We previously placed getFunction1 before getFunction2, but this creates
// problems specifically for the `NoneType` class because None.__class__
@ -356,8 +356,8 @@ function addSetMethodToPropertySymbolTable(evaluator: TypeEvaluator, propertyObj
);
let objType =
fset.details.parameters.length > 0 ? FunctionType.getEffectiveParameterType(fset, 0) : AnyType.create();
if (isTypeVar(objType) && objType.details.isSynthesizedSelf) {
fset.shared.parameters.length > 0 ? FunctionType.getEffectiveParameterType(fset, 0) : AnyType.create();
if (isTypeVar(objType) && objType.shared.isSynthesizedSelf) {
objType = evaluator.makeTopLevelTypeVarsConcrete(objType);
}
@ -371,21 +371,21 @@ function addSetMethodToPropertySymbolTable(evaluator: TypeEvaluator, propertyObj
)
);
setFunction.details.declaredReturnType = evaluator.getNoneType();
setFunction.shared.declaredReturnType = evaluator.getNoneType();
// Adopt the TypeVarScopeId of the fset function in case it has any
// TypeVars that need to be solved.
setFunction.details.typeVarScopeId = getTypeVarScopeId(fset);
setFunction.details.deprecatedMessage = fset.details.deprecatedMessage;
setFunction.shared.typeVarScopeId = getTypeVarScopeId(fset);
setFunction.shared.deprecatedMessage = fset.shared.deprecatedMessage;
let setParamType: Type = UnknownType.create();
if (
fset.details.parameters.length >= 2 &&
fset.details.parameters[1].category === ParameterCategory.Simple &&
fset.details.parameters[1].name
fset.shared.parameters.length >= 2 &&
fset.shared.parameters[1].category === ParameterCategory.Simple &&
fset.shared.parameters[1].name
) {
setParamType = fset.details.parameters[1].type;
setParamType = fset.shared.parameters[1].type;
}
FunctionType.addParameter(
setFunction,
@ -406,13 +406,13 @@ function addDelMethodToPropertySymbolTable(evaluator: TypeEvaluator, propertyObj
// Adopt the TypeVarScopeId of the fdel function in case it has any
// TypeVars that need to be solved.
delFunction.details.typeVarScopeId = getTypeVarScopeId(fdel);
delFunction.details.deprecatedMessage = fdel.details.deprecatedMessage;
delFunction.shared.typeVarScopeId = getTypeVarScopeId(fdel);
delFunction.shared.deprecatedMessage = fdel.shared.deprecatedMessage;
let objType =
fdel.details.parameters.length > 0 ? FunctionType.getEffectiveParameterType(fdel, 0) : AnyType.create();
fdel.shared.parameters.length > 0 ? FunctionType.getEffectiveParameterType(fdel, 0) : AnyType.create();
if (isTypeVar(objType) && objType.details.isSynthesizedSelf) {
if (isTypeVar(objType) && objType.shared.isSynthesizedSelf) {
objType = evaluator.makeTopLevelTypeVarsConcrete(objType);
}
@ -425,23 +425,23 @@ function addDelMethodToPropertySymbolTable(evaluator: TypeEvaluator, propertyObj
'obj'
)
);
delFunction.details.declaredReturnType = evaluator.getNoneType();
delFunction.shared.declaredReturnType = evaluator.getNoneType();
const delSymbol = Symbol.createWithType(SymbolFlags.ClassMember, delFunction);
fields.set('__delete__', delSymbol);
}
function updateGetSetDelMethodForClonedProperty(evaluator: TypeEvaluator, propertyObject: ClassType) {
const fgetInfo = propertyObject.fgetInfo;
const fgetInfo = propertyObject.priv.fgetInfo;
if (fgetInfo && isFunction(fgetInfo.methodType)) {
addGetMethodToPropertySymbolTable(evaluator, propertyObject, fgetInfo.methodType);
}
const fsetInfo = propertyObject.fsetInfo;
const fsetInfo = propertyObject.priv.fsetInfo;
if (fsetInfo && isFunction(fsetInfo.methodType)) {
addSetMethodToPropertySymbolTable(evaluator, propertyObject, fsetInfo.methodType);
}
const fdelInfo = propertyObject.fdelInfo;
const fdelInfo = propertyObject.priv.fdelInfo;
if (fdelInfo && isFunction(fdelInfo.methodType)) {
addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdelInfo.methodType);
}
@ -466,7 +466,7 @@ function addDecoratorMethodsToPropertySymbolTable(propertyObject: ClassType) {
'accessor'
)
);
accessorFunction.details.declaredReturnType = propertyObject;
accessorFunction.shared.declaredReturnType = propertyObject;
const accessorSymbol = Symbol.createWithType(SymbolFlags.ClassMember, accessorFunction);
fields.set(accessorName, accessorSymbol);
});
@ -492,17 +492,17 @@ export function assignProperty(
incompatibleDiagMsg: () => string;
}[] = [
{
getFunction: (c: ClassType) => c.fgetInfo?.methodType,
getFunction: (c: ClassType) => c.priv.fgetInfo?.methodType,
missingDiagMsg: LocAddendum.missingGetter,
incompatibleDiagMsg: LocAddendum.incompatibleGetter,
},
{
getFunction: (c: ClassType) => c.fsetInfo?.methodType,
getFunction: (c: ClassType) => c.priv.fsetInfo?.methodType,
missingDiagMsg: LocAddendum.missingSetter,
incompatibleDiagMsg: LocAddendum.incompatibleSetter,
},
{
getFunction: (c: ClassType) => c.fdelInfo?.methodType,
getFunction: (c: ClassType) => c.priv.fdelInfo?.methodType,
missingDiagMsg: LocAddendum.missingDeleter,
incompatibleDiagMsg: LocAddendum.incompatibleDeleter,
},
@ -535,12 +535,12 @@ export function assignProperty(
// here and bind them to the associated objects.
destAccessType = FunctionType.cloneWithNewFlags(
destAccessType,
destAccessType.details.flags & ~FunctionTypeFlags.StaticMethod
destAccessType.shared.flags & ~FunctionTypeFlags.StaticMethod
);
srcAccessType = FunctionType.cloneWithNewFlags(
srcAccessType,
srcAccessType.details.flags & ~FunctionTypeFlags.StaticMethod
srcAccessType.shared.flags & ~FunctionTypeFlags.StaticMethod
);
const boundDestAccessType = evaluator.bindFunctionToClassOrObject(

40
packages/pyright-internal/src/analyzer/protocols.ts
View File

@ -178,7 +178,7 @@ export function isMethodOnlyProtocol(classType: ClassType): boolean {
}
// First check for data members in any protocol base classes.
for (const baseClass of classType.details.baseClasses) {
for (const baseClass of classType.shared.baseClasses) {
if (isClass(baseClass) && ClassType.isProtocolClass(baseClass) && !isMethodOnlyProtocol(baseClass)) {
return false;
}
@ -208,7 +208,7 @@ export function isProtocolUnsafeOverlap(evaluator: TypeEvaluator, protocol: Clas
let isUnsafeOverlap = true;
protocol.details.mro.forEach((mroClass) => {
protocol.shared.mro.forEach((mroClass) => {
if (!isUnsafeOverlap || !isInstantiableClass(mroClass) || !ClassType.isProtocolClass(mroClass)) {
return;
}
@ -237,8 +237,8 @@ function getProtocolCompatibility(
flags: AssignTypeFlags,
typeVarContext: TypeVarContext | undefined
): boolean | undefined {
const map = srcType.details.protocolCompatibility as Map<string, ProtocolCompatibility[]> | undefined;
const entries = map?.get(destType.details.fullName);
const map = srcType.shared.protocolCompatibility as Map<string, ProtocolCompatibility[]> | undefined;
const entries = map?.get(destType.shared.fullName);
if (entries === undefined) {
return undefined;
}
@ -262,16 +262,16 @@ function setProtocolCompatibility(
typeVarContext: TypeVarContext | undefined,
isCompatible: boolean
) {
let map = srcType.details.protocolCompatibility as Map<string, ProtocolCompatibility[]> | undefined;
let map = srcType.shared.protocolCompatibility as Map<string, ProtocolCompatibility[]> | undefined;
if (!map) {
map = new Map<string, ProtocolCompatibility[]>();
srcType.details.protocolCompatibility = map;
srcType.shared.protocolCompatibility = map;
}
let entries = map.get(destType.details.fullName);
let entries = map.get(destType.shared.fullName);
if (!entries) {
entries = [];
map.set(destType.details.fullName, entries);
map.set(destType.shared.fullName, entries);
}
entries.push({
@ -319,7 +319,7 @@ function assignClassToProtocolInternal(
if (isClass(srcType)) {
// If the srcType is conditioned on "self", use "Self" as the selfType.
// Otherwise use the class type for selfType.
if (srcType.props?.condition?.some((c) => c.typeVar.details.isSynthesizedSelf)) {
if (srcType.props?.condition?.some((c) => c.typeVar.shared.isSynthesizedSelf)) {
selfType = synthesizeTypeVarForSelfCls(
TypeBase.cloneForCondition(srcType, undefined),
/* isClsType */ false
@ -349,7 +349,7 @@ function assignClassToProtocolInternal(
? AssignTypeFlags.RetainLiteralsForTypeVar
: AssignTypeFlags.Default;
destType.details.mro.forEach((mroClass) => {
destType.shared.mro.forEach((mroClass) => {
if (!isInstantiableClass(mroClass) || !ClassType.isProtocolClass(mroClass)) {
return;
}
@ -403,10 +403,10 @@ function assignClassToProtocolInternal(
// Look in the metaclass first if we're treating the source as an instantiable class.
if (
sourceIsClassObject &&
srcType.details.effectiveMetaclass &&
isInstantiableClass(srcType.details.effectiveMetaclass)
srcType.shared.effectiveMetaclass &&
isInstantiableClass(srcType.shared.effectiveMetaclass)
) {
srcMemberInfo = lookUpClassMember(srcType.details.effectiveMetaclass, name);
srcMemberInfo = lookUpClassMember(srcType.shared.effectiveMetaclass, name);
if (srcMemberInfo) {
isMemberFromMetaclass = true;
}
@ -490,7 +490,7 @@ function assignClassToProtocolInternal(
isSrcReadOnly = true;
}
} else {
srcSymbol = srcType.fields.get(name);
srcSymbol = srcType.priv.fields.get(name);
if (!srcSymbol) {
diag?.addMessage(LocAddendum.protocolMemberMissing().format({ name }));
@ -716,7 +716,7 @@ function assignClassToProtocolInternal(
});
// If the dest protocol has type parameters, make sure the source type arguments match.
if (typesAreConsistent && destType.details.typeParameters.length > 0) {
if (typesAreConsistent && destType.shared.typeParameters.length > 0) {
// Create a specialized version of the protocol defined by the dest and
// make sure the resulting type args can be assigned.
const genericProtocolType = ClassType.cloneForSpecialization(
@ -726,7 +726,7 @@ function assignClassToProtocolInternal(
);
const specializedProtocolType = applySolvedTypeVars(genericProtocolType, protocolTypeVarContext) as ClassType;
if (destType.typeArguments) {
if (destType.priv.typeArguments) {
if (
!evaluator.assignTypeArguments(
destType,
@ -741,7 +741,7 @@ function assignClassToProtocolInternal(
typesAreConsistent = false;
}
} else if (destTypeVarContext && !destTypeVarContext.isLocked()) {
for (const typeParam of destType.details.typeParameters) {
for (const typeParam of destType.shared.typeParameters) {
const typeArgEntry = protocolTypeVarContext.getPrimarySignature().getTypeVar(typeParam);
if (typeArgEntry) {
@ -769,7 +769,7 @@ function createProtocolTypeVarContext(
): TypeVarContext {
const protocolTypeVarContext = new TypeVarContext(getTypeVarScopeId(destType));
destType.details.typeParameters.forEach((typeParam, index) => {
destType.shared.typeParameters.forEach((typeParam, index) => {
const entry = destTypeVarContext?.getPrimarySignature().getTypeVar(typeParam);
if (entry) {
@ -779,8 +779,8 @@ function createProtocolTypeVarContext(
entry.narrowBoundNoLiterals,
entry.wideBound
);
} else if (destType.typeArguments && index < destType.typeArguments.length) {
let typeArg = destType.typeArguments[index];
} else if (destType.priv.typeArguments && index < destType.priv.typeArguments.length) {
let typeArg = destType.priv.typeArguments[index];
let flags: AssignTypeFlags;
let hasUnsolvedTypeVars = requiresSpecialization(typeArg);

12
packages/pyright-internal/src/analyzer/sourceMapper.ts
View File

@ -518,10 +518,10 @@ export class SourceMapper {
return;
}
if (isFunction(type) && type.details.declaration) {
this._addClassOrFunctionDeclarations(type.details.declaration, result, recursiveDeclCache);
if (isFunction(type) && type.shared.declaration) {
this._addClassOrFunctionDeclarations(type.shared.declaration, result, recursiveDeclCache);
} else if (isOverloadedFunction(type)) {
for (const overloadDecl of type.overloads.map((o) => o.details.declaration).filter(isDefined)) {
for (const overloadDecl of type.priv.overloads.map((o) => o.shared.declaration).filter(isDefined)) {
this._addClassOrFunctionDeclarations(overloadDecl, result, recursiveDeclCache);
}
} else if (isInstantiableClass(type)) {
@ -601,13 +601,13 @@ export class SourceMapper {
useTypeAlias = false
) {
const fileUri =
useTypeAlias && type.props?.typeAliasInfo ? type.props.typeAliasInfo.fileUri : type.details.fileUri;
useTypeAlias && type.props?.typeAliasInfo ? type.props.typeAliasInfo.fileUri : type.shared.fileUri;
const sourceFiles = this._getSourceFiles(fileUri, /* stubToShadow */ undefined, originated);
const fullName =
useTypeAlias && type.props?.typeAliasInfo ? type.props.typeAliasInfo.fullName : type.details.fullName;
useTypeAlias && type.props?.typeAliasInfo ? type.props.typeAliasInfo.fullName : type.shared.fullName;
const moduleName =
useTypeAlias && type.props?.typeAliasInfo ? type.props.typeAliasInfo.moduleName : type.details.moduleName;
useTypeAlias && type.props?.typeAliasInfo ? type.props.typeAliasInfo.moduleName : type.shared.moduleName;
const fullClassName = fullName.substring(moduleName.length + 1 /* +1 for trailing dot */);
for (const sourceFile of sourceFiles) {

14
packages/pyright-internal/src/analyzer/tracePrinter.ts
View File

@ -63,31 +63,31 @@ export function createTracePrinter(roots: Uri[]): TracePrinter {
case TypeCategory.Class:
if (TypeBase.isInstantiable(type)) {
return `Class '${type.details.name}' (${type.details.moduleName})`;
return `Class '${type.shared.name}' (${type.shared.moduleName})`;
} else {
return `Object '${type.details.name}' (${type.details.moduleName})`;
return `Object '${type.shared.name}' (${type.shared.moduleName})`;
}
case TypeCategory.Function:
return `Function '${type.details.name}' (${type.details.moduleName})`;
return `Function '${type.shared.name}' (${type.shared.moduleName})`;
case TypeCategory.Module:
return `Module '${type.moduleName}' (${type.moduleName})`;
return `Module '${type.priv.moduleName}' (${type.priv.moduleName})`;
case TypeCategory.Never:
return `Never ${wrap(type.props?.typeAliasInfo?.fullName)}`;
case TypeCategory.OverloadedFunction:
return `OverloadedFunction [${type.overloads.map((o) => wrap(printType(o), '"')).join(',')}]`;
return `OverloadedFunction [${type.priv.overloads.map((o) => wrap(printType(o), '"')).join(',')}]`;
case TypeCategory.TypeVar:
return `TypeVar '${type.details.name}' ${wrap(type.props?.typeAliasInfo?.fullName)}`;
return `TypeVar '${type.shared.name}' ${wrap(type.props?.typeAliasInfo?.fullName)}`;
case TypeCategory.Unbound:
return `Unbound ${wrap(type.props?.typeAliasInfo?.fullName)}`;
case TypeCategory.Union:
return `Union [${type.subtypes.map((o) => wrap(printType(o), '"')).join(',')}]`;
return `Union [${type.priv.subtypes.map((o) => wrap(printType(o), '"')).join(',')}]`;
case TypeCategory.Unknown:
return `Unknown ${wrap(type.props?.typeAliasInfo?.fullName)}`;

40
packages/pyright-internal/src/analyzer/typeDocStringUtils.ts
View File

@ -53,19 +53,19 @@ const DefaultClassIteratorFlagsForFunctions =
function isInheritedFromBuiltin(type: FunctionType | OverloadedFunctionType, classType?: ClassType): boolean {
if (type.category === TypeCategory.OverloadedFunction) {
if (type.overloads.length === 0) {
if (type.priv.overloads.length === 0) {
return false;
}
type = type.overloads[0];
type = type.priv.overloads[0];
}
// Functions that are bound to a different type than where they
// were declared are inherited.
return (
!!type.details.methodClass &&
ClassType.isBuiltIn(type.details.methodClass) &&
!!type.boundToType &&
!ClassType.isBuiltIn(type.boundToType)
!!type.shared.methodClass &&
ClassType.isBuiltIn(type.shared.methodClass) &&
!!type.priv.boundToType &&
!ClassType.isBuiltIn(type.priv.boundToType)
);
}
@ -86,7 +86,7 @@ export function getFunctionDocStringInherited(
// Search mro
if (!docString && classType) {
const funcName = type.details.name;
const funcName = type.shared.name;
const memberIterator = getClassMemberIterator(classType, funcName, DefaultClassIteratorFlagsForFunctions);
for (const classMember of memberIterator) {
@ -103,7 +103,7 @@ export function getFunctionDocStringInherited(
}
}
return docString || type.details.docString;
return docString || type.shared.docString;
}
export function getOverloadedFunctionDocStringsInherited(
@ -128,8 +128,8 @@ export function getOverloadedFunctionDocStringsInherited(
}
// Search mro
if (classType && type.overloads.length > 0) {
const funcName = type.overloads[0].details.name;
if (classType && type.priv.overloads.length > 0) {
const funcName = type.priv.overloads[0].shared.name;
const memberIterator = getClassMemberIterator(classType, funcName, DefaultClassIteratorFlagsForFunctions);
for (const classMember of memberIterator) {
@ -220,9 +220,9 @@ export function getModuleDocString(
resolvedDecl: DeclarationBase | undefined,
sourceMapper: SourceMapper
) {
let docString = type.docString;
let docString = type.priv.docString;
if (!docString) {
const uri = resolvedDecl?.uri ?? type.fileUri;
const uri = resolvedDecl?.uri ?? type.priv.fileUri;
docString = getModuleDocStringFromUris([uri], sourceMapper);
}
@ -234,7 +234,7 @@ export function getClassDocString(
resolvedDecl: Declaration | undefined,
sourceMapper: SourceMapper
) {
let docString = classType.details.docString;
let docString = classType.shared.docString;
if (!docString && resolvedDecl && _isAnyClassDeclaration(resolvedDecl)) {
docString = isClassDeclaration(resolvedDecl) ? _getFunctionOrClassDeclsDocString([resolvedDecl]) : undefined;
if (!docString && resolvedDecl && isStubFile(resolvedDecl.uri)) {
@ -292,10 +292,10 @@ function _getOverloadedFunctionDocStrings(
}
const docStrings: string[] = [];
if (type.overloads.some((o) => o.details.docString)) {
type.overloads.forEach((overload) => {
if (overload.details.docString) {
docStrings.push(overload.details.docString);
if (type.priv.overloads.some((o) => o.shared.docString)) {
type.priv.overloads.forEach((overload) => {
if (overload.shared.docString) {
docStrings.push(overload.shared.docString);
}
});
} else if (resolvedDecl && isStubFile(resolvedDecl.uri) && isFunctionDeclaration(resolvedDecl)) {
@ -362,13 +362,13 @@ function _getFunctionDocString(type: Type, resolvedDecl: FunctionDeclaration | u
return undefined;
}
let docString = type.details.docString;
let docString = type.shared.docString;
if (!docString && resolvedDecl) {
docString = _getFunctionDocStringFromDeclaration(resolvedDecl, sourceMapper);
}
if (!docString && type.details.declaration) {
docString = _getFunctionDocStringFromDeclaration(type.details.declaration, sourceMapper);
if (!docString && type.shared.declaration) {
docString = _getFunctionDocStringFromDeclaration(type.shared.declaration, sourceMapper);
}
return docString;

1714
packages/pyright-internal/src/analyzer/typeEvaluator.ts
View File

File diff suppressed because it is too large Load Diff

181
packages/pyright-internal/src/analyzer/typeGuards.ts
View File

@ -249,7 +249,7 @@ export function getTypeNarrowingCallback(
if (
isClassInstance(rightType) &&
(ClassType.isEnumClass(rightType) || ClassType.isBuiltIn(rightType, 'bool')) &&
rightType.literalValue !== undefined
rightType.priv.literalValue !== undefined
) {
return (type: Type) => {
return {
@ -292,7 +292,7 @@ export function getTypeNarrowingCallback(
if (isClassInstance(indexType) && isLiteralType(indexType)) {
if (ClassType.isBuiltIn(indexType, 'str')) {
const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
if (isClassInstance(rightType) && rightType.literalValue !== undefined) {
if (isClassInstance(rightType) && rightType.priv.literalValue !== undefined) {
return (type: Type) => {
return {
type: narrowTypeForDiscriminatedDictEntryComparison(
@ -310,12 +310,12 @@ export function getTypeNarrowingCallback(
const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
const rightType = rightTypeResult.type;
if (isClassInstance(rightType) && rightType.literalValue !== undefined) {
if (isClassInstance(rightType) && rightType.priv.literalValue !== undefined) {
let canNarrow = false;
// Narrowing can be applied only for bool or enum literals.
if (ClassType.isBuiltIn(rightType, 'bool')) {
canNarrow = true;
} else if (rightType.literalValue instanceof EnumLiteral) {
} else if (rightType.priv.literalValue instanceof EnumLiteral) {
canNarrow = true;
}
@ -354,7 +354,7 @@ export function getTypeNarrowingCallback(
const rightType = rightTypeResult.type;
if (isClassInstance(rightType) && rightType.literalValue !== undefined) {
if (isClassInstance(rightType) && rightType.priv.literalValue !== undefined) {
return (type: Type) => {
return {
type: narrowTypeForLiteralComparison(
@ -432,7 +432,7 @@ export function getTypeNarrowingCallback(
const memberName = testExpression.leftExpression.memberName;
if (isClassInstance(rightType)) {
if (rightType.literalValue !== undefined || isNoneInstance(rightType)) {
if (rightType.priv.literalValue !== undefined || isNoneInstance(rightType)) {
return (type: Type) => {
return {
type: narrowTypeForDiscriminatedLiteralFieldComparison(
@ -462,7 +462,7 @@ export function getTypeNarrowingCallback(
if (
isClassInstance(rightType) &&
(ClassType.isEnumClass(rightType) || ClassType.isBuiltIn(rightType, 'bool')) &&
rightType.literalValue !== undefined
rightType.priv.literalValue !== undefined
) {
return (type: Type) => {
return {
@ -517,16 +517,16 @@ export function getTypeNarrowingCallback(
);
const callType = callTypeResult.type;
if (isFunction(callType) && callType.details.fullName === 'builtins.len') {
if (isFunction(callType) && callType.shared.fullName === 'builtins.len') {
const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
const rightType = rightTypeResult.type;
if (
isClassInstance(rightType) &&
typeof rightType.literalValue === 'number' &&
rightType.literalValue >= 0
typeof rightType.priv.literalValue === 'number' &&
rightType.priv.literalValue >= 0
) {
let tupleLength = rightType.literalValue;
let tupleLength = rightType.priv.literalValue;
// We'll treat <, <= and == as positive tests with >=, > and != as
// their negative counterparts.
@ -725,9 +725,9 @@ export function getTypeNarrowingCallback(
const isFunctionReturnTypeGuard = (type: FunctionType) => {
return (
type.details.declaredReturnType &&
isClassInstance(type.details.declaredReturnType) &&
ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'TypeIs'])
type.shared.declaredReturnType &&
isClassInstance(type.shared.declaredReturnType) &&
ClassType.isBuiltIn(type.shared.declaredReturnType, ['TypeGuard', 'TypeIs'])
);
};
@ -756,10 +756,10 @@ export function getTypeNarrowingCallback(
if (
isClassInstance(functionReturnType) &&
ClassType.isBuiltIn(functionReturnType, 'bool') &&
functionReturnType.typeGuardType
functionReturnType.priv.typeGuardType
) {
const isStrictTypeGuard = !!functionReturnType.isStrictTypeGuard;
const typeGuardType = functionReturnType.typeGuardType;
const isStrictTypeGuard = !!functionReturnType.priv.isStrictTypeGuard;
const typeGuardType = functionReturnType.priv.typeGuardType;
const isIncomplete = !!callTypeResult.isIncomplete || !!functionReturnTypeResult.isIncomplete;
return (type: Type) => {
@ -1009,16 +1009,16 @@ function narrowTypeForTruthiness(evaluator: TypeEvaluator, type: Type, isPositiv
function narrowTupleTypeForIsNone(evaluator: TypeEvaluator, type: Type, isPositiveTest: boolean, indexValue: number) {
return evaluator.mapSubtypesExpandTypeVars(type, /* options */ undefined, (subtype) => {
const tupleType = getSpecializedTupleType(subtype);
if (!tupleType || isUnboundedTupleClass(tupleType) || !tupleType.tupleTypeArguments) {
if (!tupleType || isUnboundedTupleClass(tupleType) || !tupleType.priv.tupleTypeArguments) {
return subtype;
}
const tupleLength = tupleType.tupleTypeArguments.length;
const tupleLength = tupleType.priv.tupleTypeArguments.length;
if (indexValue < 0 || indexValue >= tupleLength) {
return subtype;
}
const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.tupleTypeArguments[indexValue].type);
const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.priv.tupleTypeArguments[indexValue].type);
if (isPositiveTest) {
if (!evaluator.assignType(typeOfEntry, evaluator.getNoneType())) {
@ -1056,7 +1056,7 @@ function narrowTypeForIsNone(evaluator: TypeEvaluator, type: Type, isPositiveTes
// TypeVar. For all other cases (including constrained TypeVars),
// use the expanded subtype.
const adjustedSubtype =
isTypeVar(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
isTypeVar(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
? unexpandedSubtype
: subtype;
@ -1072,7 +1072,7 @@ function narrowTypeForIsNone(evaluator: TypeEvaluator, type: Type, isPositiveTes
if (isNoneInstance(subtype) === isPositiveTest) {
resultIncludesNoneSubtype = true;
if (isTypeVar(adjustedSubtype) && adjustedSubtype.details.isSynthesizedSelf) {
if (isTypeVar(adjustedSubtype) && adjustedSubtype.shared.isSynthesizedSelf) {
return adjustedSubtype;
}
@ -1112,7 +1112,7 @@ function narrowTypeForIsEllipsis(evaluator: TypeEvaluator, type: Type, isPositiv
// TypeVar. For all other cases (including constrained TypeVars),
// use the expanded subtype.
const adjustedSubtype =
isTypeVar(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
isTypeVar(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
? unexpandedSubtype
: subtype;
@ -1164,9 +1164,9 @@ function getIsInstanceClassTypes(
classTypeList.push(subtype);
} else if (
isFunction(subtype) &&
subtype.details.parameters.length === 2 &&
subtype.details.parameters[0].category === ParameterCategory.ArgsList &&
subtype.details.parameters[1].category === ParameterCategory.KwargsDict
subtype.shared.parameters.length === 2 &&
subtype.shared.parameters[0].category === ParameterCategory.ArgsList &&
subtype.shared.parameters[1].category === ParameterCategory.KwargsDict
) {
classTypeList.push(subtype);
} else {
@ -1181,8 +1181,8 @@ function getIsInstanceClassTypes(
}
if (isClass(type) && TypeBase.isInstance(type) && isTupleClass(type)) {
if (type.tupleTypeArguments) {
type.tupleTypeArguments.forEach((tupleEntry) => {
if (type.priv.tupleTypeArguments) {
type.priv.tupleTypeArguments.forEach((tupleEntry) => {
addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
});
}
@ -1208,14 +1208,14 @@ export function isIsinstanceFilterSuperclass(
concreteFilterType: ClassType,
isInstanceCheck: boolean
) {
if (isTypeVar(filterType) || concreteFilterType.literalValue !== undefined) {
if (isTypeVar(filterType) || concreteFilterType.priv.literalValue !== undefined) {
return isTypeSame(convertToInstance(filterType), varType);
}
// If the filter type represents all possible subclasses
// of a type, we can't make any statements about its superclass
// relationship with concreteVarType.
if (concreteFilterType.includeSubclasses) {
if (concreteFilterType.priv.includeSubclasses) {
return false;
}
@ -1348,7 +1348,7 @@ function narrowTypeForIsInstanceInternal(
// If the class was implicitly specialized (e.g. because its type
// parameters have default values), replace the default type arguments
// with Unknown.
if (concreteFilterType.typeArguments && !concreteFilterType.isTypeArgumentExplicit) {
if (concreteFilterType.priv.typeArguments && !concreteFilterType.priv.isTypeArgumentExplicit) {
concreteFilterType = specializeWithUnknownTypeArgs(
ClassType.cloneForSpecialization(
concreteFilterType,
@ -1404,7 +1404,7 @@ function narrowTypeForIsInstanceInternal(
// we haven't learned anything new about the variable type.
// If the varType is a Self or type[Self], retain the unnarrowedType.
if (isTypeVar(varType) && varType.details.isSynthesizedSelf) {
if (isTypeVar(varType) && varType.shared.isSynthesizedSelf) {
filteredTypes.push(addConditionToType(varType, conditions));
} else {
filteredTypes.push(addConditionToType(concreteVarType, conditions));
@ -1432,11 +1432,11 @@ function narrowTypeForIsInstanceInternal(
if (isClass(filterType)) {
if (
ClassType.isSpecialBuiltIn(filterType) ||
filterType.details.typeParameters.length > 0
filterType.shared.typeParameters.length > 0
) {
if (
!filterType.typeArguments ||
!filterType.isTypeArgumentExplicit ||
!filterType.priv.typeArguments ||
!filterType.priv.isTypeArgumentExplicit ||
!ClassType.isSameGenericClass(concreteVarType, filterType)
) {
const typeVarContext = new TypeVarContext(getTypeVarScopeId(filterType));
@ -1482,17 +1482,17 @@ function narrowTypeForIsInstanceInternal(
// be a mix-in class used with the other. In this case, we'll
// synthesize a new class type that represents an intersection of
// the two types.
const className = `<subclass of ${concreteVarType.details.name} and ${concreteFilterType.details.name}>`;
const className = `<subclass of ${concreteVarType.shared.name} and ${concreteFilterType.shared.name}>`;
const fileInfo = getFileInfo(errorNode);
// The effective metaclass of the intersection is the narrower of the two metaclasses.
let effectiveMetaclass = concreteVarType.details.effectiveMetaclass;
if (concreteFilterType.details.effectiveMetaclass) {
let effectiveMetaclass = concreteVarType.shared.effectiveMetaclass;
if (concreteFilterType.shared.effectiveMetaclass) {
if (
!effectiveMetaclass ||
evaluator.assignType(effectiveMetaclass, concreteFilterType.details.effectiveMetaclass)
evaluator.assignType(effectiveMetaclass, concreteFilterType.shared.effectiveMetaclass)
) {
effectiveMetaclass = concreteFilterType.details.effectiveMetaclass;
effectiveMetaclass = concreteFilterType.shared.effectiveMetaclass;
}
}
@ -1505,9 +1505,9 @@ function narrowTypeForIsInstanceInternal(
ParseTreeUtils.getTypeSourceId(errorNode),
/* declaredMetaclass */ undefined,
effectiveMetaclass,
concreteVarType.details.docString
concreteVarType.shared.docString
);
newClassType.details.baseClasses = [
newClassType.shared.baseClasses = [
ClassType.cloneAsInstantiable(concreteVarType),
concreteFilterType,
];
@ -1520,8 +1520,8 @@ function narrowTypeForIsInstanceInternal(
if (
isTypeVar(varType) &&
!varType.details.isParamSpec &&
varType.details.constraints.length === 0
!varType.shared.isParamSpec &&
varType.shared.constraints.length === 0
) {
newClassType = addConditionToType(newClassType, [
{ typeVar: varType, constraintIndex: 0 },
@ -1658,7 +1658,7 @@ function narrowTypeForIsInstanceInternal(
const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
if (isInstantiableClass(concreteFilterType)) {
const filterMetaclass = concreteFilterType.details.effectiveMetaclass;
const filterMetaclass = concreteFilterType.shared.effectiveMetaclass;
if (filterMetaclass && isInstantiableClass(filterMetaclass)) {
let isMetaclassOverlap = evaluator.assignType(
@ -1670,7 +1670,7 @@ function narrowTypeForIsInstanceInternal(
// This will normally be treated as type[Any], which is compatible with
// any metaclass, but we specifically want to treat type as the class
// type[object] in this case.
if (ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.isTypeArgumentExplicit) {
if (ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.priv.isTypeArgumentExplicit) {
if (!ClassType.isBuiltIn(metaclassType, 'type')) {
isMetaclassOverlap = false;
}
@ -1680,7 +1680,10 @@ function narrowTypeForIsInstanceInternal(
if (isPositiveTest) {
filteredTypes.push(filterType);
foundPositiveMatch = true;
} else if (!isTypeSame(metaclassType, filterMetaclass) || filterMetaclass.includeSubclasses) {
} else if (
!isTypeSame(metaclassType, filterMetaclass) ||
filterMetaclass.priv.includeSubclasses
) {
filteredTypes.push(metaclassType);
isMatchIndeterminate = true;
}
@ -1916,28 +1919,28 @@ function narrowTypeForTupleLength(
if (
!isClassInstance(concreteSubtype) ||
!isTupleClass(concreteSubtype) ||
!concreteSubtype.tupleTypeArguments
!concreteSubtype.priv.tupleTypeArguments
) {
return subtype;
}
// If the tuple contains a variadic TypeVar, we can't narrow it.
if (concreteSubtype.tupleTypeArguments.some((typeArg) => isUnpackedVariadicTypeVar(typeArg.type))) {
if (concreteSubtype.priv.tupleTypeArguments.some((typeArg) => isUnpackedVariadicTypeVar(typeArg.type))) {
return subtype;
}
// If the tuple contains no unbounded elements, then we know its length exactly.
if (!concreteSubtype.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
if (!concreteSubtype.priv.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
const tupleLengthMatches = isLessThanCheck
? concreteSubtype.tupleTypeArguments.length < lengthValue
: concreteSubtype.tupleTypeArguments.length === lengthValue;
? concreteSubtype.priv.tupleTypeArguments.length < lengthValue
: concreteSubtype.priv.tupleTypeArguments.length === lengthValue;
return tupleLengthMatches === isPositiveTest ? subtype : undefined;
}
// The tuple contains a "...". We'll expand this into as many elements as
// necessary to match the lengthValue.
const elementsToAdd = lengthValue - concreteSubtype.tupleTypeArguments.length + 1;
const elementsToAdd = lengthValue - concreteSubtype.priv.tupleTypeArguments.length + 1;
if (!isLessThanCheck) {
// If the specified length is smaller than the minimum length of this tuple,
@ -1954,7 +1957,7 @@ function narrowTypeForTupleLength(
}
// If this is a tuple related to an "*args: P.args" parameter, don't expand it.
if (isParamSpec(subtype) && subtype.paramSpecAccess) {
if (isParamSpec(subtype) && subtype.priv.paramSpecAccess) {
return subtype;
}
@ -1989,7 +1992,7 @@ function narrowTypeForTupleLength(
function expandUnboundedTupleElement(tupleType: ClassType, elementsToAdd: number, keepUnbounded: boolean) {
const tupleTypeArgs: TupleTypeArgument[] = [];
tupleType.tupleTypeArguments!.forEach((typeArg) => {
tupleType.priv.tupleTypeArguments!.forEach((typeArg) => {
if (!typeArg.isUnbounded) {
tupleTypeArgs.push(typeArg);
} else {
@ -2031,7 +2034,7 @@ function narrowTypeForContainerType(
if (
!isClassInstance(containerType) ||
!ClassType.isBuiltIn(containerType, 'tuple') ||
!containerType.tupleTypeArguments
!containerType.priv.tupleTypeArguments
) {
return referenceType;
}
@ -2039,7 +2042,7 @@ function narrowTypeForContainerType(
// Determine which tuple types can be eliminated. Only "None" and
// literal types can be handled here.
const typesToEliminate: Type[] = [];
containerType.tupleTypeArguments.forEach((tupleEntry) => {
containerType.priv.tupleTypeArguments.forEach((tupleEntry) => {
if (!tupleEntry.isUnbounded) {
if (isNoneInstance(tupleEntry.type)) {
typesToEliminate.push(tupleEntry.type);
@ -2055,7 +2058,7 @@ function narrowTypeForContainerType(
return mapSubtypes(referenceType, (referenceSubtype) => {
referenceSubtype = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
if (isClassInstance(referenceSubtype) && referenceSubtype.literalValue === undefined) {
if (isClassInstance(referenceSubtype) && referenceSubtype.priv.literalValue === undefined) {
// If we're able to enumerate all possible literal values
// (for bool or enum), we can eliminate all others in a negative test.
const allLiteralTypes = enumerateLiteralsForType(evaluator, referenceSubtype);
@ -2081,13 +2084,13 @@ export function getElementTypeForContainerNarrowing(containerType: Type) {
return undefined;
}
if (!containerType.typeArguments || containerType.typeArguments.length < 1) {
if (!containerType.priv.typeArguments || containerType.priv.typeArguments.length < 1) {
return undefined;
}
let elementType = containerType.typeArguments[0];
if (isTupleClass(containerType) && containerType.tupleTypeArguments) {
elementType = combineTypes(containerType.tupleTypeArguments.map((t) => t.type));
let elementType = containerType.priv.typeArguments[0];
if (isTupleClass(containerType) && containerType.priv.tupleTypeArguments) {
elementType = combineTypes(containerType.priv.tupleTypeArguments.map((t) => t.type));
}
return elementType;
@ -2188,7 +2191,7 @@ function narrowTypeForTypedDictKey(
if (isClassInstance(subtype) && ClassType.isTypedDictClass(subtype)) {
const entries = getTypedDictMembersForClass(evaluator, subtype, /* allowNarrowed */ true);
const tdEntry = entries.knownItems.get(literalKey.literalValue as string) ?? entries.extraItems;
const tdEntry = entries.knownItems.get(literalKey.priv.literalValue as string) ?? entries.extraItems;
if (isPositiveTest) {
if (!tdEntry) {
@ -2202,11 +2205,11 @@ function narrowTypeForTypedDictKey(
}
const newNarrowedEntriesMap = new Map<string, TypedDictEntry>(
subtype.typedDictNarrowedEntries ?? []
subtype.priv.typedDictNarrowedEntries ?? []
);
// Add the new entry.
newNarrowedEntriesMap.set(literalKey.literalValue as string, {
newNarrowedEntriesMap.set(literalKey.priv.literalValue as string, {
valueType: tdEntry.valueType,
isReadOnly: tdEntry.isReadOnly,
isRequired: false,
@ -2247,7 +2250,7 @@ export function narrowTypeForDiscriminatedDictEntryComparison(
const narrowedType = mapSubtypes(referenceType, (subtype) => {
if (isClassInstance(subtype) && ClassType.isTypedDictClass(subtype)) {
const symbolMap = getTypedDictMembersForClass(evaluator, subtype);
const tdEntry = symbolMap.knownItems.get(indexLiteralType.literalValue as string);
const tdEntry = symbolMap.knownItems.get(indexLiteralType.priv.literalValue as string);
if (tdEntry && isLiteralTypeOrUnion(tdEntry.valueType)) {
if (isPositiveTest) {
@ -2295,12 +2298,16 @@ export function narrowTypeForDiscriminatedTupleComparison(
isClassInstance(subtype) &&
ClassType.isTupleClass(subtype) &&
!isUnboundedTupleClass(subtype) &&
typeof indexLiteralType.literalValue === 'number' &&
typeof indexLiteralType.priv.literalValue === 'number' &&
isClassInstance(literalType)
) {
const indexValue = indexLiteralType.literalValue;
if (subtype.tupleTypeArguments && indexValue >= 0 && indexValue < subtype.tupleTypeArguments.length) {
const tupleEntryType = subtype.tupleTypeArguments[indexValue]?.type;
const indexValue = indexLiteralType.priv.literalValue;
if (
subtype.priv.tupleTypeArguments &&
indexValue >= 0 &&
indexValue < subtype.priv.tupleTypeArguments.length
) {
const tupleEntryType = subtype.priv.tupleTypeArguments[indexValue]?.type;
if (tupleEntryType && isLiteralTypeOrUnion(tupleEntryType)) {
if (isPositiveTest) {
return evaluator.assignType(tupleEntryType, literalType) ? subtype : undefined;
@ -2343,8 +2350,8 @@ export function narrowTypeForDiscriminatedLiteralFieldComparison(
// Handle the case where the field is a property
// that has a declared literal return type for its getter.
if (isClassInstance(subtype) && isClassInstance(memberType) && isProperty(memberType)) {
const getterType = memberType.fgetInfo?.methodType;
if (getterType && getterType.details.declaredReturnType) {
const getterType = memberType.priv.fgetInfo?.methodType;
if (getterType && getterType.shared.declaredReturnType) {
const getterReturnType = FunctionType.getEffectiveReturnType(getterType);
if (getterReturnType) {
memberType = getterReturnType;
@ -2431,10 +2438,10 @@ function narrowTypeForTypeIs(evaluator: TypeEvaluator, type: Type, classType: Cl
return addConditionToType(ClassType.cloneAsInstance(classType), subtype.props?.condition);
}
if (!classType.includeSubclasses) {
if (!classType.priv.includeSubclasses) {
return undefined;
}
} else if (!classType.includeSubclasses) {
} else if (!classType.priv.includeSubclasses) {
// If the class if marked final and it matches, then
// we can eliminate it in the negative case.
if (matches && ClassType.isFinal(subtype)) {
@ -2479,8 +2486,8 @@ function narrowTypeForClassComparison(
ClassType.isBuiltIn(concreteSubtype, 'type')
) {
concreteSubtype =
concreteSubtype.typeArguments && concreteSubtype.typeArguments.length > 0
? convertToInstantiable(concreteSubtype.typeArguments[0])
concreteSubtype.priv.typeArguments && concreteSubtype.priv.typeArguments.length > 0
? convertToInstantiable(concreteSubtype.priv.typeArguments[0])
: UnknownType.create();
}
@ -2502,11 +2509,11 @@ function narrowTypeForClassComparison(
/* isInstanceCheck */ false
);
if (!classType.includeSubclasses) {
if (!classType.priv.includeSubclasses) {
// Handle the case where the LHS and RHS operands are specific
// classes, as opposed to types that represent classes and their
// subclasses.
if (!concreteSubtype.includeSubclasses) {
if (!concreteSubtype.priv.includeSubclasses) {
return ClassType.isSameGenericClass(concreteSubtype, classType) ? classType : undefined;
}
@ -2566,7 +2573,7 @@ function narrowTypeForLiteralComparison(
return subtype;
} else if (isClassInstance(subtype) && ClassType.isSameGenericClass(literalType, subtype)) {
if (subtype.literalValue !== undefined) {
if (subtype.priv.literalValue !== undefined) {
const literalValueMatches = ClassType.isLiteralValueSame(subtype, literalType);
if ((literalValueMatches && !isPositiveTest) || (!literalValueMatches && isPositiveTest)) {
return undefined;
@ -2607,9 +2614,7 @@ export function enumerateLiteralsForType(evaluator: TypeEvaluator, type: ClassTy
if (ClassType.isEnumClass(type)) {
// Enum expansion doesn't apply to enum classes that derive
// from enum.Flag.
if (
type.details.baseClasses.some((baseClass) => isClass(baseClass) && ClassType.isBuiltIn(baseClass, 'Flag'))
) {
if (type.shared.baseClasses.some((baseClass) => isClass(baseClass) && ClassType.isBuiltIn(baseClass, 'Flag'))) {
return undefined;
}
@ -2624,7 +2629,7 @@ export function enumerateLiteralsForType(evaluator: TypeEvaluator, type: ClassTy
if (
isClassInstance(symbolType) &&
ClassType.isSameGenericClass(type, symbolType) &&
symbolType.literalValue !== undefined
symbolType.priv.literalValue !== undefined
) {
enumList.push(symbolType);
}
@ -2680,7 +2685,7 @@ function narrowTypeForCallable(
// The type appears to not be callable. It's possible that the
// two type is a subclass that is callable. We'll synthesize a
// new intersection type.
const className = `<callable subtype of ${subtype.details.name}>`;
const className = `<callable subtype of ${subtype.shared.name}>`;
const fileInfo = getFileInfo(errorNode);
let newClassType = ClassType.createInstantiable(
className,
@ -2690,10 +2695,10 @@ function narrowTypeForCallable(
ClassTypeFlags.None,
ParseTreeUtils.getTypeSourceId(errorNode),
/* declaredMetaclass */ undefined,
subtype.details.effectiveMetaclass,
subtype.details.docString
subtype.shared.effectiveMetaclass,
subtype.shared.docString
);
newClassType.details.baseClasses = [ClassType.cloneAsInstantiable(subtype)];
newClassType.shared.baseClasses = [ClassType.cloneAsInstantiable(subtype)];
computeMroLinearization(newClassType);
newClassType = addConditionToType(newClassType, subtype.props?.condition) as ClassType;
@ -2708,7 +2713,7 @@ function narrowTypeForCallable(
);
FunctionType.addParameter(callMethod, selfParam);
FunctionType.addDefaultParameters(callMethod);
callMethod.details.declaredReturnType = UnknownType.create();
callMethod.shared.declaredReturnType = UnknownType.create();
ClassType.getSymbolTable(newClassType).set(
'__call__',
Symbol.createWithType(SymbolFlags.ClassMember, callMethod)

154
packages/pyright-internal/src/analyzer/typePrinter.ts
View File

@ -127,8 +127,8 @@ export function printObjectTypeForClass(
const maxLiteralStringLength = 50;
export function isLiteralValueTruncated(type: ClassType): boolean {
if (typeof type.literalValue === 'string') {
if (type.literalValue.length > maxLiteralStringLength) {
if (typeof type.priv.literalValue === 'string') {
if (type.priv.literalValue.length > maxLiteralStringLength) {
return true;
}
}
@ -137,16 +137,16 @@ export function isLiteralValueTruncated(type: ClassType): boolean {
}
export function printLiteralValueTruncated(type: ClassType): string {
if (type.details.name === 'bytes') {
if (type.shared.name === 'bytes') {
return 'bytes';
}
assert(type.details.name === 'str');
assert(type.shared.name === 'str');
return 'LiteralString';
}
export function printLiteralValue(type: ClassType, quotation = "'"): string {
const literalValue = type.literalValue;
const literalValue = type.priv.literalValue;
if (literalValue === undefined) {
return '';
}
@ -160,7 +160,7 @@ export function printLiteralValue(type: ClassType, quotation = "'"): string {
effectiveLiteralValue = literalValue.substring(0, maxLiteralStringLength) + '…';
}
if (type.details.name === 'bytes') {
if (type.shared.name === 'bytes') {
let bytesString = '';
// There's no good built-in conversion routine in javascript to convert
@ -277,10 +277,10 @@ function printTypeInternal(
isVariadicTypeVar(typeParam) &&
isClassInstance(typeArg) &&
isTupleClass(typeArg) &&
typeArg.tupleTypeArguments &&
typeArg.tupleTypeArguments.every((typeArg) => !typeArg.isUnbounded)
typeArg.priv.tupleTypeArguments &&
typeArg.priv.tupleTypeArguments.every((typeArg) => !typeArg.isUnbounded)
) {
typeArg.tupleTypeArguments.forEach((tupleTypeArg) => {
typeArg.priv.tupleTypeArguments.forEach((tupleTypeArg) => {
argumentStrings!.push(
printTypeInternal(
tupleTypeArg.type,
@ -355,8 +355,8 @@ function printTypeInternal(
) {
// If this is a recursive TypeVar, we've already expanded it once, so
// just print its name at this point.
if (isTypeVar(type) && type.details.isSynthesized && type.details.recursiveTypeAliasName) {
return type.details.recursiveTypeAliasName;
if (isTypeVar(type) && type.shared.isSynthesized && type.shared.recursiveAlias) {
return type.shared.recursiveAlias.name;
}
if (aliasInfo) {
@ -418,12 +418,12 @@ function printTypeInternal(
if (printTypeFlags & PrintTypeFlags.PythonSyntax) {
return 'Any';
}
return `Module("${type.moduleName}")`;
return `Module("${type.priv.moduleName}")`;
}
case TypeCategory.Class: {
if (TypeBase.isInstance(type)) {
if (type.literalValue !== undefined) {
if (type.priv.literalValue !== undefined) {
if (isLiteralValueTruncated(type) && (printTypeFlags & PrintTypeFlags.PythonSyntax) !== 0) {
return printLiteralValueTruncated(type);
} else {
@ -442,7 +442,7 @@ function printTypeInternal(
} else {
let typeToWrap: string;
if (type.literalValue !== undefined) {
if (type.priv.literalValue !== undefined) {
if (isLiteralValueTruncated(type) && (printTypeFlags & PrintTypeFlags.PythonSyntax) !== 0) {
typeToWrap = printLiteralValueTruncated(type);
} else {
@ -550,18 +550,18 @@ function printTypeInternal(
: printTypeFlags;
// Start by matching possible type aliases to the subtypes.
if ((printTypeFlags & PrintTypeFlags.ExpandTypeAlias) === 0 && type.typeAliasSources) {
for (const typeAliasSource of type.typeAliasSources) {
if ((printTypeFlags & PrintTypeFlags.ExpandTypeAlias) === 0 && type.priv.typeAliasSources) {
for (const typeAliasSource of type.priv.typeAliasSources) {
let matchedAllSubtypes = true;
let allSubtypesPreviouslyHandled = true;
const indicesCoveredByTypeAlias = new Set<number>();
for (const sourceSubtype of typeAliasSource.subtypes) {
for (const sourceSubtype of typeAliasSource.priv.subtypes) {
let unionSubtypeIndex = 0;
let foundMatch = false;
const sourceSubtypeInstance = convertToInstance(sourceSubtype);
for (const unionSubtype of type.subtypes) {
for (const unionSubtype of type.priv.subtypes) {
if (isTypeSame(sourceSubtypeInstance, unionSubtype)) {
if (!subtypeHandledSet.has(unionSubtypeIndex)) {
allSubtypesPreviouslyHandled = false;
@ -596,7 +596,7 @@ function printTypeInternal(
}
}
const noneIndex = type.subtypes.findIndex((subtype) => isNoneInstance(subtype));
const noneIndex = type.priv.subtypes.findIndex((subtype) => isNoneInstance(subtype));
if (noneIndex >= 0 && !subtypeHandledSet.has(noneIndex)) {
const typeWithoutNone = removeNoneFromUnion(type);
if (isNever(typeWithoutNone)) {
@ -627,7 +627,7 @@ function printTypeInternal(
const literalClassStrings = new Set<string>();
doForEachSubtype(type, (subtype, index) => {
if (!subtypeHandledSet.has(index)) {
if (isClassInstance(subtype) && subtype.literalValue !== undefined) {
if (isClassInstance(subtype) && subtype.priv.literalValue !== undefined) {
if (
isLiteralValueTruncated(subtype) &&
(printTypeFlags & PrintTypeFlags.PythonSyntax) !== 0
@ -636,7 +636,7 @@ function printTypeInternal(
} else {
literalObjectStrings.add(printLiteralValue(subtype));
}
} else if (isInstantiableClass(subtype) && subtype.literalValue !== undefined) {
} else if (isInstantiableClass(subtype) && subtype.priv.literalValue !== undefined) {
if (
isLiteralValueTruncated(subtype) &&
(printTypeFlags & PrintTypeFlags.PythonSyntax) !== 0
@ -695,15 +695,15 @@ function printTypeInternal(
// This will confuse users. The exception is if it's a bound synthesized
// type, in which case we'll print the bound type. This is used for
// "self" and "cls" parameters.
if (type.details.isSynthesized) {
if (type.shared.isSynthesized) {
// If it's a synthesized type var used to implement recursive type
// aliases, return the type alias name.
if (type.details.recursiveTypeAliasName) {
if ((printTypeFlags & PrintTypeFlags.ExpandTypeAlias) !== 0 && type.details.boundType) {
if (type.shared.recursiveAlias) {
if ((printTypeFlags & PrintTypeFlags.ExpandTypeAlias) !== 0 && type.shared.boundType) {
return printTypeInternal(
TypeBase.isInstance(type)
? convertToInstance(type.details.boundType)
: type.details.boundType,
? convertToInstance(type.shared.boundType)
: type.shared.boundType,
printTypeFlags,
returnTypeCallback,
uniqueNameMap,
@ -711,15 +711,15 @@ function printTypeInternal(
recursionCount
);
}
return type.details.recursiveTypeAliasName;
return type.shared.recursiveAlias.name;
}
// If it's a synthesized type var used to implement `self` or `cls` types,
// print the type with a special character that indicates that the type
// is internally represented as a TypeVar.
if (type.details.isSynthesizedSelf && type.details.boundType) {
if (type.shared.isSynthesizedSelf && type.shared.boundType) {
let boundTypeString = printTypeInternal(
type.details.boundType,
type.shared.boundType,
printTypeFlags & ~PrintTypeFlags.ExpandTypeAlias,
returnTypeCallback,
uniqueNameMap,
@ -727,7 +727,7 @@ function printTypeInternal(
recursionCount
);
if (!isAnyOrUnknown(type.details.boundType)) {
if (!isAnyOrUnknown(type.shared.boundType)) {
if (printTypeFlags & PrintTypeFlags.PythonSyntax) {
boundTypeString = `Self`;
} else {
@ -747,24 +747,24 @@ function printTypeInternal(
: 'Unknown';
}
if (type.details.isParamSpec) {
if (type.shared.isParamSpec) {
const paramSpecText = _getReadableTypeVarName(
type,
(printTypeFlags & PrintTypeFlags.PythonSyntax) !== 0
);
if (type.paramSpecAccess) {
return `${paramSpecText}.${type.paramSpecAccess}`;
if (type.priv.paramSpecAccess) {
return `${paramSpecText}.${type.priv.paramSpecAccess}`;
}
return paramSpecText;
}
let typeVarName = _getReadableTypeVarName(type, (printTypeFlags & PrintTypeFlags.PythonSyntax) !== 0);
if (type.isVariadicUnpacked) {
if (type.priv.isVariadicUnpacked) {
typeVarName = _printUnpack(typeVarName, printTypeFlags);
}
if (type.isVariadicInUnion) {
if (type.priv.isVariadicInUnion) {
typeVarName = `Union[${typeVarName}]`;
}
@ -772,7 +772,7 @@ function printTypeInternal(
typeVarName = `${_printNestedInstantiable(type, typeVarName)}`;
}
if (!type.details.isVariadic && (printTypeFlags & PrintTypeFlags.PrintTypeVarVariance) !== 0) {
if (!type.shared.isVariadic && (printTypeFlags & PrintTypeFlags.PrintTypeVarVariance) !== 0) {
const varianceText = _getTypeVarVarianceText(type);
if (varianceText) {
typeVarName = `${typeVarName} (${varianceText})`;
@ -783,12 +783,12 @@ function printTypeInternal(
}
case TypeCategory.Never: {
return type.isNoReturn ? 'NoReturn' : 'Never';
return type.priv.isNoReturn ? 'NoReturn' : 'Never';
}
case TypeCategory.Any: {
const anyType = type;
return anyType.isEllipsis ? '...' : 'Any';
return anyType.priv.isEllipsis ? '...' : 'Any';
}
}
@ -812,12 +812,12 @@ function printFunctionType(
// Callable works only in cases where all parameters are positional-only.
let isPositionalParamsOnly = false;
if (typeWithoutParamSpec.details.parameters.length === 0) {
if (typeWithoutParamSpec.shared.parameters.length === 0) {
isPositionalParamsOnly = true;
} else {
if (typeWithoutParamSpec.details.parameters.every((param) => param.category === ParameterCategory.Simple)) {
if (typeWithoutParamSpec.shared.parameters.every((param) => param.category === ParameterCategory.Simple)) {
const lastParam =
typeWithoutParamSpec.details.parameters[typeWithoutParamSpec.details.parameters.length - 1];
typeWithoutParamSpec.shared.parameters[typeWithoutParamSpec.shared.parameters.length - 1];
if (!lastParam.name) {
isPositionalParamsOnly = true;
}
@ -840,7 +840,7 @@ function printFunctionType(
if (isPositionalParamsOnly) {
const paramTypes: string[] = [];
typeWithoutParamSpec.details.parameters.forEach((param, index) => {
typeWithoutParamSpec.shared.parameters.forEach((param, index) => {
if (param.name) {
const paramType = FunctionType.getEffectiveParameterType(typeWithoutParamSpec, index);
if (recursionTypes.length < maxTypeRecursionCount) {
@ -863,11 +863,11 @@ function printFunctionType(
if (paramSpec) {
if (paramTypes.length > 0) {
return `Callable[Concatenate[${paramTypes.join(', ')}, ${
paramSpec.details.name
paramSpec.shared.name
}], ${returnTypeString}]`;
}
return `Callable[${paramSpec.details.name}, ${returnTypeString}]`;
return `Callable[${paramSpec.shared.name}, ${returnTypeString}]`;
}
return `Callable[[${paramTypes.join(', ')}], ${returnTypeString}]`;
@ -913,10 +913,10 @@ function printObjectTypeForClassInternal(
recursionTypes: Type[],
recursionCount: number
): string {
let objName = type.aliasName;
let objName = type.priv.aliasName;
if (!objName) {
objName =
(printTypeFlags & PrintTypeFlags.UseFullyQualifiedNames) !== 0 ? type.details.fullName : type.details.name;
(printTypeFlags & PrintTypeFlags.UseFullyQualifiedNames) !== 0 ? type.shared.fullName : type.shared.name;
}
// Special-case NoneType to convert it to None.
@ -926,7 +926,7 @@ function printObjectTypeForClassInternal(
// Use the fully-qualified name if the name isn't unique.
if (!uniqueNameMap.isUnique(objName)) {
objName = type.details.fullName;
objName = type.shared.fullName;
}
// If this is a pseudo-generic class, don't display the type arguments
@ -934,12 +934,12 @@ function printObjectTypeForClassInternal(
if (!ClassType.isPseudoGenericClass(type)) {
const typeParams = ClassType.getTypeParameters(type);
const lastTypeParam = typeParams.length > 0 ? typeParams[typeParams.length - 1] : undefined;
const isVariadic = lastTypeParam ? lastTypeParam.details.isVariadic : false;
const isVariadic = lastTypeParam ? lastTypeParam.shared.isVariadic : false;
// If there is a type arguments array, it's a specialized class.
const typeArgs: TupleTypeArgument[] | undefined =
type.tupleTypeArguments ??
type.typeArguments?.map((t) => {
type.priv.tupleTypeArguments ??
type.priv.typeArguments?.map((t) => {
return { type: t, isUnbounded: false };
});
if (typeArgs) {
@ -952,13 +952,13 @@ function printObjectTypeForClassInternal(
const typeParam = index < typeParams.length ? typeParams[index] : undefined;
if (
typeParam &&
typeParam.details.isVariadic &&
typeParam.shared.isVariadic &&
isClassInstance(typeArg.type) &&
ClassType.isBuiltIn(typeArg.type, 'tuple') &&
typeArg.type.tupleTypeArguments
typeArg.type.priv.tupleTypeArguments
) {
// Expand the tuple type that maps to the variadic type parameter.
if (typeArg.type.tupleTypeArguments.length === 0) {
if (typeArg.type.priv.tupleTypeArguments.length === 0) {
if (!isUnknown(typeArg.type)) {
isAllUnknown = false;
}
@ -969,7 +969,7 @@ function printObjectTypeForClassInternal(
} else {
appendArray(
typeArgStrings,
typeArg.type.tupleTypeArguments.map((typeArg) => {
typeArg.type.priv.tupleTypeArguments.map((typeArg) => {
if (!isUnknown(typeArg.type)) {
isAllUnknown = false;
}
@ -1017,7 +1017,7 @@ function printObjectTypeForClassInternal(
}
});
if (type.isUnpacked) {
if (type.priv.isUnpacked) {
objName = _printUnpack(objName, printTypeFlags);
}
@ -1025,7 +1025,7 @@ function printObjectTypeForClassInternal(
objName += '[' + typeArgStrings.join(', ') + ']';
}
} else {
if (type.isUnpacked) {
if (type.priv.isUnpacked) {
objName = _printUnpack(objName, printTypeFlags);
}
@ -1034,7 +1034,7 @@ function printObjectTypeForClassInternal(
}
}
} else {
if (type.isUnpacked) {
if (type.priv.isUnpacked) {
objName = _printUnpack(objName, printTypeFlags);
}
@ -1064,7 +1064,7 @@ function printObjectTypeForClassInternal(
}
// Wrap in a "Partial" for TypedDict that has been synthesized as partial.
if (type.isTypedDictPartial) {
if (type.priv.isTypedDictPartial) {
if ((printTypeFlags & PrintTypeFlags.PythonSyntax) === 0) {
objName = `Partial[${objName}]`;
}
@ -1083,7 +1083,7 @@ function printFunctionPartsInternal(
): [string[], string] {
const paramTypeStrings: string[] = [];
let sawDefinedName = false;
const functionNode = type.details.declaration?.node;
const functionNode = type.shared.declaration?.node;
// Remove the (*args: P.args, **kwargs: P.kwargs) from the end of the parameter list.
const paramSpec = FunctionType.getParamSpecFromArgsKwargs(type);
@ -1091,10 +1091,10 @@ function printFunctionPartsInternal(
type = FunctionType.cloneRemoveParamSpecArgsKwargs(type);
}
type.details.parameters.forEach((param, index) => {
type.shared.parameters.forEach((param, index) => {
// Handle specialized variadic type parameters specially.
if (
index === type.details.parameters.length - 1 &&
index === type.shared.parameters.length - 1 &&
param.category === ParameterCategory.ArgsList &&
isVariadicTypeVar(param.type)
) {
@ -1102,9 +1102,9 @@ function printFunctionPartsInternal(
if (
isClassInstance(specializedParamType) &&
ClassType.isBuiltIn(specializedParamType, 'tuple') &&
specializedParamType.tupleTypeArguments
specializedParamType.priv.tupleTypeArguments
) {
specializedParamType.tupleTypeArguments.forEach((paramType) => {
specializedParamType.priv.tupleTypeArguments.forEach((paramType) => {
const paramString = printTypeInternal(
paramType.type,
printTypeFlags,
@ -1125,7 +1125,7 @@ function printFunctionPartsInternal(
printTypeFlags & PrintTypeFlags.ExpandTypedDictArgs &&
param.type.category === TypeCategory.Class
) {
param.type.details.typedDictEntries!.knownItems.forEach((v, k) => {
param.type.shared.typedDictEntries!.knownItems.forEach((v, k) => {
const valueTypeString = printTypeInternal(
v.valueType,
printTypeFlags,
@ -1303,14 +1303,14 @@ function _printNestedInstantiable(type: Type, textToWrap: string) {
function _getReadableTypeVarName(type: TypeVarType, usePythonSyntax: boolean) {
if (usePythonSyntax) {
return type.details.name;
return type.shared.name;
}
return TypeVarType.getReadableName(type);
}
function _getTypeVarVarianceText(type: TypeVarType) {
const computedVariance = type.computedVariance ?? type.details.declaredVariance;
const computedVariance = type.priv.computedVariance ?? type.shared.declaredVariance;
if (computedVariance === Variance.Invariant) {
return 'invariant';
}
@ -1380,7 +1380,7 @@ class UniqueNameMap {
switch (type.category) {
case TypeCategory.Function: {
type.details.parameters.forEach((_, index) => {
type.shared.parameters.forEach((_, index) => {
const paramType = FunctionType.getEffectiveParameterType(type, index);
this.build(paramType, recursionTypes, recursionCount);
});
@ -1391,34 +1391,34 @@ class UniqueNameMap {
}
case TypeCategory.OverloadedFunction: {
type.overloads.forEach((overload) => {
type.priv.overloads.forEach((overload) => {
this.build(overload, recursionTypes, recursionCount);
});
break;
}
case TypeCategory.Class: {
if (type.literalValue !== undefined) {
if (type.priv.literalValue !== undefined) {
break;
}
let className = type.aliasName;
let className = type.priv.aliasName;
if (!className) {
className =
(this._printTypeFlags & PrintTypeFlags.UseFullyQualifiedNames) !== 0
? type.details.fullName
: type.details.name;
? type.shared.fullName
: type.shared.name;
}
this._addIfUnique(className, type);
if (!ClassType.isPseudoGenericClass(type)) {
if (type.tupleTypeArguments) {
type.tupleTypeArguments.forEach((typeArg) => {
if (type.priv.tupleTypeArguments) {
type.priv.tupleTypeArguments.forEach((typeArg) => {
this.build(typeArg.type, recursionTypes, recursionCount);
});
} else if (type.typeArguments) {
type.typeArguments.forEach((typeArg) => {
} else if (type.priv.typeArguments) {
type.priv.typeArguments.forEach((typeArg) => {
this.build(typeArg, recursionTypes, recursionCount);
});
}
@ -1431,7 +1431,7 @@ class UniqueNameMap {
this.build(subtype, recursionTypes, recursionCount);
});
type.typeAliasSources?.forEach((typeAliasSource) => {
type.priv.typeAliasSources?.forEach((typeAliasSource) => {
this.build(typeAliasSource, recursionTypes, recursionCount);
});
break;

703
packages/pyright-internal/src/analyzer/typeUtils.ts
View File

File diff suppressed because it is too large Load Diff

16
packages/pyright-internal/src/analyzer/typeVarContext.ts
View File

@ -269,8 +269,8 @@ export class TypeVarSignatureContext {
// If this union has a very large number of subtypes, don't bother
// accurately computing the score. Assume a fixed value.
if (type.subtypes.length < 16) {
type.subtypes.forEach((subtype) => {
if (type.priv.subtypes.length < 16) {
type.priv.subtypes.forEach((subtype) => {
const subtypeScore = this._getComplexityScoreForType(subtype, recursionCount);
maxScore = Math.max(maxScore, subtypeScore);
});
@ -294,18 +294,18 @@ export class TypeVarSignatureContext {
let typeArgScoreSum = 0;
let typeArgCount = 0;
if (classType.tupleTypeArguments) {
classType.tupleTypeArguments.forEach((typeArg) => {
if (classType.priv.tupleTypeArguments) {
classType.priv.tupleTypeArguments.forEach((typeArg) => {
typeArgScoreSum += this._getComplexityScoreForType(typeArg.type, recursionCount);
typeArgCount++;
});
} else if (classType.typeArguments) {
classType.typeArguments.forEach((type) => {
} else if (classType.priv.typeArguments) {
classType.priv.typeArguments.forEach((type) => {
typeArgScoreSum += this._getComplexityScoreForType(type, recursionCount);
typeArgCount++;
});
} else if (classType.details.typeParameters) {
classType.details.typeParameters.forEach((type) => {
} else if (classType.shared.typeParameters) {
classType.shared.typeParameters.forEach((type) => {
typeArgScoreSum += this._getComplexityScoreForType(AnyType.create(), recursionCount);
typeArgCount++;
});

12
packages/pyright-internal/src/analyzer/typeWalker.ts
View File

@ -137,9 +137,9 @@ export class TypeWalker {
}
visitFunction(type: FunctionType): void {
for (let i = 0; i < type.details.parameters.length; i++) {
for (let i = 0; i < type.shared.parameters.length; i++) {
// Ignore parameters such as "*" that have no name.
if (type.details.parameters[i].name) {
if (type.shared.parameters[i].name) {
const paramType = FunctionType.getEffectiveParameterType(type, i);
this.walk(paramType);
if (this._isWalkCanceled) {
@ -149,7 +149,7 @@ export class TypeWalker {
}
if (!this._isWalkCanceled && !FunctionType.isParamSpecValue(type) && !FunctionType.isParamSpecValue(type)) {
const returnType = type.details.declaredReturnType ?? type.inferredReturnType;
const returnType = type.shared.declaredReturnType ?? type.priv.inferredReturnType;
if (returnType) {
this.walk(returnType);
}
@ -157,7 +157,7 @@ export class TypeWalker {
}
visitOverloadedFunction(type: OverloadedFunctionType): void {
for (const overload of type.overloads) {
for (const overload of type.priv.overloads) {
this.walk(overload);
if (this._isWalkCanceled) {
break;
@ -167,7 +167,7 @@ export class TypeWalker {
visitClass(type: ClassType): void {
if (!ClassType.isPseudoGenericClass(type)) {
const typeArgs = type.tupleTypeArguments?.map((t) => t.type) || type.typeArguments;
const typeArgs = type.priv.tupleTypeArguments?.map((t) => t.type) || type.priv.typeArguments;
if (typeArgs) {
for (const argType of typeArgs) {
this.walk(argType);
@ -184,7 +184,7 @@ export class TypeWalker {
}
visitUnion(type: UnionType): void {
for (const subtype of type.subtypes) {
for (const subtype of type.priv.subtypes) {
this.walk(subtype);
if (this._isWalkCanceled) {
break;

98
packages/pyright-internal/src/analyzer/typedDicts.ts
View File

@ -109,9 +109,9 @@ export function createTypedDictType(
ClassTypeFlags.TypedDictClass | ClassTypeFlags.ValidTypeAliasClass,
ParseTreeUtils.getTypeSourceId(errorNode),
/* declaredMetaclass */ undefined,
typedDictClass.details.effectiveMetaclass
typedDictClass.shared.effectiveMetaclass
);
classType.details.baseClasses.push(typedDictClass);
classType.shared.baseClasses.push(typedDictClass);
computeMroLinearization(classType);
const classFields = ClassType.getSymbolTable(classType);
@ -195,11 +195,11 @@ export function createTypedDictType(
arg.valueExpression || errorNode
);
} else if (arg.name.value === 'total' && arg.valueExpression.constType === KeywordType.False) {
classType.details.flags |= ClassTypeFlags.CanOmitDictValues;
classType.shared.flags |= ClassTypeFlags.CanOmitDictValues;
} else if (arg.name.value === 'closed' && arg.valueExpression.constType === KeywordType.True) {
// This is an experimental feature because PEP 728 hasn't been accepted yet.
if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
classType.details.flags |=
classType.shared.flags |=
ClassTypeFlags.TypedDictMarkedClosed | ClassTypeFlags.TypedDictEffectivelyClosed;
}
}
@ -250,8 +250,8 @@ export function synthesizeTypedDictClassMethods(
FunctionParam.create(ParameterCategory.Simple, classType, FunctionParamFlags.TypeDeclared, 'cls')
);
FunctionType.addDefaultParameters(newType);
newType.details.declaredReturnType = ClassType.cloneAsInstance(classType);
newType.constructorTypeVarScopeId = getTypeVarScopeId(classType);
newType.shared.declaredReturnType = ClassType.cloneAsInstance(classType);
newType.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
// Synthesize an __init__ method with two overrides.
const initOverride1 = FunctionType.createSynthesizedInstance('__init__', FunctionTypeFlags.Overloaded);
@ -264,8 +264,8 @@ export function synthesizeTypedDictClassMethods(
'self'
)
);
initOverride1.details.declaredReturnType = evaluator.getNoneType();
initOverride1.constructorTypeVarScopeId = getTypeVarScopeId(classType);
initOverride1.shared.declaredReturnType = evaluator.getNoneType();
initOverride1.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
// The first parameter must be positional-only.
FunctionType.addParameter(
@ -292,8 +292,8 @@ export function synthesizeTypedDictClassMethods(
'self'
)
);
initOverride2.details.declaredReturnType = evaluator.getNoneType();
initOverride2.constructorTypeVarScopeId = getTypeVarScopeId(classType);
initOverride2.shared.declaredReturnType = evaluator.getNoneType();
initOverride2.priv.constructorTypeVarScopeId = getTypeVarScopeId(classType);
// All parameters must be named, so insert an empty "*".
FunctionType.addKeywordOnlyParameterSeparator(initOverride2);
@ -372,8 +372,8 @@ export function synthesizeTypedDictClassMethods(
let defaultTypeVar = TypeVarType.createInstance(`__TDefault`);
defaultTypeVar = TypeVarType.cloneForScopeId(
defaultTypeVar,
func.details.typeVarScopeId!,
classType.details.name,
func.shared.typeVarScopeId!,
classType.shared.name,
TypeVarScopeType.Function
);
return defaultTypeVar;
@ -388,7 +388,7 @@ export function synthesizeTypedDictClassMethods(
) {
const getOverload = FunctionType.createSynthesizedInstance('get', FunctionTypeFlags.Overloaded);
FunctionType.addParameter(getOverload, selfParam);
getOverload.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
getOverload.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
FunctionType.addParameter(
getOverload,
FunctionParam.create(ParameterCategory.Simple, keyType, FunctionParamFlags.TypeDeclared, 'k')
@ -423,9 +423,9 @@ export function synthesizeTypedDictClassMethods(
'default'
)
);
getOverload.details.declaredReturnType = returnType;
getOverload.shared.declaredReturnType = returnType;
} else {
getOverload.details.declaredReturnType = isEntryRequired
getOverload.shared.declaredReturnType = isEntryRequired
? valueType
: combineTypes([valueType, evaluator.getNoneType()]);
}
@ -443,12 +443,12 @@ export function synthesizeTypedDictClassMethods(
const popOverload1 = FunctionType.createSynthesizedInstance('pop', FunctionTypeFlags.Overloaded);
FunctionType.addParameter(popOverload1, selfParam);
FunctionType.addParameter(popOverload1, keyParam);
popOverload1.details.declaredReturnType = valueType;
popOverload1.shared.declaredReturnType = valueType;
const popOverload2 = FunctionType.createSynthesizedInstance('pop', FunctionTypeFlags.Overloaded);
FunctionType.addParameter(popOverload2, selfParam);
FunctionType.addParameter(popOverload2, keyParam);
popOverload2.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
popOverload2.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
const defaultTypeVar = createDefaultTypeVar(popOverload2);
let defaultParamType: Type;
@ -474,7 +474,7 @@ export function synthesizeTypedDictClassMethods(
defaultParamType
)
);
popOverload2.details.declaredReturnType = returnType;
popOverload2.shared.declaredReturnType = returnType;
return [popOverload1, popOverload2];
}
@ -492,7 +492,7 @@ export function synthesizeTypedDictClassMethods(
setDefaultOverload,
FunctionParam.create(ParameterCategory.Simple, valueType, FunctionParamFlags.TypeDeclared, 'default')
);
setDefaultOverload.details.declaredReturnType = valueType;
setDefaultOverload.shared.declaredReturnType = valueType;
return setDefaultOverload;
}
@ -503,7 +503,7 @@ export function synthesizeTypedDictClassMethods(
delItemOverload,
FunctionParam.create(ParameterCategory.Simple, keyType, FunctionParamFlags.TypeDeclared, 'k')
);
delItemOverload.details.declaredReturnType = evaluator.getNoneType();
delItemOverload.shared.declaredReturnType = evaluator.getNoneType();
return delItemOverload;
}
@ -536,9 +536,9 @@ export function synthesizeTypedDictClassMethods(
FunctionType.addPositionOnlyParameterSeparator(updateMethod1);
FunctionType.addKeywordOnlyParameterSeparator(updateMethod3);
updateMethod1.details.declaredReturnType = evaluator.getNoneType();
updateMethod2.details.declaredReturnType = evaluator.getNoneType();
updateMethod3.details.declaredReturnType = evaluator.getNoneType();
updateMethod1.shared.declaredReturnType = evaluator.getNoneType();
updateMethod2.shared.declaredReturnType = evaluator.getNoneType();
updateMethod3.shared.declaredReturnType = evaluator.getNoneType();
const tuplesToCombine: Type[] = [];
const tupleClass = evaluator.getBuiltInType(node, 'tuple');
@ -687,7 +687,7 @@ export function synthesizeTypedDictClassMethods(
if (dictValueType) {
const clearMethod = FunctionType.createSynthesizedInstance('clear');
FunctionType.addParameter(clearMethod, selfParam);
clearMethod.details.declaredReturnType = evaluator.getNoneType();
clearMethod.shared.declaredReturnType = evaluator.getNoneType();
symbolTable.set('clear', Symbol.createWithType(SymbolFlags.ClassMember, clearMethod));
const popItemMethod = FunctionType.createSynthesizedInstance('popitem');
@ -707,7 +707,7 @@ export function synthesizeTypedDictClassMethods(
tupleType = UnknownType.create();
}
popItemMethod.details.declaredReturnType = tupleType;
popItemMethod.shared.declaredReturnType = tupleType;
symbolTable.set('popitem', Symbol.createWithType(SymbolFlags.ClassMember, popItemMethod));
}
@ -724,9 +724,9 @@ export function synthesizeTypedDictClassMethods(
if (
returnTypeClass &&
isInstantiableClass(returnTypeClass) &&
returnTypeClass.details.typeParameters.length === 2
returnTypeClass.shared.typeParameters.length === 2
) {
method.details.declaredReturnType = ClassType.cloneForSpecialization(
method.shared.declaredReturnType = ClassType.cloneForSpecialization(
ClassType.cloneAsInstance(returnTypeClass),
[strType, mappingValueType],
/* isTypeArgumentExplicit */ true
@ -745,7 +745,7 @@ export function getTypedDictMembersForClass(
allowNarrowed = false
): TypedDictEntries {
// Were the entries already calculated and cached?
if (!classType.details.typedDictEntries) {
if (!classType.shared.typedDictEntries) {
const entries: TypedDictEntries = {
knownItems: new Map<string, TypedDictEntry>(),
extraItems: undefined,
@ -762,20 +762,20 @@ export function getTypedDictMembersForClass(
}
// Cache the entries for next time.
classType.details.typedDictEntries = entries;
classType.shared.typedDictEntries = entries;
}
const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
// Create a specialized copy of the entries so the caller can mutate them.
const entries = new Map<string, TypedDictEntry>();
classType.details.typedDictEntries!.knownItems.forEach((value, key) => {
classType.shared.typedDictEntries!.knownItems.forEach((value, key) => {
const tdEntry = { ...value };
tdEntry.valueType = applySolvedTypeVars(tdEntry.valueType, typeVarContext);
// If the class is "Partial", make all entries optional and convert all
// read-only entries to Never.
if (classType.isTypedDictPartial) {
if (classType.priv.isTypedDictPartial) {
tdEntry.isRequired = false;
if (tdEntry.isReadOnly) {
@ -789,8 +789,8 @@ export function getTypedDictMembersForClass(
});
// Apply narrowed types on top of existing entries if present.
if (allowNarrowed && classType.typedDictNarrowedEntries) {
classType.typedDictNarrowedEntries.forEach((value, key) => {
if (allowNarrowed && classType.priv.typedDictNarrowedEntries) {
classType.priv.typedDictNarrowedEntries.forEach((value, key) => {
const tdEntry = { ...value };
tdEntry.valueType = applySolvedTypeVars(tdEntry.valueType, typeVarContext);
entries.set(key, tdEntry);
@ -799,7 +799,7 @@ export function getTypedDictMembersForClass(
return {
knownItems: entries,
extraItems: classType.details.typedDictEntries?.extraItems,
extraItems: classType.shared.typedDictEntries?.extraItems,
};
}
@ -976,7 +976,7 @@ function getTypedDictMembersForClassRecursive(
}
recursionCount++;
classType.details.baseClasses.forEach((baseClassType) => {
classType.shared.baseClasses.forEach((baseClassType) => {
if (isInstantiableClass(baseClassType) && ClassType.isTypedDictClass(baseClassType)) {
const specializedBaseClassType = partiallySpecializeType(baseClassType, classType);
assert(isClass(specializedBaseClassType));
@ -1045,8 +1045,8 @@ export function getEffectiveExtraItemsEntryType(evaluator: TypeEvaluator, classT
};
}
if (classType.details.typedDictEntries?.extraItems) {
return classType.details.typedDictEntries.extraItems;
if (classType.shared.typedDictEntries?.extraItems) {
return classType.shared.typedDictEntries.extraItems;
}
return {
@ -1275,11 +1275,11 @@ export function assignToTypedDict(
let typeVarContext: TypeVarContext | undefined;
let genericClassType = classType;
if (classType.details.typeParameters.length > 0) {
if (classType.shared.typeParameters.length > 0) {
typeVarContext = new TypeVarContext(getTypeVarScopeId(classType));
// Create a generic (nonspecialized version) of the class.
if (classType.typeArguments) {
if (classType.priv.typeArguments) {
genericClassType = ClassType.cloneForSpecialization(
classType,
/* typeArguments */ undefined,
@ -1295,7 +1295,7 @@ export function assignToTypedDict(
if (!isClassInstance(keyType) || !ClassType.isBuiltIn(keyType, 'str') || !isLiteralType(keyType)) {
isMatch = false;
} else {
const keyValue = keyType.literalValue as string;
const keyValue = keyType.priv.literalValue as string;
const symbolEntry = tdEntries.knownItems.get(keyValue);
if (!symbolEntry) {
@ -1330,7 +1330,7 @@ export function assignToTypedDict(
const subDiag = diagAddendum?.createAddendum();
subDiag.addMessage(
LocAddendum.typedDictFieldUndefined().format({
name: keyType.literalValue as string,
name: keyType.priv.literalValue as string,
type: evaluator.printType(ClassType.cloneAsInstance(classType)),
})
);
@ -1354,7 +1354,7 @@ export function assignToTypedDict(
if (subDiag) {
subDiag.addMessage(
LocAddendum.typedDictFieldTypeMismatch().format({
name: keyType.literalValue as string,
name: keyType.priv.literalValue as string,
type: evaluator.printType(valueTypes[index].type),
})
);
@ -1443,14 +1443,14 @@ export function getTypeOfIndexedTypedDict(
}
if (isClassInstance(subtype) && ClassType.isBuiltIn(subtype, 'str')) {
if (subtype.literalValue === undefined) {
if (subtype.priv.literalValue === undefined) {
// If it's a plain str with no literal value, we can't
// make any determination about the resulting type.
return UnknownType.create();
}
// Look up the entry in the typed dict to get its type.
const entryName = subtype.literalValue as string;
const entryName = subtype.priv.literalValue as string;
const entry = entries.knownItems.get(entryName) ?? entries.extraItems;
if (!entry) {
diag.addMessage(
@ -1533,22 +1533,22 @@ export function narrowForKeyAssignment(classType: ClassType, key: string) {
// We should never be called if the classType is not a TypedDict or if typedDictEntries
// is empty, but this can theoretically happen in the presence of certain circular
// dependencies.
if (!ClassType.isTypedDictClass(classType) || !classType.details.typedDictEntries) {
if (!ClassType.isTypedDictClass(classType) || !classType.shared.typedDictEntries) {
return classType;
}
const tdEntry = classType.details.typedDictEntries.knownItems.get(key);
const tdEntry = classType.shared.typedDictEntries.knownItems.get(key);
if (!tdEntry || tdEntry.isRequired) {
return classType;
}
const narrowedTdEntry = classType.typedDictNarrowedEntries?.get(key);
const narrowedTdEntry = classType.priv.typedDictNarrowedEntries?.get(key);
if (narrowedTdEntry?.isProvided) {
return classType;
}
const narrowedEntries = classType.typedDictNarrowedEntries
? new Map<string, TypedDictEntry>(classType.typedDictNarrowedEntries)
const narrowedEntries = classType.priv.typedDictNarrowedEntries
? new Map<string, TypedDictEntry>(classType.priv.typedDictNarrowedEntries)
: new Map<string, TypedDictEntry>();
narrowedEntries.set(key, {
isProvided: true,

986
packages/pyright-internal/src/analyzer/types.ts
View File

File diff suppressed because it is too large Load Diff

10
packages/pyright-internal/src/commands/dumpFileDebugInfoCommand.ts
View File

@ -20,7 +20,7 @@ import {
TypeBase,
TypeCategory,
TypeFlags,
TypeVarDetails,
TypeVarDetailsShared,
TypeVarType,
Variance,
} from '../analyzer/types';
@ -337,15 +337,15 @@ function getTypeEvaluatorString(
if (!isNumber(value) && !isString(value)) {
if (set.has(value)) {
if (isClassType(value)) {
return `<cycle> class '${value.details.fullName}' typeSourceId:${value.details.typeSourceId}`;
return `<cycle> class '${value.shared.fullName}' typeSourceId:${value.shared.typeSourceId}`;
}
if (isFunctionType(value)) {
return `<cycle> function '${value.details.fullName}' parameter count:${value.details.parameters.length}`;
return `<cycle> function '${value.shared.fullName}' parameter count:${value.shared.parameters.length}`;
}
if (isTypeVarType(value)) {
return `<cycle> function '${value.details.name}' scope id:${value.nameWithScope}`;
return `<cycle> function '${value.shared.name}' scope id:${value.priv.nameWithScope}`;
}
return undefined;
@ -417,7 +417,7 @@ function getTypeEvaluatorString(
return isTypeBase(type) && type.details && isTypeVarDetails(type.details);
}
function isTypeVarDetails(type: any): type is TypeVarDetails {
function isTypeVarDetails(type: any): type is TypeVarDetailsShared {
return type.name !== undefined && type.constraints && type.variance !== undefined;
}

42
packages/pyright-internal/src/languageService/completionProvider.ts
View File

@ -425,8 +425,8 @@ export class CompletionProvider {
}
const symbolTable = new Map<string, Symbol>();
for (let i = 1; i < classResults.classType.details.mro.length; i++) {
const mroClass = classResults.classType.details.mro[i];
for (let i = 1; i < classResults.classType.shared.mro.length; i++) {
const mroClass = classResults.classType.shared.mro[i];
if (isInstantiableClass(mroClass)) {
getMembersForClass(mroClass, symbolTable, /* includeInstanceVars */ false);
}
@ -523,9 +523,9 @@ export class CompletionProvider {
let sb = this.parseResults.tokenizerOutput.predominantTabSequence;
if (
classType.details.baseClasses.length === 1 &&
isClass(classType.details.baseClasses[0]) &&
classType.details.baseClasses[0].details.fullName === 'builtins.object'
classType.shared.baseClasses.length === 1 &&
isClass(classType.shared.baseClasses[0]) &&
classType.shared.baseClasses[0].shared.fullName === 'builtins.object'
) {
sb += this.options.snippet ? '${0:pass}' : 'pass';
return sb;
@ -744,8 +744,8 @@ export class CompletionProvider {
// If this is an unknown type with a "possible type" associated with
// it, use the possible type.
if (isUnknown(leftType) && leftType.possibleType) {
leftType = this.evaluator.makeTopLevelTypeVarsConcrete(leftType.possibleType);
if (isUnknown(leftType) && leftType.priv.possibleType) {
leftType = this.evaluator.makeTopLevelTypeVarsConcrete(leftType.priv.possibleType);
}
doForEachSubtype(leftType, (subtype) => {
@ -1657,7 +1657,7 @@ export class CompletionProvider {
// If we can't do that using semantic info, then try syntactic info.
const symbolTable = new Map<string, Symbol>();
for (const mroClass of classResults.classType.details.mro) {
for (const mroClass of classResults.classType.shared.mro) {
if (mroClass === classResults.classType) {
// Ignore current type.
continue;
@ -1717,7 +1717,7 @@ export class CompletionProvider {
}
const symbolTable = new Map<string, Symbol>();
for (const mroClass of classResults.classType.details.mro) {
for (const mroClass of classResults.classType.shared.mro) {
if (isInstantiableClass(mroClass)) {
getMembersForClass(mroClass, symbolTable, /* includeInstanceVars */ false);
}
@ -1799,7 +1799,7 @@ export class CompletionProvider {
}
const symbolTable = new Map<string, Symbol>();
for (const mroClass of classResults.classType.details.mro) {
for (const mroClass of classResults.classType.shared.mro) {
if (isInstantiableClass(mroClass)) {
getMembersForClass(mroClass, symbolTable, /* includeInstanceVars */ false);
}
@ -1826,7 +1826,7 @@ export class CompletionProvider {
if (isStubFile(this.fileUri)) {
// In stubs, always use "...".
ellipsisForDefault = true;
} else if (classType.details.moduleName === decl.moduleName) {
} else if (classType.shared.moduleName === decl.moduleName) {
// In the same file, always print the full default.
ellipsisForDefault = false;
}
@ -2035,13 +2035,13 @@ export class CompletionProvider {
}
const type = signature.type;
const paramIndex = type.details.parameters.indexOf(signature.activeParam);
const paramIndex = type.shared.parameters.indexOf(signature.activeParam);
if (paramIndex < 0) {
return undefined;
}
const paramType = type.details.parameters[paramIndex].type;
const paramType = type.shared.parameters[paramIndex].type;
this._addLiteralValuesForTargetType(paramType, priorWord, priorText, postText, completionMap);
return undefined;
});
@ -2060,7 +2060,7 @@ export class CompletionProvider {
const value = printLiteralValue(v, quoteValue.quoteCharacter);
if (quoteValue.stringValue === undefined) {
this.addNameToCompletions(value, CompletionItemKind.Constant, priorWord, completionMap, {
sortText: this._makeSortText(SortCategory.LiteralValue, v.literalValue as string),
sortText: this._makeSortText(SortCategory.LiteralValue, v.priv.literalValue as string),
});
} else {
this._addStringLiteralToCompletions(
@ -2131,8 +2131,8 @@ export class CompletionProvider {
// Handle both overloaded and non-overloaded functions.
doForEachSignature(getItemType, (signature) => {
if (
signature.details.parameters.length >= 1 &&
signature.details.parameters[0].category === ParameterCategory.Simple
signature.shared.parameters.length >= 1 &&
signature.shared.parameters[0].category === ParameterCategory.Simple
) {
typesToCombine.push(FunctionType.getEffectiveParameterType(signature, 0));
}
@ -2816,8 +2816,10 @@ export class CompletionProvider {
// Add keys from typed dict outside signatures.
signatureInfo.signatures.forEach((signature) => {
if (signature.type.boundToType) {
const keys = Array.from(signature.type.boundToType.details.typedDictEntries?.knownItems.keys() || []);
if (signature.type.priv.boundToType) {
const keys = Array.from(
signature.type.priv.boundToType.shared.typedDictEntries?.knownItems.keys() || []
);
keys.forEach((key: string) => argNameSet.add(key));
}
});
@ -2889,7 +2891,7 @@ export class CompletionProvider {
if (curNode.nodeType === ParseNodeType.Class) {
const classType = this.evaluator.getTypeOfClass(curNode);
if (classType && isInstantiableClass(classType.classType)) {
classType.classType.details.mro.forEach((baseClass, index) => {
classType.classType.shared.mro.forEach((baseClass, index) => {
if (isInstantiableClass(baseClass)) {
this._addSymbolsForSymbolTable(
ClassType.getSymbolTable(baseClass),
@ -3148,7 +3150,7 @@ export class CompletionProvider {
symbolType &&
isClassInstance(symbolType) &&
ClassType.isSameGenericClass(symbolType, containingType) &&
symbolType.literalValue instanceof EnumLiteral
symbolType.priv.literalValue instanceof EnumLiteral
);
}
}

6
packages/pyright-internal/src/languageService/definitionProvider.ts
View File

@ -30,11 +30,11 @@ import { isDefined } from '../common/core';
import { ProgramView } from '../common/extensibility';
import { convertPositionToOffset } from '../common/positionUtils';
import { ServiceKeys } from '../common/serviceKeys';
import { ServiceProvider } from '../common/serviceProvider';
import { DocumentRange, Position, rangesAreEqual } from '../common/textRange';
import { Uri } from '../common/uri/uri';
import { ParseNode, ParseNodeType } from '../parser/parseNodes';
import { ParseFileResults } from '../parser/parser';
import { ServiceProvider } from '../common/serviceProvider';
export enum DefinitionFilter {
All = 'all',
@ -89,7 +89,9 @@ export function addDeclarationsToDefinitions(
// Handle overloaded function case
const functionType = evaluator.getTypeForDeclaration(resolvedDecl)?.type;
if (functionType && isOverloadedFunction(functionType)) {
for (const overloadDecl of functionType.overloads.map((o) => o.details.declaration).filter(isDefined)) {
for (const overloadDecl of functionType.priv.overloads
.map((o) => o.shared.declaration)
.filter(isDefined)) {
_addIfUnique(definitions, {
uri: overloadDecl.uri,
range: overloadDecl.range,

2
packages/pyright-internal/src/languageService/documentSymbolCollector.ts
View File

@ -450,7 +450,7 @@ function _getDeclarationsForNonModuleNameNode(
const type = evaluator.getType(node);
if (type?.category === TypeCategory.Module) {
// Synthesize decl for the module.
return [createSynthesizedAliasDeclaration(type.fileUri)];
return [createSynthesizedAliasDeclaration(type.priv.fileUri)];
}
}

6
packages/pyright-internal/src/languageService/hoverProvider.ts
View File

@ -141,8 +141,8 @@ export function getVariableTypeText(
const typeAliasInfo = getTypeAliasInfo(type);
if (typeAliasInfo?.name === typeNode.value) {
if (isTypeVar(type)) {
label = type.details.isParamSpec ? 'param spec' : 'type variable';
typeVarName = type.details.name;
label = type.shared.isParamSpec ? 'param spec' : 'type variable';
typeVarName = type.shared.name;
} else {
// Handle type aliases specially.
const typeText = evaluator.printType(convertToInstance(getTypeForToolTip(evaluator, typeNode)), {
@ -434,7 +434,7 @@ export class HoverProvider {
// with the type of the TypedDict key and its docstring, if available.
doForEachSubtype(type, (subtype) => {
if (isClassInstance(subtype) && ClassType.isTypedDictClass(subtype)) {
const entry = subtype.details.typedDictEntries?.knownItems.get(node.value);
const entry = subtype.shared.typedDictEntries?.knownItems.get(node.value);
if (entry) {
// If we have already added parts for another declaration (e.g. for a union of TypedDicts that share the same key)
// then we need to add a separator to prevent a visual bug.

8
packages/pyright-internal/src/languageService/signatureHelpProvider.ts
View File

@ -20,12 +20,15 @@ import {
SignatureInformation,
} from 'vscode-languageserver';
import { getFileInfo } from '../analyzer/analyzerNodeInfo';
import * as ParseTreeUtils from '../analyzer/parseTreeUtils';
import { getCallNodeAndActiveParameterIndex } from '../analyzer/parseTreeUtils';
import { SourceMapper } from '../analyzer/sourceMapper';
import { isBuiltInModule } from '../analyzer/typeDocStringUtils';
import { CallSignature, TypeEvaluator } from '../analyzer/typeEvaluatorTypes';
import { PrintTypeFlags } from '../analyzer/typePrinter';
import { throwIfCancellationRequested } from '../common/cancellationUtils';
import { DocStringService } from '../common/docStringService';
import { ProgramView } from '../common/extensibility';
import { convertPositionToOffset } from '../common/positionUtils';
import { Position } from '../common/textRange';
@ -33,9 +36,6 @@ import { Uri } from '../common/uri/uri';
import { CallNode, NameNode, ParseNodeType } from '../parser/parseNodes';
import { ParseFileResults } from '../parser/parser';
import { getDocumentationPartsForTypeAndDecl, getFunctionDocStringFromType } from './tooltipUtils';
import { DocStringService } from '../common/docStringService';
import { getFileInfo } from '../analyzer/analyzerNodeInfo';
import { isBuiltInModule } from '../analyzer/typeDocStringUtils';
export class SignatureHelpProvider {
private readonly _parseResults: ParseFileResults | undefined;
@ -235,7 +235,7 @@ export class SignatureHelpProvider {
let label = '(';
let activeParameter: number | undefined;
const params = functionType.details.parameters;
const params = functionType.shared.parameters;
stringParts[0].forEach((paramString: string, paramIndex) => {
let paramName = '';

18
packages/pyright-internal/src/languageService/tooltipUtils.ts
View File

@ -78,7 +78,7 @@ export function getOverloadedFunctionTooltip(
const overloads = OverloadedFunctionType.getOverloads(type).map((o) =>
getFunctionTooltip(
/* label */ '',
o.details.name,
o.shared.name,
o,
evaluator,
/* isProperty */ false,
@ -145,7 +145,7 @@ export function getConstructorTooltip(
let signature = '';
if (isOverloadedFunction(type)) {
const overloads = type.overloads.map((overload) =>
const overloads = type.priv.overloads.map((overload) =>
getConstructorTooltip(constructorName, overload, evaluator, functionSignatureDisplay)
);
overloads.forEach((overload, index) => {
@ -177,7 +177,7 @@ function formatSignature(
}
export function getFunctionDocStringFromType(type: FunctionType, sourceMapper: SourceMapper, evaluator: TypeEvaluator) {
const decl = type.details.declaration;
const decl = type.shared.declaration;
const enclosingClass = decl ? ParseTreeUtils.getEnclosingClass(decl.node) : undefined;
const classResults = enclosingClass ? evaluator.getTypeOfClass(enclosingClass) : undefined;
@ -189,17 +189,17 @@ export function getOverloadedFunctionDocStringsFromType(
sourceMapper: SourceMapper,
evaluator: TypeEvaluator
) {
if (type.overloads.length === 0) {
if (type.priv.overloads.length === 0) {
return [];
}
const decl = type.overloads[0].details.declaration;
const decl = type.priv.overloads[0].shared.declaration;
const enclosingClass = decl ? ParseTreeUtils.getEnclosingClass(decl.node) : undefined;
const classResults = enclosingClass ? evaluator.getTypeOfClass(enclosingClass) : undefined;
return getOverloadedFunctionDocStringsInherited(
type,
type.overloads.map((o) => o.details.declaration).filter(isDefined),
type.priv.overloads.map((o) => o.shared.declaration).filter(isDefined),
sourceMapper,
evaluator,
@ -361,9 +361,9 @@ export function combineExpressionTypes(typeNodes: ExpressionNode[], evaluator: T
typeList.length === 1 &&
result.category === TypeCategory.Class &&
ClassType.isBuiltIn(result, 'list') &&
result.typeArguments
result.priv.typeArguments
) {
result = result.typeArguments[0];
result = result.priv.typeArguments[0];
} else if (
typeList.length === 1 &&
result.category === TypeCategory.Class &&
@ -429,7 +429,7 @@ export function getClassAndConstructorTypes(node: NameNode, evaluator: TypeEvalu
!methodType ||
(methodType &&
isFunction(methodType) &&
(FunctionType.hasDefaultParameters(methodType) || methodType.details.parameters.length === 0))
(FunctionType.hasDefaultParameters(methodType) || methodType.shared.parameters.length === 0))
) {
const newMember = lookUpClassMember(
classType,

28
packages/pyright-internal/src/tests/classDeclaration.test.ts
View File

@ -137,11 +137,11 @@ test('property', () => {
assert(isProperty(result.decoratedType));
assert(isClassInstance(result.decoratedType));
assert(result.decoratedType.details.declaration);
assert(isClassDeclaration(result.decoratedType.details.declaration));
assert(result.decoratedType.shared.declaration);
assert(isClassDeclaration(result.decoratedType.shared.declaration));
assert(result.decoratedType.details.declaration.moduleName === 'builtins');
assert(result.decoratedType.details.declaration.node.name.value === 'property');
assert(result.decoratedType.shared.declaration.moduleName === 'builtins');
assert(result.decoratedType.shared.declaration.node.name.value === 'property');
});
});
@ -154,13 +154,13 @@ function checkSpecialBuiltInClassDetail(code: string) {
const type = state.program.evaluator!.getType(node);
assert(type?.category === TypeCategory.Class);
assert.strictEqual(node.value, type.aliasName ?? type.details.name);
assert.strictEqual(node.value, type.priv.aliasName ?? type.shared.name);
assert(type.details.declaration);
if (type.aliasName) {
assert(isClassDeclaration(type.details.declaration));
assert(type.shared.declaration);
if (type.priv.aliasName) {
assert(isClassDeclaration(type.shared.declaration));
} else {
assert(isSpecialBuiltInClassDeclaration(type.details.declaration));
assert(isSpecialBuiltInClassDeclaration(type.shared.declaration));
}
}
@ -181,18 +181,18 @@ function _checkClassDetail(state: TestState, range: Range | undefined, name?: st
const type = state.program.evaluator!.getType(node);
assert(type?.category === TypeCategory.Class);
assert.strictEqual(name ?? node.value, type.aliasName ?? type.details.name);
assert.strictEqual(name ?? node.value, type.priv.aliasName ?? type.shared.name);
if (range) {
assert(type.details.declaration);
assert(isClassDeclaration(type.details.declaration));
assert(type.shared.declaration);
assert(isClassDeclaration(type.shared.declaration));
assert.deepStrictEqual(
TextRange.create(type.details.declaration.node.start, type.details.declaration.node.length),
TextRange.create(type.shared.declaration.node.start, type.shared.declaration.node.length),
TextRange.fromBounds(range.pos, range.end)
);
} else {
// There should be no decl.
assert(!type.details.declaration);
assert(!type.shared.declaration);
}
}

2
packages/pyright-internal/src/tests/sourceMapperUtils.test.ts
View File

@ -216,7 +216,7 @@ function assertTypeAlias(code: string) {
const type = state.program.evaluator!.getType(node);
assert(type?.category === TypeCategory.Class);
assert.strictEqual(type.details.name, 'Mapping');
assert.strictEqual(type.shared.name, 'Mapping');
assert.strictEqual(type.props?.typeAliasInfo?.name, 'M');
assert.strictEqual(type.props?.typeAliasInfo.moduleName, 'test');

18
packages/pyright-internal/src/tests/typePrinter.test.ts
View File

@ -29,7 +29,7 @@ import { Uri } from '../common/uri/uri';
import { ParameterCategory } from '../parser/parseNodes';
function returnTypeCallback(type: FunctionType) {
return type.details.declaredReturnType ?? UnknownType.create(/* isEllipsis */ true);
return type.shared.declaredReturnType ?? UnknownType.create(/* isEllipsis */ true);
}
test('SimpleTypes', () => {
@ -58,11 +58,11 @@ test('TypeVarTypes', () => {
assert.strictEqual(printType(typeVarType, PrintTypeFlags.None, returnTypeCallback), 'T');
const paramSpecType = TypeVarType.createInstance('P');
paramSpecType.details.isParamSpec = true;
paramSpecType.shared.isParamSpec = true;
assert.strictEqual(printType(paramSpecType, PrintTypeFlags.None, returnTypeCallback), 'P');
const typeVarTupleType = TypeVarType.createInstance('Ts');
paramSpecType.details.isVariadic = true;
paramSpecType.shared.isVariadic = true;
assert.strictEqual(printType(typeVarTupleType, PrintTypeFlags.None, returnTypeCallback), 'Ts');
});
@ -81,7 +81,7 @@ test('ClassTypes', () => {
const typeVarS = TypeVarType.createInstance('S');
const typeVarT = TypeVarType.createInstance('T');
classTypeA.details.typeParameters.push(typeVarS, typeVarT);
classTypeA.shared.typeParameters.push(typeVarS, typeVarT);
assert.strictEqual(printType(classTypeA, PrintTypeFlags.None, returnTypeCallback), 'type[A[S, T]]');
@ -133,7 +133,7 @@ test('FunctionTypes', () => {
FunctionParam.create(ParameterCategory.KwargsDict, AnyType.create(), FunctionParamFlags.TypeDeclared, 'kwargs')
);
funcTypeA.details.declaredReturnType = NeverType.createNoReturn();
funcTypeA.shared.declaredReturnType = NeverType.createNoReturn();
assert.strictEqual(
printType(funcTypeA, PrintTypeFlags.None, returnTypeCallback),
@ -154,10 +154,10 @@ test('FunctionTypes', () => {
FunctionType.addPositionOnlyParameterSeparator(funcTypeB);
const paramSpecP = TypeVarType.createInstance('P');
paramSpecP.details.isParamSpec = true;
paramSpecP.shared.isParamSpec = true;
FunctionType.addParamSpecVariadics(funcTypeB, paramSpecP);
funcTypeB.details.declaredReturnType = NeverType.createNever();
funcTypeB.shared.declaredReturnType = NeverType.createNever();
assert.strictEqual(printType(funcTypeB, PrintTypeFlags.None, returnTypeCallback), '(a: Any, /, **P) -> Never');
assert.strictEqual(
@ -168,7 +168,7 @@ test('FunctionTypes', () => {
const funcTypeC = FunctionType.createInstance('C', '', '', FunctionTypeFlags.None);
const typeVarTupleTs = TypeVarType.createInstance('Ts');
typeVarTupleTs.details.isVariadic = true;
typeVarTupleTs.shared.isVariadic = true;
const unpackedTs = TypeVarType.cloneForUnpacked(typeVarTupleTs);
FunctionType.addParameter(
@ -185,7 +185,7 @@ test('FunctionTypes', () => {
const funcTypeD = FunctionType.createInstance('D', '', '', FunctionTypeFlags.None);
funcTypeD.details.declaredReturnType = AnyType.create();
funcTypeD.shared.declaredReturnType = AnyType.create();
FunctionType.addParamSpecVariadics(funcTypeD, paramSpecP);
assert.strictEqual(printType(funcTypeD, PrintTypeFlags.None, returnTypeCallback), '(**P) -> Any');