get basics working

Author: TimWhiting

json_serializable/example/example.dart

@@ -45,7 +45,9 @@ class Person2<@jsonKeyType K, V> {
   factory Person2.fromJson(Map<String, dynamic> json,
           K Function(Object?) fromJsonK, V Function(Object?) fromJsonV) =>
       Person2(id: fromJsonK(json), name: fromJsonV(json));
-  Object toJson(Object? Function(K) toJsonK, Object? Function(V) toJsonV) => {
+  Map<String, dynamic> toJson(
+          String Function(K) toJsonK, Object? Function(V) toJsonV) =>
+      {
         toJsonK(id): toJsonV(name),
       };
 }

json_serializable/example/example.g.dart

@@ -11,10 +11,13 @@ import 'package:source_gen/source_gen.dart';
 import 'package:source_helper/source_helper.dart';
 
 import '../default_container.dart';
+import '../shared_checkers.dart';
 import '../type_helper.dart';
+import '../unsupported_type_error.dart';
 import '../utils.dart';
 import 'config_types.dart';
 import 'generic_factory_helper.dart';
+import 'to_from_string.dart';
 
 const _helperLambdaParam = 'value';
 
@@ -49,12 +52,13 @@ class JsonHelper extends TypeHelper<TypeHelperContextWithConfig> {
 
       toJsonArgs.addAll(
         _helperParams(
-          context.serialize,
-          _encodeHelper,
-          interfaceType,
-          toJson.parameters.where((element) => element.isRequiredPositional),
-          toJson,
-        ),
+            context,
+            context.serialize,
+            _encodeHelper,
+            interfaceType,
+            toJson.parameters.where((element) => element.isRequiredPositional),
+            toJson,
+            isSerializing: true),
       );
     }
 
@@ -108,13 +112,9 @@ class JsonHelper extends TypeHelper<TypeHelperContextWithConfig> {
 
       final args = [
         output,
-        ..._helperParams(
-          context.deserialize,
-          _decodeHelper,
-          targetType,
-          positionalParams.skip(1),
-          fromJsonCtor,
-        ),
+        ..._helperParams(context, context.deserialize, _decodeHelper,
+            targetType, positionalParams.skip(1), fromJsonCtor,
+            isSerializing: false),
       ];
 
       output = args.join(', ');
@@ -137,13 +137,16 @@ class JsonHelper extends TypeHelper<TypeHelperContextWithConfig> {
 }
 
 List<String> _helperParams(
+  TypeHelperContextWithConfig context,
   Object? Function(DartType, String) execute,
-  TypeParameterType Function(ParameterElement, Element) paramMapper,
+  TypeParameterTypeWithKeyHelper Function(ParameterElement, Element)
+      paramMapper,
   InterfaceType type,
   Iterable<ParameterElement> positionalParams,
-  Element targetElement,
-) {
-  final rest = <TypeParameterType>[];
+  Element targetElement, {
+  required bool isSerializing,
+}) {
+  final rest = <TypeParameterTypeWithKeyHelper>[];
   for (var param in positionalParams) {
     rest.add(paramMapper(param, targetElement));
   }
@@ -152,13 +155,19 @@ List<String> _helperParams(
 
   for (var helperArg in rest) {
     final typeParamIndex =
-        type.element.typeParameters.indexOf(helperArg.element);
+        type.element.typeParameters.indexOf(helperArg.type.element);
 
     // TODO: throw here if `typeParamIndex` is -1 ?
     final typeArg = type.typeArguments[typeParamIndex];
     final body = execute(typeArg, _helperLambdaParam);
-    if (helperArg.element.declaration.metadata.any((md) => md.element?.displayName == 'jsonKeyType')){
-      final newBody = _helperParams(execute, paramMapper, type, positionalParams, targetElement);
+    if (helperArg.type.element.declaration.metadata
+        .any((md) => md.element?.displayName == 'jsonKeyType')) {
+      print('JsonKeyType');
+      const keyHelper = MapKeyHelper();
+
+      final newBody = isSerializing
+          ? keyHelper.serialize(typeArg, '', context)
+          : keyHelper.deserialize(typeArg, '', context, false);
       args.add('($_helperLambdaParam) => $newBody /* todo json key */');
     } else {
       args.add('($_helperLambdaParam) => $body');
@@ -168,7 +177,7 @@ List<String> _helperParams(
   return args;
 }
 
-TypeParameterType _decodeHelper(
+TypeParameterTypeWithKeyHelper _decodeHelper(
   ParameterElement param,
   Element targetElement,
 ) {
@@ -183,8 +192,11 @@ TypeParameterType _decodeHelper(
       final funcParamType = type.normalParameterTypes.single;
 
       if ((funcParamType.isDartCoreObject && funcParamType.isNullableType) ||
-          funcParamType.isDynamic) {
-        return funcReturnType as TypeParameterType;
+          funcParamType.isDynamic ||
+          funcParamType.isDartCoreString) {
+        return TypeParameterTypeWithKeyHelper(
+            funcReturnType as TypeParameterType,
+            funcParamType.isDartCoreString);
       }
     }
   }
@@ -199,20 +211,30 @@ TypeParameterType _decodeHelper(
   );
 }
 
-TypeParameterType _encodeHelper(
+class TypeParameterTypeWithKeyHelper {
+  final TypeParameterType type;
+  final bool isKey;
+
+  TypeParameterTypeWithKeyHelper(this.type, this.isKey);
+}
+
+TypeParameterTypeWithKeyHelper _encodeHelper(
   ParameterElement param,
   Element targetElement,
 ) {
   final type = param.type;
 
   if (type is FunctionType &&
-      (type.returnType.isDartCoreObject || type.returnType.isDynamic) &&
+      (type.returnType.isDartCoreObject ||
+          type.returnType.isDynamic ||
+          type.returnType.isDartCoreString) &&
       type.normalParameterTypes.length == 1) {
     final funcParamType = type.normalParameterTypes.single;
 
     if (param.name == toJsonForName(funcParamType.element!.name!)) {
       if (funcParamType is TypeParameterType) {
-        return funcParamType;
+        return TypeParameterTypeWithKeyHelper(
+            funcParamType, type.returnType.isDartCoreString);
       }
     }
   }
@@ -295,3 +317,119 @@ ClassConfig? _annotation(ClassConfig config, InterfaceType source) {
 MethodElement? _toJsonMethod(DartType type) => type.typeImplementations
     .map((dt) => dt is InterfaceType ? dt.getMethod('toJson') : null)
     .firstWhereOrNull((me) => me != null);
+
+class MapKeyHelper extends TypeHelper<TypeHelperContextWithConfig> {
+  const MapKeyHelper();
+
+  @override
+  String? serialize(
+    DartType targetType,
+    String expression,
+    TypeHelperContextWithConfig context,
+  ) {
+    final keyType = targetType;
+
+    _checkSafeKeyType(expression, keyType);
+
+    final subKeyValue =
+        _forType(keyType)?.serialize(keyType, _helperLambdaParam, false) ??
+            context.serialize(keyType, _helperLambdaParam);
+
+    if (_helperLambdaParam == subKeyValue) {
+      return expression;
+    }
+
+    return '$subKeyValue';
+  }
+
+  @override
+  String? deserialize(
+    DartType targetType,
+    String expression,
+    TypeHelperContextWithConfig context,
+    bool defaultProvided,
+  ) {
+    final keyArg = targetType;
+
+    _checkSafeKeyType(expression, keyArg);
+
+    final isKeyStringable = _isKeyStringable(keyArg);
+    if (!isKeyStringable) {
+      throw UnsupportedTypeError(
+        keyArg,
+        expression,
+        'Map keys must be one of: ${_allowedTypeNames.join(', ')}.',
+      );
+    }
+
+    String keyUsage;
+    if (keyArg.isEnum) {
+      keyUsage = context.deserialize(keyArg, _helperLambdaParam).toString();
+    } else if (context.config.anyMap &&
+        !(keyArg.isDartCoreObject || keyArg.isDynamic)) {
+      keyUsage = '$_helperLambdaParam as String';
+    } else if (context.config.anyMap &&
+        keyArg.isDartCoreObject &&
+        !keyArg.isNullableType) {
+      keyUsage = '$_helperLambdaParam as Object';
+    } else {
+      print('Key is $keyArg');
+      keyUsage = '$_helperLambdaParam as String';
+    }
+
+    final toFromString = _forType(keyArg);
+    if (toFromString != null) {
+      keyUsage = toFromString.deserialize(keyArg, keyUsage, false, true)!;
+    }
+
+    return keyUsage;
+  }
+}
+
+final _intString = ToFromStringHelper('int.parse', 'toString()', 'int');
+
+/// [ToFromStringHelper] instances representing non-String types that can
+/// be used as [Map] keys.
+final _instances = [
+  bigIntString,
+  dateTimeString,
+  _intString,
+  uriString,
+];
+
+ToFromStringHelper? _forType(DartType type) =>
+    _instances.singleWhereOrNull((i) => i.matches(type));
+
+/// Returns `true` if [keyType] can be automatically converted to/from String –
+/// and is therefor usable as a key in a [Map].
+bool _isKeyStringable(DartType keyType) =>
+    keyType.isEnum || _instances.any((inst) => inst.matches(keyType));
+
+void _checkSafeKeyType(String expression, DartType keyArg) {
+  // We're not going to handle converting key types at the moment
+  // So the only safe types for key are dynamic/Object/String/enum
+  if (keyArg.isDynamic ||
+      (!keyArg.isNullableType &&
+          (keyArg.isDartCoreObject ||
+              coreStringTypeChecker.isExactlyType(keyArg) ||
+              _isKeyStringable(keyArg)))) {
+    return;
+  }
+
+  throw UnsupportedTypeError(
+    keyArg,
+    expression,
+    'Map keys must be one of: ${_allowedTypeNames.join(', ')}.',
+  );
+}
+
+/// The names of types that can be used as [Map] keys.
+///
+/// Used in [_checkSafeKeyType] to provide a helpful error with unsupported
+/// types.
+Iterable<String> get _allowedTypeNames => const [
+      'Object',
+      'dynamic',
+      'enum',
+      'String',
+    ].followedBy(_instances.map((i) => i.coreTypeName));