Remove support for conflicting constructors.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 166 matching lines @@
         element.computeType(compiler);
         return null;
       }
 
       compiler.unimplemented("resolve($element)",
                              node: element.parseNode(compiler));
     });
   }
 
   String constructorNameForDiagnostics(SourceString className,
-                                   SourceString constructorName) {
+                                       SourceString constructorName) {
     String classNameString = className.slowToString();
     String constructorNameString = constructorName.slowToString();
     return (constructorName == const SourceString(''))
         ? classNameString
         : "$classNameString.$constructorNameString";
    }
 
   void resolveRedirectingConstructor(InitializerResolver resolver,
                                      Node node,
                                      FunctionElement constructor,
@@ skipping 467 matching lines @@
               member.modifiers.flags &
               (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
           if (mismatchedFlagsBits != 0) {
             final mismatchedFlags =
                 new Modifiers.withFlags(null, mismatchedFlagsBits);
             compiler.reportErrorCode(
                 member,
                 MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS,
                 {'modifiers': mismatchedFlags});
           }
-          checkConstructorNameHack(holder, member);
         }
         checkAbstractField(member);
         checkValidOverride(member, cls.lookupSuperMember(member.name));
         checkUserDefinableOperator(member);
       });
     });
   }
 
-  // TODO(ahe): Remove this method.  It is only needed while we store
-  // constructor names as ClassName$id.  Once we start storing
-  // constructors as just id, this will be caught by the general
-  // mechanism for duplicate members.
-  /// Check that a constructor name does not conflict with a member.
-  void checkConstructorNameHack(ClassElement holder, FunctionElement member) {
-    // If the name of the constructor is the same as the name of the
-    // class, there cannot be a problem.
-    if (member.name == holder.name) return;
-
-    SourceString name =
-      Elements.deconstructConstructorName(member.name, holder);
-
-    // If the name could not be deconstructed, this is is from a
-    // factory method from a deprecated interface implementation.
-    if (name == null) return;
-
-    Element otherMember = holder.lookupLocalMember(name);
-    if (otherMember != null) {
-      if (compiler.onDeprecatedFeature(member, 'conflicting constructor')) {
-        compiler.reportMessage(
-            compiler.spanFromElement(otherMember),
-            // Using GENERIC as this message is temporary.
-            MessageKind.GENERIC.error({'text': 'This member conflicts with a'
-                                               ' constructor.'}),
-            Diagnostic.INFO);
-      }
-    }
-  }
-
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
     // field once, so we just ignore setters.
     if (!member.isGetter()) return;
 
     // Find the associated abstract field.
     ClassElement classElement = member.getEnclosingClass();
     Element lookupElement = classElement.lookupLocalMember(member.name);
     if (lookupElement == null) {
@@ skipping 2612 matching lines @@
         compiler.getNextFreeClassId(),
         element.parseNode(compiler),
         Modifiers.EMPTY);  // TODO(kasperl): Should this be abstract?
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     return mixinApplication.computeType(compiler);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
-    return constructor.name == constructor.getEnclosingClass().name &&
+    return constructor.name == const SourceString('') &&
         constructor.computeSignature(compiler).parameterCount == 0;
   }
 
   FunctionElement createForwardingConstructor(FunctionElement constructor,
                                               ClassElement target) {
-    ClassElement cls = constructor.getEnclosingClass();
-    SourceString constructorName;
-    if (constructor.name == cls.name) {
-      constructorName = target.name;
-    } else {
-      SourceString selector =
-          Elements.deconstructConstructorName(constructor.name, cls);
-      constructorName =
-          Elements.constructConstructorName(target.name, selector);
-    }
-    return new SynthesizedConstructorElementX.forwarding(constructorName,
+    return new SynthesizedConstructorElementX.forwarding(constructor.name,
                                                          constructor,
                                                          target);
   }
 
   void doApplyMixinTo(MixinApplicationElement mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
     Node node = mixinApplication.parseNode(compiler);
 
     if (mixinApplication.supertype != null) {
@@ skipping 688 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }