// Copyright (c) 2018, 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.
|
|
import 'package:analyzer/dart/element/element.dart';
|
import 'package:json_annotation/json_annotation.dart';
|
import 'package:source_gen/source_gen.dart';
|
|
import 'helper_core.dart';
|
import 'json_literal_generator.dart';
|
import 'type_helper.dart';
|
import 'utils.dart';
|
|
class CreateFactoryResult {
|
final String output;
|
final Set<String> usedFields;
|
|
CreateFactoryResult(this.output, this.usedFields);
|
}
|
|
abstract class DecodeHelper implements HelperCore {
|
final StringBuffer _buffer = StringBuffer();
|
|
CreateFactoryResult createFactory(Map<String, FieldElement> accessibleFields,
|
Map<String, String> unavailableReasons) {
|
assert(config.createFactory);
|
assert(_buffer.isEmpty);
|
|
final mapType = config.anyMap ? 'Map' : 'Map<String, dynamic>';
|
_buffer.write('$targetClassReference '
|
'${prefix}FromJson${genericClassArgumentsImpl(true)}'
|
'($mapType json) {\n');
|
|
String deserializeFun(String paramOrFieldName,
|
{ParameterElement ctorParam}) =>
|
_deserializeForField(accessibleFields[paramOrFieldName],
|
ctorParam: ctorParam);
|
|
_ConstructorData data;
|
if (config.checked) {
|
final classLiteral = escapeDartString(element.name);
|
|
_buffer.write('''
|
return \$checkedNew(
|
$classLiteral,
|
json,
|
() {\n''');
|
|
data = _writeConstructorInvocation(
|
element,
|
accessibleFields.keys,
|
accessibleFields.values
|
.where((fe) => !fe.isFinal)
|
.map((fe) => fe.name)
|
.toList(),
|
unavailableReasons,
|
deserializeFun);
|
|
_writeChecks(
|
6,
|
config,
|
accessibleFields.values
|
.where((fe) => data.usedCtorParamsAndFields.contains(fe.name)));
|
_buffer.write('''
|
final val = ${data.content};''');
|
|
for (final field in data.fieldsToSet) {
|
_buffer.writeln();
|
final safeName = safeNameAccess(accessibleFields[field]);
|
_buffer.write('''
|
\$checkedConvert(json, $safeName, (v) => ''');
|
_buffer.write('val.$field = ');
|
_buffer.write(_deserializeForField(accessibleFields[field],
|
checkedProperty: true));
|
_buffer.write(');');
|
}
|
|
_buffer.write('''\n return val;
|
}''');
|
|
final fieldKeyMap = Map.fromEntries(data.usedCtorParamsAndFields
|
.map((k) => MapEntry(k, nameAccess(accessibleFields[k])))
|
.where((me) => me.key != me.value));
|
|
String fieldKeyMapArg;
|
if (fieldKeyMap.isEmpty) {
|
fieldKeyMapArg = '';
|
} else {
|
final mapLiteral = jsonMapAsDart(fieldKeyMap);
|
fieldKeyMapArg = ', fieldKeyMap: const $mapLiteral';
|
}
|
|
_buffer.write(fieldKeyMapArg);
|
|
_buffer.write(')');
|
} else {
|
data = _writeConstructorInvocation(
|
element,
|
accessibleFields.keys,
|
accessibleFields.values
|
.where((fe) => !fe.isFinal)
|
.map((fe) => fe.name)
|
.toList(),
|
unavailableReasons,
|
deserializeFun);
|
|
_writeChecks(
|
2,
|
config,
|
accessibleFields.values
|
.where((fe) => data.usedCtorParamsAndFields.contains(fe.name)));
|
|
_buffer.write('''
|
return ${data.content}''');
|
for (final field in data.fieldsToSet) {
|
_buffer.writeln();
|
_buffer.write(' ..$field = ');
|
_buffer.write(deserializeFun(field));
|
}
|
}
|
_buffer.writeln(';\n}');
|
_buffer.writeln();
|
|
return CreateFactoryResult(
|
_buffer.toString(), data.usedCtorParamsAndFields);
|
}
|
|
void _writeChecks(int indent, JsonSerializable classAnnotation,
|
Iterable<FieldElement> accessibleFields) {
|
final args = <String>[];
|
|
String constantList(Iterable<FieldElement> things) =>
|
'const ${jsonLiteralAsDart(things.map(nameAccess).toList())}';
|
|
if (classAnnotation.disallowUnrecognizedKeys) {
|
final allowKeysLiteral = constantList(accessibleFields);
|
|
args.add('allowedKeys: $allowKeysLiteral');
|
}
|
|
final requiredKeys =
|
accessibleFields.where((fe) => jsonKeyFor(fe).required).toList();
|
if (requiredKeys.isNotEmpty) {
|
final requiredKeyLiteral = constantList(requiredKeys);
|
|
args.add('requiredKeys: $requiredKeyLiteral');
|
}
|
|
final disallowNullKeys = accessibleFields
|
.where((fe) => jsonKeyFor(fe).disallowNullValue)
|
.toList();
|
if (disallowNullKeys.isNotEmpty) {
|
final dissallowNullKeyLiteral = constantList(disallowNullKeys);
|
|
args.add('disallowNullValues: $dissallowNullKeyLiteral');
|
}
|
|
if (args.isNotEmpty) {
|
_buffer.writeln('${' ' * indent}\$checkKeys(json, ${args.join(', ')});');
|
}
|
}
|
|
String _deserializeForField(FieldElement field,
|
{ParameterElement ctorParam, bool checkedProperty}) {
|
checkedProperty ??= false;
|
final jsonKeyName = safeNameAccess(field);
|
final targetType = ctorParam?.type ?? field.type;
|
final contextHelper = getHelperContext(field);
|
|
String value;
|
try {
|
if (config.checked) {
|
value = contextHelper.deserialize(targetType, 'v').toString();
|
if (!checkedProperty) {
|
value = '\$checkedConvert(json, $jsonKeyName, (v) => $value)';
|
}
|
} else {
|
assert(!checkedProperty,
|
'should only be true if `_generator.checked` is true.');
|
|
value = contextHelper
|
.deserialize(targetType, 'json[$jsonKeyName]')
|
.toString();
|
}
|
} on UnsupportedTypeError catch (e) {
|
throw createInvalidGenerationError('fromJson', field, e);
|
}
|
|
final defaultValue = jsonKeyFor(field).defaultValue;
|
if (defaultValue != null) {
|
if (!contextHelper.nullable) {
|
throwUnsupported(field,
|
'Cannot use `defaultValue` on a field with `nullable` false.');
|
}
|
|
value = '$value ?? $defaultValue';
|
}
|
return value;
|
}
|
}
|
|
/// [availableConstructorParameters] is checked to see if it is available. If
|
/// [availableConstructorParameters] does not contain the parameter name,
|
/// an [UnsupportedError] is thrown.
|
///
|
/// To improve the error details, [unavailableReasons] is checked for the
|
/// unavailable constructor parameter. If the value is not `null`, it is
|
/// included in the [UnsupportedError] message.
|
///
|
/// [writeableFields] are also populated, but only if they have not already
|
/// been defined by a constructor parameter with the same name.
|
_ConstructorData _writeConstructorInvocation(
|
ClassElement classElement,
|
Iterable<String> availableConstructorParameters,
|
Iterable<String> writeableFields,
|
Map<String, String> unavailableReasons,
|
String deserializeForField(String paramOrFieldName,
|
{ParameterElement ctorParam})) {
|
final className = classElement.name;
|
|
final ctor = classElement.unnamedConstructor;
|
if (ctor == null) {
|
// TODO(kevmoo): support using another ctor - dart-lang/json_serializable#50
|
throw UnsupportedError(
|
'The class `$className` has no default constructor.');
|
}
|
|
final usedCtorParamsAndFields = Set<String>();
|
final constructorArguments = <ParameterElement>[];
|
final namedConstructorArguments = <ParameterElement>[];
|
|
for (final arg in ctor.parameters) {
|
if (!availableConstructorParameters.contains(arg.name)) {
|
if (arg.isNotOptional) {
|
var msg = 'Cannot populate the required constructor '
|
'argument: ${arg.name}.';
|
|
final additionalInfo = unavailableReasons[arg.name];
|
|
if (additionalInfo != null) {
|
msg = '$msg $additionalInfo';
|
}
|
|
throw InvalidGenerationSourceError(msg, element: ctor);
|
}
|
|
continue;
|
}
|
|
// TODO: validate that the types match!
|
if (arg.isNamed) {
|
namedConstructorArguments.add(arg);
|
} else {
|
constructorArguments.add(arg);
|
}
|
usedCtorParamsAndFields.add(arg.name);
|
}
|
|
warnUndefinedElements(
|
constructorArguments.followedBy(namedConstructorArguments));
|
|
// fields that aren't already set by the constructor and that aren't final
|
final remainingFieldsForInvocationBody =
|
writeableFields.toSet().difference(usedCtorParamsAndFields);
|
|
final buffer = StringBuffer();
|
buffer.write('$className${genericClassArguments(classElement, false)}(');
|
if (constructorArguments.isNotEmpty) {
|
buffer.writeln();
|
buffer.writeAll(constructorArguments.map((paramElement) {
|
final content =
|
deserializeForField(paramElement.name, ctorParam: paramElement);
|
return ' $content';
|
}), ',\n');
|
if (namedConstructorArguments.isNotEmpty) {
|
buffer.write(',');
|
}
|
}
|
if (namedConstructorArguments.isNotEmpty) {
|
buffer.writeln();
|
buffer.writeAll(namedConstructorArguments.map((paramElement) {
|
final value =
|
deserializeForField(paramElement.name, ctorParam: paramElement);
|
return ' ${paramElement.name}: $value';
|
}), ',\n');
|
}
|
|
buffer.write(')');
|
|
usedCtorParamsAndFields.addAll(remainingFieldsForInvocationBody);
|
|
return _ConstructorData(buffer.toString(), remainingFieldsForInvocationBody,
|
usedCtorParamsAndFields);
|
}
|
|
class _ConstructorData {
|
final String content;
|
final Set<String> fieldsToSet;
|
final Set<String> usedCtorParamsAndFields;
|
_ConstructorData(
|
this.content, this.fieldsToSet, this.usedCtorParamsAndFields);
|
}
|
