Added support for exports and re-exports.

lib/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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 const bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 143 matching lines @@
     } finally {
       _currentElement = old;
     }
   }
 
   List<CompilerTask> tasks;
   ScannerTask scanner;
   DietParserTask dietParser;
   ParserTask parser;
   PatchParserTask patchParser;
+  LibraryLoader libraryLoader;
   TreeValidatorTask validator;
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   ti.TypesTask typesTask;
   Backend backend;
   ConstantHandler constantHandler;
   EnqueueTask enqueuer;
 
   static const SourceString MAIN = const SourceString('main');
@@ skipping 24 matching lines @@
             bool generateSourceMap = true,
             List<String> strips = const []])
       : libraries = new Map<String, LibraryElement>(),
         progress = new Stopwatch() {
     progress.start();
     world = new World(this);
     scanner = new ScannerTask(this);
     dietParser = new DietParserTask(this);
     parser = new ParserTask(this);
     patchParser = new PatchParserTask(this);
+    libraryLoader = new LibraryLoaderTask(this);
     validator = new TreeValidatorTask(this);
     resolver = new ResolverTask(this);
     closureToClassMapper = new closureMapping.ClosureTask(this);
     checker = new TypeCheckerTask(this);
     typesTask = new ti.TypesTask(this);
     backend = emitJavaScript ?
         new js_backend.JavaScriptBackend(this, generateSourceMap) :
         new dart_backend.DartBackend(this, strips);
     constantHandler = new ConstantHandler(this, backend.constantSystem);
     enqueuer = new EnqueueTask(this);
@@ skipping 163 matching lines @@
     addForeignFunctions(interceptorsLibrary);
 
     assertMethod = jsHelperLibrary.find(const SourceString('assert'));
     identicalFunction = coreLibrary.find(const SourceString('identical'));
 
     initializeSpecialClasses();
   }
 
   void loadCoreImplLibrary() {
     Uri coreImplUri = new Uri.fromComponents(scheme: 'dart', path: 'coreimpl');
-    coreImplLibrary = scanner.loadLibrary(coreImplUri, null, coreImplUri);
+    coreImplLibrary = libraryLoader.loadLibrary(coreImplUri, null, coreImplUri);
   }
 
   void importHelperLibrary(LibraryElement library) {
     if (jsHelperLibrary !== null) {
-      scanner.importLibrary(library, jsHelperLibrary, null);
+      LibraryLoader.importLibrary(this, library, jsHelperLibrary, null);

[Lasse Reichstein Nielsen, 2012/10/10 08:07:33]

capital 'L'?

[Johnni Winther, 2012/10/10 09:20:59]

Done.

     }
   }
 
-  void importCoreLibrary(LibraryElement library) {
-    if (coreLibrary === null) {
-      Uri coreUri = new Uri.fromComponents(scheme: 'dart', path: 'core');
-      coreLibrary = scanner.loadLibrary(coreUri, null, coreUri);
-    }
-    scanner.importLibrary(library,
-                          coreLibrary,
-                          null,
-                          library.entryCompilationUnit);
-  }
-
-  void patchDartLibrary(LibraryElement library, String dartLibraryPath) {
-    if (library.isPatched) return;
-    Uri patchUri = resolvePatchUri(dartLibraryPath);
-    if (patchUri !== null) {
-      patchParser.patchLibrary(patchUri, library);
-    }
-  }
-
   /**
    * Get an [Uri] pointing to a patch for the dart: library with
    * the given path. Returns null if there is no patch.
    */
   abstract Uri resolvePatchUri(String dartLibraryPath);
 
   /** Define the JS helper functions in the given library. */
   void addForeignFunctions(LibraryElement library) {
     library.addToScope(new ForeignElement(
         const SourceString('JS'), library), this);
@@ skipping 23 matching lines @@
           findHelper(const SourceString('JavaScriptIndexingBehavior'));
       if (jsIndexingBehaviorInterface !== null) {
         library.addToScope(jsIndexingBehaviorInterface, this);
       }
     }
   }
 
   void runCompiler(Uri uri) {
     log('compiling $uri ($BUILD_ID)');
     scanBuiltinLibraries();
-    mainApp = scanner.loadLibrary(uri, null, uri);
+    mainApp = libraryLoader.loadLibrary(uri, null, uri);
     libraries.forEach((_, library) {
       maybeEnableJSHelper(library);
     });
     final Element main = mainApp.find(MAIN);
     if (main === null) {
       reportFatalError('Could not find $MAIN', mainApp);
     } else {
       if (!main.isFunction()) reportFatalError('main is not a function', main);
       FunctionElement mainMethod = main;
       FunctionSignature parameters = mainMethod.computeSignature(this);
@@ skipping 369 matching lines @@
  * be either a [:bool:] or a no-arg function returning a [:bool:].
  *
  * Use this method to provide better information for assertion by calling
  * [invariant] as the argument to an [:assert:] statement:
  *
  *     assert(invariant(position, isValid));
  *
  * [spannable] must be non-null and will be used to provide positional
  * information in the generated error message.
  */
 bool invariant(Spannable spannable, var condition, {String message: null}) {

[Lasse Reichstein Nielsen, 2012/10/10 08:07:33]

"Spannable" is a bad name. It's something that is able to "span", which is
technically a verb, but you don't really mean that here. It suggests that you
can ask the object to "span". I assume it's something that can *provide* a Span
if you ask it. That perhaps makes it "Spanned". Or try finding a better name.

[Johnni Winther, 2012/10/10 09:20:59]

Added a TODO.

   // TODO(johnniwinther): Use [spannable] and [message] to provide better
   // information on assertion errors.
   if (condition is Function){
     condition = condition();
   }
+  if (!condition) {
+    print('assertion failed: $message');
+  }
   return spannable != null && condition;
 }