Revert "Refactor Library/CompilationUnit and how we define local Scope."

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.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 273 matching lines @@
 
   void onLibraryLoaded(LibraryElement library, Uri uri) {
     if (uri.toString() == 'dart:isolate') {
       enableIsolateSupport(library);
     }
     if (dynamicClass !== null) {
       // When loading the built-in libraries, dynamicClass is null. We
       // take advantage of this as core and coreimpl import js_helper
       // and see Dynamic this way.
       withCurrentElement(dynamicClass, () {
-        library.addToScope(dynamicClass, this);
+        library.define(dynamicClass, this);
       });
     }
   }
 
   abstract LibraryElement scanBuiltinLibrary(String filename);
 
   void initializeSpecialClasses() {
     bool coreLibValid = true;
     ClassElement lookupSpecialClass(SourceString name) {
       ClassElement result = coreLibrary.find(name);
@@ skipping 58 matching lines @@
     if (patchUri !== null) {
       LibraryElement patchLibrary =
           patchParser.loadPatchLibrary(patchUri);
       // We allow foreign functions in patched libraries.
       addForeignFunctions(library);  // Is safe even if already added.
       applyLibraryPatch(library, patchLibrary);
     }
   }
 
   void applyLibraryPatch(LibraryElement original, LibraryElement patch) {
-    Link<Element> patches = patch.localMembers;
-    applyContainerPatch(original, patches);
+    Link<Element> patches = patch.topLevelElements;
+    applyContainerPatch(original, patches, original.findLocal);
 
     // Copy imports from patch to original library.
     Map<String, LibraryElement> delayedPatches = <LibraryElement>{};
-    Uri patchBase = patch.uri;
+    Uri patchBase = patch.script.uri;
     for (ScriptTag tag in patch.tags.reverse()) {
       if (tag.isImport()) {
         StringNode argument = tag.argument;
         Uri resolved = patchBase.resolve(argument.dartString.slowToString());
         LibraryElement importedLibrary =
             scanner.loadLibrary(resolved, argument);
-        scanner.importLibrary(original, importedLibrary, tag,
-                              patch.entryCompilationUnit);
+        scanner.importLibrary(original, importedLibrary, tag, patch);
         if (resolved.scheme == "dart") {
           delayedPatches[resolved.path] = importedLibrary;
         }
       }
     }
 
     // Mark library as already patched.
     original.patch = patch;
 
     // We patch imported libraries after marking the current library as
     // patched, to avoid problems with cyclic dependencies.
     delayedPatches.forEach((String path, LibraryElement importedLibrary) {
       patchDartLibrary(importedLibrary, path);
     });
   }
 
-  void applyContainerPatch(ScopeContainerElement original,
-                           Link<Element> patches) {
+  void applyContainerPatch(ContainerElement original, Link<Element> patches,
+                           Element lookup(SourceString name)) {
     while (!patches.isEmpty()) {
       Element patchElement = patches.head;
-      Element originalElement = original.localLookup(patchElement.name);
+      Element originalElement = lookup(patchElement.name);
       if (patchElement.isAccessor()) {
         // Skip accessors. An accessor always has an abstract field,
         // representing the accessor in the lookup scope. We can thus skip the
         // accessors and just handle the abstract field.
       } else if (patchElement.kind === ElementKind.ABSTRACT_FIELD) {
         // Getters and setters are kept inside a synthetic field.
         if (originalElement !== null &&
             originalElement.kind !== ElementKind.ABSTRACT_FIELD) {
           internalError("Cannot patch non-getter/setter with getter/setter",
                         element: originalElement);
         }
         AbstractFieldElement patchField = patchElement;
         AbstractFieldElement originalField = originalElement;
         if (patchField.getter !== null) {
           if (originalField === null || originalField.getter === null) {
             original.addGetterOrSetter(clonePatch(patchField.getter),
                                        originalField,
                                        this);
             if (originalField === null && patchField.setter !== null) {
               // It exists now, so find it for the setter patching.
-              originalField = original.localLookup(patchElement.name);
+              originalField = lookup(patchElement.name);
             }
           } else {
             patchMember(originalField.getter, patchField.getter);
           }
         }
         if (patchField.setter !== null) {
           if (originalField === null || originalField.setter === null) {
             original.addGetterOrSetter(clonePatch(patchField.setter),
                                        originalField,
                                        this);
@@ skipping 90 matching lines @@
   }
 
   void applyClassPatch(PartialClassElement original,
                        PartialClassElement patch) {
     // Eagerly parse the class so we can patch it.
     // TODO(lrn): Perhaps find a way to delay parsing until the class is needed,
     // i.e., until [parseNode] is called on [original].
     ClassNode node = original.parseNode(this);
     // Parse patch class with "patch" parser.
     ClassNode patchNode = patchParser.parsePatchClassNode(patch);
-    Link<Element> patches = patch.localMembers;
-    applyContainerPatch(original, patches);
+    Link<Element> patches = patch.members;
+    Element lookupMemberOrConstructor(SourceString name) {
+      Element result = original.lookupLocalMember(name);
+      if (result !== null) return result;
+      return original.lookupConstructor(name);
+    }
+    applyContainerPatch(original, patches, lookupMemberOrConstructor);
   }
 
   /**
    * 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(
+    library.define(new ForeignElement(
         const SourceString('JS'), library), this);
-    library.addToScope(new ForeignElement(
+    library.define(new ForeignElement(
         const SourceString('UNINTERCEPTED'), library), this);
-    library.addToScope(new ForeignElement(
+    library.define(new ForeignElement(
         const SourceString('JS_HAS_EQUALS'), library), this);
-    library.addToScope(new ForeignElement(
+    library.define(new ForeignElement(
         const SourceString('JS_CURRENT_ISOLATE'), library), this);
-    library.addToScope(new ForeignElement(
+    library.define(new ForeignElement(
         const SourceString('JS_CALL_IN_ISOLATE'), library), this);
-    library.addToScope(new ForeignElement(
+    library.define(new ForeignElement(
         const SourceString('DART_CLOSURE_TO_JS'), library), this);
   }
 
   void runCompiler(Uri uri) {
     scanBuiltinLibraries();
     mainApp = scanner.loadLibrary(uri, null);
     final Element main = mainApp.find(MAIN);
     if (main === null) {
       reportFatalError('Could not find $MAIN', mainApp);
     } else {
@@ skipping 370 matching lines @@
     final endOffset = end.charOffset + end.slowCharCount;
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }