Support user class in compile_from_dill_test

pkg/compiler/lib/src/closure.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.
 
 library closureToClassMapper;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 63 matching lines @@
           !element.isInstanceMember &&
           resolvedAst.body == null) {
         // Skip top-level/static fields without an initializer.
         return;
       }
       computeClosureToClassMapping(element, closedWorldRefiner);
     });
   }
 
   ClosureClassMap computeClosureToClassMapping(
-      AstElement element, ClosedWorldRefiner closedWorldRefiner) {
+      MemberElement element, ClosedWorldRefiner closedWorldRefiner) {
     return measure(() {
       ClosureClassMap cached = _closureMappingCache[element];
       if (cached != null) return cached;
       if (element.resolvedAst.kind != ResolvedAstKind.PARSED) {
         return _closureMappingCache[element] =
             new ClosureClassMap(null, null, null, new ThisLocal(element));
       }
       return reporter.withCurrentElement(element.implementation, () {
         Node node = element.resolvedAst.node;
         TreeElements elements = element.resolvedAst.elements;
@@ skipping 248 matching lines @@
 
   @override
   bool get hasConstant => false;
 
   @override
   ConstantExpression get constant => null;
 }
 
 /// A local variable used encode the direct (uncaptured) references to [this].
 class ThisLocal extends Local {
-  final ExecutableElement executableContext;
+  final MemberEntity memberContext;
   final hashCode = ElementX.newHashCode();
 
-  ThisLocal(this.executableContext);
+  ThisLocal(this.memberContext);
 
-  @override
-  MemberElement get memberContext => executableContext.memberContext;
+  Entity get executableContext => memberContext;
 
   String get name => 'this';
 
-  ClassElement get enclosingClass => executableContext.enclosingClass;
+  ClassEntity get enclosingClass => memberContext.enclosingClass;
 }
 
 /// Call method of a closure class.
 class SynthesizedCallMethodElementX extends BaseFunctionElementX
     implements MethodElement {
   final LocalFunctionElement expression;
   final FunctionExpression node;
   final TreeElements treeElements;
 
   SynthesizedCallMethodElementX(String name, LocalFunctionElement other,
@@ skipping 271 matching lines @@
     // The [:elements[node]:] always points to the generative-constructor
     // element, whereas the [element] might be the constructor-body element.
     visit(node); // [visitFunctionExpression] will call [visitInvokable].
     // When variables need to be boxed their [_capturedVariableMapping] is
     // updated, but we delay updating the similar freeVariableMapping in the
     // closure datas that capture these variables.
     // The closures don't have their fields (in the closure class) set, either.
     updateClosures();
   }
 
-  void translateLazyInitializer(VariableElement element,
-      VariableDefinitions node, Expression initializer) {
+  void translateLazyInitializer(
+      FieldElement element, VariableDefinitions node, Expression initializer) {
     visitInvokable(element, node, () {
       visit(initializer);
     });
     updateClosures();
   }
 
   // This function runs through all of the existing closures and updates their
   // free variables to the boxed value. It also adds the field-elements to the
   // class representing the closure.
   void updateClosures() {
@@ skipping 446 matching lines @@
     if (insideClosure) {
       closure = element;
       closures.add(closure);
       closureData = globalizeClosure(node, closure);
       needsRti = compiler.options.enableTypeAssertions ||
           compiler.backend.rtiNeed.localFunctionNeedsRti(closure);
     } else {
       outermostElement = element;
       ThisLocal thisElement = null;
       if (element.isInstanceMember || element.isGenerativeConstructor) {
-        thisElement = new ThisLocal(element);
+        MemberElement member = element;
+        thisElement = new ThisLocal(member);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
       if (element is MethodElement) {
         needsRti = compiler.options.enableTypeAssertions ||
             compiler.backend.rtiNeed.methodNeedsRti(element);
       }
     }
     closureMappingCache[element] = closureData;
     closureMappingCache[element.declaration] = closureData;
     if (closureData.callElement != null) {
@@ skipping 110 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements MemberEntity {
   Local get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }