Alignments for the ClassMirror interface.

tests/compiler/dart2js/mirrors_test.dart

 // Copyright (c) 2012, 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("../../../pkg/dartdoc/lib/mirrors.dart");
 #import("../../../pkg/dartdoc/lib/mirrors_util.dart");
 
 #import('dart:io');
 
 int count(Iterable iterable) {
   var count = 0;
   for (var element in iterable) {
     count++;
   }
   return count;
 }
 
 bool containsType(TypeMirror expected, Iterable<TypeMirror> iterable) {
   for (var element in iterable) {
-    if (element.declaration == expected.declaration) {
+    if (element.originalDeclaration == expected.originalDeclaration) {
       return true;
     }
   }
   return false;
 }
 
 DeclarationMirror findMirror(List<DeclarationMirror> list, String name) {
   for (DeclarationMirror mirror in list) {
     if (mirror.simpleName == name) {
       return mirror;
@@ skipping 60 matching lines @@
   Expect.equals(helperLibrary, fooClass.library,
                 "Unexpected library returned from type");
 
   Expect.isFalse(fooClass.isObject, "Class is Object");
   Expect.isFalse(fooClass.isDynamic, "Class is Dynamic");
   Expect.isFalse(fooClass.isVoid, "Class is void");
   Expect.isFalse(fooClass.isTypeVariable, "Class is a type variable");
   Expect.isFalse(fooClass.isTypedef, "Class is a typedef");
   Expect.isFalse(fooClass.isFunction, "Class is a function");
 
-  Expect.isTrue(fooClass.isDeclaration, "Class is not declaration");
-  Expect.equals(fooClass, fooClass.declaration,
-                "Class is not its declaration");
+  Expect.isTrue(fooClass.isOriginalDeclaration);
+  Expect.equals(fooClass, fooClass.originalDeclaration);
 
   Expect.isTrue(fooClass.isClass, "Class is not class");
   Expect.isFalse(fooClass.isInterface, "Class is interface");
   Expect.isFalse(fooClass.isPrivate, "Class is private");
 
   var objectType = fooClass.superclass;
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
-  Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
+  Expect.isFalse(objectType.isOriginalDeclaration);
   Expect.isTrue(containsType(fooClass,
                              computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
-  var fooInterfaces = fooClass.interfaces;
+  var fooInterfaces = fooClass.superinterfaces;
   Expect.isNotNull(fooInterfaces, "Interfaces map is null");
   Expect.isTrue(fooInterfaces.isEmpty, "Interfaces map is not empty");
 
   var fooSubdeclarations = computeSubdeclarations(fooClass);
   Expect.equals(1, count(fooSubdeclarations), "Unexpected subtype count");
   for (var fooSubdeclaration in fooSubdeclarations) {
-    Expect.equals(fooClass, fooSubdeclaration.superclass.declaration,
-                  "Class is not superclass of subclass");
+    Expect.equals(fooClass, fooSubdeclaration.superclass.originalDeclaration);
   }
 
   Expect.throws(() => fooClass.typeArguments,
                 (exception) => true,
                 "Class has type arguments");
   var fooClassTypeVariables = fooClass.typeVariables;
   Expect.isNotNull(fooClassTypeVariables, "Type variable list is null");
   Expect.isTrue(fooClassTypeVariables.isEmpty,
                 "Type variable list is not empty");
 
-  Expect.isNull(fooClass.defaultType, "Class has default type");
+  Expect.isNull(fooClass.defaultFactory);
 
   var fooClassMembers = fooClass.declaredMembers;
   Expect.isNotNull(fooClassMembers, "Declared members map is null");
   Expect.isTrue(fooClassMembers.isEmpty, "Declared members map is unempty");
 
   var fooClassConstructors = fooClass.constructors;
   Expect.isNotNull(fooClassConstructors, "Constructors map is null");
   Expect.isTrue(fooClassConstructors.isEmpty,
                 "Constructors map is unempty");
 }
@@ skipping 17 matching lines @@
   Expect.equals(helperLibrary, barInterface.library,
                 "Unexpected library returned from type");
 
   Expect.isFalse(barInterface.isObject, "Interface is Object");
   Expect.isFalse(barInterface.isDynamic, "Interface is Dynamic");
   Expect.isFalse(barInterface.isVoid, "Interface is void");
   Expect.isFalse(barInterface.isTypeVariable, "Interface is a type variable");
   Expect.isFalse(barInterface.isTypedef, "Interface is a typedef");
   Expect.isFalse(barInterface.isFunction, "Interface is a function");
 
-  Expect.isTrue(barInterface.isDeclaration, "Interface is not declaration");
-  Expect.equals(barInterface, barInterface.declaration,
-                "Interface is not its declaration");
+  Expect.isTrue(barInterface.isOriginalDeclaration);
+  Expect.equals(barInterface, barInterface.originalDeclaration);
 
   Expect.isFalse(barInterface.isClass, "Interface is class");
   Expect.isTrue(barInterface.isInterface, "Interface is not interface");
   Expect.isFalse(barInterface.isPrivate, "Interface is private");
 
   var objectType = barInterface.superclass;
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
-  Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
+  Expect.isFalse(objectType.isOriginalDeclaration);
   Expect.isTrue(containsType(barInterface,
                              computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
-  var barInterfaces = barInterface.interfaces;
+  var barInterfaces = barInterface.superinterfaces;
   Expect.isNotNull(barInterfaces, "Interfaces map is null");
   Expect.isTrue(barInterfaces.isEmpty, "Interfaces map is not empty");
 
   var barSubdeclarations = computeSubdeclarations(barInterface);
   Expect.equals(1, count(barSubdeclarations), "Unexpected subtype count");
   for (var barSubdeclaration in barSubdeclarations) {
     Expect.isTrue(containsType(barInterface,
-                               barSubdeclaration.interfaces),
+                               barSubdeclaration.superinterfaces),
                   "Interface is not superinterface of subclass");
   }
 
   Expect.throws(() => barInterface.typeArguments,
               (exception) => true,
               "Interface has type arguments");
   var barInterfaceTypeVariables = barInterface.typeVariables;
   Expect.isNotNull(barInterfaceTypeVariables, "Type variable list is null");
   Expect.isFalse(barInterfaceTypeVariables.isEmpty,
                  "Type variable list is empty");
   Expect.equals(barInterfaceTypeVariables.length, 1,
                 "Unexpected number of type variables");
 
   var barE = barInterfaceTypeVariables[0];
   Expect.isNotNull(barE, "Type variable is null");
   Expect.isTrue(barE.isTypeVariable, "Type variable is not type variable");
 
-  Expect.isNull(barInterface.defaultType, "Interface has default type");
+  Expect.isNull(barInterface.defaultFactory);
 
   var barInterfaceMembers = barInterface.declaredMembers;
   Expect.isNotNull(barInterfaceMembers, "Declared members map is null");
   Expect.isTrue(barInterfaceMembers.isEmpty,
                 "Declared members map is unempty");
 
   var barInterfaceConstructors = barInterface.constructors;
   Expect.isNotNull(barInterfaceConstructors, "Constructors map is null");
   Expect.isTrue(barInterfaceConstructors.isEmpty,
                 "Constructors map is unempty");
@@ skipping 27 matching lines @@
   Expect.equals(helperLibrary, bazClass.library,
                 "Unexpected library returned from type");
 
   Expect.isFalse(bazClass.isObject, "Class is Object");
   Expect.isFalse(bazClass.isDynamic, "Class is Dynamic");
   Expect.isFalse(bazClass.isVoid, "Class is void");
   Expect.isFalse(bazClass.isTypeVariable, "Class is a type variable");
   Expect.isFalse(bazClass.isTypedef, "Class is a typedef");
   Expect.isFalse(bazClass.isFunction, "Class is a function");
 
-  Expect.isTrue(bazClass.isDeclaration, "Class is not declaration");
-  Expect.equals(bazClass, bazClass.declaration,
-                "Class is not its declaration");
+  Expect.isTrue(bazClass.isOriginalDeclaration);
+  Expect.equals(bazClass, bazClass.originalDeclaration);
 
   Expect.isTrue(bazClass.isClass, "Class is not class");
   Expect.isFalse(bazClass.isInterface, "Class is interface");
   Expect.isFalse(bazClass.isPrivate, "Class is private");
 
   var objectType = bazClass.superclass;
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
-  Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
+  Expect.isFalse(objectType.isOriginalDeclaration);
   Expect.isTrue(containsType(bazClass,
                              computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
-  var bazInterfaces = bazClass.interfaces;
+  var bazInterfaces = bazClass.superinterfaces;
   Expect.isNotNull(bazInterfaces, "Interfaces map is null");
   Expect.isTrue(!bazInterfaces.isEmpty, "Interfaces map is empty");
   for (var bazInterface in bazInterfaces) {
     Expect.isTrue(containsType(bazClass,
                                computeSubdeclarations(objectType)),
                   "Class is not subclass of superinterface");
   }
 
   var bazSubdeclarations = computeSubdeclarations(bazClass);
   Expect.equals(0, count(bazSubdeclarations), "Unexpected subtype count");
 
   var barInterface = findMirror(bazInterfaces, "Bar");
   Expect.isNotNull(barInterface, "Interface bar is missing");
-  Expect.isFalse(barInterface.isDeclaration, "Interface type is declaration");
+  Expect.isFalse(barInterface.isOriginalDeclaration);
   var barInterfaceTypeArguments = barInterface.typeArguments;
   Expect.isNotNull(barInterfaceTypeArguments, "Type arguments are missing");
   Expect.equals(1, barInterfaceTypeArguments.length,
                 "Type arguments is empty");
 
   Expect.throws(() => bazClass.typeArguments,
                 (exception) => true,
                 "Class has type arguments");
   var bazClassTypeVariables = bazClass.typeVariables;
   Expect.isNotNull(bazClassTypeVariables, "Type variable list is null");
   Expect.equals(2, bazClassTypeVariables.length,
                 "Type variable list is not empty");
 
   var bazE = bazClassTypeVariables[0];
   Expect.isNotNull(bazE, "Type variable is null");
   Expect.stringEquals('E', bazE.simpleName, "Unexpected simpleName");
   Expect.stringEquals('mirrors_helper.Baz.E', bazE.qualifiedName,
                       "Unexpected qualifiedName");
   Expect.equals(bazClass, bazE.declarer,
                 "Unexpected type variable declarer");
   var bazEbound = bazE.bound;
   Expect.isNotNull(bazEbound, "Missing type variable bound");
-  Expect.isFalse(bazEbound.isDeclaration, "Bound is declaration");
+  Expect.isFalse(bazEbound.isOriginalDeclaration);
   Expect.isTrue(bazEbound.isObject, "Bound is not object");
 
   var bazF = bazClassTypeVariables[1];
   Expect.isNotNull(bazF, "Type variable is null");
   Expect.stringEquals('F', bazF.simpleName, "Unexpected simpleName");
   Expect.stringEquals('mirrors_helper.Baz.F', bazF.qualifiedName,
                       "Unexpected qualifiedName");
   Expect.equals(bazClass, bazF.declarer);
   var bazFbound = bazF.bound;
   Expect.isNotNull(bazFbound, "Missing type variable bound");
-  Expect.isFalse(bazFbound.isDeclaration, "Bound is declaration");
+  Expect.isFalse(bazFbound.isOriginalDeclaration);
   Expect.stringEquals("mirrors_helper.Foo", bazFbound.qualifiedName,
                       "Bound is not Foo");
 
-  Expect.isNull(bazClass.defaultType, "Class has default type");
+  Expect.isNull(bazClass.defaultFactory);
 
   var bazClassMembers = bazClass.declaredMembers;
   Expect.isNotNull(bazClassMembers, "Declared members map is null");
   Expect.equals(8, bazClassMembers.length,
                 "Unexpected number of declared members");
 
   ////////////////////////////////////////////////////////////////////////////
   // static method1(e) {}
   ////////////////////////////////////////////////////////////////////////////
   var method1 = bazClassMembers["method1"];
   Expect.isNotNull(method1, "method1 not found");
   Expect.stringEquals('method1', method1.simpleName,
                       "Unexpected method simpleName");
   Expect.stringEquals('mirrors_helper.Baz.method1', method1.qualifiedName,
                       "Unexpected method qualifiedName");
-  Expect.equals(method1.owner, bazClass,
-                "Unexpected surrounding declaration");
+  Expect.equals(method1.owner, bazClass);
   Expect.isFalse(method1.isTopLevel, "Method is top level");
   Expect.isFalse(method1.isConstructor, "Method is constructor");
   Expect.isFalse(method1.isField, "Method is field");
   Expect.isTrue(method1.isMethod, "Method is not method");
   Expect.isFalse(method1.isPrivate, "Method is private");
   Expect.isTrue(method1.isStatic, "Method is not static");
   Expect.isTrue(method1 is MethodMirror, "Method is not MethodMirror");
   Expect.isFalse(method1.isConst, "Method is const");
   Expect.isFalse(method1.isFactory, "Method is factory");
   Expect.isNull(method1.constructorName,
@@ skipping 32 matching lines @@
 
   ////////////////////////////////////////////////////////////////////////////
   // static void method2(E e, [F f = null]) {}
   ////////////////////////////////////////////////////////////////////////////
   var method2 = bazClassMembers["method2"];
   Expect.isNotNull(method2, "method2 not found");
   Expect.stringEquals('method2', method2.simpleName,
                       "Unexpected method simpleName");
   Expect.stringEquals('mirrors_helper.Baz.method2', method2.qualifiedName,
                       "Unexpected method qualifiedName");
-  Expect.equals(method2.owner, bazClass,
-                "Unexpected surrounding declaration");
+  Expect.equals(method2.owner, bazClass);
   Expect.isFalse(method2.isTopLevel, "Method is top level");
   Expect.isFalse(method2.isConstructor, "Method is constructor");
   Expect.isFalse(method2.isField, "Method is field");
   Expect.isTrue(method2.isMethod, "Method is not method");
   Expect.isFalse(method2.isPrivate, "Method is private");
   Expect.isFalse(method2.isStatic, "Method is static");
   Expect.isTrue(method2 is MethodMirror, "Method is not MethodMirror");
   Expect.isFalse(method2.isConst, "Method is const");
   Expect.isFalse(method2.isFactory, "Method is factory");
   Expect.isNull(method2.constructorName,
@@ skipping 45 matching lines @@
 
   ////////////////////////////////////////////////////////////////////////////
   // Baz<E,F> method3(E func1(F f), Func<E,F> func2) => null;
   ////////////////////////////////////////////////////////////////////////////
   var method3 = bazClassMembers["method3"];
   Expect.isNotNull(method3, "method3 not found");
   Expect.stringEquals('method3', method3.simpleName,
                       "Unexpected method simpleName");
   Expect.stringEquals('mirrors_helper.Baz.method3', method3.qualifiedName,
                       "Unexpected method qualifiedName");
-  Expect.equals(method3.owner, bazClass,
-                      "Unexpected surrounding declaration");
+  Expect.equals(method3.owner, bazClass);
   Expect.isFalse(method3.isTopLevel, "Method is top level");
   Expect.isFalse(method3.isConstructor, "Method is constructor");
   Expect.isFalse(method3.isField, "Method is field");
   Expect.isTrue(method3.isMethod, "Method is not method");
   Expect.isFalse(method3.isPrivate, "Method is private");
   Expect.isFalse(method3.isStatic, "Method is static");
   Expect.isTrue(method3 is MethodMirror, "Method is not MethodMirror");
   Expect.isFalse(method3.isConst, "Method is const");
   Expect.isFalse(method3.isFactory, "Method is factory");
   Expect.isNull(method3.constructorName,
                 "Method constructorName is non-null");
   Expect.isFalse(method3.isGetter, "Method is getter");
   Expect.isFalse(method3.isSetter, "Method is setter");
   Expect.isFalse(method3.isOperator, "Method is operator");
   Expect.isNull(method3.operatorName,
                 "Method operatorName is non-null");
 
   var method3ReturnType = method3.returnType;
   Expect.isNotNull(method3ReturnType, "Return type is null");
   Expect.isTrue(method3ReturnType is ClassMirror,
                 "Return type is not interface");
-  Expect.equals(bazClass, method3ReturnType.declaration,
-                "Return type is not Baz");
+  Expect.equals(bazClass, method3ReturnType.originalDeclaration);
   // TODO(johnniwinther): Test type arguments of [method3ReturnType].
 
   var method3Parameters = method3.parameters;
   Expect.isNotNull(method3Parameters, "Method parameters is null");
   Expect.equals(2, method3Parameters.length, "Unexpected parameter count");
   var method3Parameter1 = method3Parameters[0];
   Expect.isNotNull(method3Parameter1, "Parameter is null");
   var method3Parameter1type = method3Parameter1.type;
   Expect.isNotNull(method3Parameter1type, "Parameter type of 'func1' is null");
   Expect.isTrue(method3Parameter1type is FunctionTypeMirror,
@@ skipping 34 matching lines @@
   Expect.isFalse(funcTypedef.isObject, "Typedef is Object");
   Expect.isFalse(funcTypedef.isDynamic, "Typedef is Dynamic");
   Expect.isFalse(funcTypedef.isVoid, "Typedef is void");
   Expect.isFalse(funcTypedef.isTypeVariable, "Typedef is a type variable");
   Expect.isTrue(funcTypedef.isTypedef, "Typedef is not a typedef");
   Expect.isFalse(funcTypedef.isFunction, "Typedef is a function");
 
   Expect.equals(helperLibrary, funcTypedef.library,
                 "Unexpected typedef library");
   Expect.isNull(funcTypedef.superclass, "Non-null superclass on typedef");
-  Expect.isNotNull(funcTypedef.interfaces,
-                   "Null interfaces map on typedef");
-  Expect.isTrue(funcTypedef.interfaces.isEmpty,
-                "Non-empty interfaces map on typedef");
+  Expect.isNotNull(funcTypedef.superinterfaces);
+  Expect.isTrue(funcTypedef.superinterfaces.isEmpty);
   Expect.isNotNull(funcTypedef.declaredMembers,
                    "Declared members map is null on type def");
   Expect.isTrue(funcTypedef.declaredMembers.isEmpty,
                 "Non-empty declared members map on typedef");
 
-  // TODO(johnniwinther): Returned typedef should not be the declaration:
-  Expect.isTrue(funcTypedef.isDeclaration, "Typedef is not declaration");
+  // TODO(johnniwinther): Returned typedef should not be the original
+  // declaration:
+  Expect.isTrue(funcTypedef.isOriginalDeclaration);
   Expect.isFalse(funcTypedef.isClass, "Typedef is class");
   Expect.isFalse(funcTypedef.isInterface, "Typedef is interface");
   Expect.isFalse(funcTypedef.isPrivate, "Typedef is private");
-  Expect.isNull(funcTypedef.defaultType,
-                "Typedef default type is non-null");
+  Expect.isNull(funcTypedef.defaultFactory);
   // TODO(johnniwinther): Should not throw an exception since the type should
-  // not be the declaration.
+  // not be the original declaration.
   Expect.throws(() => funcTypedef.typeArguments,
                 (exception) => true,
                 "Typedef has type arguments");
   var funcTypedefTypeVariables = funcTypedef.typeVariables;
   Expect.isNotNull(funcTypedefTypeVariables);
   Expect.equals(2, funcTypedefTypeVariables.length);
 
   var funcTypedefDefinition = funcTypedef.definition;
   Expect.isNotNull(funcTypedefDefinition);
   Expect.isTrue(funcTypedefDefinition is FunctionTypeMirror);
@@ skipping 14 matching lines @@
   // bool operator==(Object other) => false;
   ////////////////////////////////////////////////////////////////////////////
   var operator_eq = bazClassMembers['=='];
   Expect.isNotNull(operator_eq, "operator == not found");
   Expect.stringEquals('==', operator_eq.simpleName,
                       "Unexpected method simpleName");
   Expect.stringEquals('operator ==', operator_eq.displayName);
   Expect.stringEquals('mirrors_helper.Baz.==',
                       operator_eq.qualifiedName,
                       "Unexpected method qualifiedName");
-  Expect.equals(operator_eq.owner, bazClass,
-                "Unexpected surrounding declaration");
+  Expect.equals(operator_eq.owner, bazClass);
   Expect.isFalse(operator_eq.isTopLevel, "Method is top level");
   Expect.isFalse(operator_eq.isConstructor, "Method is constructor");
   Expect.isFalse(operator_eq.isField, "Method is field");
   Expect.isTrue(operator_eq.isMethod, "Method is not method");
   Expect.isFalse(operator_eq.isPrivate, "Method is private");
   Expect.isFalse(operator_eq.isStatic, "Method is static");
   Expect.isTrue(operator_eq is MethodMirror, "Method is not MethodMirror");
   Expect.isFalse(operator_eq.isConst, "Method is const");
   Expect.isFalse(operator_eq.isFactory, "Method is factory");
   Expect.isNull(operator_eq.constructorName,
                 "Method constructorName is non-null");
   Expect.isFalse(operator_eq.isGetter, "Method is getter");
   Expect.isFalse(operator_eq.isSetter, "Method is setter");
   Expect.isTrue(operator_eq.isOperator, "Method is not operator");
   Expect.stringEquals('==', operator_eq.operatorName,
                       "Unexpected operatorName");
 
   ////////////////////////////////////////////////////////////////////////////
   // int operator -() => 0;
   ////////////////////////////////////////////////////////////////////////////
   var operator_negate = bazClassMembers[Mirror.UNARY_MINUS];
   Expect.isNotNull(operator_negate, "operator < not found");
   Expect.stringEquals(Mirror.UNARY_MINUS, operator_negate.simpleName,
                       "Unexpected method simpleName");
   Expect.stringEquals('operator -', operator_negate.displayName);
   Expect.stringEquals('mirrors_helper.Baz.${Mirror.UNARY_MINUS}',
                       operator_negate.qualifiedName,
                       "Unexpected method qualifiedName");
-  Expect.equals(operator_negate.owner, bazClass,
-                "Unexpected surrounding declaration");
+  Expect.equals(operator_negate.owner, bazClass);
   Expect.isFalse(operator_negate.isTopLevel, "Method is top level");
   Expect.isFalse(operator_negate.isConstructor, "Method is constructor");
   Expect.isFalse(operator_negate.isField, "Method is field");
   Expect.isTrue(operator_negate.isMethod, "Method is not method");
   Expect.isFalse(operator_negate.isPrivate, "Method is private");
   Expect.isFalse(operator_negate.isStatic, "Method is static");
   Expect.isTrue(operator_negate is MethodMirror,
                 "Method is not MethodMirror");
   Expect.isFalse(operator_negate.isConst, "Method is const");
   Expect.isFalse(operator_negate.isFactory, "Method is factory");
@@ skipping 93 matching lines @@
   Expect.isTrue(privateConstructor.isConstructor);
   Expect.isTrue(privateConstructor.isPrivate);
 
   var privateFactoryConstructor =
       privateClass.declaredMembers['_PrivateClass._privateFactoryConstructor'];
   Expect.isNotNull(privateFactoryConstructor);
   Expect.isTrue(privateFactoryConstructor is MethodMirror);
   Expect.isTrue(privateFactoryConstructor.isFactory);
   Expect.isTrue(privateFactoryConstructor.isPrivate);
 }