Support declaring and lazy transformers in pub.

sdk/lib/_internal/pub/asset/dart/serialize/transform.dart

 // Copyright (c) 2014, 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.asset.serialize.transform;
 
 import 'dart:async';
 import 'dart:isolate';
 import 'dart:convert';
 
 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 '../serialize.dart';
 import '../utils.dart';
 
-/// Converts [transform] into a serializable map.
-Map serializeTransform(Transform transform) {
+/// Serialize the methods shared between [Transform] and [DeclaringTransform].
+///
+/// [additionalFields] contains additional serialized fields to add to the
+/// serialized transform. [handleMessage] handles additional methods that differ
+/// between the two. It should return a [Future] if it handles a method, or
+/// `null` if it doesn't.
+Map _serializeBaseTransform(transform, Map additionalFields,
+    Future handleMessage(message)) {

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

Since handleMessage is specifically for handling methods, how about putting the
message[type] checking here and pass in a map of methodName->callback. Like:

var handler = methodHandlers[message['type']];
if (handler != null) return handler();

See below...

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

Done.

   var receivePort = new ReceivePort();
   receivePort.listen((wrappedMessage) {
     respond(wrappedMessage, (message) {
-      if (message['type'] == 'getInput') {
-        return transform.getInput(deserializeId(message['id']))
-            .then((asset) => serializeAsset(asset));
-      }
-
-      if (message['type'] == 'addOutput') {
-        transform.addOutput(deserializeAsset(message['output']));
-        return null;
-      }
+      var handled = handleMessage(message);
+      if (handled != null) return handled;
 
       if (message['type'] == 'consumePrimary') {
         transform.consumePrimary();
         return null;
       }
 
       assert(message['type'] == 'log');
       var method;
       if (message['level'] == 'Info') {
         method = transform.logger.info;
       } else if (message['level'] == 'Fine') {
         method = transform.logger.fine;
       } else if (message['level'] == 'Warning') {
         method = transform.logger.warning;
       } else {
         assert(message['level'] == 'Error');
         method = transform.logger.error;

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

Seems like a map would be simpler here.

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

Done.

       }
 
       var assetId = message['assetId'] == null ? null :
         deserializeId(message['assetId']);
       var span = message['span'] == null ? null :
         deserializeSpan(message['span']);
       method(message['message'], asset: assetId, span: span);
     });
   });
 
-  return {
-    'port': receivePort.sendPort,
-    'primaryInput': serializeAsset(transform.primaryInput)
-  };
+  return {'port': receivePort.sendPort}..addAll(additionalFields);
 }
 
-/// A wrapper for a [Transform] that's in the host isolate.
-///
-/// This retrieves inputs from and sends outputs and logs to the host isolate.
-class ForeignTransform implements Transform {
+/// Converts [transform] into a serializable map.
+Map serializeTransform(Transform transform) {
+  return _serializeBaseTransform(transform, {
+    'primaryInput': serializeAsset(transform.primaryInput)
+  }, (message) {

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

...and then here, do:

{
  'getInput': () => return transform.getInput(deserializeId(message['id']))
           .then((asset) => serializeAsset(asset)),
  'addOutput': () => ...
}

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

Done.

+    if (message['type'] == 'getInput') {
+      return transform.getInput(deserializeId(message['id']))
+          .then((asset) => serializeAsset(asset));
+    }
+
+    if (message['type'] != 'addOutput') return null;
+
+    transform.addOutput(deserializeAsset(message['output']));
+    return new Future.value();
+  });
+}
+
+/// Converts [transform] into a serializable map.
+Map serializeDeclaringTransform(DeclaringTransform transform) {
+  return _serializeBaseTransform(transform, {
+    'primaryId': serializeId(transform.primaryId)
+  }, (message) {
+    if (message['type'] != 'declareOutput') return null;
+
+    transform.declareOutput(deserializeId(message['output']));
+    return new Future.value();
+  });
+}
+
+/// The base class for wrappers for [Transform]s that are in the host isolate.
+class _ForeignBaseTransform {
   /// The port with which we communicate with the host isolate.
   ///
   /// This port and all messages sent across it are specific to this transform.
   final SendPort _port;
 
-  final Asset primaryInput;
-
   TransformLogger get logger => _logger;
   TransformLogger _logger;
 
-  /// Creates a transform from a serializable map sent from the host isolate.
-  ForeignTransform(Map transform)
-      : _port = transform['port'],
-        primaryInput = deserializeAsset(transform['primaryInput']) {
+  _ForeignBaseTransform(Map transform)
+      : _port = transform['port'] {
     _logger = new TransformLogger((assetId, level, message, span) {
       call(_port, {
         'type': 'log',
         'level': level.name,
         'message': message,
         'assetId': assetId == null ? null : serializeId(assetId),
         'span': span == null ? null : serializeSpan(span)
       });
     });
   }
 
+  void consumePrimary() {
+    call(_port, {'type': 'consumePrimary'});
+  }
+}
+
+/// A wrapper for a [Transform] that's in the host isolate.
+///
+/// This retrieves inputs from and sends outputs and logs to the host isolate.
+class ForeignTransform extends _ForeignBaseTransform implements Transform {
+  final Asset primaryInput;
+
+  /// Creates a transform from a serializable map sent from the host isolate.

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

"serializable" -> "serialized".

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

Done.

+  ForeignTransform(Map transform)
+      : primaryInput = deserializeAsset(transform['primaryInput']),
+        super(transform);
+
   Future<Asset> getInput(AssetId id) {
     return call(_port, {
       'type': 'getInput',
       'id': serializeId(id)
     }).then(deserializeAsset);
   }
 
   Future<String> readInputAsString(AssetId id, {Encoding encoding}) {
     if (encoding == null) encoding = UTF8;
     return getInput(id).then((input) => input.readAsString(encoding: encoding));
   }
 
   Stream<List<int>> readInput(AssetId id) =>
       futureStream(getInput(id).then((input) => input.read()));
 
   Future<bool> hasInput(AssetId id) {
     return getInput(id).then((_) => true).catchError((error) {
       if (error is AssetNotFoundException && error.id == id) return false;
       throw error;
     });
   }
 
   void addOutput(Asset output) {
     call(_port, {
       'type': 'addOutput',
       'output': serializeAsset(output)
     });
   }
+}
 
-  void consumePrimary() {
-    call(_port, {'type': 'consumePrimary'});
+/// A wrapper for a [DeclaringTransform] that's in the host isolate.
+class ForeignDeclaringTransform extends _ForeignBaseTransform
+    implements DeclaringTransform {
+  final AssetId primaryId;
+
+  /// Creates a transform from a serializable map sent from the host isolate.
+  ForeignDeclaringTransform(Map transform)
+      : primaryId = deserializeId(transform['primaryId']),
+        super(transform);
+
+  void declareOutput(AssetId id) {
+    call(_port, {
+      'type': 'declareOutput',
+      'output': serializeId(id)
+    });
   }
 }