test/dart_codegen/expect/async/stream_transformers.dart - Issue 1148283010: Remove dart backend

Side by Side Diff: test/dart_codegen/expect/async/stream_transformers.dart

Issue 1148283010: Remove dart backend (Closed) Base URL: https://github.com/dart-lang/dev_compiler.git@master

Patch Set: Created 5 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 part of dart.async;

2 class _EventSinkWrapper<T> implements EventSink<T> {_EventSink _sink;

3 _EventSinkWrapper(this._sink);

4 void add(T data) {

5 _sink._add(data);

6 }

7 void addError(error, [StackTrace stackTrace]) {

8 _sink._addError(error, stackTrace);

9 }

10 void close() {

11 _sink._close();

12 }

13 }

14 class _SinkTransformerStreamSubscription<S, T> extends _BufferingStreamSubscrip tion<T> {EventSink _transformerSink;

15 StreamSubscription<S> _subscription;

16 _SinkTransformerStreamSubscription(Stream<S> source, _SinkMapper<S, T> mapper, void onData(T data), Function onError, void onDone(), bool cancelOnError) : supe r(onData, onError, onDone, cancelOnError) {

17 _EventSinkWrapper<T> eventSink = new _EventSinkWrapper<T>(this);

18 _transformerSink = mapper(eventSink);

19 _subscription = source.listen(_handleData, onError: _handleError, onDone: _hand leDone);

20 }

21 bool get _isSubscribed => _subscription != null;

22 void _add(T data) {

23 if (_isClosed) {

24 throw new StateError("Stream is already closed");

25 }

26 super._add(data);

27 }

28 void _addError(Object error, StackTrace stackTrace) {

29 if (_isClosed) {

30 throw new StateError("Stream is already closed");

31 }

32 super._addError(error, stackTrace);

33 }

34 void _close() {

35 if (_isClosed) {

36 throw new StateError("Stream is already closed");

37 }

38 super._close();

39 }

40 void _onPause() {

41 if (_isSubscribed) _subscription.pause();

42 }

43 void _onResume() {

44 if (_isSubscribed) _subscription.resume();

45 }

46 Future _onCancel() {

47 if (_isSubscribed) {

48 StreamSubscription subscription = _subscription;

49 _subscription = null;

50 subscription.cancel();

51 }

52 return null;

53 }

54 void _handleData(S data) {

55 try {

56 _transformerSink.add(data);

57 }

58 catch (e, s) {

59 _addError(e, s);

60 }

61 }

62 void _handleError(error, [stackTrace]) {

63 try {

64 _transformerSink.addError(error, DEVC$RT.cast(stackTrace, dynamic, StackTrace, "DynamicCast", """line 127, column 40 of dart:async/stream_transformers.dart: " "", stackTrace is StackTrace, true));

65 }

66 catch (e, s) {

67 if (identical(e, error)) {

68 _addError(error, DEVC$RT.cast(stackTrace, dynamic, StackTrace, "DynamicCast" , """line 130, column 26 of dart:async/stream_transformers.dart: """, stackTrace is StackTrace, true));

69 }

70 else {

71 _addError(e, s);

72 }

73 }

74 }

75 void _handleDone() {

76 try {

77 _subscription = null;

78 _transformerSink.close();

79 }

80 catch (e, s) {

81 _addError(e, s);

82 }

83 }

84 }

85 typedef EventSink<S> _SinkMapper<S, T>(EventSink<T> output);

86 class _StreamSinkTransformer<S, T> implements StreamTransformer<S, T> {final _S inkMapper<S, T> _sinkMapper;

87 const _StreamSinkTransformer(this._sinkMapper);

88 Stream<T> bind(Stream<S> stream) => new _BoundSinkStream<S, T>(stream, _sinkMap per);

89 }

90 class _BoundSinkStream<S, T> extends Stream<T> {final _SinkMapper<S, T> _sinkMa pper;

91 final Stream<S> _stream;

92 bool get isBroadcast => _stream.isBroadcast;

93 _BoundSinkStream(this._stream, this._sinkMapper);

94 StreamSubscription<T> listen(void onData(T event), {

95 Function onError, void onDone(), bool cancelOnError}

96 ) {

97 cancelOnError = identical(true, cancelOnError);

98 StreamSubscription<T> subscription = new _SinkTransformerStreamSubscription<dyn amic, T>(_stream, DEVC$RT.cast(_sinkMapper, DEVC$RT.type((_SinkMapper<S, T> _) {

99 }

100 ), DEVC$RT.type((_SinkMapper<dynamic, dynamic> _) {

101 }

102 ), "CompositeCast", """line 187, column 18 of dart:async/stream_transformers.dar t: """, _sinkMapper is _SinkMapper<dynamic, dynamic>, false), onData, onError, o nDone, cancelOnError);

103 return subscription;

104 }

105 }

106 typedef void _TransformDataHandler<S, T>(S data, EventSink<T> sink);

107 typedef void _TransformErrorHandler<T>(Object error, StackTrace stackTrace, Eve ntSink<T> sink);

108 typedef void _TransformDoneHandler<T>(EventSink<T> sink);

109 class _HandlerEventSink<S, T> implements EventSink<S> {final _TransformDataHand ler<S, T> _handleData;

110 final _TransformErrorHandler<T> _handleError;

111 final _TransformDoneHandler<T> _handleDone;

112 final EventSink<T> _sink;

113 _HandlerEventSink(this._handleData, this._handleError, this._handleDone, this._ sink);

114 void add(S data) => _handleData(data, _sink);

115 void addError(Object error, [StackTrace stackTrace]) => _handleError(error, sta ckTrace, _sink);

116 void close() => _handleDone(_sink);

117 }

118 class _StreamHandlerTransformer<S, T> extends _StreamSinkTransformer<S, T> {_St reamHandlerTransformer({

119 void handleData(S data, EventSink<T> sink), void handleError(Object error, Stack Trace stackTrace, EventSink<T> sink), void handleDone(EventSink<T> sink)}

120 ) : super(((__x61) => DEVC$RT.cast(__x61, DEVC$RT.type((__CastType59<T> _) {

121 }

122 ), DEVC$RT.type((_SinkMapper<S, T> _) {

123 }

124 ), "InferableClosure", """line 233, column 15 of dart:async/stream_transformers. dart: """, __x61 is _SinkMapper<S, T>, false))((EventSink<T> outputSink) {

125 if (handleData == null) handleData = DEVC$RT.cast(_defaultHandleData, __CastType 65, DEVC$RT.type((__CastType62<S, T> _) {

126 }

127 ), "CompositeCast", """line 234, column 48 of dart:async/stream_transformers.dar t: """, _defaultHandleData is __CastType62<S, T>, false);

128 if (handleError == null) handleError = DEVC$RT.cast(_defaultHandleError, __Cast Type72, DEVC$RT.type((__CastType68<T> _) {

129 }

130 ), "CompositeCast", """line 235, column 50 of dart:async/stream_transformers.dar t: """, _defaultHandleError is __CastType68<T>, false);

131 if (handleDone == null) handleDone = _defaultHandleDone;

132 return new _HandlerEventSink<S, T>(handleData, handleError, handleDone, outputS ink);

133 }

134 ));

135 Stream<T> bind(Stream<S> stream) {

136 return super.bind(stream);

137 }

138 static void _defaultHandleData(var data, EventSink sink) {

139 sink.add(data);

140 }

141 static void _defaultHandleError(error, StackTrace stackTrace, EventSink sink) {

142 sink.addError(error);

143 }

144 static void _defaultHandleDone(EventSink sink) {

145 sink.close();

146 }

147 }

148 typedef StreamSubscription<T> _SubscriptionTransformer<S, T>(Stream<S> stream, bool cancelOnError);

149 class _StreamSubscriptionTransformer<S, T> implements StreamTransformer<S, T> { final _SubscriptionTransformer<S, T> _transformer;

150 const _StreamSubscriptionTransformer(this._transformer);

151 Stream<T> bind(Stream<S> stream) => new _BoundSubscriptionStream<S, T>(stream, _transformer);

152 }

153 class _BoundSubscriptionStream<S, T> extends Stream<T> {final _SubscriptionTran sformer<S, T> _transformer;

154 final Stream<S> _stream;

155 _BoundSubscriptionStream(this._stream, this._transformer);

156 StreamSubscription<T> listen(void onData(T event), {

157 Function onError, void onDone(), bool cancelOnError}

158 ) {

159 cancelOnError = identical(true, cancelOnError);

160 StreamSubscription<T> result = _transformer(_stream, cancelOnError);

161 result.onData(onData);

162 result.onError(onError);

163 result.onDone(onDone);

164 return result;

165 }

166 }

167 typedef dynamic __CastType59<T>(EventSink<T> __u60);

168 typedef void __CastType62<S, T>(S __u63, EventSink<T> __u64);

169 typedef void __CastType65(dynamic __u66, EventSink<dynamic> __u67);

170 typedef void __CastType68<T>(Object __u69, StackTrace __u70, EventSink<T> __u71 );

171 typedef void __CastType72(dynamic __u73, StackTrace __u74, EventSink<dynamic> _ _u75);

OLD	NEW

« no previous file with comments | « test/dart_codegen/expect/async/stream_pipe.dart ('k') | test/dart_codegen/expect/async/timer.dart » ('j') | no next file with comments »