pytype.abstract._base.BaseValue

Basic initializer for all BaseValues.

Undocumented

Returns the minimum number of arguments needed for a call.

Call this abstract value with the given arguments. The posargs and namedargs arguments may be modified by this function. Args: node: The CFGNode calling this function func: The cfg.Binding containing this function. args: Arguments for the call. alias_map: A datatypes.UnionFind, which stores all the type renaming information, mapping of type parameter name to its representative. Returns: A tuple (cfg.Node, cfg.Variable). The CFGNode corresponds to the function's "return" statement(s). Raises: function.FailedFunctionCall Make the call as required by this specific kind of atomic value, and make sure to annotate the results correctly with the origins (val and also other values appearing in the arguments).

Undocumented

Undocumented

Undocumented

Gets a default type key. See get_type_key.

Get the class's type for the type parameter. Treating self as a class_mixin.Class, gets its formal type for the given type parameter. For the real implementation, see ParameterizedClass.get_formal_type_parameter. Args: t: The name of the type parameter. Returns: A formal type.

Undocumented

Get the type an instance of us would have.

Get a cfg.Variable of the instance's values for the type parameter. Treating self as an abstract.Instance, gets the variable of its values for the given type parameter. For the real implementation, see SimpleValue.get_instance_type_parameter. Args: name: The name of the type parameter. node: Optionally, the current CFG node. Returns: A Variable which may be empty.

Get this value's __new__ method, if it isn't object.__new__.

Fetch a special attribute (e.g., __get__, __iter__).

Build a key from the information used to perform type matching. Get a hashable object containing this value's type information. Type keys are only compared amongst themselves, so we don't care what the internals look like, only that values with different types *always* have different type keys and values with the same type preferably have the same type key. Args: seen: The set of values seen before while computing the type key. Returns: A hashable object built from this value's type information.

Return True if this is a function and has a **kwargs parameter.

Return True if this is a function and has a *args parameter.

Allow metaprogramming via __init_subclass__. We do not analyse __init_subclass__ methods in the code, but overlays that wish to replicate metaprogramming constructs using __init_subclass__ can define a class overriding this method, and ctx.make_class will call Class.call_init_subclass(), which will invoke the init_subclass() method for all classes in the list of base classes. This is here rather than in class_mixin.Class because a class's list of bases can include abstract objects that do not derive from Class (e.g. Unknown and Unsolvable). Args: node: cfg node cls: the abstract.InterpreterClass that is being constructed with subclass as a base Returns: A possibly new cfg node

Create an instance of self. Note that this method does not call __init__, so the instance may be incomplete. If you need a complete instance, use self.ctx.vm.init_class instead. Args: node: The current node. container: Optionally, the value that contains self. (See TypeParameter.) Returns: The instance.

Undocumented

Undocumented

Undocumented

Bind this value to the given self or cls. This function is similar to __get__ except at the abstract level. This does not trigger any code execution inside the VM. See __get__ for more details. Args: callself: The Variable that should be passed as self or cls when the call is made. We only need one of self or cls, so having them share a parameter prevents accidentally passing in both. is_class: Whether callself is self or cls. Should be cls only when we want to directly pass in a class to bind a class method to, rather than passing in an instance and calling get_class(). Returns: Another abstract value that should be returned in place of this one. The default implementation returns self, so this can always be called safely.

Treating self as a class definition, register an instance of it. This is used for keeping merging call records on instances when generating the formal definition of a class. See InterpreterClass and TupleClass. Args: instance: An instance of this class (as a BaseValue)

Undocumented

Undocumented

Undocumented

Get a PyTD definition for this object.

Get a PyTD type representing this object, as seen at a node.

Build a variable out of this abstract value. Args: node: The current CFG node. Returns: A cfg.Variable.

Get unique parameter subtypes as bindings. Like _unique_parameters, but returns bindings instead of variables. Returns: A list of list of bindings.

Update the official name.