Record dependency information to implement first version of dependency

dart/sdk/lib/_internal/compiler/implementation/compiler.dart

 // Copyright (c) 2012, 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;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 93 matching lines @@
     lib.forEachExport((Element e) {
       if (e.isFunction()) world.addToWorkList(e);
     });
   }
 
   // TODO(karlklose): get rid of this and add a factory constructor to [List]
   // that creates an instance of JSArray to make the dependency visible in from
   // the source code.
   void addBackendRtiDependencies(World world);
 
-  void enqueueHelpers(ResolutionEnqueuer world);
+  void enqueueHelpers(ResolutionEnqueuer world, TreeElements elements);
   void codegen(CodegenWorkItem work);
 
   // The backend determines the native resolution enqueuer, with a no-op
   // default, so tools like dart2dart can ignore the native classes.
   native.NativeEnqueuer nativeResolutionEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
   native.NativeEnqueuer nativeCodegenEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
 
   void assembleProgram();
   List<CompilerTask> get tasks;
 
   // TODO(ahe,karlklose): rename this?
   void dumpInferredTypes() {}
 
   ItemCompilationContext createItemCompilationContext() {
     return new ItemCompilationContext();
   }
 
   // The following methods are hooks for the backend to register its
   // helper methods.
-  void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {}
-  void registerStringInterpolation() {}
-  void registerCatchStatement() {}
-  void registerThrow() {}
-  void registerLazyField() {}
-  void registerTypeLiteral() {}
-  void registerStackTraceInCatch() {}
-  void registerIsCheck(DartType type, Enqueuer enqueuer) {}
-  void registerAsCheck(DartType type) {}
-  void registerThrowNoSuchMethod() {}
-  void registerThrowRuntimeError() {}
-  void registerAbstractClassInstantiation() {}
-  void registerFallThroughError() {}
-  void registerSuperNoSuchMethod() {}
-  void registerConstantMap() {}
-  void registerRuntimeType() {}
+  void registerInstantiatedClass(ClassElement cls,
+                                 Enqueuer enqueuer,
+                                 TreeElements elements) {}
+  void registerStringInterpolation(TreeElements elements) {}
+  void registerCatchStatement(TreeElements elements) {}
+  void registerThrow(TreeElements elements) {}
+  void registerLazyField(TreeElements elements) {}
+  void registerTypeLiteral(TreeElements elements) {}
+  void registerStackTraceInCatch(TreeElements elements) {}
+  void registerIsCheck(DartType type,
+                       Enqueuer enqueuer,
+                       TreeElements elements) {}
+  void registerAsCheck(DartType type, TreeElements elements) {}
+  void registerThrowNoSuchMethod(TreeElements elements) {}
+  void registerThrowRuntimeError(TreeElements elements) {}
+  void registerAbstractClassInstantiation(TreeElements elements) {}
+  void registerFallThroughError(TreeElements elements) {}
+  void registerSuperNoSuchMethod(TreeElements elements) {}
+  void registerConstantMap(TreeElements elements) {}
+  void registerRuntimeType(TreeElements elements) {}
 
   bool isNullImplementation(ClassElement cls) {
     return cls == compiler.nullClass;
   }
   ClassElement get intImplementation => compiler.intClass;
   ClassElement get doubleImplementation => compiler.doubleClass;
   ClassElement get numImplementation => compiler.numClass;
   ClassElement get stringImplementation => compiler.stringClass;
   ClassElement get listImplementation => compiler.listClass;
   ClassElement get growableListImplementation => compiler.listClass;
@@ skipping 52 matching lines @@
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Types types;
 
   /**
    * Map from token to the first preceeding comment token.
    */
   final TokenMap commentMap = new TokenMap();
 
+  /**
+   * Records global dependencies, that is, dependencies that don't
+   * correspond to a particular element.
+   *
+   * We should get rid of this and ensure that all dependencies are
+   * associated with a particular element.
+   */
+  final TreeElements globalDependencies = new TreeElementMapping(null);
+
   final bool enableMinification;
   final bool enableTypeAssertions;
   final bool enableUserAssertions;
   final bool enableConcreteTypeInference;
   /**
    * The maximum size of a concrete type before it widens to dynamic during
    * concrete type inference.
    */
   final int maxConcreteTypeSize;
   final bool analyzeAll;
@@ skipping 357 matching lines @@
     dynamicClass = lookupHelperClass('Dynamic_');
     nullClass = lookupHelperClass('Null');
     if (!missingHelperClasses.isEmpty) {
       internalErrorOnElement(jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
 
     types = new Types(this, dynamicClass);
     backend.initializeHelperClasses();
+
+    dynamicClass.ensureResolved(this);
   }
 
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
     Selector callConstructor = new Selector.callConstructor(
         const SourceString(""), listClass.getLibrary());
     return _unnamedListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
@@ skipping 78 matching lines @@
           reportFatalError('main is not a function', main);
         }
         FunctionElement mainMethod = main;
         FunctionSignature parameters = mainMethod.computeSignature(this);
         parameters.forEachParameter((Element parameter) {
           reportFatalError('main cannot have parameters', parameter);
         });
       }
     }
 
-    deferredLoadTask.registerMainApp(mainApp);
-
     log('Resolving...');
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
       libraries.forEach((_, lib) => fullyEnqueueLibrary(lib));
     }
-    backend.enqueueHelpers(enqueuer.resolution);
+    // Elements required by enqueueHelpers are global dependencies
+    // that are not pulled in by a particular element.
+    backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
     processQueue(enqueuer.resolution, main);
     enqueuer.resolution.logSummary(log);
 
     if (compilationFailed) return;
     if (analyzeOnly) return;
     assert(main != null);
     phase = PHASE_DONE_RESOLVING;
 
     // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
     // should know this.
     world.populate();
 
+    deferredLoadTask.onResolutionComplete(main);
+
     log('Inferring types...');
     typesTask.onResolutionComplete(main);
 
     log('Compiling...');
     phase = PHASE_COMPILING;
     // TODO(johnniwinther): Move these to [CodegenEnqueuer].
     if (hasIsolateSupport()) {
       enqueuer.codegen.addToWorkList(
           isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
     }
@@ skipping 462 matching lines @@
 
   void close() {}
 
   toString() => name;
 
   /// Convenience method for getting an [api.CompilerOutputProvider].
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }