Check for duplicate library names

lib/runtime/dart_runtime.js

 // Copyright (c) 2015, 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.
 
 var dart, _js_helper, _js_primitives, dartx;
 (function (dart) {
   'use strict';
 
   // TODO(vsm): This is referenced (as init.globalState) from
   // isolate_helper.dart.  Where should it go?
@@ skipping 32 matching lines @@
   dart.dload = dload;
 
   function dput(obj, field, value) {
     field = _canonicalFieldName(obj, field, [value], field);
     // TODO(vsm): Implement NSM and type checks.
     // See: https://github.com/dart-lang/dev_compiler/issues/170
     obj[field] = value;
   }
   dart.dput = dput;
 
+  function throwRuntimeError(message) {
+    throw Error(message);
+  }
+
   // TODO(jmesserly): this should call noSuchMethod, not throw.
   function throwNoSuchMethod(obj, name, args, opt_func) {
     if (obj === void 0) obj = opt_func;
     throw new core.NoSuchMethodError(obj, name, args);
   }
 
   function checkAndCall(f, ftype, obj, args, name) {
     if (!(f instanceof Function)) {
       // We're not a function (and hence not a method either)
       // Grab the `call` method if it's not a function.
@@ skipping 356 matching lines @@
 
   function equals(x, y) {
     if (x == null || y == null) return x == y;
     let eq = x['=='];
     return eq ? eq.call(x, y) : x == y;
   }
   dart.equals = equals;
 
   /** Checks that `x` is not null or undefined. */
   function notNull(x) {
-    if (x == null) throw 'expected not-null value';
+    if (x == null) throwRuntimeError('expected not-null value');
     return x;
   }
   dart.notNull = notNull;
 
   function _typeName(type) {
-    if (type === void 0) throw "Undefined type";
+    if (type === void 0) throwRuntimeError('Undefined type');
     var name = type.name;
-    if (!name) throw 'Unexpected type: ' + type;
+    if (!name) throwRuntimeError('Unexpected type: ' + type);
     return name;
   }
 
   class AbstractFunctionType {
     constructor() {
       this._stringValue = null;
     }
 
     /// Check that a function of this type can be applied to 
     /// actuals.
@@ skipping 267 matching lines @@
   // performance in other projects (e.g. webcomponents.js ShadowDOM polyfill).
   function defineLazyProperty(to, name, desc) {
     let init = desc.get;
     let writable = !!desc.set;
     function lazySetter(value) {
       defineProperty(to, name, { value: value, writable: writable });
     }
     function lazyGetter() {
       // Clear the init function to detect circular initialization.
       let f = init;
-      if (f === null) throw 'circular initialization for field ' + name;
+      if (f === null) throwRuntimeError('circular initialization for field ' + name);
       init = null;
 
       // Compute and store the value.
       let value = f();
       lazySetter(value);
       return value;
     }
     desc.get = lazyGetter;
     desc.configurable = true;
     if (writable) desc.set = lazySetter;
@@ skipping 200 matching lines @@
     } else if (typeof values === 'object') {
       for (let key of getOwnPropertyNames(values)) {
         map.set(key, values[key]);
       }
     }
     return map;
   }
   dart.map = map;
 
   function assert(condition) {
-    // TODO(jmesserly): throw assertion error.
-    if (!condition) throw 'assertion failed';
+    if (!condition) throw new core.AssertionError();
   }
   dart.assert = assert;
 
   function throw_(obj) { throw obj; }
   dart.throw_ = throw_;
 
   /**
    * Given a class and an initializer method name, creates a constructor
    * function with the same name. For example `new SomeClass.name(args)`.
    */
@@ skipping 13 matching lines @@
   }
   dart.stackTrace = stackTrace;
 
   /** The Symbol for storing type arguments on a specialized generic type. */
   dart.typeArguments = Symbol('typeArguments');
   dart.originalDeclaration = Symbol('originalDeclaration');
 
   /** Memoize a generic type constructor function. */
   function generic(typeConstructor) {
     let length = typeConstructor.length;
-    if (length < 1) throw Error('must have at least one generic type argument');
+    if (length < 1) throwRuntimeError('must have at least one generic type argument');
 
     let resultMap = new Map();
     function makeGenericType(/*...arguments*/) {
       if (arguments.length != length && arguments.length != 0) {
-        throw Error('requires ' + length + ' or 0 type arguments');
+        throwRuntimeError('requires ' + length + ' or 0 type arguments');
       }
       let args = slice.call(arguments);
       // TODO(leafp): This should really be core.Object for
       // consistency, but Object is not attached to core
       // until the entire core library has been processed,
       // which is too late.
       while (args.length < length) args.push(dart.dynamic);
 
       let value = resultMap;
       for (let i = 0; i < length; i++) {
         let arg = args[i];
         if (arg == null) {
-          throw Error('type arguments should not be null: ' + typeConstructor);
+          throwRuntimeError('type arguments should not be null: ' + typeConstructor);
         }
         let map = value;
         value = map.get(arg);
         if (value === void 0) {
           if (i + 1 == length) {
             value = typeConstructor.apply(null, args);
             // Save the type constructor and arguments for reflection.
             if (value) {
               value[dart.typeArguments] = args;
               value[dart.originalDeclaration] = makeGenericType;
@@ skipping 262 matching lines @@
 
   // TODO(jmesserly): right now this is a sentinel. It should be a type object
   // of some sort, assuming we keep around `dynamic` at runtime.
   dart.dynamic = { toString() { return 'dynamic'; }, get name() {return toString();}};
   dart.void = { toString() { return 'void'; }, get name() {return toString();}};
   dart.bottom = { toString() { return 'bottom'; }, get name() {return toString();}};
 
   dart.global = window || global;
   dart.JsSymbol = Symbol;
 
-  function import_(value) {
+  // All libraries, including those that have referenced (lazyImport),
+  // but not yet loaded.
+  var libraries = new Map();
+
+  // Completed libraries.
+  var loadedLibraries = new Set();
+
+  // Import a library by name.
+  // This is exported for REPL / JS interop convenience.
+  function import_(name) {
+    let loaded = loadedLibraries.has(name);
+    let value = libraries[name];
     // TODO(vsm): Change this to a hard throw.
     // For now, we're missing some libraries.  E.g., dart:js:
     // https://github.com/dart-lang/dev_compiler/issues/168
-    if (!value) {
-      console.log('missing required module');
+    if (!loaded) {
+      console.warn('Missing required module: ' + name);
+    } else if (!value) {
+      throwRuntimeError('Library import error: ' + name)
     }
     return value;
   }
   dart.import = import_;
-  
-  function lazyImport(value) {
-    return defineLibrary(value, {});
+
+  function initializeLibraryStub(name) {
+    // Create the library object if necessary.
+    if (!libraries[name]) {
+      libraries[name] = {};
+    }
+    return libraries[name];
   }
-  dart.lazyImport = lazyImport;
+  const lazyImport = initializeLibraryStub;
 
-  function defineLibrary(value, defaultValue) {
-    return value ? value : defaultValue;
+  function defineLibrary(name, defaultValue) {
+    if (loadedLibraries.has(name)) {
+      throwRuntimeError('Library is already defined: ' + name);
+    }
+    var value;
+    if (defaultValue) {
+      var oldValue = libraries[name];
+      if (oldValue && oldValue != defaultValue) {
+        throwRuntimeError(
+          `Library ${name} cannot be redefined to ${defaultValue}`);
+      }
+      libraries[name] = value = defaultValue;
+    } else {
+      value = initializeLibraryStub(name);
+    }
+    loadedLibraries.add(name);
+    return value;
   }
-  dart.defineLibrary = defineLibrary;
 
-  // TODO(jmesserly): hack to bootstrap the SDK
-  _js_helper = _js_helper || {};
+  function library(name, defaultValue, imports, lazyImports, module) {
+    var args = [];
+    var lib = defineLibrary(name, defaultValue);
+    args.push(lib);
+    for (var i = 0; i < imports.length; ++i) {
+      lib = import_(imports[i]);
+      args.push(lib);
+    }
+    for (var i = 0; i < lazyImports.length; ++i) {
+      lib = lazyImport(lazyImports[i]);
+      args.push(lib);
+    }
+    module.apply(null, args);
+  }
+  dart.library = library;
+
+  function start(libraryName) {
+    let lib = import_(libraryName);
+    _isolate_helper.startRootIsolate(lib.main, []);
+  }
+  dart.start = start;
+
+  let core = lazyImport('dart/core');
+  let collection = lazyImport('dart/collection');
+  let async = lazyImport('dart/async');
+  let _interceptors = lazyImport('dart/_interceptors');
+  let _isolate_helper = lazyImport('dart/_isolate_helper');
+  let _js_helper = lazyImport('dart/_js_helper');
   _js_helper.checkNum = notNull;
-
-  _js_primitives = _js_primitives || {};
+  let _js_primitives = lazyImport('dart/_js_primitives');
   _js_primitives.printString = (s) => console.log(s);
 
   // TODO(vsm): DOM facades?
   // See: https://github.com/dart-lang/dev_compiler/issues/173
   NodeList.prototype.get = function(i) { return this[i]; };
   NamedNodeMap.prototype.get = function(i) { return this[i]; };
   DOMTokenList.prototype.get = function(i) { return this[i]; };
 
   /** Dart extension members. */
   dartx = dartx || {};
 
 })(dart || (dart = {}));