def call(self, node, funcv, args):
if len(args.posargs) != 1:
raise function.WrongArgCount(self._SIGNATURE, args, self.vm)
arg = args.posargs[0]
for d in arg.data:
d.is_classmethod = True
return node, ClassMethodInstance(self.vm, self, arg).to_variable(node)
def call(self, node, _, args):
result = self.vm.program.NewVariable()
num_args = len(args.posargs)
if num_args == 0 and self.vm.PY3:
# The implicit type argument is available in a freevar named '__class__'.
cls_var = None
# If we are in a list comprehension we want the enclosing frame.
index = -1
while self.vm.frames[index].f_code.co_name == "<listcomp>":
index -= 1
frame = self.vm.frames[index]
for i, free_var in enumerate(frame.f_code.co_freevars):
if free_var == abstract.BuildClass.CLOSURE_NAME:
cls_var = frame.cells[len(frame.f_code.co_cellvars) + i]
break
if not (cls_var and cls_var.bindings):
self.vm.errorlog.invalid_super_call(
self.vm.frames,
message="Missing __class__ closure for super call.",
details=
"Is 'super' being called from a method defined in a class?"
)
return node, self.vm.new_unsolvable(node)
# The implicit super object argument is the first positional argument to
# the function calling 'super'.
self_arg = frame.first_posarg
if not self_arg:
self.vm.errorlog.invalid_super_call(
self.vm.frames,
message="Missing 'self' argument to 'super' call.")
return node, self.vm.new_unsolvable(node)
super_objects = self_arg.bindings
elif 1 <= num_args <= 2:
cls_var = args.posargs[0]
super_objects = args.posargs[1].bindings if num_args == 2 else [
None
]
else:
raise function.WrongArgCount(self._SIGNATURE, args, self.vm)
for cls in cls_var.bindings:
if not isinstance(
cls.data,
(class_mixin.Class, abstract.AMBIGUOUS_OR_EMPTY)):
bad = function.BadParam(name="cls",
expected=self.vm.convert.type_type)
raise function.WrongArgTypes(self._SIGNATURE,
args,
self.vm,
bad_param=bad)
for obj in super_objects:
if obj:
result.AddBinding(
SuperInstance(cls.data, obj.data, self.vm), [cls, obj],
node)
else:
result.AddBinding(SuperInstance(cls.data, None, self.vm),
[cls], node)
return node, result
def call(self, node, _, args):
if len(args.posargs) == 1:
a, = args.posargs
t = None
elif len(args.posargs) == 2:
a, t = args.posargs
else:
raise function.WrongArgCount(self._SIGNATURE, args, self.vm)
self.vm.errorlog.assert_type(self.vm.frames, node, a, t)
return node, self.vm.convert.build_none(node)
def call(self, node, unused, args):
if len(args.posargs) != 1:
sig = function.Signature.from_param_names(
"%s.add_metaclass" % self.module_name, ("cls", ))
raise function.WrongArgCount(sig, args, self.vm)
cls_var = args.posargs[0]
for b in cls_var.bindings:
cls = b.data
log.debug("Adding metaclass %r to class %r", self.meta, cls)
cls.cls = self.meta
return node, cls_var
def call(self, node, unused, args):
if len(args.posargs) != 1:
sig = function.Signature.from_param_names(
"%s.add_metaclass" % self.module_name, ("cls",))
raise function.WrongArgCount(sig, args, self.vm)
cls_var = args.posargs[0]
for b in cls_var.bindings:
cls = b.data
log.debug("Adding metaclass %r to class %r", self.meta, cls)
cls.cls = self.meta
# For metaclasses defined natively or using with_metaclass, the
# metaclass's initializer is called in vm.make_class. However, with
# add_metaclass, the metaclass is not known until the decorator fires.
if isinstance(cls, class_mixin.Class):
node = cls.call_metaclass_init(node)
return node, cls_var
def call(self, node, funcv, args):
if len(args.posargs) != 1:
raise function.WrongArgCount(self._SIGNATURE, args, self.vm)
arg = args.posargs[0]
return node, StaticMethodInstance(self.vm, self, arg).to_variable(node)
