Handle instance fields in compile_from_dill_test

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter.program_builder;
 
 import 'dart:io';
 import 'dart:convert' show JSON;
 
 import '../../closure.dart' show ClosureTask, ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../constants/values.dart'
     show ConstantValue, InterceptorConstantValue;
 import '../../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import '../../elements/elements.dart'
     show
         ClassElement,
         ConstructorBodyElement,
-        Element,
         Elements,
         FieldElement,
-        FunctionElement,
         FunctionSignature,
         GetterElement,
         LibraryElement,
         MemberElement,
         MethodElement,
         ParameterElement,
         TypedefElement;
 import '../../elements/entities.dart';
 import '../../elements/resolution_types.dart'
     show ResolutionDartType, ResolutionFunctionType, ResolutionTypedefType;
@@ skipping 479 matching lines @@
     // a method in the case where there exist multiple JavaScript classes
     // that conflict on whether the member is a getter or a method.
     var interceptorClass = _classes[_commonElements.jsJavaScriptObjectClass];
     var stubNames = new Set<String>();
     librariesMap
         .forEach((LibraryEntity library, List<ClassEntity> classElements, _) {
       for (ClassEntity cls in classElements) {
         if (_nativeData.isJsInteropClass(cls)) {
           // TODO(johnniwinther): Handle class entities.
           ClassElement e = cls;
-          e.declaration.forEachMember((_, Element member) {
+          e.declaration.forEachMember((_, MemberElement member) {
             var jsName = _nativeData.computeUnescapedJSInteropName(member.name);
             if (!member.isInstanceMember) return;
             if (member.isGetter || member.isField || member.isFunction) {
               var selectors =
                   _worldBuilder.getterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
                   var stubName = _namer.invocationName(selector);
                   if (stubNames.add(stubName.key)) {
                     interceptorClass.callStubs.add(_buildStubMethod(stubName,
                         js.js('function(obj) { return obj.# }', [jsName]),
                         element: member));
                   }
                 }
               }
             }
 
             if (member.isSetter || (member.isField && !member.isConst)) {
               var selectors =
                   _worldBuilder.setterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
-                var stubName = _namer.setterForElement(member);
+                var stubName = _namer.setterForMember(member);
                 if (stubNames.add(stubName.key)) {
                   interceptorClass.callStubs.add(_buildStubMethod(stubName,
                       js.js('function(obj, v) { return obj.# = v }', [jsName]),
                       element: member));
                 }
               }
             }
 
             // Generating stubs for direct calls and stubs for call-through
             // of getters that happen to be functions.
             bool isFunctionLike = false;
             ResolutionFunctionType functionType = null;
 
             if (member.isFunction) {
-              FunctionElement fn = member;
+              MethodElement fn = member;
               functionType = fn.type;
             } else if (member.isGetter) {
               if (_options.trustTypeAnnotations) {
                 GetterElement getter = member;
                 ResolutionDartType returnType = getter.type.returnType;
                 if (returnType.isFunctionType) {
                   functionType = returnType;
                 } else if (returnType.treatAsDynamic ||
                     _types.isSubtype(
                         returnType,
@@ skipping 465 matching lines @@
     });
   }
 
   List<Field> _buildFields(
       {bool visitStatics: false,
       bool isHolderInterceptedClass: false,
       LibraryEntity library,
       ClassEntity cls}) {
     List<Field> fields = <Field>[];
 
-    void visitField(FieldElement field, js.Name name, js.Name accessorName,
+    void visitField(FieldEntity field, js.Name name, js.Name accessorName,
         bool needsGetter, bool needsSetter, bool needsCheckedSetter) {
-      assert(field.isDeclaration, failedAt(field));
+      assert(!(field is FieldElement && !field.isDeclaration), failedAt(field));
 
       int getterFlags = 0;
       if (needsGetter) {
         if (visitStatics ||
             !_interceptorData.fieldHasInterceptedGetter(field)) {
           getterFlags = 1;
         } else {
           getterFlags += 2;
           // TODO(sra): 'isInterceptedClass' might not be the correct test
           // for methods forced to use the interceptor convention because
@@ skipping 122 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }