dart2js: Move field-visiting code to the program-builder.

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.
 
 part of dart2js.js_emitter;
 
 class ClassEmitter extends CodeEmitterHelper {
 
   ClassStubGenerator get _stubGenerator =>
       new ClassStubGenerator(compiler, namer, backend);
@@ skipping 340 matching lines @@
         for (DartType interface in classElement.interfaces) {
           types.add(task.metadataCollector.reifyType(interface));
         }
         // TODO(herhut): Fix use of reflection name here.
         enclosingBuilder.addPropertyByName("+$reflectionName",
             new jsAst.ArrayInitializer(types));
       }
     }
   }
 
-  /**
-   * Invokes [f] for each of the fields of [element].
-   *
-   * [element] must be a [ClassElement] or a [LibraryElement].
-   *
-   * If [element] is a [ClassElement], 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.
-   *
-   * 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(Element element, bool visitStatics, AcceptField f) {
-    assert(invariant(element, element.isDeclaration));
-
-    bool isClass = false;
-    bool isLibrary = false;
-    if (element.isClass) {
-      isClass = true;
-    } else if (element.isLibrary) {
-      isLibrary = true;
-      assert(invariant(element, visitStatics));
-    } else {
-      throw new SpannableAssertionFailure(
-          element, 'Expected a ClassElement or a LibraryElement.');
-    }
-
-    // If the class is never instantiated we still need to set it up for
-    // inheritance purposes, but we can simplify its JavaScript constructor.
-    bool isInstantiated =
-        compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
-
-    void visitField(Element holder, FieldElement field) {
-      assert(invariant(element, field.isDeclaration));
-
-      // Keep track of whether or not we're dealing with a field mixin
-      // into a native class.
-      bool isMixinNativeField =
-          isClass && element.isNative && holder.isMixinApplication;
-
-      // See if we can dynamically create getters and setters.
-      // We can only generate getters and setters for [element] since
-      // the fields of super classes could be overwritten with getters or
-      // setters.
-      bool needsGetter = false;
-      bool needsSetter = false;
-      if (isLibrary || isMixinNativeField || holder == element) {
-        needsGetter = fieldNeedsGetter(field);
-        needsSetter = fieldNeedsSetter(field);
-      }
-
-      if ((isInstantiated && !holder.isNative)
-          || needsGetter
-          || needsSetter) {
-        jsAst.Name accessorName = namer.fieldAccessorName(field);
-        jsAst.Name fieldName = namer.fieldPropertyName(field);
-        bool needsCheckedSetter = false;
-        if (compiler.enableTypeAssertions
-            && needsSetter
-            && !canAvoidGeneratedCheckedSetter(field)) {
-          needsCheckedSetter = true;
-          needsSetter = false;
-        }
-        // Getters and setters with suffixes will be generated dynamically.
-        f(field, fieldName, accessorName, needsGetter, needsSetter,
-          needsCheckedSetter);
-      }
-    }
-
-    if (isLibrary) {
-      LibraryElement library = element;
-      library.implementation.forEachLocalMember((Element member) {
-        if (member.isField) visitField(library, member);
-      });
-    } else if (visitStatics) {
-      ClassElement cls = element;
-      cls.implementation.forEachStaticField(visitField);
-    } else {
-      ClassElement cls = element;
-      // TODO(kasperl): We should make sure to only emit one version of
-      // overridden fields. Right now, we rely on the ordering so the
-      // fields pulled in from mixins are replaced with the fields from
-      // the class definition.
-
-      // If a class is not instantiated then we add the field just so we can
-      // generate the field getter/setter dynamically. Since this is only
-      // allowed on fields that are in [element] we don't need to visit
-      // superclasses for non-instantiated classes.
-      cls.implementation.forEachInstanceField(
-          visitField, includeSuperAndInjectedMembers: isInstantiated);
-    }
-  }
-
   void recordMangledField(Element member,
                           jsAst.Name accessorName,
                           String memberName) {
     if (!backend.shouldRetainGetter(member)) return;
     String previousName;
     if (member.isInstanceMember) {
       previousName = emitter.mangledFieldNames.putIfAbsent(
           namer.deriveGetterName(accessorName),
           () => memberName);
     } else {
       previousName = emitter.mangledGlobalFieldNames.putIfAbsent(
           accessorName,
           () => memberName);
     }
     assert(invariant(member, previousName == memberName,
                      message: '$previousName != ${memberName}'));
   }
 
-  bool fieldNeedsGetter(VariableElement field) {
-    assert(field.isField);
-    if (fieldAccessNeverThrows(field)) return false;
-    if (backend.shouldRetainGetter(field)) return true;
-    return field.isClassMember &&
-           compiler.codegenWorld.hasInvokedGetter(field, compiler.world);
-  }
-
-  bool fieldNeedsSetter(VariableElement field) {
-    assert(field.isField);
-    if (fieldAccessNeverThrows(field)) return false;
-    if (field.isFinal || field.isConst) return false;
-    if (backend.shouldRetainSetter(field)) return true;
-    return field.isClassMember &&
-           compiler.codegenWorld.hasInvokedSetter(field, compiler.world);
-  }
-
-  static bool fieldAccessNeverThrows(VariableElement 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(VariableElement member) {
-    // We never generate accessors for top-level/static fields.
-    if (!member.isInstanceMember) return true;
-    DartType type = member.type;
-    return type.treatAsDynamic || (type.element == compiler.objectClass);
-  }
-
   void generateCheckedSetter(Element member,
                              jsAst.Name fieldName,
                              jsAst.Name accessorName,
                              ClassBuilder builder) {
     jsAst.Expression code = backend.generatedCode[member];
     assert(code != null);
     jsAst.Name setterName = namer.deriveSetterName(accessorName);
     compiler.dumpInfoTask.registerElementAst(member,
         builder.addProperty(setterName, code));
     generateReflectionDataForFieldGetterOrSetter(
@@ skipping 48 matching lines @@
         ? new Selector.getter(member.name, member.library)
         : new Selector.setter(member.name, member.library);
     String reflectionName = emitter.getReflectionName(selector, name);
     if (reflectionName != null) {
       var reflectable =
           js(backend.isAccessibleByReflection(member) ? '1' : '0');
       builder.addPropertyByName('+$reflectionName', reflectable);
     }
   }
 }