Various redemptions

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

 // Copyright (c) 2015, 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.
 
 part of dart2js.js_emitter.program_builder;
 
 /**
  * [member] is a field (instance, static, or top level).
  *
  * [name] is the field name that the [Namer] has picked for this field's
@@ skipping 10 matching lines @@
  * [needsCheckedSetter] indicates that a checked getter is needed, and in this
  * case, [needsSetter] is always false. [needsCheckedSetter] is only true when
  * type assertions are enabled (checked mode).
  */
 typedef void AcceptField(FieldEntity member, js.Name name, js.Name accessorName,
     bool needsGetter, bool needsSetter, bool needsCheckedSetter);
 
 class FieldVisitor {
   final CompilerOptions _options;
   final ElementEnvironment _elementEnvironment;
+  final CommonElements _commonElements;
   final CodegenWorldBuilder _codegenWorldBuilder;
   final NativeData _nativeData;
   final MirrorsData _mirrorsData;
   final Namer _namer;
   final ClosedWorld _closedWorld;
 
   FieldVisitor(
       this._options,
       this._elementEnvironment,
+      this._commonElements,
       this._codegenWorldBuilder,
       this._nativeData,
       this._mirrorsData,
       this._namer,
       this._closedWorld);
 
   /**
    * Invokes [f] for each of the fields of [element].
    *
-   * [element] must be a [ClassElement] or a [LibraryElement].
+   * [element] must be a [ClassEntity] or a [LibraryEntity].
    *
-   * If [element] is a [ClassElement], the static fields of the class are
+   * If [element] is a [ClassEntity], the static fields of the class are
    * visited if [visitStatics] is true and the instance fields are visited if
    * [visitStatics] is false.
    *
-   * If [element] is a [LibraryElement], [visitStatics] must be true.
+   * If [element] is a [LibraryEntity], [visitStatics] must be true.
    *
    * When visiting the instance fields of a class, the fields of its superclass
    * are also visited if the class is instantiated.
    *
    * Invariant: [element] must be a declaration element.
    */
   void visitFields(AcceptField f,
       {bool visitStatics: false, LibraryEntity library, ClassEntity cls}) {
     assert(!(library is LibraryElement && !library.isDeclaration),
         failedAt(library));
     assert(!(cls is ClassElement && !cls.isDeclaration), failedAt(cls));
 
     bool isNativeClass = false;
     bool isLibrary = false;
     bool isInstantiated = false;
     if (cls != null) {
       isNativeClass = _nativeData.isNativeClass(cls);
 
       // If the class is never instantiated we still need to set it up for
       // inheritance purposes, but we can simplify its JavaScript constructor.
       isInstantiated =
           _codegenWorldBuilder.directlyInstantiatedClasses.contains(cls);
     } else if (library != null) {
       isLibrary = true;
       assert(visitStatics, failedAt(library));
     } else {
-      failedAt(NO_LOCATION_SPANNABLE,
-          'Expected a ClassElement or a LibraryElement.');
+      failedAt(
+          NO_LOCATION_SPANNABLE, 'Expected a ClassEntity or a LibraryEntity.');
     }
 
     void visitField(FieldEntity field, {ClassEntity holder}) {
       assert(!(field is FieldElement && !field.isDeclaration), failedAt(field));
 
       bool isMixinNativeField =
           isNativeClass && _elementEnvironment.isMixinApplication(holder);
 
       // See if we can dynamically create getters and setters.
       // We can only generate getters and setters for [element] since
@@ skipping 74 matching lines @@
 
   static bool fieldAccessNeverThrows(FieldEntity field) {
     return
         // We never access a field in a closure (a captured variable) without
         // knowing that it is there.  Therefore we don't need to use a getter
         // (that will throw if the getter method is missing), but can always
         // access the field directly.
         field is ClosureFieldElement;
   }
 
-  bool canAvoidGeneratedCheckedSetter(FieldElement member) {
+  bool canAvoidGeneratedCheckedSetter(FieldEntity member) {
     // We never generate accessors for top-level/static fields.
     if (!member.isInstanceMember) return true;
-    ResolutionDartType type = member.type;
-    return type.treatAsDynamic || type.isObject;
+    DartType type = _elementEnvironment.getFieldType(member);
+    return type.treatAsDynamic || type == _commonElements.objectType;
   }
 }