Support union return type for anonymous named/indexed getter

Source/bindings/scripts/IDLParser.pm

Index: Source/bindings/scripts/IDLParser.pm
diff --git a/Source/bindings/scripts/IDLParser.pm b/Source/bindings/scripts/IDLParser.pm
index 177f3e919b1d9c2be73f0bd92942f328ad1bf95c..0bd6928bd38e1fd88d7aa1e0225fa07bc9a07e5f 100644
--- a/Source/bindings/scripts/IDLParser.pm
+++ b/Source/bindings/scripts/IDLParser.pm
@@ -64,7 +64,7 @@ struct( domFunction => {
 
 # Used to represent domInterface contents (name of attribute, signature)
 struct( domAttribute => {
-    type => '$',              # Attribute type (including namespace)
+    type => '$',              # Attribute type (including namespace) (string or UnionType)
     isStatic => '$',
     isReadOnly => '$',
     signature => '$',         # Attribute signature
@@ -75,7 +75,7 @@ struct( domAttribute => {
 # Used to represent a map of 'variable name' <-> 'variable type'
 struct( domSignature => {
     name => '$',      # Variable name
-    type => '$',      # Variable type
+    type => '$',      # Variable type (string or UnionType)
     specials => '@',  # Specials
     extendedAttributes => '$', # Extended attributes
     isOptional => '$', # Is variable optional (optional T)
@@ -107,6 +107,10 @@ struct( Typedef => {
     type => '$', # Type of data
 });
 
+struct( UnionType => {
+    unionMemberTypes => '@', # (UnionType or string)[]
+});
+
 # Maps 'typedef name' -> Typedef
 my %typedefs = ();
 
@@ -1751,9 +1755,10 @@ sub parseType
     my $self = shift;
     my $next = $self->nextToken();
     if ($next->value() eq "(") {
-        $self->parseUnionType();
-        $self->parseTypeSuffix();
-        return;
+        my $unionType = $self->parseUnionType();
+        my $suffix = $self->parseTypeSuffix();
+        die "Suffix after UnionType is not supported." if $suffix ne "";
+        return $unionType;
     }
     if ($next->type() == IdentifierToken || $next->value() =~ /$nextType_1/) {
         return $self->parseSingleType();
@@ -1780,36 +1785,38 @@ sub parseUnionType
     my $self = shift;
     my $next = $self->nextToken();
     if ($next->value() eq "(") {
+        my $unionType = UnionType->new();
         $self->assertTokenValue($self->getToken(), "(", __LINE__);
-        $self->parseUnionMemberType();
+        push @{$unionType->unionMemberTypes}, $self->parseUnionMemberType();
         $self->assertTokenValue($self->getToken(), "or", __LINE__);
-        $self->parseUnionMemberType();
-        $self->parseUnionMemberTypes();
+        push @{$unionType->unionMemberTypes}, $self->parseUnionMemberType();
+        push @{$unionType->unionMemberTypes}, $self->parseUnionMemberTypes();

[haraken, 2013/05/16 05:38:05]

Is this correct for three or more UnionTypes? Remember that
$self->parseUnionMemberTypes() returns an array. I guess we will end up [type,
type, [type, type, [type, type, [...]]]].

[kojih, 2013/05/16 05:51:20]

I confirmed following.

interface TestInterface {
    [ImplementedAs=getItem] getter (Node or NodeList or Element)(DOMString
name);
};

become

$VAR1 = bless( {
                 'UnionType::unionMemberTypes' => [
                                                    'Node',
                                                    'NodeList',
                                                    'Element'
                                                  ]
               }, 'UnionType' );

#List in Perl is strange :)

         $self->assertTokenValue($self->getToken(), ")", __LINE__);
-        return;
+        return $unionType;
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
 
+# Returns UnionType or string
 sub parseUnionMemberType
 {
     my $self = shift;
     my $next = $self->nextToken();
     if ($next->value() eq "(") {
-        $self->parseUnionType();
-        $self->parseTypeSuffix();
-        return;
+        my $unionType = $self->parseUnionType();
+        my $suffix = $self->parseTypeSuffix();
+        die "Suffix after UnionType is not supported." if $suffix ne "";
+        return $unionType;
     }
     if ($next->value() eq "any") {
-        $self->assertTokenValue($self->getToken(), "any", __LINE__);
-        $self->assertTokenValue($self->getToken(), "[", __LINE__);
-        $self->assertTokenValue($self->getToken(), "]", __LINE__);
-        $self->parseTypeSuffix();
-        return;
+        my $type = $self->assertTokenValue($self->getToken(), "any", __LINE__);
+        $type .= $self->assertTokenValue($self->getToken(), "[", __LINE__);
+        $type .= $self->assertTokenValue($self->getToken(), "]", __LINE__);
+        $type .= $self->parseTypeSuffix();
+        return $type;
     }
     if ($next->type() == IdentifierToken || $next->value() =~ /$nextSingleType_1/) {
-        $self->parseNonAnyType();
-        return;
+        return $self->parseNonAnyType();
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
@@ -1817,12 +1824,14 @@ sub parseUnionMemberType
 sub parseUnionMemberTypes
 {
     my $self = shift;
+    my @types = ();
     my $next = $self->nextToken();
     if ($next->value() eq "or") {
         $self->assertTokenValue($self->getToken(), "or", __LINE__);
-        $self->parseUnionMemberType();
-        $self->parseUnionMemberTypes();
+        push @types, $self->parseUnionMemberType();
+        push @types, $self->parseUnionMemberTypes();
     }
+    return @types;
 }
 
 sub parseNonAnyType