structurize function

Future<StructurizeResult> structurize(DartType type, ConstructorElement constructorElement, SubjectGenContext<Element> context, CachedAliasCounter counter,)

Implementation

Future<StructurizeResult> structurize(
    DartType type,
    ConstructorElement constructorElement,
    SubjectGenContext<Element> context,
    CachedAliasCounter counter) async {
  List<AliasImport> imports = [];
  List<CompiledStructureField> fields = [];
  var element = type.element! as ClassElement;
  var serialName = element.name;
  for (var e in constructorElement.parameters) {
    var fieldName = e.name.replaceFirst("this.", "");
    var field = element.getField(fieldName);
    if (field == null) {
      throw Exception(
          "Serializable constructors must only reference instance fields");
    }
    var fieldType = field.type;
    var serialType = await getSerialType(fieldType, context);
    var iterableType = await getIterableType(fieldType, context);

    var optional = field.type.nullabilitySuffix == NullabilitySuffix.question;
    if (fieldType.isDynamic) optional = true;

    var propertyName = fieldName;
    if (propertyNameChecker.hasAnnotationOf(field)) {
      var annotation = propertyNameChecker.annotationsOf(field).first;
      propertyName = annotation.getField("name")!.toStringValue()!;
    }

    var propertySerializer = "null";
    if (propertySerializerChecker.hasAnnotationOf(field)) {
      var serializerAnnotation =
          propertySerializerChecker.annotationsOf(field).first;
      propertySerializer =
          counter.get(serializerAnnotation.getField("type")!.toTypeValue()!);
    }
    if (polymorphicChecker.hasAnnotationOf(field)) {
      if (field.type.isDartCoreMap) {
        propertySerializer = genPrefix.str("DefaultMapConverter");
      } else if (field.type.isDartCoreIterable) {
        propertySerializer = genPrefix.str("DefaultIterableConverter");
      } else if (field.type.isDartCoreList) {
        propertySerializer = genPrefix.str("DefaultListConverter");
      } else if (field.type.isDartCoreSet) {
        propertySerializer = genPrefix.str("DefaultSetConverter");
      } else {
        propertySerializer = genPrefix.str("PolymorphicConverter");
      }
    }

    fields.add(CompiledStructureField(
        fieldName,
        counter.get(fieldType),
        propertySerializer,
        counter.get(serialType),
        iterableType,
        propertyName,
        optional,
        !isDogPrimitiveType(serialType),
        getRetainedAnnotationSourceArray(field, counter)));
  }

  // Determine used constructor
  var constructorName = "";
  if (element.getNamedConstructor("dog") != null) {
    constructorName = ".dog";
  }

  // Create proxy arguments
  var getters = fields.map((e) => e.accessor).toList();
  var activator = "${element.name}$constructorName(${fields.mapIndexed((i, y) {
    if (y.iterableKind == IterableKind.none) return "list[$i]";
    if (y.optional) return "list[$i]?.cast<${y.serialType}>()";
    return "list[$i].cast<${y.serialType}>()";
  }).join(", ")})";

  var structure = CompiledStructure(counter.get(type), serialName, fields,
      getRetainedAnnotationSourceArray(element, counter));
  return StructurizeResult(imports, structure, getters, activator);
}