Support declaring and lazy transformers in pub.

sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart

Index: sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart
diff --git a/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart b/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart
new file mode 100644
index 0000000000000000000000000000000000000000..1cc5a1e9cc59f2921c351df70015c08aaa293f13
--- /dev/null
+++ b/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart
@@ -0,0 +1,101 @@
+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library pub.foreign_transformer;
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:barback/barback.dart';
+// TODO(nweiz): don't import from "src" once issue 14966 is fixed.
+import 'package:barback/src/internal_asset.dart';
+
+import '../../../asset/dart/serialize.dart';
+import '../barback.dart';
+import 'excluding_transformer.dart';
+
+/// A wrapper for a transformer that's in a different isolate.
+class _ForeignTransformer extends Transformer {
+  /// The port with which we communicate with the child isolate.
+  ///
+  /// This port and all messages sent across it are specific to this
+  /// transformer.
+  final SendPort _port;
+
+  /// The result of calling [toString] on the transformer in the isolate.
+  final String _toString;
+
+  _ForeignTransformer(Map map)
+      : _port = map['port'],
+        _toString = map['toString'];
+
+  Future<bool> isPrimary(AssetId id) {
+    return call(_port, {
+      'type': 'isPrimary',
+      'id': serializeId(id)
+    });
+  }
+
+  Future apply(Transform transform) {
+    return call(_port, {
+      'type': 'apply',
+      'transform': serializeTransform(transform)
+    });
+  }
+
+  String toString() => _toString;
+}
+
+class _ForeignDeclaringTransformer extends _ForeignTransformer
+    implements DeclaringTransformer {
+  _ForeignDeclaringTransformer(Map map)
+      : super(map);
+
+  Future declareOutputs(DeclaringTransform transform) {
+    return call(_port, {
+      'type': 'declareOutputs',
+      'transform': serializeDeclaringTransform(transform)
+    });
+  }
+}
+
+class _ForeignLazyTransformer extends _ForeignDeclaringTransformer
+    implements LazyTransformer {
+  _ForeignLazyTransformer(Map map)
+      : super(map);
+}
+
+/// A wrapper for a transformer group that's in a different isolate.
+class _ForeignGroup implements TransformerGroup {
+  final Iterable<Iterable> phases;
+
+  /// The result of calling [toString] on the transformer group in the isolate.
+  final String _toString;
+
+  _ForeignGroup(TransformerId id, Map map)
+      : phases = map['phases'].map((phase) {
+          return phase.map((transformer) => deserializeTransformerOrGroup(
+              transformer, id)).toList();
+        }).toList(),
+        _toString = map['toString'];
+
+  String toString() => _toString;
+}
+
+/// Converts a serializable map into a [Transformer] or a [TransformerGroup].
+deserializeTransformerOrGroup(Map map, TransformerId id) {
+  if (map['type'] == 'TransformerGroup') return new _ForeignGroup(id, map);

[Bob Nystrom, 2014/04/16 16:21:00]

How about:

switch (map['type']) { ... }

[nweiz, 2014/04/16 20:28:21]

Done.

+
+  var transformer;
+  if (map['type'] == 'Transformer') {
+    transformer = new _ForeignTransformer(map);
+  } else if (map['type'] == 'DeclaringTransformer') {
+    transformer = new _ForeignDeclaringTransformer(map);
+  } else {
+    assert(map['type'] == 'LazyTransformer');
+    transformer = new _ForeignLazyTransformer(map);
+  }
+
+  return ExcludingTransformer.wrap(transformer, id.includes, id.excludes);
+}