Reject constructor names that conflict with members.

dart/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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 474 matching lines @@
           member.modifiers.flags &
           (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
         if (mismatchedFlagsBits != 0) {
           final mismatchedFlags =
             new Modifiers.withFlags(null, mismatchedFlagsBits);
           compiler.reportMessage(
             compiler.spanFromElement(member),
             MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS.error([mismatchedFlags]),
             Diagnostic.ERROR);
         }
+        checkConstructorNameHack(holder, member);
       }
       checkAbstractField(member);
       checkValidOverride(member, cls.lookupSuperMember(member.name));
     });
   }
 
+  // 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.

[ngeoffray, 2012/12/08 13:53:32]

What makes it difficult to implement this today?

+  /// Check that a constructor name does not conflict with a member.
+  void checkConstructorNameHack(ClassElement holder, FunctionElement member) {

[ngeoffray, 2012/12/08 13:53:32]

assert that member.getEnclosingClass() == holder?

+    // 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

[ngeoffray, 2012/12/08 13:53:32]

is is from a ... -> is a ...

+    // factory method from a deprecated interface implementation.
+    if (name == null) return;
+
+    Element otherMember = holder.lookupLocalMember(name);
+    if (otherMember != null) {
+      compiler.onDeprecatedFeature(member, 'conflicting constructor');

[ngeoffray, 2012/12/08 13:53:32]

Something looks strange. Why are you implementing this check if it's deprecated?

+      compiler.reportMessage(
+          compiler.spanFromElement(otherMember),
+          MessageKind.GENERIC.error(['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 2721 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }