Revert 170357 "Revert of Make DOMWrapperWorld::current() return ..."

trunk/Source/bindings/tests/idls/TestObject.idl

Index: trunk/Source/bindings/tests/idls/TestObject.idl
===================================================================
--- trunk/Source/bindings/tests/idls/TestObject.idl	(revision 170423)
+++ trunk/Source/bindings/tests/idls/TestObject.idl	(working copy)
@@ -1,306 +1,465 @@
 /*
- * Copyright (C) 2009 Google Inc. All rights reserved.
- * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
+ * modification, are permitted provided that the following conditions are
+ * met:
  *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// This IDL file is for testing the bindings code generator and for tracking
-// changes in its ouput.
+enum TestEnum {"", "EnumValue1", "EnumValue2", "EnumValue3"};
 
-enum TestEnumType { "", "EnumValue1", "EnumValue2", "EnumValue3" };
+callback VoidCallbackFunction = void ();
+callback AnyCallbackFunctionOptionalAnyArg = any (optional any optionalAnyArg);
 
-callback TestCallbackFunction = void (TestEnumType formal1, TestObject formal2);
+// No extended attributes on the interface; those go in TestInterface.idl
+interface TestObject {
+    // Constants
+    const unsigned short CONST_VALUE_0 = 0;
+    const unsigned short CONST_VALUE_1 = 1;
+    const unsigned short CONST_VALUE_2 = 2;
+    const unsigned short CONST_VALUE_4 = 4;
+    const unsigned short CONST_VALUE_8 = 8;
+    const short CONST_VALUE_9 = -1;
+    const DOMString CONST_VALUE_10 = "my constant string";
+    const unsigned short CONST_VALUE_11 = 0xffffffff;
+    const unsigned short CONST_VALUE_12 = 0x01;
+    const unsigned short CONST_VALUE_13 = 0X20;
+    const unsigned short CONST_VALUE_14 = 0x1abc;
+    const unsigned short CONST_VALUE_15 = 010;
+    const unsigned short CONST_VALUE_16 = -010;
+    const unsigned short CONST_VALUE_16 = -0x1A;
+    const unsigned short CONST_VALUE_17 = -0X1a;
 
-// No extended attributes on the interface; those go in TestInterface.idl
-interface TestObject : EventTarget {
+    // Extended attributes
+    [DeprecateAs=Constant] const short DEPRECATED_CONSTANT = 1;
+    [RuntimeEnabled=FeatureName] const short FEATURE_ENABLED_CONST = 1;
+    [Reflect=CONST_IMPL] const short CONST_JAVASCRIPT = 1;
+
+
     // Attributes
-    readonly attribute long            readOnlyLongAttr;
-    readonly attribute DOMString       readOnlyStringAttr;
-    readonly attribute TestObject      readOnlyTestObjectAttr;
-    static readonly attribute long     staticReadOnlyLongAttr;
-    static attribute DOMString         staticStringAttr;
-    attribute TestSubObjConstructor    TestSubObj;
-    attribute TestEnumType             enumAttr;
-    readonly attribute TestEnumType    readOnlyEnumAttr;
-    attribute byte                     byteAttr;
-    attribute octet                    octetAttr;
-    attribute short                    shortAttr;
-    attribute unsigned short           unsignedShortAttr;
-    attribute long                     longAttr;
-    attribute long long                longLongAttr;
-    attribute unsigned long long       unsignedLongLongAttr;
-    attribute DOMString                stringAttr;
-    [TreatNullAs=NullString] attribute DOMString treatNullAsNullStringStringAttr;
-    [TreatNullAs=NullString, TreatUndefinedAs=NullString] attribute DOMString treatNullAsNullStringTreatUndefinedAsNullStringStringAttr;
-    attribute EventHandler             eventHandlerAttr;
-    [MeasureAs=TestFeature] attribute TestObject testObjAttr;
-    [ExposeJSAccessors] attribute DOMString attrWithJSGetterAndSetter;
-    [MeasureAs=TestFeature] attribute TestSubObjConstructor TestSubObjMeasured;
+    //
+    // Naming convention:
+    // [ExtAttr] attribute Type extAttrTypeNameAttribute;
+    // E.g.,
+    // [Foo] attribute DOMString? fooStringOrNullAttribute
+    //
+    // Type name reference:
+    // http://heycam.github.io/webidl/#dfn-type-name
+    //
+    // TestInterfaceEmpty is used as a stub interface type, for testing behavior
+    // that should not depend on particular type (beyond "interface or not").
+    // read only
+    readonly attribute DOMString readonlyStringAttribute;
+    readonly attribute TestInterfaceEmpty readonlyTestInterfaceEmptyAttribute;
+    readonly attribute long readonlyLongAttribute;
+    // Basic types
+    attribute Date dateAttribute;
+    attribute DOMString stringAttribute;
+    attribute DOMTimeStamp domTimeStampAttribute;
+    attribute boolean booleanAttribute;
+    attribute byte byteAttribute;
+    attribute double doubleAttribute;
+    attribute float floatAttribute;
+    attribute long longAttribute;
+    attribute long long longLongAttribute;
+    attribute octet octetAttribute;
+    attribute short shortAttribute;
+    attribute unsigned long unsignedLongAttribute;
+    attribute unsigned long long unsignedLongLongAttribute;
+    attribute unsigned short unsignedShortAttribute;
+    // Interface type
+    attribute TestInterfaceEmpty testInterfaceEmptyAttribute;
+    // Self-reference
+    attribute TestObject testObjectAttribute;
+    // Callback function type
+    attribute VoidCallbackFunction voidCallbackFunctionAttribute;
+    attribute AnyCallbackFunctionOptionalAnyArg anyCallbackFunctionOptionalAnyArgAttribute;
+    // Names that begin with an acronym
+    attribute long cssAttribute;
+    attribute long imeAttribute;
+    attribute long svgAttribute;
+    attribute long xmlAttribute;
+    // Non-wrapper types
+    attribute NodeFilter nodeFilterAttribute;
+    attribute SerializedScriptValue serializedScriptValueAttribute;
+    attribute any anyAttribute;
+    // Custom type conversions
+    attribute Promise promiseAttribute;
+    attribute Window windowAttribute;
+    // DOM Node types
+    attribute Document documentAttribute;
+    attribute DocumentFragment documentFragmentAttribute;
+    attribute DocumentType documentTypeAttribute;
+    attribute Element elementAttribute;
+    attribute Node nodeAttribute;
+    attribute ShadowRoot shadowRootAttribute;
+    // Typed arrays
+    attribute ArrayBuffer arrayBufferAttribute;
+    attribute Float32Array float32ArrayAttribute;
+    attribute Uint8Array uint8ArrayAttribute;
+    // Exceptions for is_keep_alive_for_gc
+    readonly attribute TestInterfaceEmpty self;
+    readonly attribute EventTarget readonlyEventTargetAttribute;
+    readonly attribute EventTarget? readonlyEventTargetOrNullAttribute;
+    readonly attribute Window readonlyWindowAttribute;
+    readonly attribute HTMLCollection htmlCollectionAttribute;
+    readonly attribute HTMLElement htmlElementAttribute;
+    // Arrays
+    attribute DOMString[] stringArrayAttribute;
+    attribute TestInterfaceEmpty[] testInterfaceEmptyArrayAttribute;
+    attribute float[] floatArrayAttribute;
+    // Nullable attributes
+    attribute DOMString? stringOrNullAttribute;
+    attribute long? longOrNullAttribute;
+    attribute TestInterface? testInterfaceOrNullAttribute;
+    // Enumerations
+    attribute TestEnum testEnumAttribute;
+    // Static attributes
+    static attribute DOMString staticStringAttribute;
+    static attribute long staticLongAttribute;
+    // Exceptional type
+    attribute EventHandler eventHandlerAttribute;
 
-    // Name starting with an acronym
-    attribute TestObject                  XMLObjAttr;
-
-    // Reflected DOM attributes
-    [Reflect] attribute DOMString reflectedStringAttr;
-    [Reflect, TreatNullAs=NullString] attribute DOMString reflectedTreatNullAsNullStringStringAttr;
-    [Reflect, TreatNullAs=NullString, TreatUndefinedAs=NullString] attribute DOMString reflectedTreatNullAsNullStringTreatUndefinedAsNullStringStringAttr;
-    [Reflect] attribute long reflectedIntegralAttr;
-    [Reflect] attribute unsigned long reflectedUnsignedIntegralAttr;
-    [Reflect] attribute boolean reflectedBooleanAttr;
-    [Reflect, URL] attribute DOMString reflectedURLAttr;
-    [Reflect, TreatNullAs=NullString, URL] attribute DOMString reflectedTreatNullAsNullStringURLAttr;
-    [Reflect, TreatNullAs=NullString, TreatUndefinedAs=NullString, URL] attribute DOMString reflectedTreatNullAsNullStringTreatUndefinedAsNullStringURLAttr;
-    [Reflect=customContentStringAttr] attribute DOMString reflectedCustomStringAttr;
-    [Reflect=customContentStringAttr, TreatNullAs=NullString] attribute DOMString reflectedTreatNullAsNullStringCustomStringAttr;
-    [Reflect=customContentStringAttr, TreatNullAs=NullString, TreatUndefinedAs=NullString] attribute DOMString reflectedTreatNullAsNullStringTreatUndefinedAsNullStringCustomStringAttr;
-    [Reflect=customContentIntegralAttr] attribute long reflectedCustomIntegralAttr;
-    [Reflect=customContentBooleanAttr] attribute boolean reflectedCustomBooleanAttr;
-    [Reflect=customContentURLAttr, URL] attribute DOMString reflectedCustomURLAttr;
-    [Reflect=customContentURLAttr, TreatNullAs=NullString, URL] attribute DOMString reflectedTreatNullAsNullStringCustomURLAttr;
-    [Reflect=customContentURLAttr, TreatNullAs=NullString, TreatUndefinedAs=NullString, URL] attribute DOMString reflectedTreatNullAsNullStringTreatUndefinedAsNullStringCustomURLAttr;
+    // Extended attributes
+    [ActivityLogging=ForAllWorlds] attribute long activityLoggingAccessForAllWorldsLongAttribute;
+    [ActivityLogging=GetterForAllWorlds] attribute long activityLoggingGetterForAllWorldsLongAttribute;
+    [ActivityLogging=SetterForAllWorlds] attribute long activityLoggingSetterForAllWorldsLongAttribute;
+    [CachedAttribute=isValueDirty] attribute any cachedAttributeAnyAttribute;
+    [CallWith=ExecutionContext] attribute any callWithExecutionContextAnyAttribute;
+    [CheckSecurity=Node] readonly attribute Document checkSecurityForNodeReadonlyDocumentAttribute; // All uses are read only
+    [Conditional=CONDITION] attribute long conditionalLongAttribute;
+    [Conditional=CONDITION_1&CONDITION_2] attribute long conditionalAndLongAttribute;
+    [Conditional=CONDITION_1|CONDITION_2] attribute long conditionalOrLongAttribute;
+    // Constructors: FIXME: replace suffix with [ConstructorAttribute]
+    attribute TestInterfaceEmptyConstructor testInterfaceEmptyConstructorAttribute;
+    [DeprecateAs=deprecatedTestInterfaceEmptyConstructorAttribute] attribute TestInterfaceEmptyConstructor testInterfaceEmptyConstructorAttribute;
+    [MeasureAs=FeatureName] attribute TestInterfaceEmptyConstructor measureAsFeatureNameTestInterfaceEmptyConstructorAttribute;
+    [Custom] attribute object customObjectAttribute;
+    [Custom=Getter] attribute long customGetterLongAttribute;
+    [Custom=Getter] readonly attribute object customGetterReadonlyObjectAttribute;
+    [Custom=Setter] attribute long customSetterLongAttribute;
+    [Conditional=CONDITION, Custom] attribute long customLongAttribute;
+    [CustomElementCallbacks] readonly attribute long customElementsCallbacksReadonlyLongAttribute;
+    [DeprecateAs=LongAttribute] attribute long deprecatedLongAttribute;
+    [EnforceRange] attribute long enforceRangeLongAttribute;
+    [ExposeJSAccessors] attribute long exposeJSAccessorsLongAttribute;
+    [ImplementedAs=implementedAsName] attribute long implementedAsLongAttribute;
+    [Custom, ImplementedAs=implementedAsNameWithCustom] attribute long customImplementedAsLongAttribute;
+    [Custom=Getter, ImplementedAs=implementedAsNameWithCustomGetter] attribute long customGetterImplementedAsLongAttribute;
+    [Custom=Setter, ImplementedAs=implementedAsNameWithCustomGetter] attribute long customSetterImplementedAsLongAttribute;
+    [MeasureAs=TestFeature] attribute long measureAsLongAttribute;
+    [NotEnumerable] attribute long notEnumerableLongAttribute;
+    [PerContextEnabled=FeatureName] attribute long perContextEnabledLongAttribute;
+    [PerWorldBindings] attribute long perWorldBindingsLongAttribute;
+    [PerWorldBindings] readonly attribute long perWorldBindingsReadonlyLongAttribute; // Separate read only attribute to check attribute configuration
+    [PerWorldBindings] readonly attribute TestInterfaceEmpty perWorldBindingsReadonlyTestInterfaceEmptyAttribute;
+    [ActivityLogging=ForAllWorlds, PerWorldBindings] attribute long activityLoggingAccessPerWorldBindingsLongAttribute;
+    [ActivityLogging=ForIsolatedWorlds, PerWorldBindings] attribute long activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute;
+    [ActivityLogging=GetterForAllWorlds, PerWorldBindings] attribute long activityLoggingGetterPerWorldBindingsLongAttribute;
+    [ActivityLogging=GetterForIsolatedWorlds, PerWorldBindings] attribute long activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute;
+    [PutForwards=href] readonly attribute TestNode location;
+    [PutForwards=hrefThrows] readonly attribute TestNode locationWithException;
+    [PutForwards=hrefCallWith] readonly attribute TestNode locationWithCallWith;
+    [PerWorldBindings, PutForwards=href] readonly attribute TestNode locationWithPerWorldBindings;
+    [PutForwards=attr1] readonly attribute TestInterfaceWillBeGarbageCollected locationWillBeGarbageCollected;
+    [RaisesException] attribute long raisesExceptionLongAttribute;
+    [RaisesException=Getter] attribute long raisesExceptionGetterLongAttribute;
+    [RaisesException=Setter] attribute long setterRaisesExceptionLongAttribute;
+    [RaisesException] attribute TestInterfaceEmpty raisesExceptionTestInterfaceEmptyAttribute;
+    [CachedAttribute=isValueDirty, RaisesException] attribute any cachedAttributeRaisesExceptionGetterAnyAttribute;
+    [Reflect] attribute TestInterface reflectTestInterfaceAttribute;
+    [Reflect=reflectedNameAttribute] attribute TestInterface reflectReflectedNameAttributeTestAttribute;
+    // [Reflect] exceptional types: exceptional getters, exceptional setters,
+    // or range checking for unsigned
+    [Reflect] attribute boolean reflectBooleanAttribute;
+    [Reflect] attribute long reflectLongAttribute;
+    [Reflect] attribute unsigned short reflectUnsignedShortAttribute;
+    [Reflect] attribute unsigned long reflectUnsignedLongAttribute;
+    // [Reflect] exceptional names
+    [Reflect] attribute DOMString id;
+    [Reflect] attribute DOMString name;
+    [Reflect] attribute DOMString class;
+    [Reflect=id] attribute DOMString reflectedId;
+    [Reflect=name] attribute DOMString reflectedName;
+    [Reflect=class] attribute DOMString reflectedClass;
+    // Limited value attributes and enumerated attributes
     [Reflect, ReflectOnly="unique"] attribute DOMString limitedToOnlyOneAttribute;
     [Reflect, ReflectOnly="Per"|"Paal"|"Espen"] attribute DOMString limitedToOnlyAttribute;
-    [Reflect=Other, ReflectOnly="Value1"|"Value2" ] attribute DOMString limitedToOnlyOtherAttribute;
-    [Reflect, ReflectOnly="rsa" | "dsa", ReflectMissing="rsa"] attribute DOMString limitedWithMissingDefaultAttribute;
-    [Reflect, ReflectOnly="ltr" | "rtl" | "auto", ReflectMissing="auto", ReflectInvalid="ltr"] attribute DOMString limitedWithInvalidMissingDefaultAttribute;
-    [Reflect, ReflectOnly="left" | "right", ReflectMissing="left", ReflectInvalid="left"] attribute DOMString limitedWithInvalidAndMissingDefaultAttribute;
+    [Reflect=other, ReflectOnly="Value1"|"Value2" ] attribute DOMString limitedToOnlyOtherAttribute;
+    [Reflect, ReflectOnly="rsa"|"dsa", ReflectMissing="rsa"] attribute DOMString limitedWithMissingDefaultAttribute;
+    [Reflect, ReflectOnly="ltr"|"rtl"|"auto", ReflectMissing="auto", ReflectInvalid="ltr"] attribute DOMString limitedWithInvalidMissingDefaultAttribute;
     [Reflect, ReflectOnly="anonymous"|"use-credentials", ReflectEmpty="anonymous", ReflectInvalid="anonymous"] readonly attribute DOMString corsSettingAttribute;
     [Reflect, ReflectOnly="empty"|"missing"|"invalid"|"a-normal", ReflectEmpty="empty", ReflectMissing="missing", ReflectInvalid="invalid"] readonly attribute DOMString limitedWithEmptyMissingInvalidAttribute;
 
-    // TypedArray attribute
-    attribute Float32Array typedArrayAttr;
+    [Replaceable] readonly attribute long replaceableReadonlyLongAttribute;
+    [Replaceable, PutForwards=href] readonly attribute TestNode locationReplaceable;
+    [RuntimeEnabled=FeatureName] attribute long runtimeEnabledLongAttribute;
+    [PerContextEnabled=FeatureName, RuntimeEnabled=FeatureName] attribute long perContextEnabledRuntimeEnabledLongAttribute;
+    [Conditional=CONDITION, RuntimeEnabled=FeatureName] attribute long conditionalRuntimeEnabledLongAttribute;
+    [SetterCallWith=ActiveWindow&FirstWindow] attribute DOMString setterCallWithActiveWindowAndFirstWindowStringAttribute;
+    [SetterCallWith=ExecutionContext] attribute DOMString setterCallWithExecutionContextStringAttribute;
+    [StrictTypeChecking] attribute float strictTypeCheckingFloatAttribute; // nop for non-interface types
+    [StrictTypeChecking] attribute TestInterface strictTypeCheckingTestInterfaceAttribute;
+    [TreatNullAs=NullString] attribute DOMString treatNullAsNullStringStringAttribute;
+    [TreatReturnedNullStringAs=Null] attribute DOMString treatReturnedNullStringAsNullStringAttribute;
+    [TreatReturnedNullStringAs=Undefined] attribute DOMString treatReturnedNullStringAsUndefinedStringAttribute;
+    [Reflect, URL] attribute DOMString urlStringAttribute;
+    [Reflect=reflectUrlAttribute, URL] attribute DOMString urlStringAttribute;
+    [Unforgeable] attribute long unforgeableLongAttribute;
 
+
     // Methods
-    void    voidMethod();
-    void    voidMethodWithArgs(long longArg, DOMString strArg, TestObject objArg);
-    long    longMethod();
-    long    longMethodWithArgs(long longArg, DOMString strArg, TestObject objArg);
-    [MeasureAs=TestFeature] TestObject objMethod();
-    TestObject objMethodWithArgs(long longArg, DOMString strArg, TestObject objArg);
+    //
+    // Naming convention:
+    // ReturnType returnTypeMethodTypeName1ArgTypeName2Arg(Type1 typeName1Arg, Type2 typeName2Arg);
+    // E.g.,
+    // void voidMethodStringArgLongArrayArg(DOMString stringArg, long[] longArrayArg);
+    void voidMethod();
+    static void staticVoidMethod();
 
-    void methodWithSequenceArg(sequence<TestInterface> sequenceArg);
-    sequence<TestInterface> methodReturningSequence(long longArg);
+    // Types
+    // Basic types
+    Date dateMethod();
+    DOMString stringMethod();
+    DOMTimeStamp readonlyDOMTimeStampMethod();
+    boolean booleanMethod();
+    byte byteMethod();
+    double doubleMethod();
+    float floatMethod();
+    long longMethod();
+    long long longLongMethod();
+    octet octetMethod();
+    short shortMethod();
+    unsigned long unsignedLongMethod();
+    unsigned long long unsignedLongLongMethod();
+    unsigned short unsignedShortMethod();
 
-    void methodWithEnumArg(TestEnumType enumArg);
-    [RaisesException] TestObject methodThatRequiresAllArgsAndThrows(DOMString strArg, TestObject objArg);
+    void voidMethodDateArg(Date dateArg);
+    void voidMethodStringArg(DOMString stringArg);
+    void voidMethodDOMTimeStampArg(DOMTimeStamp domTimeStampArg);
+    void voidMethodBooleanArg(boolean booleanArg);
+    void voidMethodByteArg(byte byteArg);
+    void voidMethodDoubleArg(double doubleArg);
+    void voidMethodFloatArg(float floatArg);
+    void voidMethodLongArg(long longArg);
+    void voidMethodLongLongArg(long long longLongArg);
+    void voidMethodOctetArg(octet octetArg);
+    void voidMethodShortArg(short shortArg);
+    void voidMethodUnsignedLongArg(unsigned long unsignedLongArg);
+    void voidMethodUnsignedLongLongArg(unsigned long long unsignedLongLongArg);
+    void voidMethodUnsignedShortArg(unsigned short unsignedShortArg);
+    // Interface types
+    TestInterfaceEmpty testInterfaceEmptyMethod();
+    void voidMethodTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg);
+    void voidMethodLongArgTestInterfaceEmptyArg(long longArg, TestInterfaceEmpty testInterfaceEmptyArg);
+    // Callback function type
+    VoidCallbackFunction voidCallbackFunctionMethod();
+    AnyCallbackFunctionOptionalAnyArg anyCallbackFunctionOptionalAnyArgMethod();
+    void voidMethodVoidCallbackFunctionArg(VoidCallbackFunction voidCallbackFunctionArg);
+    void voidMethodAnyCallbackFunctionOptionalAnyArg(AnyCallbackFunctionOptionalAnyArg anyCallbackFunctionOptionalAnyArgArg);
+    // Custom type conversions
+    CompareHow compareHowMethod();
+    any anyMethod();
+    void voidMethodCompareHowArg(CompareHow compareHowArg);
+    void voidMethodEventTargetArg(EventTarget eventTargetArg);
+    void voidMethodMediaQueryListListenerArg(MediaQueryListListener mediaQueryListListenerArg);
+    void voidMethodAnyArg(any anyArg);
+    // DOM node types
+    void voidMethodAttrArg(Attr attrArg);
+    void voidMethodDocumentArg(Document documentArg);
+    void voidMethodDocumentTypeArg(DocumentType documentTypeArg);
+    void voidMethodElementArg(Element elementArg);
+    void voidMethodNodeArg(Node nodeArg);
+    // Typed arrays
+    ArrayBuffer arrayBufferMethod();
+    ArrayBufferView arrayBufferViewMethod();
+    Float32Array float32ArrayMethod();
+    Int32Array int32ArrayMethod();
+    Uint8Array uint8ArrayMethod();
+    void voidMethodArrayBufferArg(ArrayBuffer arrayBufferArg);
+    void voidMethodArrayBufferOrNullArg(ArrayBuffer? arrayBufferArg);
+    void voidMethodArrayBufferViewArg(ArrayBufferView arrayBufferViewArg);
+    void voidMethodFloat32ArrayArg(Float32Array float32ArrayArg);
+    void voidMethodInt32ArrayArg(Int32Array int32ArrayArg);
+    void voidMethodUint8ArrayArg(Uint8Array uint8ArrayArg);
+    // Arrays
+    long[] longArrayMethod();
+    DOMString[] stringArrayMethod();
+    TestInterfaceEmpty[] testInterfaceEmptyArrayMethod();
+    void voidMethodArrayLongArg(long[] arrayLongArg);
+    void voidMethodArrayStringArg(DOMString[] arrayStringArg);
+    void voidMethodArrayTestInterfaceEmptyArg(TestInterfaceEmpty[] arrayTestInterfaceEmptyArg);
+    // Sequences
+    sequence<long> longSequenceMethod();
+    sequence<DOMString> stringSequenceMethod();
+    sequence<TestInterfaceEmpty> testInterfaceEmptySequenceMethod();
+    void voidMethodSequenceLongArg(sequence<long> longSequenceArg);
+    void voidMethodSequenceStringArg(sequence<DOMString> stringSequenceArg);
+    void voidMethodSequenceTestInterfaceEmptyArg(sequence<TestInterfaceEmpty> testInterfaceEmptySequenceArg);
+    // Nullable types
+    // Currently only used on interface type arguments
+    void voidMethodTestInterfaceEmptyOrNullArg(TestInterfaceEmpty? nullableTestInterfaceEmptyArg);
+    // Callback interface types
+    void voidMethodTestCallbackInterfaceArg(TestCallbackInterface testCallbackInterfaceArg);
+    void voidMethodOptionalTestCallbackInterfaceArg(optional TestCallbackInterface optionalTestCallbackInterfaceArg);
+    void voidMethodTestCallbackInterfaceOrNullArg(TestCallbackInterface? testCallbackInterfaceArg);
+    // Enumerations
+    TestEnum testEnumMethod();
+    void voidMethodTestEnumArg(TestEnum testEnumTypeArg);
+    // Exceptional types
+    Dictionary dictionaryMethod();
+    NodeFilter nodeFilterMethod();
+    Promise promiseMethod();
+    SerializedScriptValue serializedScriptValueMethod();
+    XPathNSResolver xPathNSResolverMethod();
+    void voidMethodDictionaryArg(Dictionary dictionaryArg);
+    void voidMethodEventListenerArg(EventListener eventListenerArg);
+    void voidMethodNodeFilterArg(NodeFilter nodeFilterArg);
+    void voidMethodPromiseArg(Promise promiseArg);
+    void voidMethodSerializedScriptValueArg(SerializedScriptValue serializedScriptValueArg);
+    void voidMethodXPathNSResolverArg(XPathNSResolver xPathNSResolverArg);
+    void voidMethodDictionarySequenceArg(sequence<Dictionary> dictionarySequenceArg);
 
-    void methodQueryListListener(MediaQueryListListener listener);
-    void serializedValue(SerializedScriptValue serializedArg);
-    void optionsObject(Dictionary oo, optional Dictionary ooo);
-    void optionsObjectList(sequence<Dictionary> list);
+    // Arguments
+    void voidMethodStringArgLongArg(DOMString stringArg, long longArg);
+    // Optional arguments
+    void voidMethodOptionalStringArg(optional DOMString optionalStringArg);
+    void voidMethodOptionalTestInterfaceEmptyArg(optional TestInterfaceEmpty optionalTestInterfaceEmptyArg);
+    void voidMethodOptionalLongArg(optional long optionalLongArg);
+    DOMString stringMethodOptionalLongArg(optional long optionalLongArg);
+    TestInterfaceEmpty testInterfaceEmptyMethodOptionalLongArg(optional long optionalLongArg);
+    long longMethodOptionalLongArg(optional long optionalLongArg);
+    void voidMethodLongArgOptionalLongArg(long longArg, optional long optionalLongArg);
+    void voidMethodLongArgOptionalLongArgOptionalLongArg(long longArg, optional long optionalLongArg1, optional long optionalLongArg2);
+    void voidMethodLongArgOptionalTestInterfaceEmptyArg(long longArg, optional TestInterfaceEmpty optionalTestInterfaceEmpty);
+    void voidMethodTestInterfaceEmptyArgOptionalLongArg(TestInterfaceEmpty optionalTestInterfaceEmpty, optional long longArg);
+    // Optional arguments: exceptional case
+    void voidMethodOptionalDictionaryArg(optional Dictionary optionalDictionaryArg);
 
-    // Indexed/named properties
-    getter Node (unsigned long index);
-    getter DOMString (DOMString name);
+    // Variadic operations
+    void voidMethodVariadicStringArg(DOMString... variadicStringArgs);
+    void voidMethodStringArgVariadicStringArg(DOMString stringArg, DOMString... variadicStringArgs);
+    void voidMethodVariadicTestInterfaceEmptyArg(TestInterfaceEmpty... variadicTestInterfaceEmptyArgs);
+    void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg, TestInterfaceEmpty... variadicTestInterfaceEmptyArgs);
+    // [WillBeGarbageCollected]
+    void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(TestInterfaceWillBeGarbageCollected... variadicTestInterfaceWillBeGarbageCollectedArg);
 
-    // Exceptions
-    [RaisesException] void methodWithException();
-    [RaisesException=Getter] attribute long attrWithGetterException;
-    [RaisesException=Setter] attribute long attrWithSetterException;
-    [RaisesException=Getter] attribute DOMString stringAttrWithGetterException;
-    [RaisesException=Setter] attribute DOMString stringAttrWithSetterException;
+    // Overloaded methods
+    void overloadedMethodA(long longArg);
+    void overloadedMethodA(long longArg1, long longArg2);
+    void overloadedMethodB(long longArg);
+    void overloadedMethodB(long longArg1, optional long longArg2);
+    void overloadedMethodC(long longArg);
+    void overloadedMethodC(long longArg, long... longArgs);
+    void overloadedMethodD(long longArg);
+    void overloadedMethodD(TestInterfaceEmpty testInterfaceEmptyArg);
+    void overloadedMethodE(long longArg);
+    void overloadedMethodE(long[] longArrayArg);
+    void overloadedMethodF(long longArg);
+    void overloadedMethodF(TestInterfaceEmpty? testInterfaceEmptyNullableArg);
+    void overloadedMethodG();
+    void overloadedMethodG([StrictTypeChecking] DOMString strictTypeCheckingStringArg);
+    void overloadedMethodH();
+    void overloadedMethodH(TestCallbackInterface testCallbackInterfaceArg);
+    // FIXME: Should be in order double, Dictionary, but Blink implementation of
+    // overload resolution can't handle this. http://crbug.com/293561
+    void overloadedMethodI(Dictionary dictionaryArg); // Non-wrapper type
+    void overloadedMethodI(double doubleArg);
 
-    // 'Custom' extended attribute
-    [Custom] attribute long            customAttr;
-    [Custom, MeasureAs=CustomTestFeature] void customMethod();
-    [Custom] void customMethodWithArgs(long longArg, DOMString strArg, TestObject objArg);
 
-    // 'CallWith' extended attribute
-    [CallWith=ScriptState] void withScriptStateVoid();
-    [CallWith=ScriptState] TestObject withScriptStateObj();
-    [CallWith=ScriptState, RaisesException] void withScriptStateVoidException();
-    [CallWith=ScriptState, RaisesException] TestObject withScriptStateObjException();
-    [CallWith=ExecutionContext] void withExecutionContext();
-    [CallWith=ExecutionContext&ScriptState] void withExecutionContextAndScriptState();
-    [CallWith=ExecutionContext&ScriptState, RaisesException] TestObject withExecutionContextAndScriptStateObjException();
-    [CallWith=  ExecutionContext  &  ScriptState  ] TestObject withExecutionContextAndScriptStateWithSpaces();
-    [CallWith=ActiveWindow&FirstWindow] void withActiveWindowAndFirstWindow();
+    [PerWorldBindings] void overloadedPerWorldBindingsMethod();
+    [PerWorldBindings] void overloadedPerWorldBindingsMethod(long longArg);
 
-    [CallWith=ExecutionContext] attribute TestObject withExecutionContextAttribute;
-    [SetterCallWith=ActiveWindow&FirstWindow] attribute TestObject withActiveWindowAndFirstWindowAttribute;
-    [RaisesException=Getter] attribute TestObject withScriptStateAttributeRaises;
+    static void overloadedStaticMethod(long longArg);
+    static void overloadedStaticMethod(long longArg1, long longArg2);
 
-    // optional parameters
-    void    methodWithOptionalArg(optional long opt);
-    void    methodWithNonOptionalArgAndOptionalArg(long nonOpt, optional long opt);
-    void    methodWithNonOptionalArgAndTwoOptionalArgs(long nonOpt, optional long opt1, optional long opt2);
-    void    methodWithOptionalString(optional DOMString str);
-    void    methodWithOptionalStringIsUndefined([Default=Undefined] optional DOMString str);
-    void    methodWithOptionalStringIsNullString([Default=NullString] optional DOMString str);
+    // Extended attributes for arguments
+    // [Clamp]
+    void voidMethodClampUnsignedShortArg([Clamp] unsigned short clampUnsignedShortArg);
+    void voidMethodClampUnsignedLongArg([Clamp] unsigned long clampUnsignedLongArg);
+    // [Default]
+    void voidMethodDefaultUndefinedTestInterfaceEmptyArg([Default=Undefined] optional TestInterfaceEmpty defaultUndefinedTestInterfaceEmptyArg);
+    void voidMethodDefaultUndefinedLongArg([Default=Undefined] optional long defaultUndefinedLongArg);
+    void voidMethodDefaultUndefinedStringArg([Default=Undefined] optional DOMString defaultUndefinedStringArg);
+    void voidMethodDefaultNullStringStringArg([Default=NullString] optional DOMString defaultNullStringStringArg);
+    // [EnforceRange]
+    void voidMethodEnforceRangeLongArg([EnforceRange] long enforceRangeLongArg);
+    // [TreatNullAs], [TreatUndefinedAs]
+    void voidMethodTreatNullAsNullStringStringArg([TreatNullAs=NullString] DOMString treatNullAsNullStringStringArg);
+    void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg([TreatNullAs=NullString, TreatUndefinedAs=NullString] DOMString treatNullAsNullStringStringArg);
 
-    // Callback interface parameters
-    void    methodWithCallbackInterfaceArg(TestCallbackInterface callbackInterface);
-    void    methodWithNonCallbackArgAndCallbackInterfaceArg(long nonCallback, TestCallbackInterface callbackInterface);
-    void    methodWithCallbackInterfaceAndOptionalArg(optional TestCallbackInterface callbackInterface);
-    void    methodWithNullableCallbackInterfaceArg(TestCallbackInterface? callbackInterface);
-    // static methods with callback interface parameter
-    static void    staticMethodWithCallbackAndOptionalArg(optional TestCallbackInterface callbackInterface);
-    static void    staticMethodWithCallbackArg(TestCallbackInterface callbackInterface);
+    // Extended attributes for methods
+    [ActivityLogging=ForAllWorlds] void activityLoggingAccessForAllWorldsMethod();
+    [CallWith=ScriptState] void callWithScriptStateVoidMethod();
+    [CallWith=ScriptState] long callWithScriptStateLongMethod();
+    [CallWith=ExecutionContext] void callWithExecutionContextVoidMethod();
+    [CallWith=ScriptState&ExecutionContext] void callWithScriptStateExecutionContextVoidMethod();
+    [CallWith=ScriptState&ScriptArguments] void callWithScriptStateScriptArgumentsVoidMethod();
+    [CallWith=ScriptState&ScriptArguments] void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(optional boolean optionalBooleanArg);
+    [CallWith=ActiveWindow] void callWithActiveWindow();
+    [CallWith=ActiveWindow&FirstWindow] void callWithActiveWindowScriptWindow();
+    [CheckSecurity=Node] void checkSecurityForNodeVoidMethod();
+    [Conditional=CONDITION] void conditionalConditionVoidMethod();
+    [Conditional=CONDITION_1&CONDITION_2] void conditionalCondition1AndCondition2VoidMethod();
+    [Conditional=CONDITION] static void conditionalConditionStaticVoidMethod();
+    [Custom] void customVoidMethod();
+    [Conditional=CONDITION, Custom] void conditionalConditionCustomVoidMethod();
+    [CustomElementCallbacks] void customElementCallbacksVoidMethod();
+    [DeprecateAs=voidMethod] void deprecatedVoidMethod();
+    [DoNotCheckSignature] void doNotCheckSignatureVoidMethod();
+    [ImplementedAs=implementedAsMethodName] void implementedAsVoidMethod();
+    [MeasureAs=TestFeature] void measureAsVoidMethod();
+    [NotEnumerable] void notEnumerableVoidMethod();
+    [PerContextEnabled=FeatureName] void perContextEnabledVoidMethod();
+    [PerWorldBindings] void perWorldBindingsVoidMethod();
+    [PerWorldBindings] void perWorldBindingsVoidMethodTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg);
+    [ActivityLogging=ForAllWorlds, PerWorldBindings] void activityLoggingForAllWorldsPerWorldBindingsVoidMethod();
+    [ActivityLogging=ForIsolatedWorlds, PerWorldBindings] void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod();
+    [RaisesException] void raisesExceptionVoidMethod();
+    [RaisesException] DOMString raisesExceptionStringMethod();
+    [RaisesException] void raisesExceptionVoidMethodOptionalLongArg(optional long optionalLongArg);
+    [RaisesException] void raisesExceptionVoidMethodTestCallbackInterfaceArg(TestCallbackInterface testCallbackInterfaceArg);
+    [RaisesException] void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optional TestCallbackInterface optionalTestCallbackInterfaceArg);
+    [RaisesException] TestInterfaceEmpty raisesExceptionTestInterfaceEmptyVoidMethod();
+    [CallWith=ExecutionContext, RaisesException] void callWithExecutionContextRaisesExceptionVoidMethodLongArg(long longArg);
+    [ReadOnly] void readOnlyVoidMethod();
+    [NotEnumerable, ReadOnly] void notEnumerableReadOnlyVoidMethod();
+    [RuntimeEnabled=FeatureName] void runtimeEnabledVoidMethod();
+    [PerWorldBindings, RuntimeEnabled=FeatureName] void perWorldBindingsRuntimeEnabledVoidMethod();
+    [StrictTypeChecking] void strictTypeCheckingVoidMethodTestInterfaceEmptyArg(TestInterfaceEmpty testInterfaceEmptyArg);
+    [StrictTypeChecking] void strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArg(TestInterfaceEmpty? testInterfaceEmptyArg);
+    [TreatReturnedNullStringAs=Null] DOMString treatReturnedNullStringAsNullStringMethod();
+    [TreatReturnedNullStringAs=Undefined] DOMString treatReturnedNullStringAsUndefinedStringMethod();
+    [Unforgeable] void unforgeableVoidMethod();
+    // [WillBeGarbageCollected]
+    void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg(sequence<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedSequenceArg);
+    void voidMethodTestInterfaceWillBeGarbageCollectedArrayArg(TestInterfaceWillBeGarbageCollected[] testInterfaceWillBeGarbageCollectedArrayArg);
 
-    // 'EnforceRange' extended attribute
-    void    methodWithEnforceRangeInt8([EnforceRange] byte value);
-    void    methodWithEnforceRangeUInt8([EnforceRange] octet value);
-    void    methodWithEnforceRangeInt16([EnforceRange] short value);
-    void    methodWithEnforceRangeUInt16([EnforceRange] unsigned short value);
-    void    methodWithEnforceRangeInt32([EnforceRange] long value);
-    void    methodWithEnforceRangeUInt32([EnforceRange] unsigned long value);
-    void    methodWithEnforceRangeInt64([EnforceRange] long long value);
-    void    methodWithEnforceRangeUInt64([EnforceRange] unsigned long long value);
-
-    [EnforceRange] attribute byte enforcedRangeByteAttr;
-    [EnforceRange] attribute octet enforcedRangeOctetAttr;
-    [EnforceRange] attribute short enforcedRangeShortAttr;
-    [EnforceRange] attribute unsigned short enforcedRangeUnsignedShortAttr;
-    [EnforceRange] attribute long enforcedRangeLongAttr;
-    [EnforceRange] attribute unsigned long enforcedRangeUnsignedLongAttr;
-    [EnforceRange] attribute long long enforcedRangeLongLongAttr;
-    [EnforceRange] attribute unsigned long long enforcedRangeUnsignedLongLongAttr;
-
-    // 'Conditional' extended attribute
-    [Conditional=Condition1] attribute long conditionalAttr1;
-    [Conditional=Condition1&Condition2] attribute long conditionalAttr2;
-    [Conditional=Condition1|Condition2|Condition3] attribute long conditionalAttr3;
-
-    // 'Conditional' extended method
-    [Conditional=Condition1] DOMString conditionalMethod1();
-    [Conditional=Condition1&Condition2] void conditionalMethod2();
-    [Conditional=Condition1|Condition2] void conditionalMethod3();
-
-    [Conditional=Condition1] attribute TestObjectectAConstructor conditionalAttr4;
-    [Conditional=Condition1&Condition2] attribute TestObjectectBConstructor conditionalAttr5;
-    [Conditional=Condition1|Condition2] attribute TestObjectectCConstructor conditionalAttr6;
-
-    readonly attribute any cachedAttribute1;
-    readonly attribute any cachedAttribute2;
-    [CachedAttribute=isValueDirty] readonly attribute any cachedDirtyableAttribute;
-    [RaisesException=Getter, CachedAttribute=isValueDirty] readonly attribute any cachedDirtyableAttributeRaises;
-
-    attribute any anyAttribute;
-
-    attribute TestCallbackFunction callbackFunctionAttribute;
-    TestCallbackFunction callbackFunctionReturnValue();
-    void callbackFunctionArgument(TestCallbackFunction function);
-
-    // Overloads
-    void    overloadedMethod(long longArg);
-    void    overloadedMethod(TestCallbackInterface callbackInterfaceArg);
-    void    overloadedMethod(TestObject objArg);
-    void    overloadedMethod(DOMString[] arrayArg);
-    void    overloadedMethod(sequence<unsigned long> sequenceArg);
-    void    overloadedMethodA(TestObject? objArg, optional long longArg);
-    void    overloadedMethodA(TestObject? objArg, DOMString strArg);
-    void    overloadedMethodB(DOMString strArg);
-    void    overloadedMethodB([StrictTypeChecking] DOMString strArg);
-    void    overloadedMethodC(Dictionary dictionaryArg); // Non-wrapper type
-    void    overloadedMethodC(double doubleArg);
-
-    // Class methods within JavaScript (like what's used for IDBKeyRange).
-    static void classMethod();
-    static long classMethodWithOptional(optional long arg);
-    [Custom] static void classMethod2(long arg);
-
-    void classMethodWithClamp([Clamp] unsigned short objArgsShort, [Clamp] unsigned long objArgsLong);
-
-    // [RuntimeEnabled] methods and attributes.
-    [RuntimeEnabled=FeatureName] void enabledAtRuntimeMethod(long longArg);
-    [RuntimeEnabled=FeatureName] attribute long enabledAtRuntimeAttr;
-    // [PerContextEnabled] methods and attributes.
-    [PerContextEnabled=FeatureName] void enabledPerContextMethod(long longArg);
-    [PerContextEnabled=FeatureName] attribute long enabledPerContextAttr;
-
-    attribute float[]                   floatArray;
-    attribute double[]                  doubleArray;
-    attribute MessagePort[]             messagePortArray;
-
-    void methodWithUnsignedLongSequence(sequence<unsigned long> unsignedLongSequence);
-    [RaisesException] DOMString[] stringArrayFunction(DOMString[] values);
-    [RaisesException] DOMStringList domStringListFunction(DOMStringList values);
-
-    [CheckSecurity=Node] readonly attribute Document contentDocument;
-
-    void convert1([TreatNullAs=NullString] TestNode value);
-    void convert2([TreatNullAs=NullString, TreatUndefinedAs=NullString] TestNode value);
-
-    [ImplementedAs=banana] void orange();
-    [ImplementedAs=blueberry] attribute long strawberry;
-
-    [StrictTypeChecking] attribute float strictFloat;
-    [StrictTypeChecking, RaisesException] boolean strictFunction(DOMString str, float a, long b);
-
-    [Replaceable] readonly attribute long replaceableAttribute;
-
-    void variadicStringMethod(DOMString head, DOMString... tail);
-    void variadicDoubleMethod(double head, double... tail);
-    void variadicNodeMethod(Node head, Node... tail);
-
-    // Nullable attributes.
-    readonly attribute double? nullableDoubleAttribute;
-    readonly attribute long? nullableLongAttribute;
-    readonly attribute boolean? nullableBooleanAttribute;
-    readonly attribute DOMString? nullableStringAttribute;
-    attribute long? nullableLongSettableAttribute;
-
-    [PerWorldBindings] readonly attribute TestObject perWorldReadOnlyAttribute;
-    [PerWorldBindings] attribute TestObject perWorldAttribute;
-    [PerWorldBindings] void perWorldMethod();
-    [PerWorldBindings] void overloadedPerWorldMethod(long longArg);
-    [PerWorldBindings] void overloadedPerWorldMethod(DOMString strArg, long longArg);
-
-    [ActivityLogging=ForAllWorlds] void activityLoggedMethod1(long longArg);
-    [PerWorldBindings, ActivityLogging=ForAllWorlds] void activityLoggedMethod2(long longArg);
-    [PerWorldBindings, ActivityLogging=ForIsolatedWorlds] void activityLoggedInIsolatedWorldMethod(long longArg);
-    [PerWorldBindings, ActivityLogging=ForAllWorlds] void overloadedActivityLoggedMethod(long longArg);
-    [PerWorldBindings, ActivityLogging=ForAllWorlds] void overloadedActivityLoggedMethod(DOMString strArg, long longArg);
-    [ActivityLogging=ForAllWorlds] attribute long activityLoggedAttr1;
-    [PerWorldBindings, ActivityLogging=ForAllWorlds] attribute long activityLoggedAttr2;
-    [PerWorldBindings, ActivityLogging=ForIsolatedWorlds] attribute long activityLoggedInIsolatedWorldsAttr;
-    [ActivityLogging=SetterForAllWorlds] attribute long activityLoggedAttrSetter1;
-    [PerWorldBindings, ActivityLogging=SetterForAllWorlds] attribute long activityLoggedAttrSetter2;
-    [PerWorldBindings, ActivityLogging=SetterForIsolatedWorlds] attribute long activityLoggedInIsolatedWorldsAttrSetter;
-    [ActivityLogging=GetterForAllWorlds] attribute long activityLoggedAttrGetter1;
-    [PerWorldBindings, ActivityLogging=GetterForAllWorlds] attribute long activityLoggedAttrGetter2;
-    [PerWorldBindings, ActivityLogging=GetterForIsolatedWorlds] attribute long activityLoggedInIsolatedWorldsAttrGetter;
-
-    // DeprecateAs
-    [DeprecateAs=StaticReadonlyAttribute] static readonly attribute long deprecatedStaticReadOnlyAttr;
-    [DeprecateAs=StaticAttribute] static attribute long deprecatedStaticAttr;
-    [DeprecateAs=ReadonlyAttribute] readonly attribute long deprecatedReadonlyAttr;
-    [DeprecateAs=Attribute] attribute long deprecatedAttr;
-
-    [DeprecateAs=Method] void deprecatedMethod();
-    [DeprecateAs=StaticMethod] static void deprecatedStaticMethod();
-    [DeprecateAs=ConstructorAttribute] attribute TestSubObjConstructor deprecatedConstructor;
-
-    [DeprecateAs=Constant] const unsigned short DEPRECATED_CONSTANT = 1;
-
-    // PutForwards
-    [PutForwards=href] readonly attribute TestNode location;
-    [PutForwards=hrefThrows] readonly attribute TestNode locationWithException;
+    // Extended attributes on referenced interfaces
+    // (not self; self-reference tests at interface themselves)
+    attribute TestInterface testInterfaceAttribute; // [ImplementedAs]
+    attribute TestInterfaceWillBeGarbageCollected testInterfaceWillBeGarbageCollectedAttribute; // [WillBeGarbageCollected]
+    attribute TestInterfaceWillBeGarbageCollected? testInterfaceWillBeGarbageCollectedOrNullAttribute; // [WillBeGarbageCollected]
 };
-
-// The following comment should not generate any code
-// TestObject implements TestImplements;
-