Remove the need for functionSignature.

sdk/lib/_internal/compiler/implementation/dart_backend/backend_ast_emitter.dart

 // Copyright (c) 2014, 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 backend_ast_emitter;
 
 import 'tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 136 matching lines @@
   void removeTrailingReturn() {
     if (statementBuffer.isEmpty) return;
     if (statementBuffer.last is! Return) return;
     Return ret = statementBuffer.last;
     Expression expr = ret.expression;
     if (expr is Literal && expr.value.isNull) {
       statementBuffer.removeLast();
     }
   }
 
-  Parameter emitParameterFromElement(FormalElement element, [String name]) {
-    if (name == null) {
+  /// TODO(johnniwinther): Remove this when issue 21283 has been resolved.
+  int pseudoNameCounter = 0;
+
+  Parameter emitParameter(DartType type,
+                          {String name,
+                           Element element,
+                           ConstantExpression defaultValue}) {
+    if (name == null && element != null) {
       name = element.name;
     }
-    if (element.functionSignature != null) {
-      FunctionSignature signature = element.functionSignature;
-      TypeAnnotation returnType = emitOptionalType(signature.type.returnType);
-      Parameters innerParameters = emitParameters(signature);
-      return new Parameter.function(name, returnType, innerParameters)
-                 ..element = element;
+    if (name == null) {
+      name = '_${pseudoNameCounter++}';
+    }
+    Parameter parameter;
+    if (type.isFunctionType) {
+      FunctionType functionType = type;
+      TypeAnnotation returnType = emitOptionalType(functionType.returnType);
+      Parameters innerParameters = emitParametersFromType(functionType);
+      parameter = new Parameter.function(name, returnType, innerParameters);
     } else {
-      TypeAnnotation type = emitOptionalType(element.type);
-      return new Parameter(name, type:type)
-                 ..element = element;
+      TypeAnnotation typeAnnotation = emitOptionalType(type);
+      parameter = new Parameter(name, type: typeAnnotation);
+    }
+    parameter.element = element;
+    if (defaultValue != null && !defaultValue.value.isNull) {
+      parameter.defaultValue = emitConstant(defaultValue);
+    }
+    return parameter;
+  }
+
+  Parameters emitParametersFromType(FunctionType functionType) {
+    if (functionType.namedParameters.isEmpty) {
+      return new Parameters(
+          emitParameters(functionType.parameterTypes),
+          emitParameters(functionType.optionalParameterTypes),
+          false);
+    } else {
+      return new Parameters(
+          emitParameters(functionType.parameterTypes),
+          emitParameters(functionType.namedParameterTypes,
+                         names: functionType.namedParameters),
+          true);
     }
   }
 
-  Parameters emitParameters(FunctionSignature signature) {
-    return new Parameters(
-        signature.requiredParameters.mapToList(emitParameterFromElement),
-        signature.optionalParameters.mapToList(emitParameterFromElement),
-        signature.optionalParametersAreNamed);
+  List<Parameter> emitParameters(
+      Iterable<DartType> parameterTypes,
+      {Iterable<String> names: const <String>[],
+       Iterable<ConstantExpression> defaultValues: const <ConstantExpression>[],
+       Iterable<Element> elements: const <Element>[]}) {
+    Iterator<String> name = names.iterator;
+    Iterator<ConstantExpression> defaultValue = defaultValues.iterator;
+    Iterator<Element> element = elements.iterator;
+    return parameterTypes.map((DartType type) {
+      return emitParameter(type,
+          name: name.moveNext() ? name.current : null,

[floitsch, 2014/10/10 12:56:04]

Minor nit. (not much better. just wanted to point it out).
could be simplified to:
name.moveNext();
defaultValue.moveNext();
element.moveNext();
return emitParameter(type, name.current, defaultValue.current, element.current);

The contract is that 'current' returns null when moveNext returned false.

[Johnni Winther, 2014/10/13 08:10:53]

Done. I thought [current] would throw!

+          defaultValue: defaultValue.moveNext() ? defaultValue.current : null,
+          element: element.moveNext() ? element.current : null);
+    }).toList();
   }
 
   /// Emits parameters that are not nested inside other parameters.
   /// Root parameters can have default values, while inner parameters cannot.
   Parameters emitRootParameters(tree.FunctionDefinition function) {
-    FunctionSignature signature = function.element.functionSignature;
-    List<ConstantExpression> defaults = function.defaultParameterValues;
-    List<Parameter> required =
-        signature.requiredParameters.mapToList(emitParameterFromElement);
-    List<Parameter> optional = new List<Parameter>(defaults.length);
-    for (int i = 0; i < defaults.length; i++) {
-      ParameterElement element = signature.orderedOptionalParameters[i];
-      optional[i] = emitParameterFromElement(element);
-      Expression constant = emitConstant(defaults[i]);
-      if (!isNullLiteral(constant)) {
-        optional[i].defaultValue = constant;
-      }
+    ParameterElement elementFromParameter(tree.Variable parameter) {

[floitsch, 2014/10/10 12:56:04]

I prefer to inline it.
If it doesn't fit, I'm ok with taking a shorter name:
((p) => p.element)

Unless you want the type check.

And I would like to suggest an improvement to the spec:
(x) => x.foo should have as shortcut: *.foo
--
parameters.map(*.element)

[Johnni Winther, 2014/10/13 08:10:53]

Done.

+      return parameter.element;
     }
-    return new Parameters(required, optional,
-        signature.optionalParametersAreNamed);
+
+    FunctionType functionType = function.element.type;
+    List<Parameter> required = emitParameters(
+        functionType.parameterTypes,
+        elements: function.parameters.map(elementFromParameter));
+    bool optionalParametersAreNamed = !functionType.namedParameters.isEmpty;
+    List<Parameter> optional = emitParameters(
+        optionalParametersAreNamed
+            ? functionType.namedParameterTypes
+            : functionType.optionalParameterTypes,
+        defaultValues: function.defaultParameterValues,
+        elements: function.parameters.skip(required.length)
+            .map(elementFromParameter));
+    return new Parameters(required, optional, optionalParametersAreNamed);
   }
 
   /// True if the two expressions are a reference to the same variable.
   bool isSameVariable(Receiver e1, Receiver e2) {
     return e1 is Identifier &&
            e2 is Identifier &&
            e1.element is VariableElement &&
            e1.element == e2.element;
   }
 
@@ skipping 643 matching lines @@
     }
   }
 
   visitVariable(tree.Variable variable) {
     if (shadowedParameters.contains(variable)) {
       hasShadowedUse.add(variable);
     }
   }
 
 }