Parse function-style extended attributes part #1

client/dom/scripts/idlnode.py

 #!/usr/bin/python
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 import sys
 
 
 class IDLNode(object):
   """Base class for all IDL elements.
@@ skipping 39 matching lines @@
     """Returns a list containing this node and all it child nodes
     (recursive).
 
     Args:
       type_filter -- can be used to limit the results to a specific
         node type (e.g. IDLOperation).
     """
     res = []
     if type_filter is None or isinstance(self, type_filter):
       res.append(self)
-    for (k, v) in self.__dict__.items():
+    for v in self._all_subnodes():
       if isinstance(v, IDLNode):
         res.extend(v.all(type_filter))
       elif isinstance(v, list):
         for item in v:
           if isinstance(item, IDLNode):
             res.extend(item.all(type_filter))
     return res
 
+  def _all_subnodes(self):
+    """Accessor used by all() to find subnodes."""
+    return self.__dict__.values()
+
   def to_dict(self):
     """Converts the IDLNode and its children into a dictionary.
     This method is useful mostly for debugging and pretty printing.
     """
     res = {}
     for (k, v) in self.__dict__.items():
       if v == None or v == False or v == [] or v == {}:
         # Skip empty/false members.
         continue
       elif isinstance(v, IDLDictNode) and not len(v):
@@ skipping 144 matching lines @@
     The IDLDictNode members are copied into a new dictionary, and
     IDLNode members are recursively converted into dicts as well.
     """
     res = {}
     for (k, v) in self.__map.items():
       if isinstance(v, IDLNode):
         v = v.to_dict()
       res[k] = v
     return res
 
-  def all(self, node_filter):
-    """Overrides the default IDLNode.all recursive operator."""
-    if node_filter is None or isinstance(self, node_filter):
-      return [self]
+  def _all_subnodes(self):
+    # Usually an IDLDictNode does not contain further IDLNodes.
     return []
 
 
 class IDLFile(IDLNode):
   """IDLFile is the top-level node in each IDL file. It may contain
   modules or interfaces."""
 
   def __init__(self, ast, filename=None):
     IDLNode.__init__(self, ast)
     self.filename = filename
@@ skipping 20 matching lines @@
   def __init__(self, ast=None):
     IDLDictNode.__init__(self, None)
     if not ast:
       return
     ext_attrs_ast = self._find_first(ast, 'ExtAttrs')
     if not ext_attrs_ast:
       return
     for ext_attr in self._find_all(ext_attrs_ast, 'ExtAttr'):
       name = self._find_first(ext_attr, 'Id')
       value = self._find_first(ext_attr, 'ExtAttrValue')
+
       func_value = self._find_first(value, 'ExtAttrFunctionValue')
       if func_value:
-        # TODO: Parse ExtAttrFunctionValue.  It is used only for
-        # NamedConstructor which is ignored.
-        pass
-      else:
-        self[name] = value
+        # E.g. NamedConstructor=Audio(in [Optional] DOMString src)
+        self[name] = IDLExtAttrFunctionValue(
+            func_value,
+            self._find_first(func_value, 'ExtAttrArgList'))
+        continue
+
+      ctor_args = not value and self._find_first(ext_attr, 'ExtAttrArgList')
+      if ctor_args:
+        # E.g. Constructor(Element host)
+        self[name] = IDLExtAttrFunctionValue(None, ctor_args)
+        continue
+
+      self[name] = value
+
+  def _all_subnodes(self):
+    # Extended attributes may contain IDLNodes, e.g. IDLExtAttrFunctionValue
+    return self.values()
+
+
+class IDLExtAttrFunctionValue(IDLNode):
+  """IDLExtAttrFunctionValue."""
+  def __init__(self, func_value_ast, arg_list_ast):
+    IDLNode.__init__(self, func_value_ast)
+    self.arguments = self._convert_all(arg_list_ast, 'Argument', IDLArgument)
 
 
 class IDLType(IDLNode):
   """IDLType is used to describe constants, attributes and operations'
   return and input types. IDLType matches AST labels such as ScopedName,
   StringType, VoidType, IntegerType, etc."""
 
   def __init__(self, ast):
     IDLNode.__init__(self, ast)
     # Search for a 'ScopedName' or any label ending with 'Type'.
@@ skipping 167 matching lines @@
   """IDLDictNode specialization for one annotation."""
   def __init__(self, ast=None):
     IDLDictNode.__init__(self, ast)
     self.id = None
     if not ast:
       return
     for arg in self._find_all(ast, 'AnnotationArg'):
       name = self._find_first(arg, 'Id')
       value = self._find_first(arg, 'AnnotationArgValue')
       self[name] = value