Support union return type for anonymous named/indexed getter

Source/bindings/scripts/IDLParser.pm

 # 
 # KDOM IDL parser
 #
 # Copyright (C) 2005 Nikolas Zimmermann <wildfox@kde.org>
 # 
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Library General Public
 # License as published by the Free Software Foundation; either
 # version 2 of the License, or (at your option) any later version.
 # 
@@ skipping 46 matching lines @@
 
 # Used to represent domInterface contents (name of method, signature)
 struct( domFunction => {
     isStatic => '$',
     signature => '$',    # Return type/Object name/extended attributes
     parameters => '@',    # List of 'domSignature'
 });
 
 # 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
     getterExceptions => '@',  # Possibly raised exceptions.
     setterExceptions => '@',  # Possibly raised exceptions.
 });
 
 # 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)
     isNullable => '$', # Is variable type Nullable (T?)
     isVariadic => '$' # Is variable variadic (long... numbers)
 });
 
 # Used to represent string constants
 struct( domConstant => {
     name => '$',      # DOM Constant identifier
@@ skipping 11 matching lines @@
 struct( Token => {
     type => '$', # type of token
     value => '$' # value of token
 });
 
 struct( Typedef => {
     extendedAttributes => '$', # Extended attributes
     type => '$', # Type of data
 });
 
+struct( UnionType => {
+    unionMemberTypes => '@', # (UnionType or string)[]
+});
+
 # Maps 'typedef name' -> Typedef
 my %typedefs = ();
 
 sub new {
     my $class = shift;
 
     my $emptyToken = Token->new();
     $emptyToken->type(EmptyToken);
     $emptyToken->value("empty");
 
@@ skipping 1624 matching lines @@
         return $self->getToken()->value();
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
 
 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();
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
 
 sub parseSingleType
 {
     my $self = shift;
     my $next = $self->nextToken();
     if ($next->value() eq "any") {
         $self->assertTokenValue($self->getToken(), "any", __LINE__);
         return "any" . $self->parseTypeSuffixStartingWithArray();
     }
     if ($next->type() == IdentifierToken || $next->value() =~ /$nextSingleType_1/) {
         return $self->parseNonAnyType();
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
 
 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();
         $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__);
 }
 
 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
 {
     my $self = shift;
     my $next = $self->nextToken();
     if ($next->value() =~ /$nextNonAnyType_1/) {
         return $self->parsePrimitiveType() . $self->parseTypeSuffix();
     }
     if ($next->value() eq "ByteString") {
@@ skipping 379 matching lines @@
             $customConstructor->{overloadedIndex} = $index++;
             push(@{$interface->customConstructors}, $customConstructor);
         }
         delete $extendedAttributeList->{"CustomConstructors"};
         $extendedAttributeList->{"CustomConstructor"} = "VALUE_IS_MISSING";
     }
     $interface->extendedAttributes($extendedAttributeList);
 }
 
 1;