[dart2dart] fix after https://codereview.chromium.org/11227007

lib/compiler/implementation/dart_backend/placeholder_collector.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 dart_backend;
 
 class LocalPlaceholder {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int get hashCode => identifier.hashCode;
   String toString() =>
       'local_placeholder[id($identifier), nodes($nodes)]';
 }
 
 class FunctionScope {
   final Set<String> parameterIdentifiers;
   final Set<LocalPlaceholder> localPlaceholders;
   FunctionScope()
       : parameterIdentifiers = new Set<String>(),
       localPlaceholders = new Set<LocalPlaceholder>();
   void registerParameter(Identifier node) {
     parameterIdentifiers.add(node.source.slowToString());
   }
 }
 
+class ConstructorPlaceholder {
+  final Node node;
+  final DartType type;
+  ConstructorPlaceholder(this.node, this.type);
+}
+
 class DeclarationTypePlaceholder {
   final TypeAnnotation typeNode;
   final bool requiresVar;
   DeclarationTypePlaceholder(this.typeNode, this.requiresVar);
 }
 
 class SendVisitor extends ResolvedVisitor {
   final PlaceholderCollector collector;
 
   get compiler => collector.compiler;
@@ skipping 48 matching lines @@
       }
     }
   }
 
   visitStaticSend(Send node) {
     final element = elements[node];
     if (Elements.isUnresolved(element)
         || identical(element, compiler.assertMethod)) {
       return;
     }
+    // TODO(smok): We should never go inside this IF, check?
     if (element.isConstructor() || element.isFactoryConstructor()) {
       // Rename named constructor in redirection position:
       // class C { C.named(); C.redirecting() : this.named(); }
+      // TODO(smok): Fix redirecting constructors.
       if (node.receiver is Identifier
           && node.receiver.asIdentifier().isThis()) {
         assert(node.selector is Identifier);
         collector.tryMakeMemberPlaceholder(node.selector);
       }
-      // Field names can be exposed as names of optional arguments, e.g.
-      // class C {
-      //   final field;
-      //   C([this.field]);
-      // }
-      // Do not forget to rename them as well.
-      FunctionElement functionElement = element;
-      Link<Element> optionalParameters =
-          functionElement.functionSignature.optionalParameters;
-      for (final argument in node.argumentsNode) {
-        NamedArgument named = argument.asNamedArgument();
-        if (named == null) continue;
-        Identifier name = named.name;
-        String nameAsString = name.source.slowToString();
-        for (final parameter in optionalParameters) {
-          if (identical(parameter.kind, ElementKind.FIELD_PARAMETER)) {
-            if (parameter.name.slowToString() == nameAsString) {
-              collector.tryMakeMemberPlaceholder(name);
-              break;
-            }
-          }
-        }
-      }
       return;
     }
     collector.makeElementPlaceholder(node.selector, element);
     // Another ugly case: <lib prefix>.<top level> is represented as
     // receiver: lib prefix, selector: top level.
     if (element.isTopLevel() && node.receiver != null) {
       assert(elements[node.receiver].isPrefix());
       // Hack: putting null into map overrides receiver of original node.
       collector.makeNullPlaceholder(node.receiver);
     }
   }
 
   internalError(String reason, {Node node}) {
     collector.internalError(reason, node);
   }
 }
 
 class PlaceholderCollector extends Visitor {
   final Compiler compiler;
   final Set<String> fixedMemberNames; // member names which cannot be renamed.
   final Map<Element, ElementAst> elementAsts;
   final Set<Node> nullNodes;  // Nodes that should not be in output.
   final Set<Identifier> unresolvedNodes;
-  final Map<Element, Set<Identifier>> elementNodes;
+  final Map<Element, Set<Node>> elementNodes;
   final Map<FunctionElement, FunctionScope> functionScopes;
   final Map<LibraryElement, Set<Identifier>> privateNodes;
   final List<DeclarationTypePlaceholder> declarationTypePlaceholders;
   final Map<String, Set<Identifier>> memberPlaceholders;
+  final Map<Element, List<ConstructorPlaceholder>> constructorPlaceholders;
   Map<String, LocalPlaceholder> currentLocalPlaceholders;
   Element currentElement;
   FunctionElement topmostEnclosingFunction;
   TreeElements treeElements;
 
   LibraryElement get coreLibrary => compiler.coreLibrary;
   FunctionElement get entryFunction => compiler.mainApp.find(Compiler.MAIN);
 
   get currentFunctionScope => functionScopes.putIfAbsent(
       topmostEnclosingFunction, () => new FunctionScope());
 
   PlaceholderCollector(this.compiler, this.fixedMemberNames, this.elementAsts) :
       nullNodes = new Set<Node>(),
       unresolvedNodes = new Set<Identifier>(),
-      elementNodes = new Map<Element, Set<Identifier>>(),
+      elementNodes = new Map<Element, Set<Node>>(),
       functionScopes = new Map<FunctionElement, FunctionScope>(),
       privateNodes = new Map<LibraryElement, Set<Identifier>>(),
       declarationTypePlaceholders = new List<DeclarationTypePlaceholder>(),
-      memberPlaceholders = new Map<String, Set<Identifier>>();
+      memberPlaceholders = new Map<String, Set<Identifier>>(),
+      constructorPlaceholders =
+          new Map<Element, List<ConstructorPlaceholder>>();
 
-  void tryMakeConstructorNamePlaceholder(
-      FunctionExpression constructor, ClassElement element) {
-    Node nameNode = constructor.name;
-    if (nameNode is Send) nameNode = nameNode.receiver;
-    if (nameNode.asIdentifier().token.slowToString()
-        == element.name.slowToString()) {
-      makeElementPlaceholder(nameNode, element);
-    }
+  void tryMakeConstructorPlaceholder(
+      FunctionExpression constructor, FunctionElement constructorElement) {
+    DartType type = constructorElement.getEnclosingClass().type.asRaw();
+    makeConstructorPlaceholder(constructor.name, constructorElement, type);
   }
 
   void collectFunctionDeclarationPlaceholders(
       FunctionElement element, FunctionExpression node) {
     if (element.isGenerativeConstructor() || element.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.
-      tryMakeConstructorNamePlaceholder(node, element.getEnclosingClass());
-
-      // If we have interface constructor, make sure that we put placeholder
-      // for its default factory implementation.
-      // Example:
-      // interface I default C { I();}
-      // class C { factory I() {} }
-      // 2 cases:
-      // Plain interface name. Rename it unless it is the default
-      // constructor for enclosing class.
-      // Example:
-      // interface I { I(); }
-      // class C implements I { C(); }  don't rename this case.
-      // OR I.named() inside C, rename first part.
-      if (element.defaultImplementation != null
-          && !identical(element.defaultImplementation, element)) {
-        FunctionElement implementingFactory = element.defaultImplementation;
-        if (implementingFactory is !SynthesizedConstructorElement) {
-          tryMakeConstructorNamePlaceholder(
-              elementAsts[implementingFactory].ast,
-              element.getEnclosingClass());
-        }
-      }
+      tryMakeConstructorPlaceholder(node, element);
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Note: this code should only rename private identifiers for class'
       // fields/getters/setters/methods.  Top-level identifiers are renamed
       // just to escape conflicts and that should be enough as we shouldn't
       // be able to resolve private identifiers for other libraries.
       makeElementPlaceholder(node.name, element);
     } else if (element.isMember()) {
       if (node.name is Identifier) {
         tryMakeMemberPlaceholder(node.name);
       } else {
@@ skipping 93 matching lines @@
     bool requiresVar = !node.modifiers.isFinalOrConst();
     declarationTypePlaceholders.add(
         new DeclarationTypePlaceholder(node.type, requiresVar));
   }
 
   void makeNullPlaceholder(Node node) {
     assert(node is Identifier || node is Send);
     nullNodes.add(node);
   }
 
-  void makeElementPlaceholder(Identifier node, Element element) {
+  void makeElementPlaceholder(Node node, Element element) {
     assert(element != null);
     if (identical(element, entryFunction)) return;
     if (identical(element.getLibrary(), coreLibrary)) return;
     if (element.getLibrary().isPlatformLibrary && !element.isTopLevel()) {
       return;
     }
     if (element == compiler.types.dynamicType.element) {
       internalError(
           'Should never make element placeholder for dynamic type element',
           node: node);
     }
-    elementNodes.putIfAbsent(element, () => new Set<Identifier>()).add(node);
+    elementNodes.putIfAbsent(element, () => new Set<Node>()).add(node);
   }
 
   void makePrivateIdentifier(Identifier node) {
     assert(node != null);
     privateNodes.putIfAbsent(
         currentElement.getLibrary(), () => new Set<Identifier>()).add(node);
   }
 
   void makeUnresolvedPlaceholder(Node node) {
     unresolvedNodes.add(node);
   }
 
   void makeLocalPlaceholder(Identifier identifier) {
     LocalPlaceholder getLocalPlaceholder() {
       String name = identifier.source.slowToString();
       return currentLocalPlaceholders.putIfAbsent(name, () {
         LocalPlaceholder localPlaceholder = new LocalPlaceholder(name);
         currentFunctionScope.localPlaceholders.add(localPlaceholder);
         return localPlaceholder;
       });
     }
 
     getLocalPlaceholder().nodes.add(identifier);
   }
 
+  void makeConstructorPlaceholder(Node node, Element element, DartType type) {
+    constructorPlaceholders
+        .putIfAbsent(element, () => <ConstructorPlaceholder>[])
+            .add(new ConstructorPlaceholder(node, type));
+  }
+
   void internalError(String reason, {Node node}) {
     compiler.cancel(reason, node: node);
   }
 
   void unreachable() { internalError('Unreachable case'); }
 
   visit(Node node) => (node == null) ? null : node.accept(this);
 
   visitNode(Node node) { node.visitChildren(this); }  // We must go deeper.
 
+  visitNewExpression(NewExpression node) {
+    Send send = node.send;
+    InterfaceType type = treeElements.getType(node);
+    assert(type !== null);

[Anton Muhin, 2012/10/29 18:19:22]

nit: != here and everywhere

[Roman, 2012/10/29 18:40:28]

Done.

+    Element constructor = treeElements[send];
+    assert(constructor !== null);
+    assert(send.receiver == null);
+    if (constructor is !ErroneousElement) {
+      makeConstructorPlaceholder(node.send.selector, constructor, type);
+      // TODO(smok): Should this be in visitNamedArgument?
+      // Field names can be exposed as names of optional arguments, e.g.
+      // class C {
+      //   final field;
+      //   C([this.field]);
+      // }
+      // Do not forget to rename them as well.
+      Link<Element> optionalParameters =
+          constructor.functionSignature.optionalParameters;
+      print(send.argumentsNode);
+      for (final argument in send.argumentsNode) {
+        NamedArgument named = argument.asNamedArgument();
+        if (named == null) continue;
+        Identifier name = named.name;
+        String nameAsString = name.source.slowToString();
+        for (final parameter in optionalParameters) {
+          if (identical(parameter.kind, ElementKind.FIELD_PARAMETER)) {
+            if (parameter.name.slowToString() == nameAsString) {
+              tryMakeMemberPlaceholder(name);
+              break;
+            }
+          }
+        }
+      }
+    } else {
+      makeUnresolvedPlaceholder(node.send.selector);
+    }
+    visit(node.send.argumentsNode);
+  }
+
   visitSend(Send send) {
     new SendVisitor(this, treeElements).visitSend(send);
     send.visitChildren(this);
   }
 
   visitSendSet(SendSet send) {
     Element element = treeElements[send];
     if (Elements.isErroneousElement(element)) {
       // Complicated case: constructs like receiver.selector++ can resolve
       // to ErroneousElement.  Fortunately, receiver.selector still
@@ skipping 49 matching lines @@
     } else {
       typeDeclarationElement = currentElement.getEnclosingClass();
     }
     if (typeDeclarationElement != null && isPlainTypeName(node)
         && tryResolveAndCollectTypeVariable(
                typeDeclarationElement, node.typeName)) {
       return;
     }
     // We call [resolveReturnType] to allow having 'void'.
     final type = compiler.resolveReturnType(currentElement, node);
-    bool hasPrefix = false;
     if (type is InterfaceType || type is TypedefType) {
-      Node target = node.typeName;
-      if (node.typeName is Send) {
-        final send = node.typeName.asSend();
-        Identifier receiver = send.receiver;
-        Identifier selector = send.selector;
-        Element potentialPrefix =
-            currentElement.getLibrary().findLocal(receiver.source);
-        if (potentialPrefix != null && potentialPrefix.isPrefix()) {
-          // prefix.Class case.
-          hasPrefix = true;
-        } else {
-          // Class.namedContructor case.
-          target = receiver;
-          // If element is unresolved, mark namedConstructor as unresolved.
-          if (treeElements[node] == null) {
-            makeUnresolvedPlaceholder(selector);
-          }
-        }
-      }
       // TODO(antonm): is there a better way to detect unresolved types?
       // Corner case: dart:core type with a prefix.
       // Most probably there are some additional problems with
       // coreLibPrefix.topLevels.
-      Element typeElement = type.element;
-      Element dynamicTypeElement = compiler.types.dynamicType.element;
-      if (hasPrefix &&
-          (identical(typeElement.getLibrary(), coreLibrary) ||
-          identical(typeElement, dynamicTypeElement))) {
-        makeNullPlaceholder(node.typeName.asSend().receiver);
+      if (!identical(type.element, compiler.types.dynamicType.element)) {
+        makeTypePlaceholder(node.typeName, type);
       } else {
-        if (hasPrefix) {
-          assert(node.typeName is Send);
-          Send typeName = node.typeName;
-          assert(typeName.receiver is Identifier);
-          assert(typeName.selector is Identifier);
-          makeNullPlaceholder(typeName.receiver);
-        }
-        if (!identical(typeElement, dynamicTypeElement)) {
-          makeTypePlaceholder(target, type);
-        } else {
-          if (!isDynamicType(node)) makeUnresolvedPlaceholder(target);
-        }
+        if (!isDynamicType(node)) makeUnresolvedPlaceholder(node.typeName);
       }
     }
-    // Trying to differentiate new A.foo() and lib.A cases. In the latter case
-    // we don't want to go deeper into typeName.
-    if (hasPrefix) {
-      // Visit only type arguments, otherwise in case of lib.Class type
-      // annotation typeName is Send and we go to visitGetterSend, as a result
-      // "Class" is added to member placeholders.
-      visit(node.typeArguments);
-    } else {
-      node.visitChildren(this);
-    }
+    // Visit only type arguments, otherwise in case of lib.Class type
+    // annotation typeName is Send and we go to visitGetterSend, as a result
+    // "Class" is added to member placeholders.
+    visit(node.typeArguments);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     // Collect only local placeholders.
     for (Node definition in node.definitions.nodes) {
       Element definitionElement = treeElements[definition];
       // definitionElement may be null if we're inside variable definitions
       // of a function that is a parameter of another function.
       // TODO(smok): Fix this when resolver correctly deals with
       // such cases.
@@ skipping 121 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }