Generate tear-off closures dynamically.

dart/sdk/lib/_internal/compiler/implementation/universe/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.
 
 library universe;
 
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../types/types.dart';
@@ skipping 174 matching lines @@
         : <String>[];
     Selector result = new Selector.internal(
         kind, name, library, argumentCount,
         namedArguments, orderedNamedArguments,
         hashCode);
     list.add(result);
     return result;
   }
 
   factory Selector.fromElement(Element element, Compiler compiler) {
+    // TODO(ahe): This method doesn't work as one might expect if there are
+    // optional arguments.
     String name = element.name;
     if (element.isFunction()) {
-      int arity = element.asFunctionElement().requiredParameterCount(compiler);
       if (name == '[]') {
         return new Selector.index();
       } else if (name == '[]=') {
         return new Selector.indexSet();
-      } else if (Elements.operatorNameToIdentifier(name) != name) {
-        return new Selector(SelectorKind.OPERATOR, name, null, arity);
+      }
+      FunctionSignature signature =
+          element.asFunctionElement().computeSignature(compiler);
+      int arity = signature.parameterCount;
+      List<String> namedArguments = null;
+      if (signature.optionalParametersAreNamed) {
+        namedArguments =
+            signature.orderedOptionalParameters.map((e) => e.name).toList();
+      }
+      if (Elements.operatorNameToIdentifier(name) != name) {
+        // Operators cannot have named arguments, however, that doesn't prevent
+        // a user from declaring such an operator.
+        return new Selector(
+            SelectorKind.OPERATOR, name, null, arity, namedArguments);
       } else {
-        return new Selector.call(name, element.getLibrary(), arity);
+        return new Selector.call(
+            name, element.getLibrary(), arity, namedArguments);
       }
     } else if (element.isSetter()) {
       return new Selector.setter(name, element.getLibrary());
     } else if (element.isGetter()) {
       return new Selector.getter(name, element.getLibrary());
     } else if (element.isField()) {
       return new Selector.getter(name, element.getLibrary());
+    } else {
+      throw new SpannableAssertionFailure(
+          element, "Can't get selector from $element");
     }
   }
 
   factory Selector.getter(String name, LibraryElement library)
       => new Selector(SelectorKind.GETTER, name, library, 0);
 
   factory Selector.getterFrom(Selector selector)
       => new Selector(SelectorKind.GETTER, selector.name, selector.library, 0);
 
   factory Selector.setter(String name, LibraryElement library)
@@ skipping 369 matching lines @@
     String type = '';
     if (namedArgumentCount > 0) named = ', named=${namedArgumentsToString()}';
     if (mask != null) type = ', mask=$mask';
     return 'Selector($kind, $name, '
            'arity=$argumentCount$named$type)';
   }
 
   Selector extendIfReachesAll(Compiler compiler) {
     return new TypedSelector(compiler.typesTask.dynamicType, this);
   }
+
+  Selector toCallSelector() => new Selector.callClosureFrom(this);
 }
 
 class TypedSelector extends Selector {
   final Selector asUntyped;
   final TypeMask mask;
 
   TypedSelector.internal(this.mask, Selector selector, int hashCode)
       : asUntyped = selector,
         super.internal(selector.kind,
                        selector.name,
@@ skipping 51 matching lines @@
   }
 
   Selector extendIfReachesAll(Compiler compiler) {
     bool canReachAll = compiler.enabledInvokeOn
         && mask.needsNoSuchMethodHandling(this, compiler);
     return canReachAll
         ? new TypedSelector(compiler.typesTask.dynamicType, this)
         : this;
   }
 }