fixes dart.throw to work for non-objects

lib/runtime/_operations.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.
 
 /* This library defines runtime operations on objects used by the code
  * generator.
  */
 dart_library.library('dart_runtime/_operations', null, /* Imports */[
 ], /* Lazy Imports */[
   'dart/async',
@@ skipping 251 matching lines @@
     }
     return map;
   }
   exports.map = map;
 
   function assert(condition) {
     if (!condition) errors.throwAssertionError();
   }
   exports.assert = assert;
 
-  let _stack = Symbol('_stack');
-
+  let _stack = new WeakMap();
   function throw_(obj) {
-    obj[_stack] = new Error();
+    if (obj != null && (typeof obj == 'object' || typeof obj == 'function')) {
+      // TODO(jmesserly): couldn't we store the most recent stack in a single
+      // variable? There should only be one active stack trace. That would
+      // allow it to work for things like strings and numbers.

[vsm, 2015/07/23 14:00:04]

I don't think we want this in the general case.  I encounter a lot of wrapped
exceptions (e.g., in async code), where it's really useful to look at the inner
exception's trace.

Another possibility is to box the string, etc., if we encounter a primitive:

obj = Object(obj);

and throw that instead.

[Jennifer Messerly, 2015/07/23 15:51:30]

Sure, but they should be wrapping the stack trace parameter too? Then they'll
have saved the original inner stack trace, and it will all work.
eeep. I suspect that would break a lot of things

+      _stack.set(obj, new Error());
+    }
     throw obj;
   }
   exports.throw = throw_;
 
   function getError(exception) {
-    return exception[_stack] ? exception[_stack] : exception;
+    var stack = _stack.get(exception);
+    return stack !== void 0 ? stack : exception;
   }
 
   // This is a utility function: it is only intended to be called from dev
   // tools.
   function stackPrint(exception) {
     var error = getError(exception);
     console.log(error.stack ? error.stack : 'No stack trace for: ' + error);
   }
   exports.stackPrint = stackPrint;
 
@@ skipping 114 matching lines @@
     next() {
       let i = this.dartIterator;
       let done = !i.moveNext();
       return { done: done, value: done ? void 0 : i.current };
     }
   }
   exports.JsIterator = JsIterator;
 
 
 });