anchor.diff:      assert(invariant(member, member.isDeclaration));
       if (isProcessed(member)) return;
       if (!member.isInstanceMember()) return;
  -    if (member.isField()) {
  -      // Fields are implicitly used by the constructor of the
  -      // instantiated class they are part of.
  -      compiler.world.registerUsedElement(member);
  -      // Native fields need to go into instanceMembersByName as they
  -      // are virtual instantiation points and escape points. Test the
  -      // enclosing class, since the metadata has not been parsed yet.
  -      if (!member.enclosingElement.isNative()) return;
  -    }
   
       String memberName = member.name.slowToString();
   
  -    if (member.kind == ElementKind.FUNCTION) {
  +    if (member.kind == ElementKind.FIELD) {
  +      // The obvious thing to test here would be "member.isNative()",
  +      // however, that only works after metadata has been parsed/analyzed,
  +      // and that may not have happened yet.
  +      // So instead we use the enclosing class, which we know have had
  +      // its metadata parsed and analyzed.
  +      // Note: this assumes that there are no non-native fields on native
  +      // classes, which may not be the case when a native class is subclassed.
  +      if (cls.isNative()) {
  +        compiler.world.registerUsedElement(member);
  +        nativeEnqueuer.handleFieldAnnotations(member);
  +        if (universe.hasInvokedGetter(member, compiler) ||
  +            universe.hasInvocation(member, compiler)) {
  +          nativeEnqueuer.registerFieldLoad(member);
  +          // In handleUnseenSelector we can't tell if the field is loaded or
  +          // stored.  We need the basic algorithm to be Church-Rosser, since the
  +          // resolution 'reduction' order is different to the codegen order. So
  +          // register that the field is also stored.  In other words: if we
  +          // don't register the store here during resolution, the store could be
  +          // registered during codegen on the handleUnseenSelector path, and
  +          // cause the set of codegen elements to include unresolved elements.
  +          nativeEnqueuer.registerFieldStore(member);
  +          return;
  +        }
  +        if (universe.hasInvokedSetter(member, compiler)) {
  +          nativeEnqueuer.registerFieldStore(member);
  +          // See comment after registerFieldLoad above.
  +          nativeEnqueuer.registerFieldLoad(member);
  +          return;
  +        }
  +        // Native fields need to go into instanceMembersByName as they
  +        // are virtual instantiation points and escape points.
  +      } else {
  +        // The codegen inlines instance fields initialization, so it
  +        // does not need to add individual fields in the work list.
  +        if (isResolutionQueue) {
  +          addToWorkList(member);
  +        }
  +        return;
  +      }
  +    } else if (member.kind == ElementKind.FUNCTION) {
         if (member.name == Compiler.NO_SUCH_METHOD) {
           enableNoSuchMethod(member);
         }
  
positive.code:             // TODO(sra): Process fields for storing separately.
              nativeEnqueuer.registerFieldStore(member);
            } else {
              nativeEnqueuer.registerFieldStore(member);
              // We have to also handle loading from the field because we only get
              // one look at each member and there might be a load we have not
  
negative.code:         cls.ensureResolved(compiler);
          cls.implementation.forEachMember(processInstantiatedClassMember);
          if (isResolutionQueue) {
            compiler.resolver.checkClass(cls);
          }
        }
  