Remove support for conflicting constructors.

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 "package:expect/expect.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/filenames.dart'
        show currentDirectory, nativeToUriPath;
@@ skipping 607 matching lines @@
   Expect.isFalse(method1.isVariable);
   Expect.isTrue(method1.isMethod);
   Expect.isFalse(method1.isPrivate);
   Expect.isTrue(method1.isStatic);
   Expect.isTrue(method1 is MethodMirror);
   Expect.isTrue(method1.isRegularMethod);
   Expect.isFalse(method1.isConstConstructor);
   Expect.isFalse(method1.isGenerativeConstructor);
   Expect.isFalse(method1.isRedirectingConstructor);
   Expect.isFalse(method1.isFactoryConstructor);
-  Expect.isNull(method1.constructorName);
   Expect.isFalse(method1.isGetter);
   Expect.isFalse(method1.isSetter);
   Expect.isFalse(method1.isOperator);
 
   var dynamicType = method1.returnType;
   Expect.isNotNull(dynamicType, "Return type was null");
   Expect.isFalse(dynamicType.isObject, "dynamic is Object");
   Expect.isTrue(dynamicType.isDynamic, "dynamic is not dynamic");
   Expect.isFalse(dynamicType.isVoid, "dynamic is void");
   Expect.isFalse(dynamicType.isTypeVariable, "dynamic is a type variable");
@@ skipping 32 matching lines @@
   Expect.isFalse(method2.isVariable);
   Expect.isTrue(method2.isMethod);
   Expect.isFalse(method2.isPrivate);
   Expect.isFalse(method2.isStatic);
   Expect.isTrue(method2 is MethodMirror);
   Expect.isTrue(method2.isRegularMethod);
   Expect.isFalse(method2.isConstConstructor);
   Expect.isFalse(method2.isGenerativeConstructor);
   Expect.isFalse(method2.isRedirectingConstructor);
   Expect.isFalse(method2.isFactoryConstructor);
-  Expect.isNull(method2.constructorName);
   Expect.isFalse(method2.isGetter);
   Expect.isFalse(method2.isSetter);
   Expect.isFalse(method2.isOperator);
 
   var voidType = method2.returnType;
   Expect.isNotNull(voidType, "Return type was null");
   Expect.isFalse(voidType.isObject, "void is Object");
   Expect.isFalse(voidType.isDynamic, "void is dynamic");
   Expect.isTrue(voidType.isVoid, "void is not void");
   Expect.isFalse(voidType.isTypeVariable, "void is a type variable");
@@ skipping 45 matching lines @@
   Expect.isFalse(method3.isVariable);
   Expect.isTrue(method3.isMethod);
   Expect.isFalse(method3.isPrivate);
   Expect.isFalse(method3.isStatic);
   Expect.isTrue(method3 is MethodMirror);
   Expect.isTrue(method3.isRegularMethod);
   Expect.isFalse(method3.isConstConstructor);
   Expect.isFalse(method3.isGenerativeConstructor);
   Expect.isFalse(method3.isRedirectingConstructor);
   Expect.isFalse(method3.isFactoryConstructor);
-  Expect.isNull(method3.constructorName);
   Expect.isFalse(method3.isGetter);
   Expect.isFalse(method3.isSetter);
   Expect.isFalse(method3.isOperator);
 
   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.originalDeclaration);
   // TODO(johnniwinther): Test type arguments of [method3ReturnType].
@@ skipping 102 matching lines @@
   Expect.isFalse(operator_eq.isVariable);
   Expect.isTrue(operator_eq.isMethod);
   Expect.isFalse(operator_eq.isPrivate);
   Expect.isFalse(operator_eq.isStatic);
   Expect.isTrue(operator_eq is MethodMirror);
   Expect.isTrue(operator_eq.isRegularMethod);
   Expect.isFalse(operator_eq.isConstConstructor);
   Expect.isFalse(operator_eq.isGenerativeConstructor);
   Expect.isFalse(operator_eq.isRedirectingConstructor);
   Expect.isFalse(operator_eq.isFactoryConstructor);
-  Expect.isNull(operator_eq.constructorName);
   Expect.isFalse(operator_eq.isGetter);
   Expect.isFalse(operator_eq.isSetter);
   Expect.isTrue(operator_eq.isOperator);
   Expect.stringEquals('==', operatorName(operator_eq));
 
   ////////////////////////////////////////////////////////////////////////////
   // 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 -', displayName(operator_negate));
   Expect.stringEquals('mirrors_helper.Baz.${Mirror.UNARY_MINUS}',
                       operator_negate.qualifiedName,
                       "Unexpected method qualifiedName");
   Expect.equals(operator_negate.owner, bazClass);
   Expect.isFalse(operator_negate.isTopLevel);
   Expect.isFalse(operator_negate.isConstructor);
   Expect.isFalse(operator_negate.isVariable);
   Expect.isTrue(operator_negate.isMethod);
   Expect.isFalse(operator_negate.isPrivate);
   Expect.isFalse(operator_negate.isStatic);
   Expect.isTrue(operator_negate is MethodMirror);
   Expect.isTrue(operator_negate.isRegularMethod);
   Expect.isFalse(operator_negate.isConstConstructor);
   Expect.isFalse(operator_negate.isGenerativeConstructor);
   Expect.isFalse(operator_negate.isRedirectingConstructor);
   Expect.isFalse(operator_negate.isFactoryConstructor);
-  Expect.isNull(operator_negate.constructorName);
   Expect.isFalse(operator_negate.isGetter);
   Expect.isFalse(operator_negate.isSetter);
   Expect.isTrue(operator_negate.isOperator);
   Expect.stringEquals('-', operatorName(operator_negate));
 
 
   var bazClassConstructors = bazClass.constructors;
   Expect.isNotNull(bazClassConstructors, "Constructors map is null");
   Expect.equals(3, bazClassConstructors.length,
                 "Unexpected number of constructors");
 
   ////////////////////////////////////////////////////////////////////////////
   //   Baz();
   ////////////////////////////////////////////////////////////////////////////
-  var bazClassNonameConstructor = bazClassConstructors['Baz'];
+  var bazClassNonameConstructor = bazClassConstructors[''];
   Expect.isNotNull(bazClassNonameConstructor);
   Expect.isTrue(bazClassNonameConstructor is MethodMirror);
   Expect.isTrue(bazClassNonameConstructor.isConstructor);
   Expect.isFalse(bazClassNonameConstructor.isRegularMethod);
   Expect.isFalse(bazClassNonameConstructor.isConstConstructor);
   Expect.isTrue(bazClassNonameConstructor.isGenerativeConstructor);
   Expect.isFalse(bazClassNonameConstructor.isRedirectingConstructor);
   Expect.isFalse(bazClassNonameConstructor.isFactoryConstructor);
-  Expect.stringEquals('Baz', bazClassNonameConstructor.simpleName);
+  Expect.stringEquals('', bazClassNonameConstructor.simpleName);
   Expect.stringEquals('Baz', displayName(bazClassNonameConstructor));
-  Expect.stringEquals('mirrors_helper.Baz.Baz',
+  Expect.stringEquals('mirrors_helper.Baz.',
       bazClassNonameConstructor.qualifiedName);
-  Expect.stringEquals('', bazClassNonameConstructor.constructorName);
 
   ////////////////////////////////////////////////////////////////////////////
   //   const Baz.named();
   ////////////////////////////////////////////////////////////////////////////
-  var bazClassNamedConstructor = bazClassConstructors['Baz.named'];
+  var bazClassNamedConstructor = bazClassConstructors['named'];
   Expect.isNotNull(bazClassNamedConstructor);
   Expect.isTrue(bazClassNamedConstructor is MethodMirror);
   Expect.isTrue(bazClassNamedConstructor.isConstructor);
   Expect.isFalse(bazClassNamedConstructor.isRegularMethod);
   Expect.isTrue(bazClassNamedConstructor.isConstConstructor);
   Expect.isFalse(bazClassNamedConstructor.isGenerativeConstructor);
   Expect.isFalse(bazClassNamedConstructor.isRedirectingConstructor);
   Expect.isFalse(bazClassNamedConstructor.isFactoryConstructor);
-  Expect.stringEquals('Baz.named', bazClassNamedConstructor.simpleName);
+  Expect.stringEquals('named', bazClassNamedConstructor.simpleName);
   Expect.stringEquals('Baz.named', displayName(bazClassNamedConstructor));
-  Expect.stringEquals('mirrors_helper.Baz.Baz.named',
+  Expect.stringEquals('mirrors_helper.Baz.named',
       bazClassNamedConstructor.qualifiedName);
-  Expect.stringEquals('named', bazClassNamedConstructor.constructorName);
 
   ////////////////////////////////////////////////////////////////////////////
   //   factory Baz.factory() => new Baz<E,F>();
   ////////////////////////////////////////////////////////////////////////////
-  var bazClassFactoryConstructor = bazClassConstructors['Baz.factory'];
+  var bazClassFactoryConstructor = bazClassConstructors['factory'];
   Expect.isNotNull(bazClassFactoryConstructor);
   Expect.isTrue(bazClassFactoryConstructor is MethodMirror);
   Expect.isTrue(bazClassFactoryConstructor.isConstructor);
   Expect.isFalse(bazClassFactoryConstructor.isRegularMethod);
   Expect.isFalse(bazClassFactoryConstructor.isConstConstructor);
   Expect.isFalse(bazClassFactoryConstructor.isGenerativeConstructor);
   Expect.isFalse(bazClassFactoryConstructor.isRedirectingConstructor);
   Expect.isTrue(bazClassFactoryConstructor.isFactoryConstructor);
-  Expect.stringEquals('Baz.factory', bazClassFactoryConstructor.simpleName);
+  Expect.stringEquals('factory', bazClassFactoryConstructor.simpleName);
   Expect.stringEquals('Baz.factory', displayName(bazClassFactoryConstructor));
-  Expect.stringEquals('mirrors_helper.Baz.Baz.factory',
+  Expect.stringEquals('mirrors_helper.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.
 
   var metadata = bazClass.metadata;
   Expect.isNotNull(metadata);
   Expect.equals(0, metadata.length);
 }
 
 // class _PrivateClass {
@@ skipping 32 matching lines @@
   Expect.isTrue(privateSetter.isPrivate);
   Expect.isFalse(privateSetter.isRegularMethod);
 
   var privateMethod = privateClass.members['_privateMethod'];
   Expect.isNotNull(privateMethod);
   Expect.isTrue(privateMethod is MethodMirror);
   Expect.isTrue(privateMethod.isPrivate);
   Expect.isTrue(privateMethod.isRegularMethod);
 
   var privateConstructor =
-      privateClass.members['_PrivateClass._privateConstructor'];
+      privateClass.members['_privateConstructor'];
   Expect.isNotNull(privateConstructor);
   Expect.isTrue(privateConstructor is MethodMirror);
   Expect.isTrue(privateConstructor.isConstructor);
   Expect.isTrue(privateConstructor.isPrivate);
   Expect.isFalse(privateConstructor.isConstConstructor);
   Expect.isFalse(privateConstructor.isRedirectingConstructor);
   Expect.isTrue(privateConstructor.isGenerativeConstructor);
   Expect.isFalse(privateConstructor.isFactoryConstructor);
 
   var privateFactoryConstructor =
-      privateClass.members['_PrivateClass._privateFactoryConstructor'];
+      privateClass.members['_privateFactoryConstructor'];
   Expect.isNotNull(privateFactoryConstructor);
   Expect.isTrue(privateFactoryConstructor is MethodMirror);
   Expect.isTrue(privateFactoryConstructor.isConstructor);
   Expect.isTrue(privateFactoryConstructor.isPrivate);
   Expect.isFalse(privateFactoryConstructor.isConstConstructor);
   Expect.isFalse(privateFactoryConstructor.isRedirectingConstructor);
   Expect.isFalse(privateFactoryConstructor.isGenerativeConstructor);
   Expect.isTrue(privateFactoryConstructor.isFactoryConstructor);
 
   var metadata = privateClass.metadata;
   Expect.isNotNull(metadata);
   Expect.equals(0, metadata.length);
 }