Remove cancel and make crash exit with code 253.

sdk/lib/_internal/compiler/implementation/library_loader.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;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
@@ skipping 279 matching lines @@
           if (import.uri.dartString.slowToString() == 'dart:core') {
             importsDartCore = true;
           }
           libraryDependencies.addLast(import);
         } else if (tag.isExport) {
           tagState = checkTag(TagState.IMPORT_OR_EXPORT, tag);
           libraryDependencies.addLast(tag);
         } else if (tag.isLibraryName) {
           tagState = checkTag(TagState.LIBRARY, tag);
           if (library.libraryTag != null) {
-            compiler.cancel("duplicated library declaration", node: tag);
+            compiler.internalError(tag, "Duplicated library declaration.");
           } else {
             library.libraryTag = tag;
           }
         } else if (tag.isPart) {
           Part part = tag;
           StringNode uri = part.uri;
           Uri resolvedUri = base.resolve(uri.dartString.slowToString());
           tagState = checkTag(TagState.SOURCE, part);
           return scanPart(part, resolvedUri, library);
         } else {
-          compiler.internalError("Unhandled library tag.", node: tag);
+          compiler.internalError(tag, "Unhandled library tag.");
         }
       });
     }).then((_) {
       return compiler.withCurrentElement(library, () {
         checkDuplicatedLibraryName(library);
         // Apply patch, if any.
         if (library.isPlatformLibrary) {
           return patchDartLibrary(handler, library, library.canonicalUri.path);
         }
       });
@@ skipping 84 matching lines @@
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
    */
   Future scanPart(Part part, Uri resolvedUri, LibraryElement library) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = compiler.translateResolvedUri(library, resolvedUri, part);
     if (readableUri == null) return new Future.value();
-    return compiler.readScript(readableUri, library, part).
-        then((Script sourceScript) {
-          if (sourceScript == null) return;
+    return compiler.withCurrentElement(library, () {
+      return compiler.readScript(part, readableUri).
+          then((Script sourceScript) {
+            if (sourceScript == null) return;
 
-          CompilationUnitElement unit =
-              new CompilationUnitElementX(sourceScript, library);
-          compiler.withCurrentElement(unit, () {
-            compiler.scanner.scan(unit);
-            if (unit.partTag == null) {
-              compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
-            }
+            CompilationUnitElement unit =
+                new CompilationUnitElementX(sourceScript, library);
+            compiler.withCurrentElement(unit, () {
+              compiler.scanner.scan(unit);
+              if (unit.partTag == null) {
+                compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
+              }
+            });
           });
-        });
+    });
   }
 
   /**
    * Handle an import/export tag by loading the referenced library and
    * registering its dependency in [handler] for the computation of the import/
    * export scope.
    */
   Future registerLibraryFromTag(LibraryDependencyHandler handler,
                                 LibraryElement library,
                                 LibraryDependency tag) {
@@ skipping 10 matching lines @@
 
   /**
    * Create (or reuse) a library element for the library specified by the
    * [resolvedUri].
    *
    * If a new library is created, the [handler] is notified.
    */
   // TODO(johnniwinther): Remove [canonicalUri] and make [resolvedUri] the
   // canonical uri when [Compiler.scanBuiltinLibrary] is removed.
   Future<LibraryElement> createLibrary(LibraryDependencyHandler handler,
-                               LibraryElement importingLibrary,
-                               Uri resolvedUri, Node node, Uri canonicalUri) {
+                                       LibraryElement importingLibrary,
+                                       Uri resolvedUri,
+                                       Node node,
+                                       Uri canonicalUri) {
     // TODO(johnniwinther): Create erroneous library elements for missing
     // libraries.
     Uri readableUri =
         compiler.translateResolvedUri(importingLibrary, resolvedUri, node);
     if (readableUri == null) return new Future.value();
     LibraryElement library;
     if (canonicalUri != null) {
       library = compiler.libraries[canonicalUri.toString()];
     }
     if (library != null) {
       return new Future.value(library);
     }
-    return compiler.readScript(readableUri, importingLibrary, node)
-        .then((Script script) {
-          if (script == null) return null;
-          LibraryElement element = new LibraryElementX(script, canonicalUri);
-          compiler.withCurrentElement(element, () {
-            handler.registerNewLibrary(element);
-            native.maybeEnableNative(compiler, element);
-            if (canonicalUri != null) {
-              compiler.libraries[canonicalUri.toString()] = element;
-            }
-            compiler.scanner.scanLibrary(element);
+    return compiler.withCurrentElement(importingLibrary, () {
+      return compiler.readScript(node, readableUri)
+          .then((Script script) {
+            if (script == null) return null;
+            LibraryElement element = new LibraryElementX(script, canonicalUri);
+            compiler.withCurrentElement(element, () {
+              handler.registerNewLibrary(element);
+              native.maybeEnableNative(compiler, element);
+              if (canonicalUri != null) {
+                compiler.libraries[canonicalUri.toString()] = element;
+              }
+              compiler.scanner.scanLibrary(element);
+            });
+            return processLibraryTags(handler, element).then((_) {
+              compiler.withCurrentElement(element, () {
+                handler.registerLibraryExports(element);
+                onLibraryLoadedCallbacks.add(
+                    () => compiler.onLibraryLoaded(element, resolvedUri));
+              });
+              return element;
+            });
           });
-          return processLibraryTags(handler, element).then((_) {
-            compiler.withCurrentElement(element, () {
-              handler.registerLibraryExports(element);
-              onLibraryLoadedCallbacks.add(
-                  () => compiler.onLibraryLoaded(element, resolvedUri));
-            });
-            return element;
-          });
-        });
+    });
   }
 
   // TODO(johnniwinther): Remove this method when 'js_helper' is handled by
   // [LibraryLoaderTask].
   void importLibrary(LibraryElement importingLibrary,
                      LibraryElement importedLibrary,
                      Import tag) {
     new ImportLink(tag, importedLibrary).importLibrary(compiler,
                                                        importingLibrary);
   }
@@ skipping 416 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }