Handle compile-time constants to interfaces.

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 955 matching lines @@
         }
       }
       if (classElement.superclass != compiler.coreLibrary.find(Types.OBJECT)) {
         compiler.unimplemented("ConstantHandler with super", node: node);
       }
       return jsNewArguments;
     }
 
     if (!node.isConst()) error(node);
 
+    FunctionElement constructor = elements[node.send];
+    compiler.resolver.resolveMethodElement(constructor);
+    constructor = constructor.defaultImplementation;
+
+    ClassElement classElement = constructor.enclosingElement;
     // TODO(floitsch): get the type from somewhere.

[ngeoffray, 2012/03/18 13:56:04]

Why is classElement.computeType(compiler) not sufficient?

[floitsch, 2012/03/18 18:44:15]

It doesn't take generic types into account. But better than creating a new
simpletype myself.
Updated and changed comment.

-    FunctionElement constructor = elements[node.send];
-    ClassElement classElement = constructor.enclosingElement;
+    Type type = new SimpleType(classElement.name, classElement);      
     TreeElements constructorElements =
         compiler.resolver.resolveMethodElement(constructor);

[ngeoffray, 2012/03/18 13:56:04]

You could avoid calling resolveMethodElement twice if constructor ===
constructor.defaultImplementation.

[floitsch, 2012/03/18 18:44:15]

Done.

     FunctionExpression functionNode = constructor.parseNode(compiler);
     NodeList initializerList = functionNode.initializers;
     FunctionParameters parameters = constructor.computeParameters(compiler);
 
     Map<Element, Constant> fieldValues = new Map<Element, Constant>();
     Map<Element, Constant> constructorDefinitions =
         new Map<Element, Constant>();
 
     assignArgumentsToParameters(parameters, constructorDefinitions,
                                 fieldValues);
     CompileTimeConstantEvaluator initializerEvaluator =
         new CompileTimeConstantEvaluator.insideConstructor(
             constantHandler, constructorElements, compiler,
             constructorDefinitions);
     if (initializerList !== null) {
       Link<Node> initializers = functionNode.initializers.nodes;
       compileInitializers(initializers,
                           initializerEvaluator,
                           constructorElements,
                           constructorDefinitions,
                           fieldValues);
     }
     List<Constant> jsNewArguments =
         buildJsNewArguments(classElement, fieldValues);
 
     compiler.registerInstantiatedClass(classElement);
-    Type type = new SimpleType(classElement.name, classElement);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
     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 []));
   }
 }