Use signature inheritance when method types are unchanged

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _js_helper = dart.lazyImport(_js_helper);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _js_helper, _isolate_helper, collection) {
   'use strict';
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
@@ skipping 14 matching lines @@
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
       return dart.toString(this.error);
     }
   }
   AsyncError[dart.implements] = () => [core.Error];
-  dart.setSignature(AsyncError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
+  dart.setSignature(AsyncError, {});
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _UncaughtAsyncError._getBestStackTrace(error, stackTrace));
     }
     static _getBestStackTrace(error, stackTrace) {
       if (stackTrace != null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace != null) {
         result = dart.notNull(result) + `\nStack Trace:\n${this.stackTrace}`;
       }
       return result;
     }
   }
   dart.setSignature(_UncaughtAsyncError, {
-    methods: () => ({toString: dart.functionType(core.String, [])}),
     statics: () => ({_getBestStackTrace: dart.functionType(core.StackTrace, [dart.dynamic, core.StackTrace])}),
     names: ['_getBestStackTrace']
   });
   let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   let _add = Symbol('_add');
   let _closeUnchecked = Symbol('_closeUnchecked');
   let _addError = Symbol('_addError');
   let _completeError = Symbol('_completeError');
   let _complete = Symbol('_complete');
   let _sink = Symbol('_sink');
@@ skipping 1154 matching lines @@
       [_onCancel]() {
         return this[_controller][_recordCancel](this);
       }
       [_onPause]() {
         this[_controller][_recordPause](this);
       }
       [_onResume]() {
         this[_controller][_recordResume](this);
       }
     }
-    dart.setSignature(_ControllerSubscription, {
-      methods: () => ({
-        [_onCancel]: dart.functionType(Future, []),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, [])
-      })
-    });
+    dart.setSignature(_ControllerSubscription, {});

[Jennifer Messerly, 2015/05/20 20:16:22]

we could skip empty signatures too?

[Leaf, 2015/05/20 20:41:36]

Done.

     return _ControllerSubscription;
   });
   let _ControllerSubscription = _ControllerSubscription$();
   let _eventState = Symbol('_eventState');
   let _expectsEvent = Symbol('_expectsEvent');
   let _toggleEventId = Symbol('_toggleEventId');
   let _isFiring = Symbol('_isFiring');
   let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
   let _removeAfterFiring = Symbol('_removeAfterFiring');
   let _BroadcastSubscription$ = dart.generic(function(T) {
@@ skipping 25 matching lines @@
         return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription$()._STATE_REMOVE_AFTER_FIRING)) != 0;
       }
       [_onPause]() {}
       [_onResume]() {}
     }
     _BroadcastSubscription[dart.implements] = () => [_BroadcastSubscriptionLink];
     dart.setSignature(_BroadcastSubscription, {
       methods: () => ({
         [_expectsEvent]: dart.functionType(core.bool, [core.int]),
         [_toggleEventId]: dart.functionType(dart.void, []),
-        [_setRemoveAfterFiring]: dart.functionType(dart.void, []),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, [])
+        [_setRemoveAfterFiring]: dart.functionType(dart.void, [])
       })
     });
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$();
   _BroadcastSubscription._STATE_EVENT_ID = 1;
   _BroadcastSubscription._STATE_FIRING = 2;
   _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
   let _addStreamState = Symbol('_addStreamState');
   let _doneFuture = Symbol('_doneFuture');
@@ skipping 397 matching lines @@
           this[_pending].clear();
           this[_pending] = null;
         }
         super[_callOnCancel]();
       }
     }
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     dart.setSignature(_AsBroadcastStreamController, {
       methods: () => ({
         [_addPendingEvent]: dart.functionType(dart.void, [_DelayedEvent]),
-        add: dart.functionType(dart.void, [T]),
-        addError: dart.functionType(dart.void, [core.Object], [core.StackTrace]),
-        close: dart.functionType(Future, []),
-        [_callOnCancel]: dart.functionType(dart.void, [])
+        add: dart.functionType(dart.void, [T])
       })
     });
     return _AsBroadcastStreamController;
   });
   let _AsBroadcastStreamController = _AsBroadcastStreamController$();
   let _pauseCount = Symbol('_pauseCount');
   let _resume = Symbol('_resume');
   let _DoneSubscription$ = dart.generic(function(T) {
     class _DoneSubscription extends core.Object {
       _DoneSubscription() {
@@ skipping 70 matching lines @@
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s) {
       this[_s] = s;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
-  dart.setSignature(DeferredLoadException, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
+  dart.setSignature(DeferredLoadException, {});
   let _completeWithValue = Symbol('_completeWithValue');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new (_Future$(T))();
         Timer.run(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
@@ skipping 175 matching lines @@
     toString() {
       let result = "TimeoutException";
       if (this.duration != null)
         result = `TimeoutException after ${this.duration}`;
       if (this.message != null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
   TimeoutException[dart.implements] = () => [core.Exception];
-  dart.setSignature(TimeoutException, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
-  });
+  dart.setSignature(TimeoutException, {});
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
         return new (_AsyncCompleter$(T))();
       }
       sync() {
         return new (_SyncCompleter$(T))();
       }
     }
     dart.defineNamedConstructor(Completer, 'sync');
@@ skipping 2226 matching lines @@
       [_handleError](error, stackTrace) {
         this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream][_handleDone](this);
       }
     }
     dart.setSignature(_ForwardingStreamSubscription, {
       methods: () => ({
         [_add]: dart.functionType(dart.void, [T]),
-        [_addError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, []),
-        [_onCancel]: dart.functionType(Future, []),
         [_handleData]: dart.functionType(dart.void, [S]),
         [_handleError]: dart.functionType(dart.void, [dart.dynamic, core.StackTrace]),
         [_handleDone]: dart.functionType(dart.void, [])
       })
     });
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
   let _Predicate$ = dart.generic(function(T) {
     let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
@@ skipping 427 matching lines @@
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
     }
     dart.setSignature(_SinkTransformerStreamSubscription, {
       methods: () => ({
         [_add]: dart.functionType(dart.void, [T]),
-        [_addError]: dart.functionType(dart.void, [core.Object, core.StackTrace]),
-        [_close]: dart.functionType(dart.void, []),
-        [_onPause]: dart.functionType(dart.void, []),
-        [_onResume]: dart.functionType(dart.void, []),
-        [_onCancel]: dart.functionType(Future, []),
         [_handleData]: dart.functionType(dart.void, [S]),
         [_handleError]: dart.functionType(dart.void, [dart.dynamic], [dart.dynamic]),
         [_handleDone]: dart.functionType(dart.void, [])
       })
     });
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
   let _SinkMapper$ = dart.generic(function(S, T) {
     let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
@@ skipping 1118 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async, core, _internal, _js_helper, _isolate_helper, collection);