Improve renaming of constructors and factories.

lib/compiler/implementation/dart_backend/renamer.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.
 
 /**
  * Renames only top-level elements that would let to ambiguity if not renamed.
  * TODO(smok): Make sure that top-level fields are correctly renamed.
  */
 class ConflictingRenamer extends Renamer {
   final Compiler compiler;
@@ skipping 60 matching lines @@
           .resolveTypeAnnotation(typeAnnotation, null, context);
     } else {
       type = compiler.resolveTypeAnnotation(context, typeAnnotation);
     }
     return renameType(type);
   }
 
   String renameType(Type type) => renameElement(type.element);
 
   String renameIdentifier(Identifier node) {
-    if (context.isGenerativeConstructor()) {
-      // This is either a named constructor or simple one.
-      // TODO(smok): Check if resolver can help us identifying named
-      // constructors.
-      var enclosingClass = context.getEnclosingClass();
-      if (node.token.slowToString() == context.name.slowToString()
-          || enclosingClass.name.slowToString() == node.token.slowToString()) {
+    if (context.isGenerativeConstructor() || context.isFactoryConstructor()) {
+      // Two complicated cases for class/interface renaming:
+      // 1) class which implements constructors of other interfaces, but not
+      //    implements interfaces themselves:
+      //      0.dart: class C { I(); }
+      //      1.dart and 2.dart: interface I default C { I(); }
+      //    now we have to duplicate our I() constructor in C class with
+      //    proper names.
+      // 2) (even worse for us):
+      //      0.dart: class C { C(); }
+      //      1.dart: interface C default p0.C { C(); }
+      //    the second case is just a bug now.
+      final enclosingClass = context.getEnclosingClass();
+      if (node.token.slowToString() == enclosingClass.name.slowToString()) {
+        // TODO: distinguish the case of constructor vs. nested named closure
+        // (see function_syntax_test).
+        // TODO: fix the bugs above and turn if into the assert.
         return renameElement(enclosingClass);
       }
     }
     if (context.isFunction() && context.cachedNode.name == node) {

[Roman, 2012/08/02 05:44:53]

Can now (context.isFunction()) be false?

[Anton Muhin, 2012/08/03 13:57:57]

Good point, but yes, getters/setters, and they should be addressed later on.

On 2012/08/02 05:44:53, Roman wrote:

       return renameElement(context);
     }
     return null;
   }
 
   String renameElement(Element element) {
     // TODO(smok): Make sure that the new name does not conflict with existing
     // local identifiers.
     if (renamed[element] !== null) return renamed[element];
 
@@ skipping 11 matching lines @@
     final library = element.getLibrary();
     if (library === compiler.coreLibrary) return originalName;
     if (isDartCoreLib(compiler, library)) {
       final prefix =
           imports.putIfAbsent(library, () => generateUniqueName('p'));
       return '$prefix.$originalName';
     }
     return renamed[element] = generateUniqueName(originalName);
   }
 }