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;
 (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);
     // 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) {
+    console.error(message);

[Jennifer Messerly, 2015/06/05 16:22:27]

what's the benefit of logging and throwing? Don't they both appear at the
console?

[vsm, 2015/06/05 17:01:04]

removed

+    throw new _js_helper.RuntimeError(message);

[Jennifer Messerly, 2015/06/05 16:22:27]

what happens if this isn't loaded? don't we have bootstrapping issues?
it seems better to just throw a JS Error. I suspect this will all be replaced
with a general module loader pattern/polyfill at some point, so it won't even be
Dart specific.

[vsm, 2015/06/05 17:01:04]

Done.

+  }
+
   // 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 361 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 158 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 = Array.prototype.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 250 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) {
+  var loadedLibraries = {};

[Jennifer Messerly, 2015/06/05 16:22:27]

How will this work with JS interop? It seems we are assuming closed world here,
in other words, that all modules come from Dart. I was hoping we could integrate
more naturally at runtime with the JS code that's been loaded

[vsm, 2015/06/05 17:01:04]

Not really assuming a closed world.  For JS code, we can either:
(1) Always use lazyImport - we never require a lib to be in loadedLibraries to
run code
(2) Provide a different import / register API
(3) Make import a little more forgiving - though it *is* catching real errors
right now

+
+  function import_(name) {
+    let value = loadedLibraries[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');
+      console.warn('Missing required module: ' + name);
+    } else if (value != dart.global[name]) {
+      throwRuntimeError('Library name mismatch: ' + name)
     }
     return value;
   }
   dart.import = import_;
+
+  function initializeLibraryStub(name) {
+    // Create the library object if necessary.
+    if (!dart.global[name]) {
+      dart.global[name] = {};
+    }
+    return dart.global[name];
+  }
   
-  function lazyImport(value) {
-    return defineLibrary(value, {});
+  function lazyImport(name) {
+    return initializeLibraryStub(name);
   }
   dart.lazyImport = lazyImport;
 
-  function defineLibrary(value, defaultValue) {
-    return value ? value : defaultValue;
+  function defineLibrary(name, defaultValue) {
+    if (loadedLibraries[name]) {
+      throwRuntimeError('Library is already defined: ' + name);
+    }
+    var value;
+    if (defaultValue) {
+      var oldValue = dart.global[name];
+      if (oldValue && oldValue != defaultValue) {
+        throwRuntimeError('Library ' + name + ' cannot be redefined to ' + defaultValue);

[Jennifer Messerly, 2015/06/05 16:22:27]

long line.
also could use interpolation:

`Library ${name} cannot be ...`

[vsm, 2015/06/05 17:01:04]

Done.

+      }
+      dart.global[name] = value = defaultValue;
+    } else {
+      value = initializeLibraryStub(name);
+    }
+    loadedLibraries[name] = value;
+    return value;
   }
   dart.defineLibrary = defineLibrary;
 
   // TODO(jmesserly): hack to bootstrap the SDK
   _js_helper = _js_helper || {};
   _js_helper.checkNum = notNull;
 
   _js_primitives = _js_primitives || {};
   _js_primitives.printString = (s) => console.log(s);
 
@@ skipping 31 matching lines @@
   Number.prototype['>'] = function(arg) { return this.valueOf() > arg; };
   Number.prototype['+'] = function(arg) { return this.valueOf() + arg; };
 
   // 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 || (dart = {}));