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 117 matching lines @@
 
   // 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) {}
 }
 
 /**
  * Key class used in [TokenMap] in which the hash code for a token is based
  * on the [charOffset].
  */
 class TokenKey {
   final Token token;
   TokenKey(this.token);
   int get hashCode => token.charOffset;
@@ skipping 34 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 439 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);
     processQueue(enqueuer.resolution, main);
     enqueuer.resolution.logSummary(log);
 
     if (compilationFailed) return;
     if (analyzeOnly) return;
     assert(main != null);
 
     // 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');
   }
 }