qualify core types: Object, Error, Symbol

lib/runtime/dart/_internal.js

 dart_library.library('dart/_internal', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/math',
   'dart/_interceptors',
   'dart/_js_primitives'
 ], function(exports, dart, core, collection, math, _interceptors, _js_primitives) {
   'use strict';
@@ skipping 272 matching lines @@
       'toSet',
       'iterator',
       'isEmpty',
       'first',
       'last',
       'single'
     ]);
     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) {
         this[_iterable] = iterable;
         this[_start] = start;
         this[_endOrLength] = endOrLength;
         super.ListIterable();
         core.RangeError.checkNotNegative(this[_start], "start");
         if (this[_endOrLength] != null) {
           core.RangeError.checkNotNegative(this[_endOrLength], "end");
@@ skipping 83 matching lines @@
     dart.defineExtensionMembers(SubListIterable, [
       'elementAt',
       'skip',
       'take',
       'toList',
       'length'
     ]);
     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) {
         this[_iterable] = iterable;
         this[_length] = iterable[dartx.length];
         this[_index] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
@@ skipping 18 matching lines @@
       methods: () => ({moveNext: [core.bool, []]})
     });
     return ListIterator;
   });
   let ListIterator = ListIterator$();
   let _Transformation$ = dart.generic(function(S, T) {
     let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     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) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthMappedIterable$(S, T))(iterable, func);
         }
         return new (MappedIterable$(S, T))._(dart.as(iterable, core.Iterable$(S)), func);
       }
       _(iterable, f) {
         this[_iterable] = iterable;
@@ skipping 48 matching lines @@
         super._(dart.as(iterable, core.Iterable$(S)), func);
       }
     }
     EfficientLengthMappedIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EfficientLengthMappedIterable, {
       constructors: () => ({EfficientLengthMappedIterable: [EfficientLengthMappedIterable$(S, T), [core.Iterable, dart.functionType(T, [S])]]})
     });
     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) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_current] = null;
       }
       moveNext() {
         if (dart.notNull(this[_iterator].moveNext())) {
           this[_current] = this[_f](this[_iterator].current);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     dart.setSignature(MappedIterator, {
       constructors: () => ({MappedIterator: [MappedIterator$(S, T), [core.Iterator$(S), dart.functionType(T, [S])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     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) {
         this[_source] = source;
         this[_f] = f;
         super.ListIterable();
       }
       get length() {
         return this[_source][dartx.length];
       }
@@ skipping 74 matching lines @@
         return new (ExpandIterator$(S, T))(this[_iterable][dartx.iterator], dart.as(this[_f], __CastType0));
       }
     }
     dart.setSignature(ExpandIterable, {
       constructors: () => ({ExpandIterable: [ExpandIterable$(S, T), [core.Iterable$(S), dart.functionType(core.Iterable$(T), [S])]]})
     });
     dart.defineExtensionMembers(ExpandIterable, ['iterator']);
     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) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_currentExpansion] = dart.const(new (EmptyIterator$(T))());
         this[_current] = null;
       }
       [_nextExpansion]() {}
       get current() {
@@ skipping 19 matching lines @@
     dart.setSignature(ExpandIterator, {
       constructors: () => ({ExpandIterator: [ExpandIterator$(S, T), [core.Iterator$(S), dart.functionType(core.Iterable$(T), [S])]]}),
       methods: () => ({
         [_nextExpansion]: [dart.void, []],
         moveNext: [core.bool, []]
       })
     });
     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) {
         if (!(typeof takeCount == 'number') || dart.notNull(takeCount) < 0) {
           dart.throw(new core.ArgumentError(takeCount));
         }
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthTakeIterable$(E))(iterable, takeCount);
         }
         return new (TakeIterable$(E))._(iterable, takeCount);
@@ skipping 31 matching lines @@
       }
     }
     EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EfficientLengthTakeIterable, {
       constructors: () => ({EfficientLengthTakeIterable: [EfficientLengthTakeIterable$(E), [core.Iterable$(E), core.int]]})
     });
     dart.defineExtensionMembers(EfficientLengthTakeIterable, ['length']);
     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) {
         this[_iterator] = iterator;
         this[_remaining] = remaining;
         dart.assert(typeof this[_remaining] == 'number' && dart.notNull(this[_remaining]) >= 0);
       }
       moveNext() {
         this[_remaining] = dart.notNull(this[_remaining]) - 1;
         if (dart.notNull(this[_remaining]) >= 0) {
@@ skipping 26 matching lines @@
         return new (TakeWhileIterator$(E))(this[_iterable][dartx.iterator], this[_f]);
       }
     }
     dart.setSignature(TakeWhileIterable, {
       constructors: () => ({TakeWhileIterable: [TakeWhileIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
     });
     dart.defineExtensionMembers(TakeWhileIterable, ['iterator']);
     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) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_isFinished] = false;
       }
       moveNext() {
         if (dart.notNull(this[_isFinished]))
           return false;
         if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(this[_f](this[_iterator].current))) {
           this[_isFinished] = true;
           return false;
         }
         return true;
       }
       get current() {
         if (dart.notNull(this[_isFinished]))
           return null;
         return this[_iterator].current;
       }
     }
     dart.setSignature(TakeWhileIterator, {
       constructors: () => ({TakeWhileIterator: [TakeWhileIterator$(E), [core.Iterator$(E), dart.functionType(core.bool, [E])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     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) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthSkipIterable$(E))(iterable, count);
         }
         return new (SkipIterable$(E))._(iterable, count);
       }
       _(iterable, skipCount) {
         this[_iterable] = iterable;
@@ skipping 82 matching lines @@
         return new (SkipWhileIterator$(E))(this[_iterable][dartx.iterator], this[_f]);
       }
     }
     dart.setSignature(SkipWhileIterable, {
       constructors: () => ({SkipWhileIterable: [SkipWhileIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
     });
     dart.defineExtensionMembers(SkipWhileIterable, ['iterator']);
     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) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_hasSkipped] = false;
       }
       moveNext() {
         if (!dart.notNull(this[_hasSkipped])) {
           this[_hasSkipped] = true;
@@ skipping 872 matching lines @@
   let FixedLengthListBase = FixedLengthListBase$();
   let UnmodifiableListBase$ = dart.generic(function(E) {
     class UnmodifiableListBase extends dart.mixin(collection.ListBase$(E), UnmodifiableListMixin$(E)) {
       UnmodifiableListBase() {
         super.ListBase(...arguments);
       }
     }
     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;
       super.ListIterable();
     }
     get length() {
       return this[_backedList][dartx.length];
     }
     elementAt(index) {
       core.RangeError.checkValidIndex(index, this);
       return index;
     }
   }
   dart.setSignature(_ListIndicesIterable, {
     constructors: () => ({_ListIndicesIterable: [_ListIndicesIterable, [core.List]]}),
     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) {
         this[_values] = values;
       }
       get(key) {
         return dart.notNull(this.containsKey(key)) ? this[_values][dartx.get](dart.as(key, core.int)) : null;
       }
       get length() {
         return this[_values][dartx.length];
@@ skipping 479 matching lines @@
     statics: () => ({
       sort: [dart.void, [core.List, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       sortRange: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       _doSort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       _insertionSort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       _dualPivotQuicksort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]]
     }),
     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;
+  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));
+      }
     }
-    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`));
-      }
-      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:
   exports.EfficientLength = EfficientLength;
   exports.ListIterable$ = ListIterable$;
   exports.ListIterable = ListIterable;
   exports.SubListIterable$ = SubListIterable$;
   exports.SubListIterable = SubListIterable;
   exports.ListIterator$ = ListIterator$;
   exports.ListIterator = ListIterator;
@@ skipping 53 matching lines @@
   exports.ListMapView$ = ListMapView$;
   exports.ListMapView = ListMapView;
   exports.ReversedListIterable$ = ReversedListIterable$;
   exports.ReversedListIterable = ReversedListIterable;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
-  exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 });