compute interfaces lazily

lib/runtime/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
   class EfficientLength extends core.Object {
   }
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
@@ skipping 203 matching lines @@
         return result;
       }
       toSet() {
         let result = new core.Set();
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           result.add(this.elementAt(i));
         }
         return result;
       }
     }
-    ListIterable[dart.implements] = [EfficientLength];
+    ListIterable[dart.implements] = () => [EfficientLength];
     return ListIterable;
   });
   let ListIterable = ListIterable$(dart.dynamic);
   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) {
@@ skipping 102 matching lines @@
         }
         if (dart.notNull(this[_index]) >= dart.notNull(length)) {
           this[_current] = null;
           return false;
         }
         this[_current] = this[_iterable].elementAt(this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
-    ListIterator[dart.implements] = [core.Iterator$(E)];
+    ListIterator[dart.implements] = () => [core.Iterator$(E)];
     return ListIterator;
   });
   let ListIterator = ListIterator$(dart.dynamic);
   let _ = Symbol('_');
   let _f = Symbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, func) {
         if (dart.is(iterable, EfficientLength)) {
           return new EfficientLengthMappedIterable(iterable, func);
@@ skipping 30 matching lines @@
     dart.defineNamedConstructor(MappedIterable, _);
     return MappedIterable;
   });
   let MappedIterable = MappedIterable$(dart.dynamic, dart.dynamic);
   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];
+    EfficientLengthMappedIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthMappedIterable;
   });
   let EfficientLengthMappedIterable = EfficientLengthMappedIterable$(dart.dynamic, dart.dynamic);
   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;
@@ skipping 22 matching lines @@
         this[_f] = f$;
         super.ListIterable();
       }
       get length() {
         return this[_source].length;
       }
       elementAt(index) {
         return this[_f](this[_source].elementAt(index));
       }
     }
-    MappedListIterable[dart.implements] = [EfficientLength];
+    MappedListIterable[dart.implements] = () => [EfficientLength];
     return MappedListIterable;
   });
   let MappedListIterable = MappedListIterable$(dart.dynamic, dart.dynamic);
   let WhereIterable$ = dart.generic(function(E) {
     class WhereIterable extends collection.IterableBase$(E) {
       WhereIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
@@ skipping 63 matching lines @@
             this[_currentExpansion] = null;
             this[_currentExpansion] = dart.as(dart.dinvokef(this[_f], this[_iterator].current).iterator, core.Iterator$(T));
           } else {
             return false;
           }
         }
         this[_current] = this[_currentExpansion].current;
         return true;
       }
     }
-    ExpandIterator[dart.implements] = [core.Iterator$(T)];
+    ExpandIterator[dart.implements] = () => [core.Iterator$(T)];
     return ExpandIterator;
   });
   let ExpandIterator = ExpandIterator$(dart.dynamic, dart.dynamic);
   let _takeCount = Symbol('_takeCount');
   let TakeIterable$ = dart.generic(function(E) {
     class TakeIterable extends collection.IterableBase$(E) {
       TakeIterable(iterable, takeCount) {
         if (dart.notNull(!(typeof takeCount == 'number')) || dart.notNull(takeCount) < 0) {
           throw new core.ArgumentError(takeCount);
         }
@@ skipping 20 matching lines @@
       EfficientLengthTakeIterable(iterable, takeCount) {
         super[_](iterable, takeCount);
       }
       get length() {
         let iterableLength = this[_iterable].length;
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
-    EfficientLengthTakeIterable[dart.implements] = [EfficientLength];
+    EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthTakeIterable;
   });
   let EfficientLengthTakeIterable = EfficientLengthTakeIterable$(dart.dynamic);
   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;
         super.Iterator();
@@ skipping 95 matching lines @@
       EfficientLengthSkipIterable(iterable, skipCount) {
         super[_](iterable, skipCount);
       }
       get length() {
         let length = dart.notNull(this[_iterable].length) - dart.notNull(this[_skipCount]);
         if (dart.notNull(length) >= 0)
           return length;
         return 0;
       }
     }
-    EfficientLengthSkipIterable[dart.implements] = [EfficientLength];
+    EfficientLengthSkipIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthSkipIterable;
   });
   let EfficientLengthSkipIterable = EfficientLengthSkipIterable$(dart.dynamic);
   let SkipIterator$ = dart.generic(function(E) {
     class SkipIterator extends core.Iterator$(E) {
       SkipIterator(iterator$, skipCount$) {
         this[_iterator] = iterator$;
         this[_skipCount] = skipCount$;
         super.Iterator();
         dart.assert(dart.notNull(typeof this[_skipCount] == 'number') && dart.notNull(this[_skipCount]) >= 0);
@@ skipping 137 matching lines @@
         return this;
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return growable ? new core.List$(E).from([]) : new core.List(0);
       }
       toSet() {
         return new core.Set();
       }
     }
-    EmptyIterable[dart.implements] = [EfficientLength];
+    EmptyIterable[dart.implements] = () => [EfficientLength];
     return EmptyIterable;
   });
   let EmptyIterable = EmptyIterable$(dart.dynamic);
   let EmptyIterator$ = dart.generic(function(E) {
     class EmptyIterator extends core.Object {
       EmptyIterator() {
       }
       moveNext() {
         return false;
       }
       get current() {
         return null;
       }
     }
-    EmptyIterator[dart.implements] = [core.Iterator$(E)];
+    EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
     return EmptyIterator;
   });
   let EmptyIterator = EmptyIterator$(dart.dynamic);
   let BidirectionalIterator$ = dart.generic(function(T) {
     class BidirectionalIterator extends core.Object {
     }
-    BidirectionalIterator[dart.implements] = [core.Iterator$(T)];
+    BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$(dart.dynamic);
   let _rangeCheck = Symbol('_rangeCheck');
   let IterableMixinWorkaround$ = dart.generic(function(T) {
     class IterableMixinWorkaround extends core.Object {
       static contains(iterable, element) {
         for (let e of iterable) {
           if (dart.equals(e, element))
             return true;
@@ skipping 464 matching lines @@
       }
       replaceRange(start, end, iterable) {
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       fillRange(start, end, fillValue) {
         if (fillValue === void 0)
           fillValue = null;
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
     }
-    UnmodifiableListMixin[dart.implements] = [core.List$(E)];
+    UnmodifiableListMixin[dart.implements] = () => [core.List$(E)];
     return UnmodifiableListMixin;
   });
   let UnmodifiableListMixin = UnmodifiableListMixin$(dart.dynamic);
   let FixedLengthListBase$ = dart.generic(function(E) {
     class FixedLengthListBase extends dart.mixin(FixedLengthListMixin$(E)) {
     }
     return FixedLengthListBase;
   });
   let FixedLengthListBase = FixedLengthListBase$(dart.dynamic);
   let UnmodifiableListBase$ = dart.generic(function(E) {
@@ skipping 67 matching lines @@
       clear() {
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       addAll(other) {
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       toString() {
         return collection.Maps.mapToString(this);
       }
     }
-    ListMapView[dart.implements] = [core.Map$(core.int, E)];
+    ListMapView[dart.implements] = () => [core.Map$(core.int, E)];
     return ListMapView;
   });
   let ListMapView = ListMapView$(dart.dynamic);
   let ReversedListIterable$ = dart.generic(function(E) {
     class ReversedListIterable extends ListIterable$(E) {
       ReversedListIterable(source) {
         this[_source] = source;
         super.ListIterable();
       }
       get length() {
@@ skipping 363 matching lines @@
         return name;
       if (name.startsWith('_')) {
         throw new core.ArgumentError(`"${name}" is a private identifier`);
       }
       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];
+  Symbol[dart.implements] = () => [core.Symbol];
   dart.defineNamedConstructor(Symbol, 'unvalidated');
   dart.defineNamedConstructor(Symbol, 'validated');
   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-)';
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
       return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
     },
@@ skipping 69 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 || (_internal = {}));