Handle assert_test without useKernelInSsa

pkg/compiler/lib/src/js_emitter/full_emitter/class_emitter.dart

 // Copyright (c) 2013, 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.full_emitter.class_emitter;
 
 import '../../common.dart';
 import '../../common/names.dart' show Names;
 import '../../common_elements.dart';
 import '../../elements/resolution_types.dart' show ResolutionDartType;
 import '../../deferred_load.dart' show OutputUnit;
-import '../../elements/elements.dart'
-    show ClassElement, FieldElement, MemberElement;
+import '../../elements/elements.dart' show ClassElement, FieldElement;
 import '../../elements/entities.dart';
 import '../../js/js.dart' as jsAst;
 import '../../js/js.dart' show js;
 import '../../js_backend/js_backend.dart' show CompoundName, Namer;
 import '../../universe/selector.dart' show Selector;
 import '../../util/util.dart' show equalElements;
 import '../../world.dart' show ClosedWorld;
 import '../js_emitter.dart' hide Emitter, EmitterFactory;
 import '../model.dart';
 import 'emitter.dart';
@@ skipping 64 matching lines @@
   */
   void emitConstructorsForCSP(Class cls) {
     List<jsAst.Name> fieldNames = <jsAst.Name>[];
 
     if (!compiler.options.useContentSecurityPolicy) return;
 
     if (!cls.onlyForRti && !cls.isNative) {
       fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
 
-    ClassElement classElement = cls.element;
+    ClassEntity classElement = cls.element;
 
     jsAst.Expression constructorAst = _stubGenerator.generateClassConstructor(
         classElement, fieldNames, cls.hasRtiField);
 
     jsAst.Name constructorName = namer.className(classElement);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(classElement);
     emitter.assemblePrecompiledConstructor(
         outputUnit, constructorName, constructorAst, fieldNames);
   }
@@ skipping 106 matching lines @@
       builder.fieldMetadata = fieldMetadata;
     }
     return fieldsAdded;
   }
 
   /// Emits checked setters for fields.
   void emitCheckedClassSetters(Class cls, ClassBuilder builder) {
     if (cls.onlyForRti) return;
 
     for (StubMethod method in cls.checkedSetters) {
-      MemberElement member = method.element;
+      MemberEntity member = method.element;
       assert(member != null);
       jsAst.Expression code = method.code;
       jsAst.Name setterName = method.name;
       compiler.dumpInfoTask
           .registerElementAst(member, builder.addProperty(setterName, code));
       generateReflectionDataForFieldGetterOrSetter(member, setterName, builder,
           isGetter: false);
     }
   }
 
   /// Emits getters/setters for fields if compiling in CSP mode.
   void emitClassGettersSettersForCSP(Class cls, ClassBuilder builder) {
     if (!compiler.options.useContentSecurityPolicy || cls.onlyForRti) return;
 
     for (Field field in cls.fields) {
-      FieldElement member = field.element;
+      FieldEntity member = field.element;
       reporter.withCurrentElement(member, () {
         if (field.needsGetter) {
           emitGetterForCSP(member, field.name, field.accessorName, builder);
         }
         if (field.needsUncheckedSetter) {
           emitSetterForCSP(member, field.name, field.accessorName, builder);
         }
       });
     }
   }
@@ skipping 146 matching lines @@
       previousName = emitter.mangledFieldNames
           .putIfAbsent(namer.deriveGetterName(accessorName), () => memberName);
     } else {
       previousName = emitter.mangledGlobalFieldNames
           .putIfAbsent(accessorName, () => memberName);
     }
     assert(previousName == memberName,
         failedAt(member, '$previousName != ${memberName}'));
   }
 
-  void emitGetterForCSP(FieldElement member, jsAst.Name fieldName,
+  void emitGetterForCSP(FieldEntity member, jsAst.Name fieldName,
       jsAst.Name accessorName, ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateGetter(member, fieldName);
 
     jsAst.Name getterName = namer.deriveGetterName(accessorName);
-    ClassElement cls = member.enclosingClass;
+    ClassEntity cls = member.enclosingClass;
     jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter
         .cspPrecompiledFunctionFor(outputUnit)
         .add(js('#.prototype.# = #', [className, getterName, function]));
     if (backend.mirrorsData.isMemberAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(js(
           '#.prototype.#.${namer.reflectableField} = 1',
           [className, getterName]));
     }
   }
 
-  void emitSetterForCSP(FieldElement member, jsAst.Name fieldName,
+  void emitSetterForCSP(FieldEntity member, jsAst.Name fieldName,
       jsAst.Name accessorName, ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateSetter(member, fieldName);
 
     jsAst.Name setterName = namer.deriveSetterName(accessorName);
-    ClassElement cls = member.enclosingClass;
+    ClassEntity cls = member.enclosingClass;
     jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter
         .cspPrecompiledFunctionFor(outputUnit)
         .add(js('#.prototype.# = #', [className, setterName, function]));
     if (backend.mirrorsData.isMemberAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(js(
           '#.prototype.#.${namer.reflectableField} = 1',
           [className, setterName]));
     }
   }
 
   void generateReflectionDataForFieldGetterOrSetter(
-      MemberElement member, jsAst.Name name, ClassBuilder builder,
+      MemberEntity member, jsAst.Name name, ClassBuilder builder,
       {bool isGetter}) {
     Selector selector = isGetter
         ? new Selector.getter(member.memberName.getter)
         : new Selector.setter(member.memberName.setter);
     String reflectionName = emitter.getReflectionSelectorName(selector, name);
     if (reflectionName != null) {
       var reflectable = js(
           backend.mirrorsData.isMemberAccessibleByReflection(member)
               ? '1'
               : '0');
       builder.addPropertyByName('+$reflectionName', reflectable);
     }
   }
 }