"""Construct an XML-safe attribute string from the given attributes

from xml.sax.saxutils import quoteattr

s = ''

for attr, value in list(attrs.items()):

if not isinstance(value, str):

value = str(value)

elif isinstance(value, str):

value = value.encode("utf-8")

s += ' %s=%s' % (attr, quoteattr(value))

"""Encode the given string for inclusion in a UTF-8 XML document.

# As defined in the XML spec some of the character from 0x00 to 0x19

# are not allowed in well-formed XML. We replace those with entity

# references here.

# http://www.w3.org/TR/2000/REC-xml-20001006#charsets

#

# Dev Notes:

# - It would be nice if Python has a codec for this. Perhaps we

# should write one.

# - Eric, at one point, had this change to '_xmlencode' for rubycile:

# p4 diff2 -du \

# //depot/main/Apps/Komodo-devel/src/codeintel/ruby/rubycile.py#7 \

# //depot/main/Apps/Komodo-devel/src/codeintel/ruby/rubycile.py#8

# but:

# My guess is that there was a bug here, and explicitly

# utf-8-encoding non-ascii characters fixed it. This was a year

# ago, and I don't recall what I mean by "avoid shuffling the data

# around", but it must be related to something I observed without

# that code.

# replace with XML decimal char entity, e.g. ''

"""Return the string escaped for inclusion in an XML CDATA section.

if isinstance(s, str):

s = s.encode("utf-8")

parts = s.split("]]>")

if isinstance(x, str):

return x

elif isinstance(x, str):

return x.decode('utf8')

else:

return dict(name=node["name"],

line=node.get("line"),

doc=node.get("doc"),

attributes=node.get("attributes") or None,

max_type = None

max_score = -1

#'guesses' is a types dict: {<type guess>: <score>, ...}

guesses = node.get("types", {})

for type, score in list(guesses.items()):

if ' ' in type:

# XXX Drop the <start-scope> part of CITDL for now.

type = type.split(None, 1)[0]

# Don't emit None types, it does not help us. Fix for bug:

# http://bugs.activestate.com/show_bug.cgi?id=71989

if type != "None":

if score > max_score:

max_type = type

max_score = score

"""Generate Code Intelligence XML (CIX) from walking a Python AST tree.

DEBUG = 0

def __init__(self, moduleName=None, content=None, lang="Python"):

self.lang = lang

if self.DEBUG is None:

self.DEBUG = log.isEnabledFor(logging.DEBUG)

self.moduleName = moduleName

self.content = content

if content and self.DEBUG:

self.lines = content.splitlines(0)

else:

self.lines = None

# Symbol Tables (dicts) are built up for each scope. The namespace

# stack to the global-level is maintain in self.nsstack.

self.st = { # the main module symbol table

# <scope name>: <namespace dict>

}

self.nsstack = []

self.cix = ET.TreeBuilder()

self.tree = None

def parse(self):

"""Parse text into a tree and walk the result"""

self.tree = ast.parse(self.content)

def walk(self):

return self.visit(self.tree)

def emit_start(self, s, attrs={}):

self.cix.start(s, _et_attrs(attrs))

def emit_data(self, data):

self.cix.data(_et_data(data))

def emit_end(self, s):

self.cix.end(s)

def emit_tag(self, s, attrs={}, data=None):

self.emit_start(s, _et_attrs(attrs))

if data is not None:

self.emit_data(data)

self.emit_end(s)

def cix_module(self, node):

"""Emit CIX for the given module namespace."""

# log.debug("cix_module(%s, level=%r)", '.'.join(node["nspath"]),

# level)

assert len(node["types"]) == 1 and "module" in node["types"]

attrs = _node_attrs(node, lang=self.lang, ilk="blob")

module = self.emit_start('scope', attrs)

for import_ in node.get("imports", []):

self.cix_import(import_)

self.cix_symbols(node["symbols"])

self.emit_end('scope')

def cix_import(self, node):

# log.debug("cix_import(%s, level=%r)", node["module"], level)

attrs = node

self.emit_tag('import', attrs)

def cix_symbols(self, node, parentIsClass=0):

# Sort variables by line order. This provide the most naturally

# readable comparison of document with its associate CIX content.

vars = sorted(list(node.values()), key=lambda v: v.get("line"))

for var in vars:

self.cix_symbol(var, parentIsClass)

def cix_symbol(self, node, parentIsClass=0):

if _isclass(node):

self.cix_class(node)

elif _isfunction(node):

self.cix_function(node)

else:

self.cix_variable(node, parentIsClass)

def cix_variable(self, node, parentIsClass=0):

# log.debug("cix_variable(%s, level=%r, parentIsClass=%r)",

# '.'.join(node["nspath"]), level, parentIsClass)

attrs = _node_attrs(node, citdl=_node_citdl(node))

if parentIsClass and "is-class-var" not in node:

# Special CodeIntel <variable> attribute to distinguish from the

# usual class variables.

if attrs["attributes"]:

attrs["attributes"] += " __instancevar__"

else:

attrs["attributes"] = "__instancevar__"

self.emit_tag('variable', attrs)

def cix_class(self, node):

# log.debug("cix_class(%s, level=%r)", '.'.join(node["nspath"]), level)

if node["classrefs"]:

citdls = (t for t in (_node_citdl(n) for n in node["classrefs"])

if t is not None)

classrefs = " ".join(citdls)

else:

classrefs = None

attrs = _node_attrs(node,

lineend=node.get("lineend"),

signature=node.get("signature"),

ilk="class",

classrefs=classrefs)

self.emit_start('scope', attrs)

for import_ in node.get("imports", []):

self.cix_import(import_)

self.cix_symbols(node["symbols"], parentIsClass=1)

self.emit_end('scope')

def cix_argument(self, node):

# log.debug("cix_argument(%s, level=%r)", '.'.join(node["nspath"]),

# level)

attrs = _node_attrs(node, citdl=_node_citdl(node), ilk="argument")

self.emit_tag('variable', attrs)

def cix_function(self, node):

# log.debug("cix_function(%s, level=%r)", '.'.join(node["nspath"]), level)

# Determine the best return type.

best_citdl = None

max_count = 0

for citdl, count in list(node["returns"].items()):

if count > max_count:

best_citdl = citdl

attrs = _node_attrs(node,

lineend=node.get("lineend"),

returns=best_citdl,

signature=node.get("signature"),

ilk="function")

self.emit_start("scope", attrs)

for import_ in node.get("imports", []):

self.cix_import(import_)

argNames = []

for arg in node["arguments"]:

argNames.append(arg["name"])

self.cix_argument(arg)

symbols = {} # don't re-emit the function arguments

for symbolName, symbol in list(node["symbols"].items()):

if symbolName not in argNames:

symbols[symbolName] = symbol

self.cix_symbols(symbols)

# XXX <returns/> if one is defined

self.emit_end('scope')

def getCIX(self, path):

"""Return CIX content for parsed data."""

log.debug("getCIX")

self.emit_start('file', dict(lang=self.lang, path=path))

if self.st:

moduleNS = self.st[()]

self.cix_module(moduleNS)

self.emit_end('file')

file = self.cix.close()

return file

# def generic_visit(self, node):

# method = 'visit_' + node.__class__.__name__

# if not hasattr(self, method):

# log.info("generic visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

# return super(AST2CIXVisitor, self).generic_visit(node)

def visit_Module(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

nspath = ()

namespace = {"name": self.moduleName,

"nspath": nspath,

"types": {"module": 1},

"symbols": {}}

doc = ast.get_docstring(node)

if doc:

summarylines = util.parseDocSummary(doc.splitlines(0))

namespace["doc"] = "\n".join(summarylines)

self.st[nspath] = namespace

self.nsstack.append(namespace)

self.generic_visit(node)

self.nsstack.pop()

def visit_Return(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

citdl_types = self._guessTypes(node.value)

for citdl in citdl_types:

if citdl:

citdl = citdl.split(None, 1)[0]

if citdl and citdl not in ("None", "NoneType"):

if citdl in ("False", "True"):

citdl = "bool"

func_node = self.nsstack[-1]

t = func_node["returns"]

t[citdl] = t.get(citdl, 0) + 1

def visit_ClassDef(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

locals = self.nsstack[-1]

name = node.name

nspath = locals["nspath"] + (name,)

namespace = {

"nspath": nspath,

"name": name,

"types": {"class": 1},

# XXX Example of a base class that might surprise: the

# __metaclass__ class in

# c:\python22\lib\site-packages\ctypes\com\automation.py

# Should this be self._getCITDLExprRepr()???

"classrefs": [],

"symbols": {},

}

namespace["declaration"] = namespace

if node.lineno:

namespace["line"] = node.lineno

namespace["lineend"] = node.lineno

lastNode = node

while True:

try:

lastNode = list(ast.iter_child_nodes(lastNode))[-1]

if hasattr(lastNode, 'lineno'):

namespace["lineend"] = lastNode.lineno

except IndexError:

break

attributes = []

if name.startswith("__") and name.endswith("__"):

pass

elif name.startswith("__"):

attributes.append("private")

elif name.startswith("_"):

attributes.append("protected")

namespace["attributes"] = ' '.join(attributes)

if node.bases:

for baseNode in node.bases:

baseName = self._getExprRepr(baseNode)

classref = {"name": baseName, "types": {}}

for t in self._guessTypes(baseNode):

if t not in classref["types"]:

classref["types"][t] = 0

classref["types"][t] += 1

namespace["classrefs"].append(classref)

doc = ast.get_docstring(node)

if doc:

siglines, desclines = util.parsePyFuncDoc(doc)

if siglines:

namespace["signature"] = "\n".join(siglines)

if desclines:

namespace["doc"] = "\n".join(desclines)

self.st[nspath] = locals["symbols"][name] = namespace

self.nsstack.append(namespace)

self.generic_visit(node)

self.nsstack.pop()

def visit_FunctionDef(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

parent = self.nsstack[-1]

parentIsClass = _isclass(parent)

namespace = {

"types": {"function": 1},

"returns": {},

"arguments": [],

"symbols": {},

}

namespace["declaration"] = namespace

if node.lineno:

namespace["line"] = node.lineno

namespace["lineend"] = node.lineno

lastNode = node

while True:

try:

lastNode = list(ast.iter_child_nodes(lastNode))[-1]

if hasattr(lastNode, 'lineno'):

namespace["lineend"] = lastNode.lineno

except IndexError:

break

name = node.name

# Determine attributes

attributes = []

if name.startswith("__") and name.endswith("__"):

pass

elif name.startswith("__"):

attributes.append("private")

elif name.startswith("_"):

attributes.append("protected")

if name == "__init__" and parentIsClass:

attributes.append("__ctor__")

# process decorators

prop_var = None

if node.decorator_list:

for deco in node.decorator_list:

deco_name = getattr(deco, 'id', None)

prop_mode = None

if deco_name == 'staticmethod':

attributes.append("__staticmethod__")

continue

if deco_name == 'classmethod':

attributes.append("__classmethod__")

continue

if deco_name == 'property':

prop_mode = 'getter'

elif hasattr(deco, 'attrname') and deco.attrname in ('getter',

'setter',

'deleter'):

prop_mode = deco.attrname

if prop_mode:

if prop_mode == 'getter':

# it's a getter, create a pseudo-var

prop_var = parent["symbols"].get(name, None)

if prop_var is None:

prop_var = dict(name=name,

nspath=parent["nspath"] + (name,),

doc=None,

types={},

symbols={})

var_attrs = ['property']

if name.startswith("__") and name.endswith("__"):

pass

elif name.startswith("__"):

var_attrs.append("private")

elif name.startswith("_"):

var_attrs.append("protected")

prop_var["attributes"] = ' '.join(var_attrs)

prop_var["declaration"] = prop_var

parent["symbols"][name] = prop_var

if not "is-class-var" in prop_var:

prop_var["is-class-var"] = 1

# hide the function

attributes += ['__hidden__']

name += " (property %s)" % prop_mode

# only one property decorator makes sense

break

namespace["attributes"] = ' '.join(attributes)

if parentIsClass and name == "__init__":

fallbackSig = parent["name"]

else:

fallbackSig = name

namespace["name"] = name

nspath = parent["nspath"] + (name,)

namespace["nspath"] = nspath

# Handle arguments. The format of the relevant Function attributes

# makes this a little bit of pain.

node_args = node.args

defaultArgsBaseIndex = len(node_args.args) - len(node_args.defaults)

if node_args.kwarg:

defaultArgsBaseIndex -= 1

if node_args.vararg:

defaultArgsBaseIndex -= 1

varargsIndex = len(node_args.args) - 2

else:

varargsIndex = None

kwargsIndex = len(node_args.args) - 1

elif node_args.vararg:

defaultArgsBaseIndex -= 1

varargsIndex = len(node_args.args) - 1

kwargsIndex = None

else:

varargsIndex = kwargsIndex = None

sigArgs = []

for i in range(len(node_args.args)):

argName = node_args.args[i].arg

argument = {"name": argName,

"nspath": nspath + (argName,),

"doc": None,

"types": {},

"line": node.lineno,

"symbols": {}}

if i == kwargsIndex:

argument["attributes"] = "kwargs"

sigArgs.append("**" + argName)

elif i == varargsIndex:

argument["attributes"] = "varargs"

sigArgs.append("*" + argName)

elif i >= defaultArgsBaseIndex:

defaultNode = node_args.defaults[i - defaultArgsBaseIndex]

try:

argument["default"] = self._getExprRepr(defaultNode)

except PythonCILEError as ex:

raise PythonCILEError("unexpected default argument node "

"type for Function '%s': %s"

% (node.name, ex))

sigArgs.append(argName + '=' + argument["default"])

for t in self._guessTypes(defaultNode):

log.info("guessed type: %s ::= %s", argName, t)

if t not in argument["types"]:

argument["types"][t] = 0

argument["types"][t] += 1

else:

sigArgs.append(argName)

if i == 0 and parentIsClass:

# If this is a class method, then the first arg is the class

# instance.

className = self.nsstack[-1]["nspath"][-1]

argument["types"][className] = 1

argument["declaration"] = self.nsstack[-1]

arguments = [argument]

for argument in arguments:

if "declaration" not in argument:

argument[

"declaration"] = argument # namespace dict of the declaration

namespace["arguments"].append(argument)

namespace["symbols"][argument["name"]] = argument

# Drop first "self" argument from class method signatures.

# - This is a little bit of a compromise as the "self" argument

# should *sometimes* be included in a method's call signature.

if _isclass(parent) and sigArgs and "__staticmethod__" not in attributes:

# Delete the first "self" argument.

del sigArgs[0]

fallbackSig += "(%s)" % (", ".join(sigArgs))

if "__staticmethod__" in attributes:

fallbackSig += " - staticmethod"

elif "__classmethod__" in attributes:

fallbackSig += " - classmethod"

doc = ast.get_docstring(node)

if doc:

siglines, desclines = util.parsePyFuncDoc(doc, [fallbackSig])

namespace["signature"] = "\n".join(siglines)

if desclines:

namespace["doc"] = "\n".join(desclines)

else:

namespace["signature"] = fallbackSig

self.st[nspath] = parent["symbols"][name] = namespace

self.nsstack.append(namespace)

self.generic_visit(node)

self.nsstack.pop()

if prop_var:

# this is a property getter function,

# copy its return types to the corresponding property variable...

var_types = prop_var["types"]

for t in namespace["returns"]:

if t not in var_types:

var_types[t] = 0

else:

var_types[t] += 1

# ... as well as its line number

if "line" in namespace:

prop_var["line"] = namespace["line"]

def visit_Import(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

imports = self.nsstack[-1].setdefault("imports", [])

for alias in node.names:

import_ = {"module": alias.name}

if node.lineno:

import_["line"] = node.lineno

if alias.asname:

import_["alias"] = alias.asname

imports.append(import_)

def visit_ImportFrom(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

imports = self.nsstack[-1].setdefault("imports", [])

module = node.module or ''

if node.level > 0:

module = ("." * node.level) + module

for alias in node.names:

import_ = {"module": module, "symbol": alias.name}

if node.lineno:

import_["line"] = node.lineno

if alias.asname:

import_["alias"] = alias.asname

imports.append(import_)

# XXX

# def visit_Return(self, node):

# # set __rettypes__ on Functions

# pass

# def visit_Global(self, node):

# # note for future visitAssign to control namespace

# pass

# def visit_Yield(self, node):

# # modify the Function into a generator??? what are the implications?

# pass

# def visit_Assert(self, node):

# # support the assert hints that Wing does

# pass

def _assignVariable(self, varName, namespace, rhsNode, line,

isClassVar=0):

"""Handle a simple variable name assignment.

log.debug("_assignVariable(varName=%r, namespace %s, rhsNode=%r, "

"line, isClassVar=%r)", varName,

'.'.join(namespace["nspath"]), rhsNode, isClassVar)

variable = namespace["symbols"].get(varName, None)

new_var = False

if variable is None:

new_var = True

variable = {"name": varName,

"nspath": namespace["nspath"]+(varName,),

# Could try to parse documentation from a near-by

# string.

"doc": None,

# 'types' is a dict mapping a type name to the number

# of times this was guessed as the variable type.

"types": {},

"symbols": {}}

# Determine attributes

attributes = []

if varName.startswith("__") and varName.endswith("__"):

pass

elif varName.startswith("__"):

attributes.append("private")

elif varName.startswith("_"):

attributes.append("protected")

variable["attributes"] = ' '.join(attributes)

variable["declaration"] = variable

if line:

variable["line"] = line

namespace["symbols"][varName] = variable

if isClassVar and not "is-class-var" in variable:

variable["is-class-var"] = 1

# line number of first class-level assignment wins

if line:

variable["line"] = line

if (not new_var and

_isfunction(variable) and

isinstance(rhsNode, ast.Call) and

rhsNode.args and

isinstance(rhsNode.args[0], ast.Name) and

variable["name"] == rhsNode.args[0].id

):

# a speial case for 2.4-styled decorators

return

varTypes = variable["types"]

for t in self._guessTypes(rhsNode, namespace):

log.info("guessed type: %s ::= %s", varName, t)

if t not in varTypes:

varTypes[t] = 0

varTypes[t] += 1

def _visitSimpleAssign(self, lhsNode, rhsNode, line):

"""Handle a simple assignment: assignment to a symbol name or to

log.debug("_visitSimpleAssign(lhsNode=%r, rhsNode=%r)", lhsNode,

rhsNode)

if isinstance(lhsNode, ast.Name):

# E.g.: foo = ...

# Assign this to the local namespace, unless there was a

# 'global' statement. (XXX Not handling 'global' yet.)

ns = self.nsstack[-1]

self._assignVariable(lhsNode.id, ns, rhsNode, line,

isClassVar=_isclass(ns))

elif isinstance(lhsNode, ast.Attribute):

# E.g.: foo.bar = ...

# If we can resolve "foo", then we update that namespace.

variable, citdl = self._resolveObjectRef(lhsNode.value)

if variable:

self._assignVariable(lhsNode.attr,

variable["declaration"], rhsNode, line)

else:

log.debug("could not handle simple assign (module '%s'): "

"lhsNode=%r, rhsNode=%r", self.moduleName, lhsNode,

rhsNode)

def visit_Assign(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

lhsNode = node.targets[0]

rhsNode = node.value

if isinstance(lhsNode, (ast.Name, ast.Attribute)):

# E.g.:

# foo = ... (Name)

# foo.bar = ... (Attribute)

self._visitSimpleAssign(lhsNode, rhsNode, node.lineno)

elif isinstance(lhsNode, (ast.Tuple, ast.List)):

# E.g.:

# foo, bar = ...

# [foo, bar] = ...

# If the RHS is a sequence with the same number of elements,

# then we update each assigned-to variable. Otherwise, bail.

if isinstance(rhsNode, (ast.Tuple, ast.List)):

if len(lhsNode.elts) == len(rhsNode.elts):

for i in range(len(lhsNode.elts)):

self._visitSimpleAssign(lhsNode.elts[i],

rhsNode.elts[i],

node.lineno)

elif isinstance(rhsNode, ast.Dict):

if len(lhsNode.elts) == len(rhsNode.keys):

for i in range(len(lhsNode.elts)):

self._visitSimpleAssign(lhsNode.elts[i],

rhsNode.keys[i],

node.lineno)

elif isinstance(rhsNode, ast.Call):

for i in range(len(lhsNode.elts)):

self._visitSimpleAssign(lhsNode.elts[i],

None, # we don't have a good type.

node.lineno)

else:

log.info(

"visitAssign:: skipping unknown rhsNode type: %r - %r",

type(rhsNode), rhsNode)

elif isinstance(lhsNode, ast.Slice):

# E.g.: bar[1:2] = "foo"

# We don't bother with these: too hard.

log.info("visitAssign:: skipping slice - too hard")

pass

elif isinstance(lhsNode, ast.Subscript):

# E.g.: bar[1] = "foo"

# We don't bother with these: too hard.

log.info("visitAssign:: skipping subscript - too hard")

pass

else:

raise PythonCILEError("unexpected type of LHS of assignment: %r"

% lhsNode)

def _handleUnknownAssignment(self, assignNode, lineno):

if isinstance(assignNode, ast.Name):

self._visitSimpleAssign(assignNode, None, lineno)

elif isinstance(assignNode, ast.Tuple):

for anode in assignNode.elts:

self._visitSimpleAssign(anode, None, lineno)

def visit_For(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

# E.g.:

# for foo in ...

# None: don't bother trying to resolve the type of the RHS

self._handleUnknownAssignment(node.target, node.lineno)

self.generic_visit(node)

def visit_With(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

for item in node.items:

self._handleUnknownAssignment(item.context_expr, node.lineno)

self.generic_visit(node)

def visit_Try(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, getattr(node, 'lineno', '?'), self.lines and hasattr(node, 'lineno') and self.lines[node.lineno - 1], node._fields)

for body in node.body:

self.visit(body)

for handler in node.handlers:

try:

if handler.name:

lineno = handler.lineno

self._handleUnknownAssignment(handler.name, lineno)

for body in handler.body:

self.visit(body)

except IndexError:

pass

for orelse in node.orelse:

self.visit(orelse)

for finalbody in node.finalbody:

self.visit(finalbody)

def _resolveObjectRef(self, expr):

"""Try to resolve the given expression to a variable namespace.

log.debug("_resolveObjectRef(expr=%r)", expr)

if isinstance(expr, ast.Name):

name = expr.id

nspath = self.nsstack[-1]["nspath"]

for i in range(len(nspath), -1, -1):

ns = self.st[nspath[:i]]

if name in ns["symbols"]:

return (ns["symbols"][name], None)

else:

log.debug(

"_resolveObjectRef: %r not in namespace %r", name,

'.'.join(ns["nspath"]))

elif isinstance(expr, ast.Attribute):

obj, citdl = self._resolveObjectRef(expr.value)

decl = obj and obj["declaration"] or None # want the declaration

if (decl # and "symbols" in decl #XXX this "and"-part necessary?

and expr.attr in decl["symbols"]):

return (decl["symbols"][expr.attr], None)

elif isinstance(expr.value, ast.Num):

# Special case: specifically refer to type object for

# attribute access on constants, e.g.:

# ' '.join

citdl = "__builtins__.%s.%s"\

% ((type(expr.value.n).__name__), expr.attr)

return (None, citdl)

# XXX Could optimize here for common built-in attributes. E.g.,

# we *know* that str.join() returns a string.