Emit a compile-time error when using default values in function typed parameter.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 3455 matching lines @@
                          TreeElementMapping mapping)
       : super(compiler, typedefElement, mapping);
 
   visitTypedef(Typedef node) {
     TypedefType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     FunctionSignature signature = SignatureResolver.analyze(
         compiler, node.formals, node.returnType, element,
-        defaultValuesAllowed: false);
+        defaultValuesError: MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT);
     element.functionSignature = signature;
 
     scope = new MethodScope(scope, element);
     signature.forEachParameter((Element element) {
       defineElement(element.parseNode(compiler), element);
     });
 
     element.alias = compiler.computeFunctionType(element, signature);
 
     void checkCyclicReference() {
@@ skipping 614 matching lines @@
       }
     }
   }
 }
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends CommonResolverVisitor<Element> {
   final Element enclosingElement;
-  final bool defaultValuesAllowed;
+  final MessageKind defaultValuesError;
   Link<Element> optionalParameters = const Link<Element>();
   int optionalParameterCount = 0;
   bool isOptionalParameter = false;
   bool optionalParametersAreNamed = false;
   VariableDefinitions currentDefinitions;
 
   SignatureResolver(Compiler compiler,
                     this.enclosingElement,
-                    {this.defaultValuesAllowed: true})
+                    {this.defaultValuesError})
       : super(compiler);
 
+  bool get defaultValuesAllowed => defaultValuesError == null;
+
   Element visitNodeList(NodeList node) {
     // This must be a list of optional arguments.
     String value = node.beginToken.stringValue;
     if ((!identical(value, '[')) && (!identical(value, '{'))) {
       internalError(node, "expected optional parameters");
     }
     optionalParametersAreNamed = (identical(value, '{'));
     isOptionalParameter = true;
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
@@ skipping 108 matching lines @@
       Identifier identifier = node.selector.asIdentifier() != null ?
           node.selector.asIdentifier() :
           node.selector.asFunctionExpression().name.asIdentifier();
       validateName(identifier);
       SourceString source = identifier.source;
       element = new VariableElementX(source, variables,
           ElementKind.PARAMETER, node);
     }
     Node defaultValue = node.arguments.head;
     if (!defaultValuesAllowed) {
-      error(defaultValue, MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT);
+      error(defaultValue, defaultValuesError);
     }
     // Visit the value. The compile time constant handler will
     // make sure it's a compile time constant.
     resolveExpression(defaultValue);
     return element;
   }
 
   Element visitFunctionExpression(FunctionExpression node) {
+    // This is a function typed parameter.
     Modifiers modifiers = currentDefinitions.modifiers;
     if (modifiers.isFinal()) {
       compiler.reportError(modifiers,
           MessageKind.FINAL_FUNCTION_TYPE_PARAMETER);
     }
     if (modifiers.isVar()) {
       compiler.reportError(modifiers, MessageKind.VAR_FUNCTION_TYPE_PARAMETER);
     }
-    // This is a function typed parameter.
-    // TODO(ahe): Resolve the function type.
-    return visit(node.name);
+
+    Element variable = visit(node.name);
+    SignatureResolver.analyze(compiler, node.parameters, node.returnType,
+        variable,
+        defaultValuesError: MessageKind.FUNCTION_TYPE_FORMAL_WITH_DEFAULT);
+    // TODO(ahe): Resolve and record the function type in the correct
+    // [TreeElements].
+    return variable;
   }
 
   LinkBuilder<Element> analyzeNodes(Link<Node> link) {
     LinkBuilder<Element> elements = new LinkBuilder<Element>();
     for (; !link.isEmpty; link = link.tail) {
       Element element = link.head.accept(this);
       if (element != null) {
         elements.addLast(element);
       } else {
         // If parameter is null, the current node should be the last,
         // and a list of optional named parameters.
         if (!link.tail.isEmpty || (link.head is !NodeList)) {
           internalError(link.head, "expected optional parameters");
         }
       }
     }
     return elements;
   }
 
   /**
    * Resolves formal parameters and return type to a [FunctionSignature].
    */
   static FunctionSignature analyze(Compiler compiler,
                                    NodeList formalParameters,
                                    Node returnNode,
                                    Element element,
-                                   {bool defaultValuesAllowed: true}) {
+                                   {MessageKind defaultValuesError}) {
     SignatureResolver visitor = new SignatureResolver(compiler, element,
-            defaultValuesAllowed: defaultValuesAllowed);
+        defaultValuesError: defaultValuesError);
     Link<Element> parameters = const Link<Element>();
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter()) {
         compiler.reportError(element, MessageKind.MISSING_FORMALS);
       }
     } else {
       if (element.isGetter()) {
         if (!identical(formalParameters.getEndToken().next.stringValue,
                        // TODO(ahe): Remove the check for native keyword.
@@ skipping 217 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, SourceString name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }