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

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 '../js_emitter.dart' show computeMixinClass, Emitter;
 import '../model.dart';
 
 import '../../common.dart';
+import '../../closure.dart' show ClosureFieldElement;
 import '../../js/js.dart' as js;
 
 import '../../js_backend/js_backend.dart' show
     Namer,
     JavaScriptBackend,
     JavaScriptConstantCompiler;
 
 import '../js_emitter.dart' show
     ClassStubGenerator,
     CodeEmitterTask,
     InterceptorStubGenerator,
     MainCallStubGenerator,
     ParameterStubGenerator,
     RuntimeTypeGenerator,
     TypeTestProperties;
 
-import '../../elements/elements.dart' show ParameterElement, MethodElement;
+import '../../elements/elements.dart' show
+    FieldElement,
+    ParameterElement,
+    MethodElement;
 
 import '../../universe/universe.dart' show Universe, TypeMaskSet;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 
 part 'collector.dart';
 part 'registry.dart';
+part 'field_visitor.dart';
 
 /// Builds a self-contained representation of the program that can then be
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
   final Compiler _compiler;
   final Namer namer;
   final CodeEmitterTask _task;
 
   /// Contains the collected information the program builder used to build
   /// the model.
   // The collector will be filled on the first call to `buildProgram`.
-  // It is stored and publicly exposed for backwards compatibility.
+  // It is stored and publicly exposed for backwards compatibility. New code
+  // (and in particular new emitters) should not use it.
   final Collector collector;
 
   final Registry _registry;
 
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
   ProgramBuilder(Compiler compiler,
                  Namer namer,
                  this._task,
                  Emitter emitter,
-                 Emitter oldEmitter,
                  Set<ClassElement> rtiNeededClasses)
       : this._compiler = compiler,
         this.namer = namer,
-        this.collector = new Collector(
-            compiler, namer, rtiNeededClasses, emitter, oldEmitter),
+        this.collector =
+            new Collector(compiler, namer, rtiNeededClasses, emitter),
         this._registry = new Registry(compiler);
 
   JavaScriptBackend get backend => _compiler.backend;
   Universe get universe => _compiler.codegenWorld;
 
   /// Mapping from [ClassElement] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
@@ skipping 581 matching lines @@
     List<js.Name> names = specializedGetInterceptors.keys.toList()..sort();
     return names.map((js.Name name) {
       Set<ClassElement> classes = specializedGetInterceptors[name];
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   List<Field> _buildFields(Element holder, bool visitStatics) {
     List<Field> fields = <Field>[];
-    _task.oldEmitter.classEmitter.visitFields(
+    new FieldVisitor(_compiler, namer).visitFields(
         holder, visitStatics, (VariableElement field,
                                js.Name name,
                                js.Name accessorName,
                                bool needsGetter,
                                bool needsSetter,
                                bool needsCheckedSetter) {
       assert(invariant(field, field.isDeclaration));
 
       int getterFlags = 0;
       if (needsGetter) {
@@ skipping 110 matching lines @@
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
       js.Name name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 }