Add name and library to selectors.

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 444 matching lines @@
       warning(initialized[name], MessageKind.ALREADY_INITIALIZED, [name]);
     }
     initialized[name] = init;
     // Resolve initializing value.
     visitor.visitInStaticContext(init.arguments.head);
   }
 
   Element resolveSuperOrThisForSend(FunctionElement constructor,
                                     FunctionExpression functionNode,
                                     Send call) {
-    // Resolve the arguments, and make sure the call gets a selector
-    // by calling handleArguments.
+    // Resolve the selector and the arguments.
     ResolverTask resolver = visitor.compiler.resolver;
-    visitor.inStaticContext( () => visitor.handleArguments(call) );
+    visitor.inStaticContext(() {
+      visitor.resolveSelector(call);
+      visitor.visitArguments(call.argumentsNode);
+    });
     Selector selector = visitor.mapping.getSelector(call);
     bool isSuperCall = Initializers.isSuperConstructorCall(call);
     SourceString constructorName = resolver.getConstructorName(call);
     Element result = resolveSuperOrThis(
         constructor, isSuperCall, false, constructorName, selector, call);
     visitor.useElement(call, result);
     return result;
   }
 
   void resolveImplicitSuperConstructorSend(FunctionElement constructor,
                                            FunctionExpression functionNode) {
     // If the class has a super resolve the implicit super call.
     ClassElement classElement = constructor.getEnclosingClass();
     ClassElement superClass = classElement.superclass;
     if (classElement != visitor.compiler.objectClass) {
       assert(superClass !== null);
       assert(superClass.resolutionState == ClassElement.STATE_DONE);
+      SourceString name = const SourceString('');
+      Selector call = new Selector.call(name, classElement.getLibrary(), 0);
       var element = resolveSuperOrThis(constructor, true, true,
-                                       const SourceString(''),
-                                       Selector.INVOCATION_0, functionNode);
+                                       name, call, functionNode);
       visitor.world.registerStaticUse(element);
     }
   }
 
   Element resolveSuperOrThis(FunctionElement constructor,
                              bool isSuperCall,
                              bool isImplicitSuperCall,
                              SourceString constructorName,
                              Selector selector,
                              Node diagnosticNode) {
@@ skipping 608 matching lines @@
     visit(node.thenPart);
     visit(node.elsePart);
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
     return (str === '&&' || str == '||' || str == '!');
   }
 
   Element resolveSend(Send node) {
+    Selector selector = resolveSelector(node);
+
     if (node.receiver === null) {
       return node.selector.accept(this);
     }
+
     var oldCategory = allowedCategory;
     allowedCategory |=
       ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER;
     Element resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
 
     Element target;
     SourceString name = node.selector.asIdentifier().source;
     if (name.stringValue === 'this') {
       error(node.selector, MessageKind.GENERIC, ["expected an identifier"]);
     } else if (node.isSuperCall) {
       if (node.isOperator) {
         if (isUserDefinableOperator(name.stringValue)) {
-          name = Elements.constructOperatorName(const SourceString('operator'),
-                                                name);
+          name = selector.name;
         } else {
           error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, [name]);
         }
       }
       if (!inInstanceContext) {
         error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, [name]);
         return null;
       }
       if (currentClass.supertype === null) {
         // This is just to guard against internal errors, so no need
@@ skipping 26 matching lines @@
   Type resolveTypeTest(Node argument) {
     TypeAnnotation node = argument.asTypeAnnotation();
     if (node === null) {
       // node is of the form !Type.
       node = argument.asSend().receiver.asTypeAnnotation();
       if (node === null) compiler.cancel("malformed send");
     }
     return resolveTypeRequired(node);
   }
 
-  void handleArguments(Send node) {
-    int count = 0;
-    List<SourceString> namedArguments = <SourceString>[];
+  static Selector computeSendSelector(Send node, LibraryElement library) {
+    // First determine if this is part of an assignment.
+    bool isSet = node is SendSet;
+
+    if (node.isIndex) {
+      return isSet ? new Selector.indexSet() : new Selector.index();
+    }
+
+    if (node.isOperator) {
+      SourceString source = node.selector.asOperator().source;
+      switch (source.stringValue) {
+        case '!'  : case '&&' : case '||':
+        case 'is' : case 'as' :
+        case '===': case '!==':
+        case '>>>':
+          return null;
+      }
+      return node.arguments.isEmpty()
+          ? new Selector.unaryOperator(source)
+          : new Selector.binaryOperator(source);
+    }
+
+    Identifier identifier = node.selector.asIdentifier();
+    if (node.isPropertyAccess) {
+      assert(!isSet);
+      return new Selector.getter(identifier.source, library);
+    } else if (isSet) {

[Søren Gjesse, 2012/08/14 12:01:38]

Maybe get rid of the else here.

+      return new Selector.setter(identifier.source, library);
+    }
+
+    // Compute the arity and the list of named arguments.
+    int arity = 0;
+    List<SourceString> named = <SourceString>[];
+    for (Link<Node> link = node.argumentsNode.nodes;
+        !link.isEmpty();
+        link = link.tail) {
+      Expression argument = link.head;
+      if (argument.asNamedArgument() != null) {
+        named.add((argument as NamedArgument).name.source);
+      }
+      arity++;
+    }
+
+    // If we're invoking a closure, we do not have an identifier. In
+    // that case, we create a wildcard selector that can call any
+    // method that may have been closurized.
+    return (identifier == null)
+        ? new Selector.callAny(arity, named)
+        : new Selector.call(identifier.source, library, arity, named);
+  }
+
+  Selector resolveSelector(Send node) {
+    LibraryElement library = enclosingElement.getLibrary();
+    Selector selector = computeSendSelector(node, library);
+    if (selector != null) mapping.setSelector(node, selector);
+    return selector;
+  }
+
+  void visitArguments(NodeList list) {
     bool seenNamedArgument = false;
-    for (Link<Node> link = node.argumentsNode.nodes;
-         !link.isEmpty();
-         link = link.tail) {
-      count++;
+    for (Link<Node> link = list.nodes; !link.isEmpty(); link = link.tail) {
       Expression argument = link.head;
       visit(argument);
       if (argument.asNamedArgument() != null) {
         seenNamedArgument = true;
-        NamedArgument named = argument;
-        namedArguments.add(named.name.source);
       } else if (seenNamedArgument) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
-    mapping.setSelector(node, new Selector.invocation(count, namedArguments));
   }
 
   visitSend(Send node) {
     Element target = resolveSend(node);
     if (node.isOperator) {
       Operator op = node.selector.asOperator();
       if (op.source.stringValue === 'is' || op.source.stringValue === 'as') {
         resolveTypeTest(node.arguments.head);
         assert(node.arguments.tail.isEmpty());
-        mapping.setSelector(node, Selector.BINARY_OPERATOR);
       } else if (node.arguments.isEmpty()) {
         assert(op.token.kind !== PLUS_TOKEN);
-        mapping.setSelector(node, Selector.UNARY_OPERATOR);
       } else {
         visit(node.argumentsNode);
-        mapping.setSelector(node, Selector.BINARY_OPERATOR);
       }
     } else if (node.isIndex) {
       visit(node.argumentsNode);
       assert(node.arguments.tail.isEmpty());
-      mapping.setSelector(node, Selector.INDEX);
     } else if (node.isPropertyAccess) {
-      mapping.setSelector(node, Selector.GETTER);
+      // Nothing to do here.
     } else {
-      handleArguments(node);
+      visitArguments(node.argumentsNode);
     }
+
     if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.getter;
     }
     if (node.isCall &&
         (target === null ||
          target.isGetter() ||
          Elements.isClosureSend(node, target))) {
+      Selector selector = mapping.getSelector(node);
+      Selector call = new Selector.call(
+          compiler.namer.CLOSURE_INVOCATION_NAME,
+          selector.library,
+          selector.argumentCount,
+          selector.namedArguments);
       world.registerDynamicInvocation(compiler.namer.CLOSURE_INVOCATION_NAME,
-                                      mapping.getSelector(node));
+                                      call);
     }
     // TODO(ngeoffray): We should do the check in
     // visitExpressionStatement instead.
     if (target === compiler.assertMethod && !node.isCall) {
       // We can only use assert by calling it.
       if (!inInstanceContext) {
         error(node, MessageKind.MISSING_ARGUMENTS_TO_ASSERT, [node]);
       }
       target = null;
     }
@@ skipping 10 matching lines @@
     Element getter = null;
     if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       setter = field.setter;
       getter = field.getter;
     } else {
       setter = target;
       getter = target;
     }
     // TODO(ngeoffray): Check if the target can be assigned.
-    Identifier op = node.assignmentOperator;
-    bool needsGetter = op.source.stringValue !== '=';
-    Selector selector;
-    if (needsGetter) {
-      if (node.isIndex) {
-        selector = Selector.INDEX_AND_INDEX_SET;
-      } else {
-        selector = Selector.GETTER_AND_SETTER;
-      }
+    Identifier identifier = node.assignmentOperator;
+    bool compoundAssignment = identifier.source.stringValue !== '=';
+    if (compoundAssignment) {
       useElement(node.selector, getter);
-    } else if (node.isIndex) {
-      selector = Selector.INDEX_SET;
-    } else {
-      selector = Selector.SETTER;
     }
     visit(node.argumentsNode);
-    mapping.setSelector(node, selector);
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
     registerDynamicSend(node);
     return useElement(node, setter);
   }
 
   registerDynamicSend(Send node) {
     Identifier id = node.selector.asIdentifier();
     if (id === null) return;
     SourceString name = node.selector.asIdentifier().source;
-    if (node.isIndex && !node.arguments.tail.isEmpty()) {
+    if (node.isIndex && node is SendSet) {
       name = Elements.constructOperatorName(
           const SourceString('operator'),
           const SourceString('[]='));
     } else if (node.selector.asOperator() != null) {
       switch (name.stringValue) {
         case '===':
         case '!==':
         case '!':
         case '&&':
         case '||':
         case 'is':
         case 'as':
         case '>>>':
           return null;
       }
       name = Elements.constructOperatorName(
           const SourceString('operator'),
           name,
           node.argumentsNode is Prefix);
     }
     Selector selector = mapping.getSelector(node);
-    if (Selector.GETTER === selector) {
+    if (selector.isGetter()) {
       world.registerDynamicGetter(name, selector);
-    } else if (Selector.SETTER === selector) {
+    } else if (selector.isSetter()) {
       world.registerDynamicSetter(name, selector);
       // Also register the getter for compound assignments.
-      world.registerDynamicGetter(name, Selector.GETTER);
+      LibraryElement library = enclosingElement.getLibrary();
+      Selector getter = new Selector.getter(name, library);
+      world.registerDynamicGetter(name, getter);
     } else {
+      // TODO(kasperl): In case of an index-set selector, we
+      // should probably also register the corresponding
+      // index selector.
       world.registerDynamicInvocation(name, selector);
     }
     var interceptor = new Interceptors(compiler).getStaticInterceptor(
         name,
         node.argumentCount());
     if (interceptor !== null) {
       world.registerStaticUse(interceptor);
     }
   }
 
@@ skipping 48 matching lines @@
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
 
     FunctionElement constructor = resolveConstructor(node);
-    handleArguments(node.send);
+    resolveSelector(node.send);
+    visitArguments(node.send.argumentsNode);
     if (constructor === null) return null;
     // TODO(karlklose): handle optional arguments.
     if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
       // TODO(ngeoffray): resolution error with wrong number of
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
     useElement(node.send, constructor);
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
@@ skipping 68 matching lines @@
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
-    world.registerDynamicInvocation(
-        const SourceString('toString'), Selector.INVOCATION_0);
+    SourceString name = const SourceString('toString');
+    LibraryElement library = enclosingElement.getLibrary();
+    Selector selector = new Selector.call(name, library, 0);
+    world.registerDynamicInvocation(name, selector);
     node.visitChildren(this);
   }
 
   visitBreakStatement(BreakStatement node) {
     TargetElement target;
     if (node.target === null) {
       target = statementScope.currentBreakTarget();
       if (target === null) {
         error(node, MessageKind.NO_BREAK_TARGET);
         return;
@@ skipping 910 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }