Resolve initializers in their proper scope.

dart/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 916 matching lines @@
       return folded;
     }
     return super.visitSend(send);
   }
 
   visitSendSet(SendSet node) {
     error(node);
   }
 
   Constant visitNewExpression(NewExpression node) {
+    Element currentElement = compiler.currentElement;
+
     void assignArgumentsToParameters(
         FunctionParameters parameters,
         Map<Element, Constant> constructorDefinitions,
         Map<Element, Constant> fieldValues) {
       Send send = node.send;
       if (send.arguments.isEmpty() && parameters.parameterCount == 0) return;
       List<Constant> arguments = <Constant>[];
       Selector selector = elements.getSelector(send);
 
       Function compileArgument = evaluate;
@@ skipping 45 matching lines @@
         if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
           Constant fieldValue = fieldValues[member];
           if (fieldValue === null) {
             // Use the default value.
             fieldValue = constantHandler.compileVariable(member);
           }
           jsNewArguments.add(fieldValue);
         }
       }
       if (classElement.superclass != compiler.coreLibrary.find(Types.OBJECT)) {
-        compiler.unimplemented("ConstantHandler with super", node: node);
+        compiler.withCurrentElement(currentElement, () {

[ngeoffray, 2012/03/23 07:50:22]

Why is that necessary? The withCurrentElement line 1024 should be enough.

[ahe, 2012/03/23 11:30:31]

That's the wrong element. It is the element for the constructor that is being
inlined, not the element of the node.

This will get more ugly the more we inline. We need to find a better solution
than withCurrentElement.

+          compiler.unimplemented("ConstantHandler with super", node: node);
+        });
       }
       return jsNewArguments;
     }
 
     if (!node.isConst()) error(node);
 
     FunctionElement constructor = elements[node.send];
     TreeElements constructorElements =
         compiler.resolver.resolveMethodElement(constructor);
     if (constructor != constructor.defaultImplementation) {
@@ skipping 39 matching lines @@
     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 []));
   }
 }