Make Mirror.simpleName unique.

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) {
       return true;
     }
   }
   return false;
 }
 
+Mirror findMirror(List<Mirror> list, String name) {
+  var foundMirror = null;
+  list.forEach((Mirror mirror) {
+    if (mirror.simpleName == name) {
+      foundMirror = mirror;

[ngeoffray, 2012/10/02 20:19:43]

Can it have duplicates and then you take the last occurrence? Otherwise you
could use a for loop with a break.

[Johnni Winther, 2012/10/03 09:36:24]

Done.

+    }
+  });
+  return foundMirror;
+}
+
 main() {
   var scriptPath = new Path.fromNative(new Options().script);
   var dirPath = scriptPath.directoryPath;
   var libPath = dirPath.join(new Path.fromNative('../../../'));
   var inputPath = dirPath.join(new Path.fromNative('mirrors_helper.dart'));
   var compilation = new Compilation.library([inputPath], libPath);
   Expect.isNotNull(compilation, "No compilation created");
 
   var mirrors = compilation.mirrors;
   Expect.isNotNull(mirrors, "No mirror system returned from compilation");
 
   var libraries = mirrors.libraries;
   Expect.isNotNull(libraries, "No libraries map returned");
   Expect.isFalse(libraries.isEmpty(), "Empty libraries map returned");
 
-  var helperLibrary = findMirror(libraries, "mirrors_helper");
+  var helperLibrary = libraries["mirrors_helper"];
   Expect.isNotNull(helperLibrary, "Library 'mirrors_helper' not found");
   Expect.stringEquals("mirrors_helper", helperLibrary.simpleName,
     "Unexpected library simple name");
   Expect.stringEquals("mirrors_helper", helperLibrary.qualifiedName,
     "Unexpected library qualified name");
 
   var types = helperLibrary.types;
   Expect.isNotNull(types, "No types map returned");
   Expect.isFalse(types.isEmpty(), "Empty types map returned");
 
   testFoo(mirrors, helperLibrary, types);
   testBar(mirrors, helperLibrary, types);
   testBaz(mirrors, helperLibrary, types);
   // TODO(johnniwinther): Add test of class [Boz] and typedef [Func].
   // TODO(johnniwinther): Add tests of type argument substitution, which
   // is not currently implemented in dart2js.
   // TODO(johnniwinther): Add tests of Location and Source.
 }
 
 // Testing class Foo:
 //
 // class Foo {
 //
 // }
 void testFoo(MirrorSystem system, LibraryMirror helperLibrary,
              Map<Object,TypeMirror> types) {
-  var fooClass = findMirror(types, "Foo");
+  var fooClass = types["Foo"];
   Expect.isNotNull(fooClass, "Type 'Foo' not found");
   Expect.isTrue(fooClass is InterfaceMirror,
                 "Unexpected mirror type returned");
   Expect.stringEquals("Foo", fooClass.simpleName,
                       "Unexpected type simple name");
   Expect.stringEquals("mirrors_helper.Foo", fooClass.qualifiedName,
                       "Unexpected type qualified name");
 
   Expect.equals(helperLibrary, fooClass.library,
                 "Unexpected library returned from type");
@@ skipping 52 matching lines @@
                 "Constructors map is unempty");
 }
 
 // Testing interface Bar:
 //
 // interface Bar<E> {
 //
 // }
 void testBar(MirrorSystem system, LibraryMirror helperLibrary,
              Map<Object,TypeMirror> types) {
-  var barInterface = findMirror(types, "Bar");
+  var barInterface = types["Bar"];
   Expect.isNotNull(barInterface, "Type 'Bar' not found");
   Expect.isTrue(barInterface is InterfaceMirror,
                "Unexpected mirror type returned");
   Expect.stringEquals("Bar", barInterface.simpleName,
                       "Unexpected type simple name");
   Expect.stringEquals("mirrors_helper.Bar", barInterface.qualifiedName,
                       "Unexpected type qualified name");
 
   Expect.equals(helperLibrary, barInterface.library,
                 "Unexpected library returned from type");
@@ skipping 22 matching lines @@
                 "Class is not subclass of superclass");
 
   var barInterfaces = barInterface.interfaces;
   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.getValues()),
+                               barSubdeclaration.interfaces),
                   "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");
@@ skipping 26 matching lines @@
 //
 //   static method1(e) {}
 //   void method2(E e, [F f = null]) {}
 //   Baz<E,F> method3(E func1(F f), Func<E,F> func2) => null;
 //
 //   bool operator==(Object other) => false;
 //   int operator -() => 0;
 // }
 void testBaz(MirrorSystem system, LibraryMirror helperLibrary,
              Map<Object,TypeMirror> types) {
-  var bazClass = findMirror(types, "Baz");
+  var bazClass = types["Baz"];
   Expect.isNotNull(bazClass, "Type 'Baz' not found");
   Expect.isTrue(bazClass is InterfaceMirror,
                 "Unexpected mirror type returned");
   Expect.stringEquals("Baz", bazClass.simpleName,
                       "Unexpected type simple name");
   Expect.stringEquals("mirrors_helper.Baz", bazClass.qualifiedName,
                       "Unexpected type qualified name");
 
   Expect.equals(helperLibrary, bazClass.library,
                 "Unexpected library returned from type");
@@ skipping 17 matching lines @@
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
   Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
   Expect.isTrue(containsType(bazClass,
                              computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
   var bazInterfaces = bazClass.interfaces;
   Expect.isNotNull(bazInterfaces, "Interfaces map is null");
   Expect.isTrue(!bazInterfaces.isEmpty(), "Interfaces map is empty");
-  for (var bazInterface in bazInterfaces.getValues()) {
+  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");
@@ skipping 38 matching lines @@
   Expect.isNull(bazClass.defaultType, "Class has default type");
 
   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 = findMirror(bazClassMembers, "method1");
+  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.surroundingDeclaration, bazClass,
                 "Unexpected surrounding declaration");
   Expect.isFalse(method1.isTopLevel, "Method is top level");
   Expect.isFalse(method1.isConstructor, "Method is constructor");
   Expect.isFalse(method1.isField, "Method is field");
@@ skipping 33 matching lines @@
                       "Unexpected parameter qualifiedName");
   Expect.isFalse(method1Parameter1.hasDefaultValue,
     "Parameter has default value");
   Expect.isNull(method1Parameter1.defaultValue,
     "Parameter default value is non-null");
   Expect.isFalse(method1Parameter1.isOptional, "Parameter is optional");
 
   ////////////////////////////////////////////////////////////////////////////
   // static void method2(E e, [F f = null]) {}
   ////////////////////////////////////////////////////////////////////////////
-  var method2 = findMirror(bazClassMembers, "method2");
+  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.surroundingDeclaration, bazClass,
                 "Unexpected surrounding declaration");
   Expect.isFalse(method2.isTopLevel, "Method is top level");
   Expect.isFalse(method2.isConstructor, "Method is constructor");
   Expect.isFalse(method2.isField, "Method is field");
@@ skipping 46 matching lines @@
                       "Unexpected parameter qualifiedName");
   Expect.isTrue(method2Parameter2.hasDefaultValue,
                  "Parameter has default value");
   Expect.stringEquals("null", method2Parameter2.defaultValue,
                       "Parameter default value is non-null");
   Expect.isTrue(method2Parameter2.isOptional, "Parameter is not optional");
 
   ////////////////////////////////////////////////////////////////////////////
   // Baz<E,F> method3(E func1(F f), Func<E,F> func2) => null;
   ////////////////////////////////////////////////////////////////////////////
-  var method3 = findMirror(bazClassMembers, "method3");
+  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.surroundingDeclaration, bazClass,
                       "Unexpected surrounding declaration");
   Expect.isFalse(method3.isTopLevel, "Method is top level");
   Expect.isFalse(method3.isConstructor, "Method is constructor");
   Expect.isFalse(method3.isField, "Method is field");
@@ skipping 108 matching lines @@
   Expect.isFalse(method3Parameter2.hasDefaultValue,
                  "Parameter 'func2' has default value: "
                  "${method3Parameter2.defaultValue}");
   Expect.isNull(method3Parameter2.defaultValue,
                 "Parameter default value is non-null");
   Expect.isFalse(method3Parameter2.isOptional, "Parameter is optional");
 
   ////////////////////////////////////////////////////////////////////////////
   // bool operator==(Object other) => false;
   ////////////////////////////////////////////////////////////////////////////
-  var operator_eq = findMirror(bazClassMembers, "operator", operatorName: '==');
+  var operator_eq = bazClassMembers['=='];
   Expect.isNotNull(operator_eq, "operator == not found");
-  Expect.stringEquals('operator', operator_eq.simpleName,
+  Expect.stringEquals('==', operator_eq.simpleName,
                       "Unexpected method simpleName");
-  Expect.stringEquals('mirrors_helper.Baz.operator ==',
+  Expect.stringEquals('operator ==', operator_eq.displayName);
+  Expect.stringEquals('mirrors_helper.Baz.==',
                       operator_eq.qualifiedName,
                       "Unexpected method qualifiedName");
   Expect.equals(operator_eq.surroundingDeclaration, bazClass,
                 "Unexpected surrounding declaration");
   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 = findMirror(bazClassMembers, "operator",
-                           operatorName: 'negate');
+  var operator_negate = bazClassMembers[Mirror.UNARY_MINUS];
   Expect.isNotNull(operator_negate, "operator < not found");
-  Expect.stringEquals('operator', operator_negate.simpleName,
+  Expect.stringEquals(Mirror.UNARY_MINUS, operator_negate.simpleName,
                       "Unexpected method simpleName");
-  Expect.stringEquals('mirrors_helper.Baz.operator negate',
+  Expect.stringEquals('operator -', operator_negate.displayName);
+  Expect.stringEquals('mirrors_helper.Baz.${Mirror.UNARY_MINUS}',
                       operator_negate.qualifiedName,
                       "Unexpected method qualifiedName");
   Expect.equals(operator_negate.surroundingDeclaration, bazClass,
                 "Unexpected surrounding declaration");
   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");
   Expect.isNull(operator_negate.constructorName,
                 "Method constructorName is non-null");
   Expect.isFalse(operator_negate.isGetter, "Method is getter");
   Expect.isFalse(operator_negate.isSetter, "Method is setter");
   Expect.isTrue(operator_negate.isOperator, "Method is not operator");
-  Expect.stringEquals('negate', operator_negate.operatorName,
+  Expect.stringEquals('-', operator_negate.operatorName,
                       "Unexpected operatorName");
 
 
   var bazClassConstructors = bazClass.constructors;
   Expect.isNotNull(bazClassConstructors, "Constructors map is null");
   Expect.equals(3, bazClassConstructors.length,
                 "Unexpected number of constructors");
-  // TODO(johnniwinther): Add tests of constructors.
+
+  var bazClassNonameConstructor = bazClassConstructors['Baz'];
+  Expect.isNotNull(bazClassNonameConstructor);
+  Expect.isTrue(bazClassNonameConstructor is MethodMirror);
+  Expect.isTrue(bazClassNonameConstructor.isConstructor);
+  Expect.isFalse(bazClassNonameConstructor.isFactory);
+  Expect.stringEquals('Baz', bazClassNonameConstructor.simpleName);
+  Expect.stringEquals('Baz', bazClassNonameConstructor.displayName);
+  Expect.stringEquals('mirrors_helper.Baz.Baz',
+      bazClassNonameConstructor.qualifiedName);
+  Expect.stringEquals('', bazClassNonameConstructor.constructorName);
+
+  var bazClassNamedConstructor = bazClassConstructors['Baz.named'];
+  Expect.isNotNull(bazClassNamedConstructor);
+  Expect.isTrue(bazClassNamedConstructor is MethodMirror);
+  Expect.isTrue(bazClassNamedConstructor.isConstructor);
+  Expect.isFalse(bazClassNamedConstructor.isFactory);
+  Expect.stringEquals('Baz.named', bazClassNamedConstructor.simpleName);
+  Expect.stringEquals('Baz.named', bazClassNamedConstructor.displayName);
+  Expect.stringEquals('mirrors_helper.Baz.Baz.named',
+      bazClassNamedConstructor.qualifiedName);
+  Expect.stringEquals('named', bazClassNamedConstructor.constructorName);
+
+  var bazClassFactoryConstructor = bazClassConstructors['Baz.factory'];
+  Expect.isNotNull(bazClassFactoryConstructor);
+  Expect.isTrue(bazClassFactoryConstructor is MethodMirror);
+  Expect.isTrue(bazClassFactoryConstructor.isConstructor);
+  Expect.isTrue(bazClassFactoryConstructor.isFactory);
+  Expect.stringEquals('Baz.factory', bazClassFactoryConstructor.simpleName);
+  Expect.stringEquals('Baz.factory', bazClassFactoryConstructor.displayName);
+  Expect.stringEquals('mirrors_helper.Baz.Baz.factory',
+      bazClassFactoryConstructor.qualifiedName);
+  Expect.stringEquals('factory', bazClassFactoryConstructor.constructorName);
+
+  // TODO(johnniwinther): Add more tests of constructors.
+  // TODO(johnniwinther): Add a test for unnamed factory methods.
 }