Add constructors to signatures

lib/runtime/dart/_internal.js

 var _internal = dart.defineLibrary(_internal, {});
 var core = dart.import(core);
 var collection = dart.import(collection);
 var math = dart.lazyImport(math);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_primitives = dart.lazyImport(_js_primitives);
 (function(exports, core, collection, math, _interceptors, _js_primitives) {
   'use strict';
   class EfficientLength extends core.Object {}
   let ListIterable$ = dart.generic(function(E) {
@@ skipping 221 matching lines @@
       [core.$toSet]() {
         let result = new (core.Set$(E))();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[core.$length]); i = dart.notNull(i) + 1) {
           result.add(this[core.$elementAt](i));
         }
         return result;
       }
     }
     ListIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(ListIterable, {
+      constructors: () => ({ListIterable: [ListIterable$(E), []]}),
       methods: () => ({
         [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
         [core.$every]: [core.bool, [dart.functionType(core.bool, [E])]],
         [core.$any]: [core.bool, [dart.functionType(core.bool, [E])]],
         [core.$firstWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
         [core.$lastWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
         [core.$singleWhere]: [E, [dart.functionType(core.bool, [E])]],
         [core.$where]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         [core.$map]: [core.Iterable, [dart.functionType(core.Object, [E])]],
         [core.$reduce]: [E, [dart.functionType(E, [dart.bottom, E])]],
@@ skipping 92 matching lines @@
         })() : new (core.List$(E))(length);
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[core.$set](i, this[_iterable][core.$elementAt](dart.notNull(start) + dart.notNull(i)));
           if (dart.notNull(this[_iterable][core.$length]) < dart.notNull(end))
             throw new core.ConcurrentModificationError(this);
         }
         return dart.as(result, core.List$(E));
       }
     }
     dart.setSignature(SubListIterable, {
+      constructors: () => ({SubListIterable: [SubListIterable$(E), [core.Iterable$(E), core.int, core.int]]}),
       methods: () => ({
         [core.$elementAt]: [E, [core.int]],
         [core.$skip]: [core.Iterable$(E), [core.int]],
         [core.$take]: [core.Iterable$(E), [core.int]],
         [core.$toList]: [core.List$(E), [], {rowabl: core.bool}]
       })
     });
     return SubListIterable;
   });
   let SubListIterable = SubListIterable$();
@@ skipping 20 matching lines @@
           this[_current] = null;
           return false;
         }
         this[_current] = this[_iterable][core.$elementAt](this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     ListIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(ListIterator, {
+      constructors: () => ({ListIterator: [ListIterator$(E), [core.Iterable$(E)]]}),
       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$();
@@ skipping 28 matching lines @@
       }
       get [core.$single]() {
         return this[_f](this[_iterable][core.$single]);
       }
       [core.$elementAt](index) {
         return this[_f](this[_iterable][core.$elementAt](index));
       }
     }
     dart.defineNamedConstructor(MappedIterable, '_');
     dart.setSignature(MappedIterable, {
+      constructors: () => ({
+        MappedIterable: [MappedIterable$(S, T), [core.Iterable, dart.functionType(T, [S])]],
+        _: [MappedIterable$(S, T), [core.Iterable$(S), dart.functionType(T, [S])]]
+      }),
       methods: () => ({[core.$elementAt]: [T, [core.int]]})
     });
     return MappedIterable;
   });
   let MappedIterable = MappedIterable$();
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
         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 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 (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 MappedListIterable$ = dart.generic(function(S, T) {
     class MappedListIterable extends ListIterable$(T) {
       MappedListIterable(source, f) {
         this[_source] = source;
         this[_f] = f;
         super.ListIterable();
       }
       get [core.$length]() {
         return this[_source][core.$length];
       }
       [core.$elementAt](index) {
         return this[_f](this[_source][core.$elementAt](index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(MappedListIterable, {
+      constructors: () => ({MappedListIterable: [MappedListIterable$(S, T), [core.Iterable$(S), dart.functionType(T, [S])]]}),
       methods: () => ({[core.$elementAt]: [T, [core.int]]})
     });
     return MappedListIterable;
   });
   let MappedListIterable = MappedListIterable$();
   let _ElementPredicate$ = dart.generic(function(E) {
     let _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functionType(core.bool, [E]));
     return _ElementPredicate;
   });
   let _ElementPredicate = _ElementPredicate$();
   let WhereIterable$ = dart.generic(function(E) {
     class WhereIterable extends collection.IterableBase$(E) {
       WhereIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (WhereIterator$(E))(this[_iterable][core.$iterator], this[_f]);
       }
     }
+    dart.setSignature(WhereIterable, {
+      constructors: () => ({WhereIterable: [WhereIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
+    });
     return WhereIterable;
   });
   let WhereIterable = WhereIterable$();
   let WhereIterator$ = dart.generic(function(E) {
     class WhereIterator extends core.Iterator$(E) {
       WhereIterator(iterator, f) {
         this[_iterator] = iterator;
         this[_f] = f;
       }
       moveNext() {
         while (this[_iterator].moveNext()) {
           if (this[_f](this[_iterator].current)) {
             return true;
           }
         }
         return false;
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(WhereIterator, {
+      constructors: () => ({WhereIterator: [WhereIterator$(E), [core.Iterator$(E), dart.functionType(core.bool, [E])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return WhereIterator;
   });
   let WhereIterator = WhereIterator$();
   let _ExpandFunction$ = dart.generic(function(S, T) {
     let _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionType(core.Iterable$(T), [S]));
     return _ExpandFunction;
   });
   let _ExpandFunction = _ExpandFunction$();
   let ExpandIterable$ = dart.generic(function(S, T) {
     class ExpandIterable extends collection.IterableBase$(T) {
       ExpandIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (ExpandIterator$(S, T))(this[_iterable][core.$iterator], dart.as(this[_f], __CastType0));
       }
     }
+    dart.setSignature(ExpandIterable, {
+      constructors: () => ({ExpandIterable: [ExpandIterable$(S, T), [core.Iterable$(S), dart.functionType(core.Iterable$(T), [S])]]})
+    });
     return ExpandIterable;
   });
   let ExpandIterable = ExpandIterable$();
   let _currentExpansion = dart.JsSymbol('_currentExpansion');
   let _nextExpansion = dart.JsSymbol('_nextExpansion');
   let ExpandIterator$ = dart.generic(function(S, T) {
     class ExpandIterator extends core.Object {
       ExpandIterator(iterator, f) {
         this[_iterator] = iterator;
         this[_f] = f;
@@ skipping 15 matching lines @@
           } else {
             return false;
           }
         }
         this[_current] = this[_currentExpansion].current;
         return true;
       }
     }
     ExpandIterator[dart.implements] = () => [core.Iterator$(T)];
     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 TakeIterable$ = dart.generic(function(E) {
@@ skipping 10 matching lines @@
       _(iterable, takeCount) {
         this[_iterable] = iterable;
         this[_takeCount] = takeCount;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (TakeIterator$(E))(this[_iterable][core.$iterator], this[_takeCount]);
       }
     }
     dart.defineNamedConstructor(TakeIterable, '_');
+    dart.setSignature(TakeIterable, {
+      constructors: () => ({
+        TakeIterable: [TakeIterable$(E), [core.Iterable$(E), core.int]],
+        _: [TakeIterable$(E), [core.Iterable$(E), core.int]]
+      })
+    });
     return TakeIterable;
   });
   let TakeIterable = TakeIterable$();
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super._(iterable, takeCount);
       }
       get [core.$length]() {
         let iterableLength = this[_iterable][core.$length];
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
     EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
+    dart.setSignature(EfficientLengthTakeIterable, {
+      constructors: () => ({EfficientLengthTakeIterable: [EfficientLengthTakeIterable$(E), [core.Iterable$(E), core.int]]})
+    });
     return EfficientLengthTakeIterable;
   });
   let EfficientLengthTakeIterable = EfficientLengthTakeIterable$();
   let _remaining = dart.JsSymbol('_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) {
           return this[_iterator].moveNext();
         }
         this[_remaining] = -1;
         return false;
       }
       get current() {
         if (dart.notNull(this[_remaining]) < 0)
           return null;
         return this[_iterator].current;
       }
     }
     dart.setSignature(TakeIterator, {
+      constructors: () => ({TakeIterator: [TakeIterator$(E), [core.Iterator$(E), core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return TakeIterator;
   });
   let TakeIterator = TakeIterator$();
   let TakeWhileIterable$ = dart.generic(function(E) {
     class TakeWhileIterable extends collection.IterableBase$(E) {
       TakeWhileIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (TakeWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], __CastType2));
       }
     }
+    dart.setSignature(TakeWhileIterable, {
+      constructors: () => ({TakeWhileIterable: [TakeWhileIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
+    });
     return TakeWhileIterable;
   });
   let TakeWhileIterable = TakeWhileIterable$();
   let _isFinished = dart.JsSymbol('_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 (this[_isFinished])
           return false;
         if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(dart.dcall(this[_f], this[_iterator].current))) {
           this[_isFinished] = true;
           return false;
         }
         return true;
       }
       get current() {
         if (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 SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       SkipIterable(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
@@ skipping 16 matching lines @@
         }
         core.RangeError.checkNotNegative(this[_skipCount], "count");
         return new (SkipIterable$(E))._(this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
       }
       get [core.$iterator]() {
         return new (SkipIterator$(E))(this[_iterable][core.$iterator], this[_skipCount]);
       }
     }
     dart.defineNamedConstructor(SkipIterable, '_');
     dart.setSignature(SkipIterable, {
+      constructors: () => ({
+        SkipIterable: [SkipIterable$(E), [core.Iterable$(E), core.int]],
+        _: [SkipIterable$(E), [core.Iterable$(E), core.int]]
+      }),
       methods: () => ({[core.$skip]: [core.Iterable$(E), [core.int]]})
     });
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$();
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super._(iterable, skipCount);
       }
       get [core.$length]() {
         let length = dart.notNull(this[_iterable][core.$length]) - dart.notNull(this[_skipCount]);
         if (dart.notNull(length) >= 0)
           return length;
         return 0;
       }
     }
     EfficientLengthSkipIterable[dart.implements] = () => [EfficientLength];
+    dart.setSignature(EfficientLengthSkipIterable, {
+      constructors: () => ({EfficientLengthSkipIterable: [EfficientLengthSkipIterable$(E), [core.Iterable$(E), core.int]]})
+    });
     return EfficientLengthSkipIterable;
   });
   let EfficientLengthSkipIterable = EfficientLengthSkipIterable$();
   let SkipIterator$ = dart.generic(function(E) {
     class SkipIterator extends core.Iterator$(E) {
       SkipIterator(iterator, skipCount) {
         this[_iterator] = iterator;
         this[_skipCount] = skipCount;
         dart.assert(typeof this[_skipCount] == 'number' && dart.notNull(this[_skipCount]) >= 0);
       }
       moveNext() {
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_skipCount]); i = dart.notNull(i) + 1)
           this[_iterator].moveNext();
         this[_skipCount] = 0;
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(SkipIterator, {
+      constructors: () => ({SkipIterator: [SkipIterator$(E), [core.Iterator$(E), core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return SkipIterator;
   });
   let SkipIterator = SkipIterator$();
   let SkipWhileIterable$ = dart.generic(function(E) {
     class SkipWhileIterable extends collection.IterableBase$(E) {
       SkipWhileIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get [core.$iterator]() {
         return new (SkipWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], __CastType4));
       }
     }
+    dart.setSignature(SkipWhileIterable, {
+      constructors: () => ({SkipWhileIterable: [SkipWhileIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
+    });
     return SkipWhileIterable;
   });
   let SkipWhileIterable = SkipWhileIterable$();
   let _hasSkipped = dart.JsSymbol('_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;
           while (this[_iterator].moveNext()) {
             if (!dart.notNull(dart.dcall(this[_f], this[_iterator].current)))
               return true;
           }
         }
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(SkipWhileIterator, {
+      constructors: () => ({SkipWhileIterator: [SkipWhileIterator$(E), [core.Iterator$(E), dart.functionType(core.bool, [E])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return SkipWhileIterator;
   });
   let SkipWhileIterator = SkipWhileIterator$();
   let EmptyIterable$ = dart.generic(function(E) {
     class EmptyIterable extends collection.IterableBase$(E) {
       EmptyIterable() {
         super.IterableBase();
       }
@@ skipping 96 matching lines @@
       [core.$toList](opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return growable ? dart.setType([], core.List$(E)) : new (core.List$(E))(0);
       }
       [core.$toSet]() {
         return new (core.Set$(E))();
       }
     }
     EmptyIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EmptyIterable, {
+      constructors: () => ({EmptyIterable: [EmptyIterable$(E), []]}),
       methods: () => ({
         [core.$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
         [core.$elementAt]: [E, [core.int]],
         [core.$every]: [core.bool, [dart.functionType(core.bool, [E])]],
         [core.$any]: [core.bool, [dart.functionType(core.bool, [E])]],
         [core.$firstWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
         [core.$lastWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
         [core.$singleWhere]: [E, [dart.functionType(core.bool, [E])], {rEls: dart.functionType(E, [])}],
         [core.$where]: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
         [core.$map]: [core.Iterable, [dart.functionType(core.Object, [E])]],
@@ skipping 16 matching lines @@
       }
       moveNext() {
         return false;
       }
       get current() {
         return null;
       }
     }
     EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(EmptyIterator, {
+      constructors: () => ({EmptyIterator: [EmptyIterator$(E), []]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return EmptyIterator;
   });
   let EmptyIterator = EmptyIterator$();
   let BidirectionalIterator$ = dart.generic(function(T) {
     class BidirectionalIterator extends core.Object {}
     BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
     return BidirectionalIterator;
   });
@@ skipping 663 matching lines @@
     }
     get [core.$length]() {
       return this[_backedList][core.$length];
     }
     [core.$elementAt](index) {
       core.RangeError.checkValidIndex(index, this);
       return index;
     }
   }
   dart.setSignature(_ListIndicesIterable, {
+    constructors: () => ({_ListIndicesIterable: [_ListIndicesIterable, [core.List]]}),
     methods: () => ({[core.$elementAt]: [core.int, [core.int]]})
   });
   let _values = dart.JsSymbol('_values');
   let ListMapView$ = dart.generic(function(E) {
     class ListMapView extends core.Object {
       ListMapView(values) {
         this[_values] = values;
       }
       get(key) {
         return this.containsKey(key) ? this[_values][core.$get](key) : null;
@@ skipping 46 matching lines @@
       addAll(other) {
         dart.as(other, core.Map$(core.int, E));
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       toString() {
         return collection.Maps.mapToString(this);
       }
     }
     ListMapView[dart.implements] = () => [core.Map$(core.int, E)];
     dart.setSignature(ListMapView, {
+      constructors: () => ({ListMapView: [ListMapView$(E), [core.List$(E)]]}),
       methods: () => ({
         get: [E, [core.Object]],
         containsValue: [core.bool, [core.Object]],
         containsKey: [core.bool, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [core.int, E])]],
         set: [dart.void, [core.int, E]],
         putIfAbsent: [E, [core.int, dart.functionType(E, [])]],
         remove: [E, [core.Object]],
         clear: [dart.void, []],
         addAll: [dart.void, [core.Map$(core.int, E)]]
       })
     });
     return ListMapView;
   });
   let ListMapView = ListMapView$();
   let ReversedListIterable$ = dart.generic(function(E) {
     class ReversedListIterable extends ListIterable$(E) {
       ReversedListIterable(source) {
         this[_source] = source;
         super.ListIterable();
       }
       get [core.$length]() {
         return this[_source][core.$length];
       }
       [core.$elementAt](index) {
         return this[_source][core.$elementAt](dart.notNull(this[_source][core.$length]) - 1 - dart.notNull(index));
       }
     }
     dart.setSignature(ReversedListIterable, {
+      constructors: () => ({ReversedListIterable: [ReversedListIterable$(E), [core.Iterable$(E)]]}),
       methods: () => ({[core.$elementAt]: [E, [core.int]]})
     });
     return ReversedListIterable;
   });
   let ReversedListIterable = ReversedListIterable$();
   class UnmodifiableListError extends core.Object {
     static add() {
       return new core.UnsupportedError("Cannot add to unmodifiable List");
     }
     static change() {
@@ skipping 423 matching lines @@
       throw new core.ArgumentError(`"${name}" is not a valid (qualified) symbol name`);
     }
     static isValidSymbol(name) {
       return dart.notNull(name.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$]*';
@@ skipping 75 matching lines @@
   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;
 })(_internal, core, collection, math, _interceptors, _js_primitives);