Make selector registration in the resolver and code generator more explicit.

lib/compiler/implementation/universe.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.
 
 class Universe {
   Map<Element, CodeBuffer> generatedCode;
   Map<Element, CodeBuffer> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
@@ skipping 57 matching lines @@
     return hasMatchingSelector(fieldSetters[member.name], member, compiler);
   }
 }
 
 class SelectorKind {
   final String name;
   const SelectorKind(this.name);
 
   static final SelectorKind GETTER = const SelectorKind('getter');
   static final SelectorKind SETTER = const SelectorKind('setter');
-  // TODO(kasperl): Rename INVOCATION to CALL and introduce CALL_ANY.
-  static final SelectorKind INVOCATION = const SelectorKind('invocation');
+  static final SelectorKind CALL = const SelectorKind('call');
   static final SelectorKind OPERATOR = const SelectorKind('operator');
   static final SelectorKind INDEX = const SelectorKind('index');
 
   toString() => name;
 }
 
 class Selector implements Hashable {
   final SelectorKind kind;
-  final SourceString name;       // Name is null for call-any selectors.
+  final SourceString name;
   final LibraryElement library;  // Library is null for non-private selectors.

[ahe, 2012/08/15 14:32:21]

Extra space before //

[kasperl, 2012/08/16 10:35:47]

Done.

 
   // The numbers of arguments of the selector. Includes named arguments.
   final int argumentCount;
   final List<SourceString> namedArguments;
   final List<SourceString> orderedNamedArguments;
 
   Selector(
       this.kind,
       SourceString name,
       LibraryElement library,
       this.argumentCount,
       [List<SourceString> namedArguments = const <SourceString>[]])
     : this.name = name,
-      this.library = (name != null && name.isPrivate()) ? library : null,
+      this.library = name.isPrivate() ? library : null,
       this.namedArguments = namedArguments,
       this.orderedNamedArguments = namedArguments.isEmpty()
           ? namedArguments
           : <SourceString>[] {
-    // TODO(kasperl): Only allow null name for call-any selectors.
-    assert(name == null || !name.isPrivate() || library != null);
+    assert(!name.isPrivate() || library != null);
   }
 
   Selector.getter(SourceString name, LibraryElement library)
       : this(SelectorKind.GETTER, name, library, 0);
 
+  Selector.getterFrom(Selector selector)
+      : this(SelectorKind.GETTER, selector.name, selector.library, 0);
+
   Selector.setter(SourceString name, LibraryElement library)
       : this(SelectorKind.SETTER, name, library, 1);
 
   Selector.unaryOperator(SourceString name)
       : this(SelectorKind.OPERATOR, operatorName(name, true), null, 0);
 
   Selector.binaryOperator(SourceString name)
       : this(SelectorKind.OPERATOR, operatorName(name, false), null, 1);
 
   Selector.index()
       : this(SelectorKind.INDEX, indexName(), null, 1);
 
   Selector.indexSet()
       : this(SelectorKind.INDEX, indexSetName(), null, 2);
 
   Selector.call(SourceString name,
                 LibraryElement library,
                 int arity,
                 [List<SourceString> named = const []])
-      : this(SelectorKind.INVOCATION, name, library, arity, named);
+      : this(SelectorKind.CALL, name, library, arity, named);
 
-  Selector.callAny(int arity, [List<SourceString> named = const []])
-      : this(SelectorKind.INVOCATION, null, null, arity, named);
+  Selector.callClosure(int arity, [List<SourceString> named = const []])
+      : this(SelectorKind.CALL, Namer.CLOSURE_INVOCATION_NAME, null,
+             arity, named);
+
+  Selector.callClosureFrom(Selector selector)
+      : this(SelectorKind.CALL, Namer.CLOSURE_INVOCATION_NAME, null,
+             selector.argumentCount, selector.namedArguments);
 
   // TODO(kasperl): This belongs somewhere else.
   Selector.noSuchMethod()
-      : this(SelectorKind.INVOCATION, Compiler.NO_SUCH_METHOD, null, 2);
+      : this(SelectorKind.CALL, Compiler.NO_SUCH_METHOD, null, 2);
 
   bool isGetter() => kind === SelectorKind.GETTER;
   bool isSetter() => kind === SelectorKind.SETTER;
-  bool isCall() => kind === SelectorKind.INVOCATION;
+  bool isCall() => kind === SelectorKind.CALL;
 
   bool isIndex() => kind === SelectorKind.INDEX && argumentCount == 1;
   bool isIndexSet() => kind === SelectorKind.INDEX && argumentCount == 2;
 
   bool isOperator() => kind === SelectorKind.OPERATOR;
   bool isUnaryOperator() => isOperator() && argumentCount == 0;
   bool isBinaryOperator() => isOperator() && argumentCount == 1;
 
   static SourceString operatorName(SourceString name, bool isUnary)
       => Elements.constructOperatorName(
              const SourceString('operator'), name, isUnary);
 
   static SourceString indexName()
       => operatorName(const SourceString('[]'), false);
 
   static SourceString indexSetName()
       => operatorName(const SourceString('[]='), false);
 
   int hashCode() => argumentCount + 1000 * namedArguments.length;
   int get namedArgumentCount() => namedArguments.length;
   int get positionalArgumentCount() => argumentCount - namedArgumentCount;
   Type get receiverType() => null;
 
   bool applies(Element element, Compiler compiler) {
-    if (element.isSetter()) return kind === SelectorKind.SETTER;
-    if (element.isGetter()) {
-      return kind === SelectorKind.GETTER || kind === SelectorKind.INVOCATION;
-    }
-    if (element.isField()) {
-      return kind === SelectorKind.GETTER
-          || kind === SelectorKind.INVOCATION
-          || kind === SelectorKind.SETTER;
-    }
-    if (kind === SelectorKind.GETTER) return true;
+    if (element.isSetter()) return isSetter();
+    if (element.isGetter()) return isGetter() || isCall();
+    if (element.isField()) return isGetter() || isSetter() || isCall();
+    if (isGetter()) return true;
 
     FunctionElement function = element;
     FunctionSignature parameters = function.computeSignature(compiler);
     if (argumentCount > parameters.parameterCount) return false;
     int requiredParameterCount = parameters.requiredParameterCount;
     int optionalParameterCount = parameters.optionalParameterCount;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
     bool hasOptionalParameters = !parameters.optionalParameters.isEmpty();
     if (namedArguments.isEmpty()) {
@@ skipping 187 matching lines @@
 
     if (!self.isInterface() && self.isSubclassOf(other)) {
       // Resolve an invocation of [element.name] on [self]. If it
       // is found, this selector is a candidate.
       return hasElementIn(self, element) && super.applies(element, compiler);
     }
 
     return false;
   }
 
-  toString() => 'TypedSelector($kind, $receiverType, $argumentCount)';
+  toString() => 'Selector($kind, $name, $argumentCount, type=$receiverType)';
 }