Merge pull request #16 from davidmorgan/fix-comments

Stopped falling back to <Object> for collection generic types. Fixes for review comments.

Author: davidmorgan

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.0.3
+
+- Stop falling back to "<Object>" for collection type parameters.
+- Extend code generation to add the builders needed for collections.
+- Differentiate Object from unspecified.
+
 ## 0.0.2
 
 - Rewrite to fully use static type information.

built_json/lib/built_json.dart

@@ -37,34 +37,37 @@ abstract class Serializers {
   ///
   /// A [Serializer] must have been provided for every the object uses.
   ///
-  /// Types that are known statically can be provided via [genericType]. This
+  /// Types that are known statically can be provided via [specifiedType]. This
   /// will reduce the amount of data needed on the wire. The exact same
-  /// [genericType] will be needed to deserialize.
+  /// [specifiedType] will be needed to deserialize.
   ///
   /// Create one using [SerializersBuilder].
   ///
   /// TODO(davidmorgan): document the wire format.
   Object serialize(Object object,
-      {GenericType genericType: const GenericType()});
+      {FullType specifiedType: FullType.unspecified});
 
   /// Deserializes [serialized].
   ///
   /// A [Serializer] must have been provided for every the object uses.
   ///
-  /// If [serialized] was produced by calling [serialize] with [genericType],
-  /// the exact same [genericType] must be provided to deserialize.
+  /// If [serialized] was produced by calling [serialize] with [specifiedType],
+  /// the exact same [specifiedType] must be provided to deserialize.
   Object deserialize(Object serialized,
-      {GenericType genericType: const GenericType()});
+      {FullType specifiedType: FullType.unspecified});
 
-  /// Creates a new builder for the type represented by [genericType].
+  /// Creates a new builder for the type represented by [fullType].
   ///
-  /// For example, if [genericType] is `BuiltList<int, String>`, returns a
+  /// For example, if [fullType] is `BuiltList<int, String>`, returns a
   /// `ListBuilder<int, String>`. This helps serializers to instantiate with
   /// correct generic type parameters.
   ///
   /// May return null if no matching builder factory has been added. In this
-  /// case the serializer should fall back to `Object`.
-  Object newBuilder(GenericType genericType);
+  /// case the serializer should throw a [StateError].
+  Object newBuilder(FullType fullType);
+
+  /// Whether a builder for [fullType] is available via [newBuilder].
+  bool hasBuilder(FullType fullType);
 
   SerializersBuilder toBuilder();
 }
@@ -75,22 +78,35 @@ abstract class SerializersBuilder {
 
   void add(Serializer serializer);
 
-  void addBuilderFactory(GenericType genericType, Function function);
+  void addBuilderFactory(FullType specifiedType, Function function);
 
   Serializers build();
 }
 
-/// A tree of [Type] instances.
-class GenericType {
+/// A [Type] with, optionally, [FullType] generic type parameters.
+///
+/// May also be [unspecified], indicating that no type information is
+/// available.
+class FullType {
+  // An unspecified type.
+  static const unspecified = const FullType(null);
+
   /// The root of the type.
   final Type root;
 
   /// Type parameters of the type.
-  final List<GenericType> parameters;
+  final List<FullType> parameters;
+
+  const FullType(this.root, [this.parameters = const []]);
 
-  const GenericType([this.root = Object, this.parameters = const []]);
+  bool get isUnspecified => identical(root, null);
 
-  bool get isObject => root == Object;
+  @override
+  String toString() => isUnspecified
+      ? 'unspecified'
+      : parameters.isEmpty
+          ? root.toString()
+          : '${root.toString()}<${parameters.join(", ")}>';
 }
 
 /// Serializes a single type.
@@ -118,16 +134,16 @@ abstract class Serializer<T> {
   /// Serializes [object].
   ///
   /// Use [serializers] as needed for nested serialization. Information about
-  /// the type being serialized is provided in [genericType].
+  /// the type being serialized is provided in [specifiedType].
   ///
   /// TODO(davidmorgan): document the wire format.
   Object serialize(Serializers serializers, T object,
-      {GenericType genericType: const GenericType()});
+      {FullType specifiedType: FullType.unspecified});
 
   /// Deserializes [serialized].
   ///
   /// Use [serializers] as needed for nested deserialization. Information about
-  /// the type being deserialized is provided in [genericType].
+  /// the type being deserialized is provided in [specifiedType].
   T deserialize(Serializers serializers, Object serialized,
-      {GenericType genericType: const GenericType()});
+      {FullType specifiedType: FullType.unspecified});
 }

built_json/lib/src/bool_serializer.dart

@@ -11,14 +11,14 @@ class BoolSerializer implements Serializer<bool> {
   final String wireName = 'bool';
 
   @override
-  Object serialize(Serializers serializers, bool object,
-      {GenericType genericType: const GenericType()}) {
-    return object;
+  Object serialize(Serializers serializers, bool boolean,
+      {FullType specifiedType: FullType.unspecified}) {
+    return boolean;
   }
 
   @override
-  bool deserialize(Serializers serializers, Object object,
-      {GenericType genericType: const GenericType()}) {
-    return object as bool;
+  bool deserialize(Serializers serializers, Object serialized,
+      {FullType specifiedType: FullType.unspecified}) {
+    return serialized as bool;
   }
 }

built_json/lib/src/built_json_serializers.dart

@@ -10,15 +10,15 @@ class BuiltJsonSerializers implements Serializers {
   final BuiltMap<Type, Serializer> _typeToSerializer;
   final BuiltMap<String, Serializer> _wireNameToSerializer;
   final BuiltMap<String, Serializer> _typeNameToSerializer;
-  final BuiltMap<GenericType, Function> _builderFactories;
+  final BuiltMap<FullType, Function> _builderFactories;
 
   BuiltJsonSerializers._(this._typeToSerializer, this._wireNameToSerializer,
       this._typeNameToSerializer, this._builderFactories);
 
   @override
   Object serialize(Object object,
-      {GenericType genericType: const GenericType()}) {
-    if (genericType.isObject) {
+      {FullType specifiedType: FullType.unspecified}) {
+    if (specifiedType.isUnspecified) {
       final serializer = _getSerializerByType(object.runtimeType);
       if (serializer == null) throw new StateError(
           "No serializer for '${object.runtimeType}'.");
@@ -31,19 +31,19 @@ class BuiltJsonSerializers implements Serializers {
         return <Object>[serializer.wireName, serialized];
       }
     } else {
-      final serializer = _getSerializerByType(genericType.root);
+      final serializer = _getSerializerByType(specifiedType.root);
       if (serializer == null) throw new StateError(
-          "No serializer for '${genericType.root}'.");
+          "No serializer for '${specifiedType.root}'.");
       final result =
-          serializer.serialize(this, object, genericType: genericType);
+          serializer.serialize(this, object, specifiedType: specifiedType);
       return serializer.structured ? (result as Iterable).toList() : result;
     }
   }
 
   @override
   Object deserialize(Object object,
-      {GenericType genericType: const GenericType()}) {
-    if (genericType.isObject) {
+      {FullType specifiedType: FullType.unspecified}) {
+    if (specifiedType.isUnspecified) {
       final wireName = (object as List).first;
 
       final serializer = _wireNameToSerializer[wireName];
@@ -55,19 +55,24 @@ class BuiltJsonSerializers implements Serializers {
           : (object as List)[1];
       return serializer.deserialize(this, json);
     } else {
-      final serializer = _getSerializerByType(genericType.root);
+      final serializer = _getSerializerByType(specifiedType.root);
       if (serializer == null) throw new StateError(
-          "No serializer for '${genericType.root}'.");
-      return serializer.deserialize(this, object, genericType: genericType);
+          "No serializer for '${specifiedType.root}'.");
+      return serializer.deserialize(this, object, specifiedType: specifiedType);
     }
   }
 
   @override
-  Object newBuilder(types) {
-    final builderFactory = _builderFactories[types];
+  Object newBuilder(FullType fullType) {
+    final builderFactory = _builderFactories[fullType];
     return builderFactory == null ? null : builderFactory();
   }
 
+  @override
+  bool hasBuilder(FullType fullType) {
+    return _builderFactories.containsKey(fullType);
+  }
+
   @override
   SerializersBuilder toBuilder() {
     return new BuiltJsonSerializersBuilder._(
@@ -91,8 +96,8 @@ class BuiltJsonSerializersBuilder implements SerializersBuilder {
   MapBuilder<String, Serializer> _typeNameToSerializer =
       new MapBuilder<String, Serializer>();
 
-  MapBuilder<GenericType, Function> _builderFactories =
-      new MapBuilder<GenericType, Function>();
+  MapBuilder<FullType, Function> _builderFactories =
+      new MapBuilder<FullType, Function>();
 
   BuiltJsonSerializersBuilder();
 
@@ -110,7 +115,7 @@ class BuiltJsonSerializersBuilder implements SerializersBuilder {
     }
   }
 
-  void addBuilderFactory(GenericType types, Function function) {
+  void addBuilderFactory(FullType types, Function function) {
     _builderFactories[types] = function;
   }
 

built_json/lib/src/built_list_serializer.dart

@@ -11,27 +11,43 @@ class BuiltListSerializer implements Serializer<BuiltList> {
   final String wireName = 'list';
 
   @override
-  Object serialize(Serializers serializers, BuiltList object,
-      {GenericType genericType: const GenericType()}) {
-    final valueGenericType = genericType.parameters.isEmpty
-        ? const GenericType()
-        : genericType.parameters[0];
-
-    return object.map(
-        (item) => serializers.serialize(item, genericType: valueGenericType));
+  Object serialize(Serializers serializers, BuiltList builtList,
+      {FullType specifiedType: FullType.unspecified}) {
+    final isUnderspecified =
+        specifiedType.isUnspecified || specifiedType.parameters.isEmpty;
+
+    final elementType = specifiedType.parameters.isEmpty
+        ? FullType.unspecified
+        : specifiedType.parameters[0];
+
+    if (!isUnderspecified && !serializers.hasBuilder(specifiedType)) {
+      throw new StateError(
+          'No builder for $specifiedType, cannot serialize.');
+    }
+
+    return builtList.map(
+        (item) => serializers.serialize(item, specifiedType: elementType));
   }
 
   @override
-  BuiltList deserialize(Serializers serializers, Object object,
-      {GenericType genericType: const GenericType()}) {
-    final valueGenericType = genericType.parameters.isEmpty
-        ? const GenericType()
-        : genericType.parameters[0];
-
-    final result = serializers.newBuilder(genericType) as ListBuilder ??
-        new ListBuilder<Object>();
-    result.addAll((object as Iterable).map((item) =>
-        serializers.deserialize(item, genericType: valueGenericType)));
+  BuiltList deserialize(Serializers serializers, Object serialized,
+      {FullType specifiedType: FullType.unspecified}) {
+    final isUnderspecified =
+        specifiedType.isUnspecified || specifiedType.parameters.isEmpty;
+
+    final elementType = specifiedType.parameters.isEmpty
+        ? FullType.unspecified
+        : specifiedType.parameters[0];
+
+    final result = isUnderspecified
+        ? new ListBuilder<Object>()
+        : serializers.newBuilder(specifiedType) as ListBuilder;
+    if (result == null) {
+      throw new StateError(
+          'No builder for $specifiedType, cannot deserialize.');
+    }
+    result.addAll((serialized as Iterable).map((item) =>
+        serializers.deserialize(item, specifiedType: elementType)));
     return result.build();
   }
 }

built_json/lib/src/built_map_serializer.dart

@@ -11,46 +11,61 @@ class BuiltMapSerializer implements Serializer<BuiltMap> {
   final String wireName = 'map';
 
   @override
-  Object serialize(Serializers serializers, BuiltMap object,
-      {GenericType genericType: const GenericType()}) {
-    final keyTypes = genericType.parameters.isEmpty
-        ? const GenericType()
-        : genericType.parameters[0];
-    final valueTypes = genericType.parameters.isEmpty
-        ? const GenericType()
-        : genericType.parameters[1];
+  Object serialize(Serializers serializers, BuiltMap builtMap,
+      {FullType specifiedType: FullType.unspecified}) {
+    final isUnderspecified =
+        specifiedType.isUnspecified || specifiedType.parameters.isEmpty;
+
+    final keyType = specifiedType.parameters.isEmpty
+        ? FullType.unspecified
+        : specifiedType.parameters[0];
+    final valueType = specifiedType.parameters.isEmpty
+        ? FullType.unspecified
+        : specifiedType.parameters[1];
+
+    if (!isUnderspecified && !serializers.hasBuilder(specifiedType)) {
+      throw new StateError('No builder for $specifiedType, cannot serialize.');
+    }
 
     final result = <Object>[];
-    for (final key in object.keys) {
-      result.add(serializers.serialize(key, genericType: keyTypes));
-      final value = object[key];
-      result.add(serializers.serialize(value, genericType: valueTypes));
+    for (final key in builtMap.keys) {
+      result.add(serializers.serialize(key, specifiedType: keyType));
+      final value = builtMap[key];
+      result.add(serializers.serialize(value, specifiedType: valueType));
     }
     return result;
   }
 
   @override
-  BuiltMap deserialize(Serializers serializers, Object object,
-      {GenericType genericType: const GenericType()}) {
-    final keyTypes = genericType.parameters.isEmpty
-        ? const GenericType()
-        : genericType.parameters[0];
-    final valueTypes = genericType.parameters.isEmpty
-        ? const GenericType()
-        : genericType.parameters[1];
-
-    final result = serializers.newBuilder(genericType) as MapBuilder ??
-        new MapBuilder<Object, Object>();
-    final list = object as List<Object>;
+  BuiltMap deserialize(Serializers serializers, Object serialized,
+      {FullType specifiedType: FullType.unspecified}) {
+    final isUnderspecified =
+        specifiedType.isUnspecified || specifiedType.parameters.isEmpty;
+
+    final keyType = specifiedType.parameters.isEmpty
+        ? FullType.unspecified
+        : specifiedType.parameters[0];
+    final valueType = specifiedType.parameters.isEmpty
+        ? FullType.unspecified
+        : specifiedType.parameters[1];
+
+    final result = isUnderspecified
+        ? new MapBuilder<Object, Object>()
+        : serializers.newBuilder(specifiedType) as MapBuilder;
+    if (result == null) {
+      throw new StateError(
+          'No builder for $specifiedType, cannot deserialize.');
+    }
+    final list = serialized as List<Object>;
 
     if (list.length & 1 == 1) {
       throw new ArgumentError('odd length');
     }
 
     for (int i = 0; i != list.length; i += 2) {
-      final key = serializers.deserialize(list[i], genericType: keyTypes);
+      final key = serializers.deserialize(list[i], specifiedType: keyType);
       final value =
-          serializers.deserialize(list[i + 1], genericType: valueTypes);
+          serializers.deserialize(list[i + 1], specifiedType: valueType);
       result[key] = value;
     }