Emit error on default values in typedefs.

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 3263 matching lines @@
                          TypedefElement typedefElement,
                          TreeElementMapping mapping)
       : super(compiler, typedefElement, mapping);
 
   visitTypedef(Typedef node) {
     TypedefType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     element.functionSignature = SignatureResolver.analyze(
-        compiler, node.formals, node.returnType, element);
+        compiler, node.formals, node.returnType, element,
+        defaultValuesAllowed: false);
 
     element.alias = compiler.computeFunctionType(
         element, element.functionSignature);
 
     // TODO(johnniwinther): Check for cyclic references in the typedef alias.
   }
 }
 
 /**
  * The implementation of [ResolverTask.resolveClass].
@@ skipping 477 matching lines @@
       resolver.defineElement(link.head, element);
     }
   }
 }
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends CommonResolverVisitor<Element> {
   final Element enclosingElement;
+  final bool defaultValuesAllowed;
   Link<Element> optionalParameters = const Link<Element>();
   int optionalParameterCount = 0;
   bool optionalParametersAreNamed = false;
   VariableDefinitions currentDefinitions;
 
-  SignatureResolver(Compiler compiler, this.enclosingElement) : super(compiler);
+  SignatureResolver(Compiler compiler,
+                    this.enclosingElement,
+                    {this.defaultValuesAllowed: true})
+      : super(compiler);
 
   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, '{'));
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
@@ skipping 71 matching lines @@
       } else if (!fieldElement.isInstanceMember()) {
         error(node, MessageKind.NOT_INSTANCE_FIELD, {'fieldName': name});
       }
       Element variables = new VariableListElementX.node(currentDefinitions,
           ElementKind.VARIABLE_LIST, enclosingElement);
       element = new FieldParameterElementX(name, fieldElement, variables, node);
     }
     return element;
   }
 
+  /// A [SendSet] node is an optional parameter with a default value.
   Element visitSendSet(SendSet node) {
     Element element;
     if (node.receiver != null) {
       element = visitSend(node);
     } else if (node.selector.asIdentifier() != null ||
                node.selector.asFunctionExpression() != null) {
       Element variables = new VariableListElementX.node(currentDefinitions,
           ElementKind.VARIABLE_LIST, enclosingElement);
       SourceString source = node.selector.asIdentifier() != null ?
           node.selector.asIdentifier().source :
           node.selector.asFunctionExpression().name.asIdentifier().source;
       element = new VariableElementX(source, variables,
           ElementKind.PARAMETER, node);
     }
+    Node defaultValue = node.arguments.head;
+    if (!defaultValuesAllowed) {
+      error(defaultValue, MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT);
+    }
     // Visit the value. The compile time constant handler will
     // make sure it's a compile time constant.
-    resolveExpression(node.arguments.head);
+    resolveExpression(defaultValue);
     return element;
   }
 
   Element visitFunctionExpression(FunctionExpression node) {
     // This is a function typed parameter.
     // TODO(ahe): Resolve the function type.
     return visit(node.name);
   }
 
   LinkBuilder<Element> analyzeNodes(Link<Node> link) {
@@ skipping 12 matching lines @@
     }
     return elements;
   }
 
   /**
    * Resolves formal parameters and return type to a [FunctionSignature].
    */
   static FunctionSignature analyze(Compiler compiler,
                                    NodeList formalParameters,
                                    Node returnNode,
-                                   Element element) {
-    SignatureResolver visitor = new SignatureResolver(compiler, element);
+                                   Element element,
+                                   {bool defaultValuesAllowed: true}) {
+    SignatureResolver visitor = new SignatureResolver(compiler, element,
+            defaultValuesAllowed: defaultValuesAllowed);
     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 209 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }