Support WebIDL's ExtendedAttributeIdentList in the Blink parser

Source/bindings/scripts/utilities.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Utility functions (file reading, simple IDL parsing by regexes) for IDL build.
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-build
 """
 
 import os
@@ skipping 135 matching lines @@
                       r'(interface|exception)\s+'
                       r'\w+\s*'
                       r'(:\s*\w+\s*)?'
                       r'{',
                       file_contents, flags=re.DOTALL)
     if not match:
         return {}
 
     extended_attributes_string = match.group(1)
     extended_attributes = {}
-    # FIXME: this splitting is WRONG: it fails on ExtendedAttributeArgList like
-    # 'NamedConstructor=Foo(a, b)'
+    # FIXME: this splitting is WRONG: it fails on extended attributes where lists of
+    # multiple values are used, which are seperated by a comma and a space.
     parts = [extended_attribute.strip()
-             for extended_attribute in extended_attributes_string.split(',')
+             for extended_attribute in re.split(',\s+', extended_attributes_string)

[haraken, 2014/08/06 01:08:48]

I wonder if this should be re.split(',\s*', ...)

You want to split:

"a,b" => ["a", "b"]
"a, b" => ["a", "b"]

don't you?

[Peter Beverloo, 2014/08/07 13:32:37]

This regular expression essentially is mimicing the ExtendedAttributeList IDL
rule -- it creates a list of the extended attributes, together with their
values.

Given the following IDL extended attribute block:

[Foo,
 Bar=Baz(a, b),
 Cond=(A,B),]

In the previous hack, the following would happen:
    len=5, having ("Foo", "Bar=Baz(a", "b)", "Cond=(A", "B)")

In the new hack, the following will happen:
    len=4, having ("Foo", "Bar=Baz(a", "b)", "Cond=(A,B)")

Since \s* means zero or more spaces, the expression would be identical to the
comma-split we previously did.

It's a hack, but it's compatible with the Blink IDL style. The real solution
here would be to have a smarter parsing mechanism, ideally using the normal IDL
parser, but I suspect that there will be performance worries.

[haraken, 2014/08/07 14:16:34]

Makes sense. Since we don't care about performance of the IDL compiler, it's
better to integrate the logic to the normal IDL parser.

              # Discard empty parts, which may exist due to trailing comma
              if extended_attribute.strip()]
     for part in parts:
         name, _, value = map(string.strip, part.partition('='))
         extended_attributes[name] = value
     return extended_attributes
 
 
 def get_put_forward_interfaces_from_idl(file_contents):
     put_forwards_pattern = (r'\[[^\]]*PutForwards=[^\]]*\]\s+'
                             r'readonly\s+'
                             r'attribute\s+'
                             r'(\w+)')
     return sorted(set(match.group(1)
                       for match in re.finditer(put_forwards_pattern,
                                                file_contents,
                                                flags=re.DOTALL)))