Report errors when the number of arguments don't match the number of parameters in a const construc…

lib/compiler/implementation/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.
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
 class ConstantHandler extends CompilerTask {
@@ skipping 512 matching lines @@
       return folded;
     }
     return signalNotCompileTimeConstant(send);
   }
 
   Constant visitSendSet(SendSet node) {
     return signalNotCompileTimeConstant(node);
   }
 
   /** Returns the list of constants that are passed to the static function. */
-  List<Constant> evaluateArgumentsToConstructor(Selector selector,
+  List<Constant> evaluateArgumentsToConstructor(Node node,
+                                                Selector selector,
                                                 Link<Node> arguments,
                                                 FunctionElement target) {
     List<Constant> compiledArguments = <Constant>[];
 
     Function compileArgument = evaluateConstant;
     Function compileConstant = compiler.compileConstant;
     bool succeeded = selector.addArgumentsToList(arguments,
                                                  compiledArguments,
                                                  target,
                                                  compileArgument,
                                                  compileConstant,
                                                  compiler);
-    assert(succeeded);
+    if (!succeeded) {
+      MessageKind kind = MessageKind.INVALID_ARGUMENTS;
+      compiler.reportError(node,
+          new CompileTimeConstantError(kind, [target.name.slowToString()]));
+    }
     return compiledArguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
     if (!node.isConst()) {
       return signalNotCompileTimeConstant(node);
     }
 
     Send send = node.send;
     FunctionElement constructor = elements[send];
     ClassElement classElement = constructor.getEnclosingClass();
     if (classElement.isInterface()) {
       compiler.resolver.resolveMethodElement(constructor);
       constructor = constructor.defaultImplementation;
       classElement = constructor.getEnclosingClass();
     }
 
     Selector selector = elements.getSelector(send);
-    List<Constant> arguments =
-        evaluateArgumentsToConstructor(selector, send.arguments, constructor);
+    List<Constant> arguments = evaluateArgumentsToConstructor(
+        node, selector, send.arguments, constructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructor, constantSystem, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
     compiler.enqueuer.codegen.registerInstantiatedClass(classElement);
     // TODO(floitsch): take generic types into account.
     DartType type = classElement.computeType(compiler);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
@@ skipping 98 matching lines @@
       Node node = parameter.parseNode(compiler);
       potentiallyCheckType(node, parameter, argument);
       definitions[parameter] = argument;
       if (parameter.kind == ElementKind.FIELD_PARAMETER) {
         FieldParameterElement fieldParameterElement = parameter;
         updateFieldValue(node, fieldParameterElement.fieldElement, argument);
       }
     });
   }
 
-  void evaluateSuperOrRedirectSend(Selector selector,
+  void evaluateSuperOrRedirectSend(Node currentNode,
+                                   Selector selector,
                                    Link<Node> arguments,
                                    FunctionElement targetConstructor) {
-    List<Constant> compiledArguments =
-        evaluateArgumentsToConstructor(selector, arguments, targetConstructor);
+    List<Constant> compiledArguments = evaluateArgumentsToConstructor(
+        currentNode, selector, arguments, targetConstructor);
 
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
         targetConstructor, constantSystem, compiler);
     evaluator.evaluateConstructorFieldValues(compiledArguments);
     // Copy over the fieldValues from the super/redirect-constructor.
     // No need to go through [updateFieldValue] because the
     // assignments have already been checked in checked mode.
     evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
   }
 
@@ skipping 11 matching lines @@
       for (Link<Node> link = initializerList.nodes;
            !link.isEmpty();
            link = link.tail) {
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           FunctionElement targetConstructor = elements[call];
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
-          evaluateSuperOrRedirectSend(selector, arguments, targetConstructor);
+          evaluateSuperOrRedirectSend(
+              call, selector, arguments, targetConstructor);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> initArguments = init.arguments;
           assert(!initArguments.isEmpty() && initArguments.tail.isEmpty());
           Constant fieldValue = evaluate(initArguments.head);
           updateFieldValue(init, elements[init], fieldValue);
         }
       }
@@ skipping 10 matching lines @@
         FunctionElement targetConstructor =
             superClass.lookupConstructor(superClass.name);
         if (targetConstructor === null) {
           compiler.internalError("no default constructor available",
                                  node: functionNode);
         }
 
         Selector selector = new Selector.call(superClass.name,
                                               enclosingClass.getLibrary(),
                                               0);
-        evaluateSuperOrRedirectSend(selector,
+        evaluateSuperOrRedirectSend(functionNode,
+                                    selector,
                                     const EmptyLink<Node>(),
                                     targetConstructor);
       }
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
    * [arguments] to obtain the field values that need to be passed to the
    * native JavaScript constructor.
@@ skipping 14 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileConstant(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }