def make_ref(self, node, **kwargs): """Make a reference from a node.""" assert "data" in kwargs # required kwarg args = { "name": node_utils.get_name(node, self._ast), "scope": self.scope_id(), "ref_scope": None, "typ": node_utils.typename(node), "location": get_location(node), "target": None, } args.update(kwargs) return Reference(**args)
def make_def(self, node, **kwargs): """Make a definition from a node.""" if isinstance(node, self._ast.Name): t = node_utils.typename(node.ctx) elif isinstance(node, self._ast.arg): t = "Param" else: t = node_utils.typename(node) args = { "name": node_utils.get_name(node, self._ast), "scope": self.scope_id(), "typ": t, "data": None, "target": None, "doc": None, } args.update(kwargs) defn = Definition(**args) line, col = self._get_location(node, args) assert line is not None defloc = DefLocation(defn.id, source.Location(line, col)) return (defn, defloc)
def _from_data(cls, data): """Construct a PytypeValue from a single datum.""" if isinstance(data, abstract.PyTDClass): if data.module: # If we have a remote reference, return Remote rather than PytypeValue. return Remote(data.module, data.name, resolved=True) else: # This is a namedtuple or some other special case pytype has generated a # local PyTDClass for. We need special cases for them too. return None elif isinstance(data, abstract.Module): return Remote(data.name, IMPORT_FILE_MARKER, resolved=True) elif isinstance(data, abstract.InterpreterClass): return cls("module", data.name, "Class") elif isinstance(data, abstract.BoundFunction): # TODO(mdemello): Handle multiple class bindings. name = data.repr_names(callself_repr=node_utils.typename)[0] return cls("module", name, "BoundFunction") else: # TODO(mdemello): We need to infer the module here. return cls("module", str(data), node_utils.typename(data))
def __repr__(self): types_repr = tuple(t and [node_utils.typename(x) for x in t] for t in self.types) return "%s %s" % (super(VmTrace, self).__repr__(), types_repr)