initial creation
This commit is contained in:
@@ -0,0 +1,347 @@
|
||||
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
|
||||
# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
|
||||
# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
|
||||
|
||||
"""
|
||||
Inference objects are a way to represent composite AST nodes,
|
||||
which are used only as inference results, so they can't be found in the
|
||||
original AST tree. For instance, inferring the following frozenset use,
|
||||
leads to an inferred FrozenSet:
|
||||
|
||||
Call(func=Name('frozenset'), args=Tuple(...))
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from collections.abc import Generator
|
||||
from typing import Any, TypeVar
|
||||
|
||||
from astroid import bases, decorators, util
|
||||
from astroid.context import InferenceContext
|
||||
from astroid.exceptions import (
|
||||
AttributeInferenceError,
|
||||
InferenceError,
|
||||
MroError,
|
||||
SuperError,
|
||||
)
|
||||
from astroid.manager import AstroidManager
|
||||
from astroid.nodes import node_classes, scoped_nodes
|
||||
|
||||
objectmodel = util.lazy_import("interpreter.objectmodel")
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
from functools import cached_property
|
||||
from typing import Literal
|
||||
else:
|
||||
from typing_extensions import Literal
|
||||
|
||||
from astroid.decorators import cachedproperty as cached_property
|
||||
|
||||
_T = TypeVar("_T")
|
||||
|
||||
|
||||
class FrozenSet(node_classes.BaseContainer):
|
||||
"""class representing a FrozenSet composite node"""
|
||||
|
||||
def pytype(self) -> Literal["builtins.frozenset"]:
|
||||
return "builtins.frozenset"
|
||||
|
||||
def _infer(self, context=None, **kwargs: Any):
|
||||
yield self
|
||||
|
||||
@cached_property
|
||||
def _proxied(self): # pylint: disable=method-hidden
|
||||
ast_builtins = AstroidManager().builtins_module
|
||||
return ast_builtins.getattr("frozenset")[0]
|
||||
|
||||
|
||||
class Super(node_classes.NodeNG):
|
||||
"""Proxy class over a super call.
|
||||
|
||||
This class offers almost the same behaviour as Python's super,
|
||||
which is MRO lookups for retrieving attributes from the parents.
|
||||
|
||||
The *mro_pointer* is the place in the MRO from where we should
|
||||
start looking, not counting it. *mro_type* is the object which
|
||||
provides the MRO, it can be both a type or an instance.
|
||||
*self_class* is the class where the super call is, while
|
||||
*scope* is the function where the super call is.
|
||||
"""
|
||||
|
||||
# pylint: disable=unnecessary-lambda
|
||||
special_attributes = util.lazy_descriptor(lambda: objectmodel.SuperModel())
|
||||
|
||||
def __init__(self, mro_pointer, mro_type, self_class, scope):
|
||||
self.type = mro_type
|
||||
self.mro_pointer = mro_pointer
|
||||
self._class_based = False
|
||||
self._self_class = self_class
|
||||
self._scope = scope
|
||||
super().__init__()
|
||||
|
||||
def _infer(self, context=None, **kwargs: Any):
|
||||
yield self
|
||||
|
||||
def super_mro(self):
|
||||
"""Get the MRO which will be used to lookup attributes in this super."""
|
||||
if not isinstance(self.mro_pointer, scoped_nodes.ClassDef):
|
||||
raise SuperError(
|
||||
"The first argument to super must be a subtype of "
|
||||
"type, not {mro_pointer}.",
|
||||
super_=self,
|
||||
)
|
||||
|
||||
if isinstance(self.type, scoped_nodes.ClassDef):
|
||||
# `super(type, type)`, most likely in a class method.
|
||||
self._class_based = True
|
||||
mro_type = self.type
|
||||
else:
|
||||
mro_type = getattr(self.type, "_proxied", None)
|
||||
if not isinstance(mro_type, (bases.Instance, scoped_nodes.ClassDef)):
|
||||
raise SuperError(
|
||||
"The second argument to super must be an "
|
||||
"instance or subtype of type, not {type}.",
|
||||
super_=self,
|
||||
)
|
||||
|
||||
if not mro_type.newstyle:
|
||||
raise SuperError("Unable to call super on old-style classes.", super_=self)
|
||||
|
||||
mro = mro_type.mro()
|
||||
if self.mro_pointer not in mro:
|
||||
raise SuperError(
|
||||
"The second argument to super must be an "
|
||||
"instance or subtype of type, not {type}.",
|
||||
super_=self,
|
||||
)
|
||||
|
||||
index = mro.index(self.mro_pointer)
|
||||
return mro[index + 1 :]
|
||||
|
||||
@cached_property
|
||||
def _proxied(self):
|
||||
ast_builtins = AstroidManager().builtins_module
|
||||
return ast_builtins.getattr("super")[0]
|
||||
|
||||
def pytype(self) -> Literal["builtins.super"]:
|
||||
return "builtins.super"
|
||||
|
||||
def display_type(self):
|
||||
return "Super of"
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
"""Get the name of the MRO pointer."""
|
||||
return self.mro_pointer.name
|
||||
|
||||
def qname(self) -> Literal["super"]:
|
||||
return "super"
|
||||
|
||||
def igetattr(self, name: str, context: InferenceContext | None = None):
|
||||
"""Retrieve the inferred values of the given attribute name."""
|
||||
# '__class__' is a special attribute that should be taken directly
|
||||
# from the special attributes dict
|
||||
if name == "__class__":
|
||||
yield self.special_attributes.lookup(name)
|
||||
return
|
||||
|
||||
try:
|
||||
mro = self.super_mro()
|
||||
# Don't let invalid MROs or invalid super calls
|
||||
# leak out as is from this function.
|
||||
except SuperError as exc:
|
||||
raise AttributeInferenceError(
|
||||
(
|
||||
"Lookup for {name} on {target!r} because super call {super!r} "
|
||||
"is invalid."
|
||||
),
|
||||
target=self,
|
||||
attribute=name,
|
||||
context=context,
|
||||
super_=exc.super_,
|
||||
) from exc
|
||||
except MroError as exc:
|
||||
raise AttributeInferenceError(
|
||||
(
|
||||
"Lookup for {name} on {target!r} failed because {cls!r} has an "
|
||||
"invalid MRO."
|
||||
),
|
||||
target=self,
|
||||
attribute=name,
|
||||
context=context,
|
||||
mros=exc.mros,
|
||||
cls=exc.cls,
|
||||
) from exc
|
||||
found = False
|
||||
for cls in mro:
|
||||
if name not in cls.locals:
|
||||
continue
|
||||
|
||||
found = True
|
||||
for inferred in bases._infer_stmts([cls[name]], context, frame=self):
|
||||
if not isinstance(inferred, scoped_nodes.FunctionDef):
|
||||
yield inferred
|
||||
continue
|
||||
|
||||
# We can obtain different descriptors from a super depending
|
||||
# on what we are accessing and where the super call is.
|
||||
if inferred.type == "classmethod":
|
||||
yield bases.BoundMethod(inferred, cls)
|
||||
elif self._scope.type == "classmethod" and inferred.type == "method":
|
||||
yield inferred
|
||||
elif self._class_based or inferred.type == "staticmethod":
|
||||
yield inferred
|
||||
elif isinstance(inferred, Property):
|
||||
function = inferred.function
|
||||
try:
|
||||
yield from function.infer_call_result(
|
||||
caller=self, context=context
|
||||
)
|
||||
except InferenceError:
|
||||
yield util.Uninferable
|
||||
elif bases._is_property(inferred):
|
||||
# TODO: support other descriptors as well.
|
||||
try:
|
||||
yield from inferred.infer_call_result(self, context)
|
||||
except InferenceError:
|
||||
yield util.Uninferable
|
||||
else:
|
||||
yield bases.BoundMethod(inferred, cls)
|
||||
|
||||
# Only if we haven't found any explicit overwrites for the
|
||||
# attribute we look it up in the special attributes
|
||||
if not found and name in self.special_attributes:
|
||||
yield self.special_attributes.lookup(name)
|
||||
return
|
||||
|
||||
if not found:
|
||||
raise AttributeInferenceError(target=self, attribute=name, context=context)
|
||||
|
||||
def getattr(self, name, context=None):
|
||||
return list(self.igetattr(name, context=context))
|
||||
|
||||
|
||||
class ExceptionInstance(bases.Instance):
|
||||
"""Class for instances of exceptions
|
||||
|
||||
It has special treatment for some of the exceptions's attributes,
|
||||
which are transformed at runtime into certain concrete objects, such as
|
||||
the case of .args.
|
||||
"""
|
||||
|
||||
@cached_property
|
||||
def special_attributes(self):
|
||||
qname = self.qname()
|
||||
instance = objectmodel.BUILTIN_EXCEPTIONS.get(
|
||||
qname, objectmodel.ExceptionInstanceModel
|
||||
)
|
||||
return instance()(self)
|
||||
|
||||
|
||||
class DictInstance(bases.Instance):
|
||||
"""Special kind of instances for dictionaries
|
||||
|
||||
This instance knows the underlying object model of the dictionaries, which means
|
||||
that methods such as .values or .items can be properly inferred.
|
||||
"""
|
||||
|
||||
# pylint: disable=unnecessary-lambda
|
||||
special_attributes = util.lazy_descriptor(lambda: objectmodel.DictModel())
|
||||
|
||||
|
||||
# Custom objects tailored for dictionaries, which are used to
|
||||
# disambiguate between the types of Python 2 dict's method returns
|
||||
# and Python 3 (where they return set like objects).
|
||||
class DictItems(bases.Proxy):
|
||||
__str__ = node_classes.NodeNG.__str__
|
||||
__repr__ = node_classes.NodeNG.__repr__
|
||||
|
||||
|
||||
class DictKeys(bases.Proxy):
|
||||
__str__ = node_classes.NodeNG.__str__
|
||||
__repr__ = node_classes.NodeNG.__repr__
|
||||
|
||||
|
||||
class DictValues(bases.Proxy):
|
||||
__str__ = node_classes.NodeNG.__str__
|
||||
__repr__ = node_classes.NodeNG.__repr__
|
||||
|
||||
|
||||
class PartialFunction(scoped_nodes.FunctionDef):
|
||||
"""A class representing partial function obtained via functools.partial"""
|
||||
|
||||
@decorators.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead")
|
||||
def __init__(
|
||||
self, call, name=None, doc=None, lineno=None, col_offset=None, parent=None
|
||||
):
|
||||
# TODO: Pass end_lineno and end_col_offset as well
|
||||
super().__init__(name, lineno=lineno, col_offset=col_offset, parent=None)
|
||||
# Assigned directly to prevent triggering the DeprecationWarning.
|
||||
self._doc = doc
|
||||
# A typical FunctionDef automatically adds its name to the parent scope,
|
||||
# but a partial should not, so defer setting parent until after init
|
||||
self.parent = parent
|
||||
self.filled_args = call.positional_arguments[1:]
|
||||
self.filled_keywords = call.keyword_arguments
|
||||
|
||||
wrapped_function = call.positional_arguments[0]
|
||||
inferred_wrapped_function = next(wrapped_function.infer())
|
||||
if isinstance(inferred_wrapped_function, PartialFunction):
|
||||
self.filled_args = inferred_wrapped_function.filled_args + self.filled_args
|
||||
self.filled_keywords = {
|
||||
**inferred_wrapped_function.filled_keywords,
|
||||
**self.filled_keywords,
|
||||
}
|
||||
|
||||
self.filled_positionals = len(self.filled_args)
|
||||
|
||||
def infer_call_result(self, caller=None, context=None):
|
||||
if context:
|
||||
current_passed_keywords = {
|
||||
keyword for (keyword, _) in context.callcontext.keywords
|
||||
}
|
||||
for keyword, value in self.filled_keywords.items():
|
||||
if keyword not in current_passed_keywords:
|
||||
context.callcontext.keywords.append((keyword, value))
|
||||
|
||||
call_context_args = context.callcontext.args or []
|
||||
context.callcontext.args = self.filled_args + call_context_args
|
||||
|
||||
return super().infer_call_result(caller=caller, context=context)
|
||||
|
||||
def qname(self) -> str:
|
||||
return self.__class__.__name__
|
||||
|
||||
|
||||
# TODO: Hack to solve the circular import problem between node_classes and objects
|
||||
# This is not needed in 2.0, which has a cleaner design overall
|
||||
node_classes.Dict.__bases__ = (node_classes.NodeNG, DictInstance)
|
||||
|
||||
|
||||
class Property(scoped_nodes.FunctionDef):
|
||||
"""Class representing a Python property"""
|
||||
|
||||
@decorators.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead")
|
||||
def __init__(
|
||||
self, function, name=None, doc=None, lineno=None, col_offset=None, parent=None
|
||||
):
|
||||
self.function = function
|
||||
super().__init__(name, lineno=lineno, col_offset=col_offset, parent=parent)
|
||||
# Assigned directly to prevent triggering the DeprecationWarning.
|
||||
self._doc = doc
|
||||
|
||||
# pylint: disable=unnecessary-lambda
|
||||
special_attributes = util.lazy_descriptor(lambda: objectmodel.PropertyModel())
|
||||
type = "property"
|
||||
|
||||
def pytype(self) -> Literal["builtins.property"]:
|
||||
return "builtins.property"
|
||||
|
||||
def infer_call_result(self, caller=None, context=None):
|
||||
raise InferenceError("Properties are not callable")
|
||||
|
||||
def _infer(
|
||||
self: _T, context: InferenceContext | None = None, **kwargs: Any
|
||||
) -> Generator[_T, None, None]:
|
||||
yield self
|
||||
Reference in New Issue
Block a user