self.paramname = paramname

self.paramtype = paramtype

self.doc = doc

if paramname:

self.optional = paramname[0] == '[' and paramname[-1] == ']'

name = paramname[1:-1] if self.optional else paramname

name, _, default = name.partition('=')

self.name = name.strip()

self.default = default.strip()

else:

self.name = None

self.default = None

self.optional = None

if paramtype:

paramtype = paramtype.strip()

paramtype = paramtype.lstrip('{') # FIXME: Bug in JSDoc "{string|function}" gets "{string"

self.type = JSDocParameter.type_map.get(paramtype.lower(), paramtype)

else:

def __init__(self, comment=None, strip_html_tags=False):

RealJSDoc.__init__(self, comment=comment, strip_html_tags=strip_html_tags)

params_dict = {}

for param in self.params:

params_dict[param.paramname] = param

return (len(namespace["types"]) == 1 and CITDL_OBJECT in namespace["types"] or (

CITDL_MODULE not in namespace["types"] and

CITDL_CLASS not in namespace["types"] and

CITDL_INTERFACE not in namespace["types"] and

CITDL_FUNCTION not in namespace["types"] and

CITDL_REQUIRE not in namespace["types"] and

"""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, six.string_types):

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

elif isinstance(value, six.text_type):

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 ECMAScript 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, six.text_type):

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

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

if isinstance(x, six.text_type):

return x

elif isinstance(x, six.binary_type):

return x.decode('utf8')

else:

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

line=node.get("line"),

lineend=node.get("lineend"),

start=node.get("start"),

end=node.get("end"),

doc=node.get("doc"),

attributes=" ".join(node.get("attributes", []) + extra_attributes) or None,

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

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

for item in sorted(reversed(list(guesses.items())), key=lambda x: -x[1]):

citdl = item[0]

if citdl:

ts = citdl.split(None, 1)

# Don't emit void types, it does not help us.

if ts[0] not in CITDL_EMPTY:

citdl = ts[0] # XXX Drop the <start-scope> part of CITDL for now.

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

DEBUG = 0

def __init__(self, moduleName=None, content=None, filename=None, lang='ECMAScript'):

self.lang = lang

if self.DEBUG is None:

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

self.moduleName = moduleName

self.content = content

self.filename = filename

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

self.uniques = {}

def _unique_id(self, name):

if name not in self.uniques:

self.uniques[name] = 0

unique_name = "____%s_%s" % (name, self.uniques[name])

self.uniques[name] += 1

return unique_name

def get_type(self, obj):

typ = type(obj.value)

return {

type(None): CITDL_NULL,

type(u''): CITDL_STRING,

type(b''): CITDL_STRING,

type(1): CITDL_NUMBER,

type(1.1): CITDL_NUMBER,

type(1 == 1): CITDL_BOOLEAN,

type(re.compile('')): CITDL_REGEXP,

}.get(typ, typ.__name__)

def get_repr(self, obj):

if obj.regex:

r = "/%s/%s" % (obj.regex.pattern, obj.regex.flags)

elif isinstance(obj.value, six.text_type):

r = repr(obj.value).lstrip('bur')

else:

r = repr(obj.value)

return r

def parse(self, **kwargs):

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

convertor = None

log.info('FILE: %s', self.filename)

self.tree = _getAST(convertor, self.content, self.filename, **kwargs)

# log.debug('TREE: %r', self.tree)

def generic_visit(self, node):

"""Called if no explicit visitor function exists for a node."""

# log.info("GENERIC visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

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

def generic_transform(self, node, metadata):

"""Called if no explicit visitor function exists for a node."""

# log.info("GENERIC transform_%s:%s: %r %r", node.__class__.__name__, metadata.start.line, self.lines and metadata.start.line and self.lines[metadata.start.line - 1], node.keys())

return super(AST2CIXVisitor, self).generic_transform(node, metadata)

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 CITDL_MODULE in node["types"]

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

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=False):

# 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=False):

if _isclass(node):

self.cix_class(node)

elif _isinterface(node):

self.cix_interface(node)

elif _isfunction(node):

self.cix_function(node)

elif _isobject(node):

self.cix_object(node)

else:

self.cix_variable(node, parentIsClass)

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

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

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

extra_attributes = []

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

# Special CodeIntel <variable> attribute to distinguish from the

# usual class variables.

extra_attributes.append(__INSTANCEVAR__)

citdl = _node_citdl(node)

required_library_name = node.get("required_library_name")

attrs = _node_attrs(node,

citdl=citdl,

required_library_name=required_library_name,

extra_attributes=extra_attributes)

self.emit_start('variable', attrs)

self.cix_symbols(node["symbols"])

self.emit_end('variable')

def cix_class(self, node):

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

if node.get("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

extra_attributes = []

attrs = _node_attrs(node,

extra_attributes=extra_attributes,

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=True)

self.emit_end('scope')

def cix_interface(self, node):

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

if node.get("interfacerefs"):

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

if t is not None)

interfacerefs = " ".join(citdls)

else:

interfacerefs = None

extra_attributes = []

attrs = _node_attrs(node,

extra_attributes=extra_attributes,

signature=node.get("signature"),

ilk="interface",

interfacerefs=interfacerefs)

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_object(self, node):

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

if node.get("objectrefs"):

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

if t is not None)

objectrefs = " ".join(citdls)

else:

objectrefs = None

extra_attributes = []

citdl = _node_citdl(node)

required_library_name = node.get("required_library_name")

attrs = _node_attrs(node,

extra_attributes=extra_attributes,

signature=node.get("signature"),

ilk="object",

citdl=citdl,

required_library_name=required_library_name,

objectrefs=objectrefs)

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_argument(self, node):

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

extra_attributes = []

citdl = _node_citdl(node)

required_library_name = node.get("required_library_name")

attrs = _node_attrs(node,

extra_attributes=extra_attributes,

citdl=citdl,

required_library_name=required_library_name,

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

extra_attributes = []

attrs = _node_attrs(node,

extra_attributes=extra_attributes,

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 _parseMemberExpression(self, expr, base):

object, _, property = expr.rpartition('.')

property = esprima.nodes.Identifier(property)

property.loc = base.loc

property.range = base.range

if object:

expression = esprima.nodes.StaticMemberExpression(self._parseMemberExpression(object, base), property)

expression.loc = base.loc

expression.range = base.range

return expression

return property

def visit_Module(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

nspath = ()

namespace = {"name": self.moduleName,

"nspath": nspath,

"types": OrderedDict({CITDL_MODULE: 0}),

"symbols": {}}

doc = None

if node.body:

leadingComments = node.body[0].leadingComments

if leadingComments:

doc = "/*%s*/" % "\n".join(d.value for d in leadingComments if d.value.startswith('*'))

jsdoc = JSDoc(doc) if doc else None

if jsdoc:

if jsdoc.doc:

namespace["doc"] = jsdoc.doc

self.st[nspath] = namespace

self.nsstack.append(namespace)

self.generic_visit(node)

self.nsstack.pop()

def visit_ReturnStatement(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

self.generic_visit(node)

# If there's already a variable assigned to the node, use it:

variable = node.argument and node.argument._variable

if variable:

if _isclass(variable) or _isinterface(variable) or _isfunction(variable) or _isobject(variable) or _isrequire(variable):

citdl_types = [".".join(variable["nspath"])]

else:

citdl_types = list(variable["types"].keys())

else:

citdl_types = self._guessTypes(node.argument)

for citdl in citdl_types:

if citdl:

ts = citdl.split(None, 1)

if ts[0] not in CITDL_EMPTY:

func_node = self.nsstack[-1]

if "returns" in func_node:

t = func_node["returns"]

citdl = ts[0] # XXX Drop the <start-scope> part of CITDL for now.

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

def _createObject(self, type, parent, node, extra_attributes):

nspath = parent["nspath"]

namespace = {

"types": OrderedDict({type: 0}),

"%srefs" % type: [],

"symbols": {},

}

bodies = node.body

if bodies and not isinstance(bodies, list):

bodies = bodies.body

if bodies and not isinstance(bodies, list):

bodies = [bodies]

doc = None

if node.body:

leadingComments = node.leadingComments

if leadingComments:

doc = "/*%s*/" % "\n".join(d.value for d in leadingComments if d.value.startswith('*'))

jsdoc = JSDoc(doc) if doc else None

if jsdoc:

if jsdoc.doc:

namespace["doc"] = jsdoc.doc

namespace["declaration"] = namespace

namespace["line"] = node.loc.start.line

namespace["start"] = node.range[0]

namespace["end"] = node.range[1]

if bodies:

lastNode = bodies[-1]

namespace["lineend"] = lastNode.loc.end.line

namespace["end"] = lastNode.range[1]

name = None

if node._member or node._field:

if node._member:

name = node._member.property.name

else: # if node._field:

name = node._field.name

if not name and node.id:

name = node.id.name

if not name and node.name:

name = node.name

if not name:

name = self._unique_id(type)

nspath = nspath + (name,)

namespace["nspath"] = nspath

namespace["name"] = name

# self.st[nspath] = namespace # Objects don't add to the scope's symbol table

parent["symbols"][name] = namespace

attributes = []

namespace["attributes"] = attributes

namespace["attributes"].extend(extra_attributes)

node._parent = parent

node._variable = namespace

return namespace

def visit_JSXElement(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

self._visitJSXElement(node)

def _visitJSXElement(self, node, extra_attributes=[]):

parent = self.nsstack[-1]

node.name = self._unique_id(node.openingElement.name.name)

namespace = self._createObject(CITDL_OBJECT, parent, node, extra_attributes)

namespace["objectrefs"] = [{"name": "Object", "types": OrderedDict({CITDL_INSTANCE: 0})}]

# Guess JSX element type:

for citdl in self._guessTypes(node.openingElement.name.name):

# ts = citdl.split(None, 1)

# ts[0] += "()"

# citdl = " ".join(ts)

if citdl not in namespace["types"]:

namespace["types"][citdl] = 0

namespace["types"][citdl] += 1

namespace["attributes"].append("__jsx__")

self.nsstack.append(namespace)

node.openingElement.name = "props"

props = self._createObject(CITDL_OBJECT, namespace, node.openingElement, extra_attributes)

props["types"][CITDL_INSTANCE] = 0

props["objectrefs"] = [{"name": "Object", "types": OrderedDict({CITDL_INSTANCE: 0})}]

self.nsstack.append(props)

self.visit(node.openingElement)

self.nsstack.pop()

if node.children:

for child in node.children:

self.visit(child)

if node.closingElement:

self.visit(node.closingElement)

self.nsstack.pop()

if __EXPORTED__ in extra_attributes:

default = self._parseMemberExpression("exports." + namespace["name"], node)

name = self._parseMemberExpression(namespace["name"], node)

name._member = default

self._visitSimpleAssign(default, name, node.loc.start.line, node.range[0], node.range[1])

def visit_JSXAttribute(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

self._visitAssign(node.name, node.value, node.loc.start.line, node.range[0], node.range[1])

def visit_ExportAllDeclaration(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

exports, citdl = self._resolveObjectRef(u"exports")

exports["types"][CITDL_REQUIRE] = 0

exports["required_library_name"] = node.source.value

if "line" not in exports:

exports["line"] = node.loc.start.line

exports["start"] = node.range[0]

exports["end"] = node.range[1]

self.generic_visit(node)

def visit_ExportNamedDeclaration(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

exports, citdl = self._resolveObjectRef(u"exports")

self.nsstack.append(exports)

if node.source:

self._addImports(node)

if node.specifiers:

for specifier in node.specifiers:

typ = specifier.type

if typ is esprima.Syntax.ExportDefaultSpecifier:

specifier.exported = specifier.local

declaration = specifier.exported if node.source else specifier.local

# Try resolving the variable for the declaration and use the line where it was declared

variable, citdl = self._resolveObjectRef(declaration)

if variable:

line = variable.get('line', node.loc.start.line)

start = variable.get('start', node.range[0])

end = variable.get('end', node.range[1])

else:

line = node.loc.start.line

start = node.range[0]

end = node.range[1]

self._visitAssign(specifier.exported, declaration, line, start, end, extra_attributes=["__no_defn__"])

self.nsstack.pop()

if node.declaration:

typ = node.declaration.type

if typ is esprima.Syntax.VariableDeclaration:

self._visitVariableDeclaration(node.declaration, extra_attributes=[__EXPORTED__])

elif typ is esprima.Syntax.AssignmentExpression:

self._visitAssignmentExpression(node.declaration, extra_attributes=[__EXPORTED__])

elif typ is esprima.Syntax.ObjectExpression:

self._visitObject(node.declaration, extra_attributes=[__EXPORTED__])

elif typ in (esprima.Syntax.ClassDeclaration, esprima.Syntax.ClassExpression):

self._visitClass(node.declaration, extra_attributes=[__EXPORTED__])

elif typ in (esprima.Syntax.FunctionDeclaration, esprima.Syntax.FunctionExpression):

self._visitFunction(node.declaration, extra_attributes=[__EXPORTED__])

else:

self.generic_visit(node)

def visit_ExportDefaultDeclaration(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

exports, citdl = self._resolveObjectRef(u"exports")

self.nsstack.append(exports)

default = self._parseMemberExpression(u"default", node)

node.declaration._field = default

typ = node.declaration.type

if typ is esprima.Syntax.AssignmentExpression:

self._visitAssignmentExpression(node.declaration)

declaration = node.declaration.left

else:

self.visit(node.declaration)

declaration = node.declaration

# Try resolving the variable for the declaration and use the line where it was declared

variable, citdl = self._resolveObjectRef(declaration)

if variable:

line = variable.get('line', node.loc.start.line)

start = variable.get('start', node.range[0])

end = variable.get('end', node.range[1])

else:

line = node.loc.start.line

start = node.range[0]

end = node.range[1]

if typ in (esprima.Syntax.Identifier, esprima.JSXSyntax.JSXIdentifier, esprima.Syntax.MemberExpression):

extra_attributes = ["__no_defn__"]

else:

extra_attributes = []

self._visitSimpleAssign(default, declaration, line, start, end, extra_attributes=extra_attributes)

self.nsstack.pop()

def visit_ObjectExpression(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

for prop in node.properties:

if prop.type is esprima.Syntax.Property and not prop.computed:

prop.value._member = esprima.nodes.StaticMemberExpression(prop.value, prop.key)

prop.value._member.loc = prop.value.loc

prop.value._member.range = prop.value.range

self._visitObject(node)

def _visitObject(self, node, extra_attributes=[]):

parent = self.nsstack[-1]

namespace = self._createObject(CITDL_OBJECT, parent, node, extra_attributes)

namespace["types"][CITDL_INSTANCE] = 0

namespace["objectrefs"] = [{"name": "Object", "types": OrderedDict({CITDL_INSTANCE: 0})}]

self.nsstack.append(namespace)

self.generic_visit(node)

self.nsstack.pop()

if __EXPORTED__ in extra_attributes:

default = self._parseMemberExpression("exports." + namespace["name"], node)

name = self._parseMemberExpression(namespace["name"], node)

name._member = default

self._visitSimpleAssign(default, name, node.loc.start.line, node.range[0], node.range[1])

def visit_Property(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

# Propagate comments:

if not node.value.leadingComments and node.leadingComments:

node.value.leadingComments = node.leadingComments

self.generic_visit(node)

if not node.computed:

self._visitSimpleAssign(node.key, node.value, node.loc.start.line, node.range[0], node.range[1])

def visit_SpreadElement(self, node):

log.info("visit_%s:%s: %r %r", node.__class__.__name__, node.loc.start.line, self.lines and node.loc.start.line and self.lines[node.loc.start.line - 1], node.keys())

self.generic_visit(node)

namespace = self.nsstack[-1]

if "objectrefs" in namespace: