Refactor Library/CompilationUnit and how we define local Scope.

lib/compiler/implementation/scanner/scanner_task.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.
 
 class ScannerTask extends CompilerTask {
   ScannerTask(Compiler compiler) : super(compiler);
   String get name() => 'Scanner';
 
+  void scanLibrary(LibraryElement library) {
+    var compilationUnit = library.entryCompilationUnit;
+    compiler.log("scanning library ${compilationUnit.script.name}");
+    scan(compilationUnit);
+    processScriptTags(library);
+  }
+
   void scan(CompilationUnitElement compilationUnit) {
     measure(() {
-      if (compilationUnit.kind === ElementKind.LIBRARY) {
-        compiler.log("scanning library ${compilationUnit.script.name}");
-      }
       scanElements(compilationUnit);
-      if (compilationUnit.kind === ElementKind.LIBRARY) {
-        processScriptTags(compilationUnit);
-      }
     });
   }
 
   void processScriptTags(LibraryElement library) {
     int tagState = TagState.NO_TAG_SEEN;
 
     /**
      * If [value] is less than [tagState] complain and return
      * [tagState]. Otherwise return the new value for [tagState]
      * (transition function for state machine).
      */
     int checkTag(int value, ScriptTag tag) {
       if (tagState > value) {
         compiler.reportError(tag, 'out of order');
         return tagState;
       }
       return TagState.NEXT[value];
     }
 
     LinkBuilder<ScriptTag> imports = new LinkBuilder<ScriptTag>();
-    Uri base = library.script.uri;
+    Uri base = library.uri;
     for (ScriptTag tag in library.tags.reverse()) {
       StringNode argument = tag.argument;
       // TODO(lrn): Support interpolations here. We need access to the
       // special constants that can be inserted into script tag strings.
       Uri resolved = base.resolve(argument.dartString.slowToString());
       if (tag.isImport()) {
         tagState = checkTag(TagState.IMPORT, tag);
         // It is not safe to import other libraries at this point as
         // another library could then observe the current library
         // before it fully declares all the members that are sourced
@@ skipping 66 matching lines @@
     LibraryElement library =
       compiler.libraries.putIfAbsent(uri.toString(), () {
           newLibrary = true;
           Script script = compiler.readScript(uri, node);
           LibraryElement element = new LibraryElement(script);
           native.maybeEnableNative(compiler, element, uri);
           return element;
         });
     if (newLibrary) {
       compiler.withCurrentElement(library, () {
-        scan(library);
+        scanLibrary(library);
         compiler.onLibraryLoaded(library, uri);
       });
     }
     return library;
   }
 
   void importLibrary(LibraryElement library, LibraryElement imported,
-                     ScriptTag tag, [CompilationUnitElement patch]) {
+                     ScriptTag tag,
+                     [CompilationUnitElement patchCompilationUnit]) {
     if (!imported.hasLibraryName()) {
       compiler.withCurrentElement(library, () {
         compiler.reportError(tag === null ? null : tag.argument,
-                             'no #library tag found in ${imported.script.uri}');
+                             'no #library tag found in ${imported.uri}');
       });
     }
     if (tag !== null && tag.prefix !== null) {
       SourceString prefix =
           new SourceString(tag.prefix.dartString.slowToString());
       Element e = library.find(prefix);
       if (e === null) {
-        e = new PrefixElement(prefix, library, tag.getBeginToken(), patch);
-        library.define(e, compiler);
+        e = new PrefixElement(prefix, library, tag.getBeginToken(),
+                              patchCompilationUnit);
+        library.addToScope(e, compiler);
       }
       if (e.kind !== ElementKind.PREFIX) {
         compiler.withCurrentElement(e, () {
           compiler.reportWarning(new Identifier(e.position()),
                                  'duplicated definition');
         });
         compiler.reportError(tag.prefix, 'duplicate defintion');
       }
       PrefixElement prefixElement = e;
       imported.forEachExport((Element element) {
         Element existing =
             prefixElement.imported.putIfAbsent(element.name, () => element);
         if (existing !== element) {
           compiler.withCurrentElement(existing, () {
             compiler.reportWarning(new Identifier(existing.position()),
                                    'duplicated import');
           });
           compiler.withCurrentElement(element, () {
             compiler.reportError(new Identifier(element.position()),
                                  'duplicated import');
           });
         }
       });
     } else {
       imported.forEachExport((Element element) {
         compiler.withCurrentElement(element, () {
-          library.define(element, compiler);
+          library.addToScope(element, compiler);
         });
       });
     }
   }
 }
 
 class DietParserTask extends CompilerTask {
   DietParserTask(Compiler compiler) : super(compiler);
   final String name = 'Diet Parser';
 
@@ skipping 20 matching lines @@
   static final int RESOURCE = 4;
 
   /** Next state. */
   static final List<int> NEXT =
       const <int>[NO_TAG_SEEN,
                   IMPORT, // Only one library tag is allowed.
                   IMPORT,
                   SOURCE,
                   RESOURCE];
 }