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)
