Remove the need for functionSignature.

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

Index: sdk/lib/_internal/compiler/implementation/dart_backend/backend_ast_emitter.dart
diff --git a/sdk/lib/_internal/compiler/implementation/dart_backend/backend_ast_emitter.dart b/sdk/lib/_internal/compiler/implementation/dart_backend/backend_ast_emitter.dart
index f7f954f8595bfceb571f1491dfd9ca9d2eb910e9..186cda741512c0ca1cdd2a9e18f8578fb412e9fc 100644
--- a/sdk/lib/_internal/compiler/implementation/dart_backend/backend_ast_emitter.dart
+++ b/sdk/lib/_internal/compiler/implementation/dart_backend/backend_ast_emitter.dart
@@ -154,48 +154,87 @@ class ASTEmitter extends tree.Visitor<dynamic, Expression> {
     }
   }
 
-  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 emitParameters(FunctionSignature signature) {
-    return new Parameters(
-        signature.requiredParameters.mapToList(emitParameterFromElement),
-        signature.optionalParameters.mapToList(emitParameterFromElement),
-        signature.optionalParametersAreNamed);
+  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);
+    }
+  }
+
+  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;
-      }
-    }
-    return new Parameters(required, optional,
-        signature.optionalParametersAreNamed);
+    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;
+    }
+
+    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.