qualify core types: Object, Error, Symbol

lib/runtime/dart/_internal.js

Index: lib/runtime/dart/_internal.js
diff --git a/lib/runtime/dart/_internal.js b/lib/runtime/dart/_internal.js
index 8f2e5dd0c6e7d42ceec2f59460d3d4999b01ca71..5f75243fcec6e84ac4946d792b65c9fb5f1a8a95 100644
--- a/lib/runtime/dart/_internal.js
+++ b/lib/runtime/dart/_internal.js
@@ -290,11 +290,11 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return ListIterable;
   });
   let ListIterable = ListIterable$();
-  let _iterable = dart.JsSymbol('_iterable');
-  let _start = dart.JsSymbol('_start');
-  let _endOrLength = dart.JsSymbol('_endOrLength');
-  let _endIndex = dart.JsSymbol('_endIndex');
-  let _startIndex = dart.JsSymbol('_startIndex');
+  let _iterable = Symbol('_iterable');
+  let _start = Symbol('_start');
+  let _endOrLength = Symbol('_endOrLength');
+  let _endIndex = Symbol('_endIndex');
+  let _startIndex = Symbol('_startIndex');
   let SubListIterable$ = dart.generic(function(E) {
     class SubListIterable extends ListIterable$(E) {
       SubListIterable(iterable, start, endOrLength) {
@@ -398,9 +398,9 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return SubListIterable;
   });
   let SubListIterable = SubListIterable$();
-  let _length = dart.JsSymbol('_length');
-  let _index = dart.JsSymbol('_index');
-  let _current = dart.JsSymbol('_current');
+  let _length = Symbol('_length');
+  let _index = Symbol('_index');
+  let _current = Symbol('_current');
   let ListIterator$ = dart.generic(function(E) {
     class ListIterator extends core.Object {
       ListIterator(iterable) {
@@ -439,7 +439,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return _Transformation;
   });
   let _Transformation = _Transformation$();
-  let _f = dart.JsSymbol('_f');
+  let _f = Symbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       static new(iterable, func) {
@@ -508,7 +508,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return EfficientLengthMappedIterable;
   });
   let EfficientLengthMappedIterable = EfficientLengthMappedIterable$();
-  let _iterator = dart.JsSymbol('_iterator');
+  let _iterator = Symbol('_iterator');
   let MappedIterator$ = dart.generic(function(S, T) {
     class MappedIterator extends core.Iterator$(T) {
       MappedIterator(iterator, f) {
@@ -535,7 +535,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return MappedIterator;
   });
   let MappedIterator = MappedIterator$();
-  let _source = dart.JsSymbol('_source');
+  let _source = Symbol('_source');
   let MappedListIterable$ = dart.generic(function(S, T) {
     class MappedListIterable extends ListIterable$(T) {
       MappedListIterable(source, f) {
@@ -630,8 +630,8 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return ExpandIterable;
   });
   let ExpandIterable = ExpandIterable$();
-  let _currentExpansion = dart.JsSymbol('_currentExpansion');
-  let _nextExpansion = dart.JsSymbol('_nextExpansion');
+  let _currentExpansion = Symbol('_currentExpansion');
+  let _nextExpansion = Symbol('_nextExpansion');
   let ExpandIterator$ = dart.generic(function(S, T) {
     class ExpandIterator extends core.Object {
       ExpandIterator(iterator, f) {
@@ -671,7 +671,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return ExpandIterator;
   });
   let ExpandIterator = ExpandIterator$();
-  let _takeCount = dart.JsSymbol('_takeCount');
+  let _takeCount = Symbol('_takeCount');
   let TakeIterable$ = dart.generic(function(E) {
     class TakeIterable extends collection.IterableBase$(E) {
       static new(iterable, takeCount) {
@@ -723,7 +723,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return EfficientLengthTakeIterable;
   });
   let EfficientLengthTakeIterable = EfficientLengthTakeIterable$();
-  let _remaining = dart.JsSymbol('_remaining');
+  let _remaining = Symbol('_remaining');
   let TakeIterator$ = dart.generic(function(E) {
     class TakeIterator extends core.Iterator$(E) {
       TakeIterator(iterator, remaining) {
@@ -770,7 +770,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return TakeWhileIterable;
   });
   let TakeWhileIterable = TakeWhileIterable$();
-  let _isFinished = dart.JsSymbol('_isFinished');
+  let _isFinished = Symbol('_isFinished');
   let TakeWhileIterator$ = dart.generic(function(E) {
     class TakeWhileIterator extends core.Iterator$(E) {
       TakeWhileIterator(iterator, f) {
@@ -800,7 +800,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return TakeWhileIterator;
   });
   let TakeWhileIterator = TakeWhileIterator$();
-  let _skipCount = dart.JsSymbol('_skipCount');
+  let _skipCount = Symbol('_skipCount');
   let SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       static new(iterable, count) {
@@ -903,7 +903,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return SkipWhileIterable;
   });
   let SkipWhileIterable = SkipWhileIterable$();
-  let _hasSkipped = dart.JsSymbol('_hasSkipped');
+  let _hasSkipped = Symbol('_hasSkipped');
   let SkipWhileIterator$ = dart.generic(function(E) {
     class SkipWhileIterator extends core.Iterator$(E) {
       SkipWhileIterator(iterator, f) {
@@ -1796,7 +1796,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     return UnmodifiableListBase;
   });
   let UnmodifiableListBase = UnmodifiableListBase$();
-  let _backedList = dart.JsSymbol('_backedList');
+  let _backedList = Symbol('_backedList');
   class _ListIndicesIterable extends ListIterable$(core.int) {
     _ListIndicesIterable(backedList) {
       this[_backedList] = backedList;
@@ -1815,7 +1815,7 @@ dart_library.library('dart/_internal', null, /* Imports */[
     methods: () => ({elementAt: [core.int, [core.int]]})
   });
   dart.defineExtensionMembers(_ListIndicesIterable, ['elementAt', 'length']);
-  let _values = dart.JsSymbol('_values');
+  let _values = Symbol('_values');
   let ListMapView$ = dart.generic(function(E) {
     class ListMapView extends core.Object {
       ListMapView(values) {
@@ -2315,70 +2315,73 @@ dart_library.library('dart/_internal', null, /* Imports */[
     names: ['sort', 'sortRange', '_doSort', '_insertionSort', '_dualPivotQuicksort']
   });
   Sort._INSERTION_SORT_THRESHOLD = 32;
-  let _name = dart.JsSymbol('_name');
-  class Symbol extends core.Object {
-    Symbol(name) {
-      this[_name] = name;
-    }
-    unvalidated(name) {
-      this[_name] = name;
-    }
-    validated(name) {
-      this[_name] = Symbol.validatePublicSymbol(name);
-    }
-    ['=='](other) {
-      return dart.is(other, Symbol) && this[_name] == other[_name];
-    }
-    get hashCode() {
-      let arbitraryPrime = 664597;
-      return 536870911 & dart.notNull(arbitraryPrime) * dart.notNull(dart.hashCode(this[_name]));
-    }
-    toString() {
-      return `Symbol("${this[_name]}")`;
-    }
-    static getName(symbol) {
-      return symbol[_name];
-    }
-    static validatePublicSymbol(name) {
-      if (dart.notNull(name[dartx.isEmpty]) || dart.notNull(Symbol.publicSymbolPattern.hasMatch(name)))
-        return name;
-      if (dart.notNull(name[dartx.startsWith]('_'))) {
-        dart.throw(new core.ArgumentError(`"${name}" is a private identifier`));
+  let _name = Symbol('_name');
+  exports.Symbol = (() => {
+    class Symbol extends core.Object {

[ochafik, 2015/09/15 16:58:33]

Note that this pattern will likely break closure's inlining in advanced mode.
The alternative:

  goog.module('lib');
  exports.Symbol = class Symbol {
    foo(x) { console.log(x); }
  }
  new exports.Symbol().foo(10);

Would inline foo completely. Compare the outputs:
- Inlined: http://goo.gl/VqfUDE
- Not inlined: http://goo.gl/3Vlm1q

(but it would require a bit more exports.Symbol references in the
dart.defineNamedConstructor statements and alike)

[Jennifer Messerly, 2015/09/15 17:06:09]

Right. I don't think that we have a goal at the present time to support advanced
optimizations, hence that is not part of my thinking when it comes to DDC's
output.

(and fwiw, an immediately invoked lambda shouldn't be very hard for a compiler
to analyze. I suspect they just never had need to do it.)

[ochafik, 2015/09/15 18:05:17]

Advanced optimizations are my main goal (to let Closure size-optimize DDC's
output), with "simple" optimizations (and ES5 lowering for free as a
side-effect) being a milestone on that path. Maybe if we split out a
ClassBuilder interface we can resurrect the idea of having two backends with
different goals, in which case the "normal" codegen wouldn't even have to deal
with Closure's simple mode.
I would also suspect so :-)

[Jennifer Messerly, 2015/09/15 18:34:23]

hmm, yeah, let's discuss tomorrow?

Generally, I feel like size of DDC's output is mainly going to be addressed in
the JS way: by structuring libraries so you as the developer have insight and
control over your size. That seems to be the favored approach in the JS
ecosystem, and mostly preferred over accepting the constraints that
advanced_opts imposes.

Tree-shaking is temping, but, we already have that: dart2js. Hard to see how
DDC+Closure_Advanced would be better than dart2js at this.

Regarding inlining: it's usually a throughput optimization. It typically makes
code size worse. (Compilers often try to limit this by having a max code size
increase they're willing to tolerate.)

But yeah, I think a high level "DartClass node" which can be lowered differently
would be good.

I'm definitely in favor of multiple back ends. Ideally the flow would be like:

    Dart AST --[js_codegen]--> "high level" JS AST --[specific JS flavor
backend]--> JS file on disk.

Where some JS flavors might be: ES6, TypeScript, ClosureSimple, ClosureAdvanced.
 Somewhat independently, since ES6 modules aren't there yet, we'll probably have
another step for lowering the modules to something like: AMD, commonjs.

What worries me a bit is ClosureAdvanced because it seems to impose a lot of
constraints that typical JS code does not follow, and that could lead us away
from our readable/idiomatic JS goals...
Yeah, maybe another perspective to share... I think of DDC as kind of a new
project, trying to get off the ground really fast with a small team. That's why
I tend to be biased in favor of tradeoffs that let us go fast and keep the
compiler very small and hackable. e.g. I don't think we should try and work
around Closure limitations or bugs. IMO, we just don't have that kind of
bandwidth, and I think we can afford to wait for Closure's ES6 support to reach
a good place. (Workarounds like that would end up being dead code anyway.)

+      Symbol(name) {
+        this[_name] = name;
+      }
+      unvalidated(name) {
+        this[_name] = name;
+      }
+      validated(name) {
+        this[_name] = exports.Symbol.validatePublicSymbol(name);
+      }
+      ['=='](other) {
+        return dart.is(other, exports.Symbol) && this[_name] == other[_name];
+      }
+      get hashCode() {
+        let arbitraryPrime = 664597;
+        return 536870911 & dart.notNull(arbitraryPrime) * dart.notNull(dart.hashCode(this[_name]));
+      }
+      toString() {
+        return `Symbol("${this[_name]}")`;
+      }
+      static getName(symbol) {
+        return symbol[_name];
+      }
+      static validatePublicSymbol(name) {
+        if (dart.notNull(name[dartx.isEmpty]) || dart.notNull(exports.Symbol.publicSymbolPattern.hasMatch(name)))
+          return name;
+        if (dart.notNull(name[dartx.startsWith]('_'))) {
+          dart.throw(new core.ArgumentError(`"${name}" is a private identifier`));
+        }
+        dart.throw(new core.ArgumentError(`"${name}" is not a valid (qualified) symbol name`));
+      }
+      static isValidSymbol(name) {
+        return dart.notNull(name[dartx.isEmpty]) || dart.notNull(exports.Symbol.symbolPattern.hasMatch(name));
       }
-      dart.throw(new core.ArgumentError(`"${name}" is not a valid (qualified) symbol name`));
-    }
-    static isValidSymbol(name) {
-      return dart.notNull(name[dartx.isEmpty]) || dart.notNull(Symbol.symbolPattern.hasMatch(name));
     }
-  }
-  Symbol[dart.implements] = () => [core.Symbol];
-  dart.defineNamedConstructor(Symbol, 'unvalidated');
-  dart.defineNamedConstructor(Symbol, 'validated');
-  dart.setSignature(Symbol, {
-    constructors: () => ({
-      Symbol: [Symbol, [core.String]],
-      unvalidated: [Symbol, [core.String]],
-      validated: [Symbol, [core.String]]
-    }),
-    methods: () => ({'==': [core.bool, [core.Object]]}),
-    statics: () => ({
-      getName: [core.String, [Symbol]],
-      validatePublicSymbol: [core.String, [core.String]],
-      isValidSymbol: [core.bool, [core.String]]
-    }),
-    names: ['getName', 'validatePublicSymbol', 'isValidSymbol']
-  });
-  Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|oid)|w(?:hile|ith))';
-  Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
-  Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
-  Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
+    Symbol[dart.implements] = () => [core.Symbol];
+    dart.defineNamedConstructor(Symbol, 'unvalidated');
+    dart.defineNamedConstructor(Symbol, 'validated');
+    dart.setSignature(Symbol, {
+      constructors: () => ({
+        Symbol: [exports.Symbol, [core.String]],
+        unvalidated: [exports.Symbol, [core.String]],
+        validated: [exports.Symbol, [core.String]]
+      }),
+      methods: () => ({'==': [core.bool, [core.Object]]}),
+      statics: () => ({
+        getName: [core.String, [exports.Symbol]],
+        validatePublicSymbol: [core.String, [core.String]],
+        isValidSymbol: [core.bool, [core.String]]
+      }),
+      names: ['getName', 'validatePublicSymbol', 'isValidSymbol']
+    });
+    return Symbol;
+  })();
+  exports.Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|oid)|w(?:hile|ith))';
+  exports.Symbol.publicIdentifierRE = '(?!' + `${exports.Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
+  exports.Symbol.identifierRE = '(?!' + `${exports.Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
+  exports.Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
   let POWERS_OF_TEN = dart.const([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
-      return core.RegExp.new(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
+      return core.RegExp.new(`^(?:${exports.Symbol.operatorRE}$|${exports.Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
     },
     get symbolPattern() {
-      return core.RegExp.new(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(?:=?$|[.](?!$)))+?$`);
+      return core.RegExp.new(`^(?:${exports.Symbol.operatorRE}$|${exports.Symbol.identifierRE}(?:=?$|[.](?!$)))+?$`);
     }
   });
   // Exports:
@@ -2452,6 +2455,5 @@ dart_library.library('dart/_internal', null, /* Imports */[
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
-  exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 });