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)