Support default values for optional parameters.

dart/frog/leg/resolver.dart

 // Copyright (c) 2011, 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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 24 matching lines @@
   TreeElements resolve(Element element) {
     return measure(() {
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
           return resolveMethodElement(element);
 
         case ElementKind.FIELD:
-          return resolveFieldElement(element);
+        case ElementKind.PARAMETER:
+          return resolveVariableElement(element);
 
         default:
           compiler.unimplemented(
               "resolver", node: element.parseNode(compiler));
       }
     });
   }
 
   TreeElements resolveMethodElement(FunctionElement element) {
     FunctionExpression tree = element.parseNode(compiler);
@@ skipping 12 matching lines @@
       ClassElement classElement = toResolve.removeFirst();
       if (!classElement.isResolved) {
         classElement.resolve(compiler);
       }
       newResolvedClasses = newResolvedClasses.prepend(classElement);
     }
     checkClassHierarchy(newResolvedClasses);
     return visitor.mapping;
   }
 
-  TreeElements resolveFieldElement(Element element) {
+  TreeElements resolveVariableElement(Element element) {
     Node tree = element.parseNode(compiler);
     ResolverVisitor visitor = new FullResolverVisitor(compiler, element);
     if (tree is SendSet) {
       SendSet send = tree;
       visitor.visit(send.arguments.head);
     }
     return visitor.mapping;
   }
 
   Type resolveType(ClassElement element) {
@@ skipping 250 matching lines @@
     : this.compiler = compiler,
       this.mapping  = new TreeElementMapping(),
       this.enclosingElement = element,
       inInstanceContext = element.isInstanceMember()
           || element.isGenerativeConstructor(),
       this.context  = element.isMember()
         ? new ClassScope(element.enclosingElement, compiler.universe)
         : new TopScope(compiler.universe),
       this.currentClass = element.isMember() ? element.enclosingElement : null;
 
+  ResolverVisitor.from(ResolverVisitor other)
+    : this.compiler = other.compiler,
+      this.mapping  = other.mapping,
+      this.enclosingElement = other.enclosingElement,
+      this.inInstanceContext = other.inInstanceContext,
+      this.context  = other.context,
+      this.currentClass = other.currentClass;
+
   void error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError error  = new ResolutionError(kind, arguments);
     compiler.reportError(node, error);
   }
 
   void warning(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
     compiler.reportWarning(node, warning);
   }
 
@@ skipping 109 matching lines @@
   visitNode(Node node) {
     cancel(node, 'not implemented');
   }
 }
 
 class FullResolverVisitor extends ResolverVisitor {
 
   FullResolverVisitor(Compiler compiler, Element element)
     : super(compiler, element);
 
+  FullResolverVisitor.from(ResolverVisitor other) : super.from(other);
+
   Element visitClassNode(ClassNode node) {
     cancel(node, "shouldn't be called");
   }
 
   visitIn(Node node, Scope scope) {
     context = scope;
     Element element = visit(node);
     context = context.parent;
     return element;
   }
@@ skipping 539 matching lines @@
   }
 
   Element visitIdentifier(Identifier node) {
     Element variables = new VariableListElement.node(currentDefinitions,
         ElementKind.VARIABLE_LIST, enclosingElement);
     return new VariableElement(node.source, variables,
         ElementKind.PARAMETER, enclosingElement, node: node);
   }
 
   Element visitSend(Send node) {
-    if (node.receiver === null) {
-      cancel(node, 'internal error: no receiver on a parameter send');
-    }
     Element element;
     if (node.receiver.asIdentifier() === null ||
         !node.receiver.asIdentifier().isThis()) {
       error(node, MessageKind.INVALID_PARAMETER, []);
     } else if (enclosingElement.kind !== ElementKind.GENERATIVE_CONSTRUCTOR) {
       error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED, []);
     } else {
       if (node.selector.asIdentifier() == null) {
         cancel(node,
                'internal error: unimplemented receiver on parameter send');
       }
       SourceString name = node.selector.asIdentifier().source;
       element = currentClass.lookupLocalMember(name);
       if (element.kind !== ElementKind.FIELD) {
         error(node, MessageKind.NOT_A_FIELD, [name]);
       } else if (!element.isInstanceMember()) {
         error(node, MessageKind.NOT_INSTANCE_FIELD, [name]);
       }
     }
+    // TODO(ngeoffray): it's not right to put the field element in
+    // the parameters element. Create another element instead.
+    return element;
+  }
+
+  Element visitSendSet(SendSet node) {
+    Element element;
+    if (node.receiver != null) {
+      // TODO(ngeoffray): it's not right to put the field element in
+      // the parameters element. Create another element instead.
+      element = visitSend(node);
+    } else if (node.selector.asIdentifier() != null) {
+      Element variables = new VariableListElement.node(currentDefinitions,
+          ElementKind.VARIABLE_LIST, enclosingElement);
+      element = new VariableElement(node.selector.asIdentifier().source,
+          variables, ElementKind.PARAMETER, enclosingElement, node: node);
+    }
+    // Visit the value. The compile time constant handler will
+    // make sure it's a compile time constant.
+    new FullResolverVisitor.from(this).visit(node.arguments.head);
+    compiler.enqueue(new WorkItem.toCompile(element));
     return element;
   }
 
   Element visit(Node node) {
     if (node == null) return null;
     return node.accept(this);
   }
 
   Element visitNode(Node node) {
     cancel(node, 'not implemented');
@@ skipping 56 matching lines @@
 class TopScope extends Scope {
   Universe universe;
 
   TopScope(Universe this.universe) : super(null, null);
   Element lookup(SourceString name) => universe.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }