const constructors with optional arguments.

frog/leg/compile_time_constants.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.
 
 class Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
@@ skipping 882 matching lines @@
       return folded;
     }
     return super.visitSend(send);
   }
 
   visitSendSet(SendSet node) {
     error(node);
   }
 
   Constant visitNewExpression(NewExpression node) {
-    List<Constant> compileArguments() {
-      if (!node.isConst()) error(node);
-      Send send = node.send;
-      List<Constant> arguments;
-      if (send.arguments.isEmpty()) {
-        arguments = const <Constant>[];
-      } else {
-        arguments = <Constant>[];
-        for (Link<Node> link = send.arguments;
-             !link.isEmpty();
-             link = link.tail) {
-          arguments.add(evaluate(link.head));
-        }
-      }
-      return arguments;
-    }
-
     void assignArgumentsToParameters(
-        List<Constant> arguments,
         FunctionParameters parameters,
         Map<Element, Constant> constructorDefinitions) {
-      if (arguments.length != parameters.parameterCount) {
-        if (arguments.length < parameters.parameterCount &&
-            arguments.length >= parameters.requiredParameterCount) {
-          compiler.unimplemented("ConstantHandler with optional arguments",
-                                 node: node);
-        } else {
-          error(node);
-        }
-      }
+      Send send = node.send;
+      if (send.arguments.isEmpty() && parameters.parameterCount == 0) return;
+      List<Constant> arguments = <Constant>[];
+      Selector selector = elements.getSelector(send);
+
+      Function compileArgument = evaluate;
+      Function compileConstant = constantHandler.compileVariable;
+      bool succeeded = selector.addSendArgumentsToList(
+          send, arguments, parameters, compileArgument, compileConstant);
+      if (!succeeded) error(node);
+
       int index = 0;
       parameters.forEachParameter((Element parameter) {
         constructorDefinitions[parameter] = arguments[index++];
       });
     }
 
     void compileInitializers(Link<Node> initializers,
                              CompileTimeConstantEvaluator evaluator,
                              TreeElements constructorElements,
                              Map<Element, Constant> constructorDefinitions) {
@@ skipping 30 matching lines @@
           }
           fieldValues.add(fieldValue);
         }
       }
       if (classElement.superclass != compiler.coreLibrary.find(Types.OBJECT)) {
         compiler.unimplemented("ConstantHandler with super", node: node);
       }
       return fieldValues;
     }
 
+    if (!node.isConst()) error(node);
+
     // TODO(floitsch): get the type from somewhere.
     FunctionElement constructor = elements[node.send];
     ClassElement classElement = constructor.enclosingElement;
     TreeElements constructorElements =
         compiler.resolver.resolveMethodElement(constructor);
     FunctionExpression functionNode = constructor.parseNode(compiler);
     NodeList initializerList = functionNode.initializers;
     FunctionParameters parameters = constructor.computeParameters(compiler);
 
     Map<Element, Constant> constructorDefinitions =
         new Map<Element, Constant>();
 
-    List<Constant> arguments = compileArguments();
-    assignArgumentsToParameters(arguments, parameters, constructorDefinitions);
+    assignArgumentsToParameters(parameters, constructorDefinitions);
     CompileTimeConstantEvaluator initializerEvaluator =
         new CompileTimeConstantEvaluator.insideConstructor(
             constantHandler, constructorElements, compiler,
             constructorDefinitions);
     if (initializerList !== null) {
       Link<Node> initializers = functionNode.initializers.nodes;
       compileInitializers(initializers,
                           initializerEvaluator,
                           constructorElements,
                           constructorDefinitions);
     }
     List<Constant> fieldValues =
         buildJsConstructorArguments(classElement, constructorDefinitions);
 
     compiler.registerInstantiatedClass(classElement);
     Type type = new SimpleType(classElement.name, classElement);
     Constant constant = new ConstructedConstant(type, fieldValues);
     constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     compiler.reportError(node, new CompileTimeConstantError(kind, const []));
   }
 }