instantiated empty target

Author: KernelPanic92

generator/lib/src/dartstruct_generator.dart

@@ -2,6 +2,7 @@ import 'package:analyzer/dart/element/element.dart';
 import 'package:build/src/builder/build_step.dart';
 import 'package:code_builder/code_builder.dart';
 import 'package:dart_style/dart_style.dart';
+import 'package:dartstruct_generator/src/name_provider.dart';
 import 'package:source_gen/source_gen.dart';
 import 'package:dartstruct/dartstruct.dart';
 import './extensions/extensions.dart';
@@ -29,21 +30,24 @@ class DartStructGenerator extends GeneratorForAnnotation<Mapper> {
       );
     }
 
-    final classBuilder = ClassBuilder()
-      ..name = '${classElement.displayName}Impl'
-      ..abstract = false
-      ..extend = refer(classElement.displayName)
-      ..methods.addAll(classElement.methods.where((method) => method.isAbstract).map(_generateMethod));
+    final nameProvider = NameProvider(classElement);
 
-    final mapperImpl = classBuilder.build();
+
+    final mapperImpl = Class((builder) {
+      builder
+        ..name = '${classElement.displayName}Impl'
+        ..abstract = false
+        ..extend = refer(classElement.displayName)
+        ..methods.addAll(classElement.methods.where((method) => method.isAbstract).map((method) => _generateMethod(method, nameProvider.forMethod(method))));
+    });
 
     final code = '${mapperImpl.accept(_emitter)}';
 
     return _formatter.format(code);
 
   }
 
-  Method _generateMethod(MethodElement method) {
+  Method _generateMethod(MethodElement method, NameProvider nameProvider) {
 
     if (method.parameters.isEmpty) {
       throw InvalidGenerationSourceError('Method must provide an argument',
@@ -95,13 +99,25 @@ class DartStructGenerator extends GeneratorForAnnotation<Mapper> {
       );
     }
 
+    if (returnType.isDynamic) {
+      throw InvalidGenerationSourceError('Dynamic type is not supported',
+        element: method
+      );
+    }
+
+    if (!returnType.hasEmptyConstructor) {
+      throw InvalidGenerationSourceError('Return type must provide an empty parameters constructor',
+        element: method.returnType.element
+      );
+    }
+
     return Method((builder) {
       builder
         ..annotations.add(CodeExpression(Code('override')))
         ..name = method.displayName
         ..requiredParameters.add(_generateSourceParameter(source))
         ..returns = refer(returnType.element.displayName)
-        ..body = _generateMethodBody(method);
+        ..body = _generateMethodBody(method, nameProvider);
     });
   }
 
@@ -113,8 +129,19 @@ class DartStructGenerator extends GeneratorForAnnotation<Mapper> {
     });
   }
 
-  Code _generateMethodBody(MethodElement methodElement) {
-    return Code('return null;');
+  Code _generateMethodBody(MethodElement methodElement, NameProvider nameProvider) {
+
+    print(nameProvider);
+
+    final targetType = methodElement.returnType;
+
+    final targetName = nameProvider.provideVariableName(targetType);
+
+    return Block((builder) {
+      builder
+        ..addExpression(refer(targetType.element.displayName).newInstance([]).assignFinal(targetName))
+        ..addExpression(refer(targetName).returned);
+    });
   }
 
 }

generator/lib/src/extensions/dart_type_extension.dart

@@ -1,3 +1,4 @@
+import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 
 extension DartTypeExtension on DartType {
@@ -16,4 +17,27 @@ extension DartTypeExtension on DartType {
 
   bool get isCollection => isDartCoreMap || isDartCoreList || isDartCoreSet;
 
+  bool get hasEmptyConstructor {
+
+    if (element is ClassElement) {
+      final classElement = element as ClassElement;
+
+      for (final constructor in classElement.constructors) {
+
+        final hasRequiredParameter = constructor.parameters.any(_isRequiredParameter);
+
+        if (!hasRequiredParameter) {
+          return true;
+        }
+
+      }
+    }
+
+    return false;
+
+  }
+
+  bool _isRequiredParameter(ParameterElement parameterElement) {
+     return parameterElement.isRequiredNamed || parameterElement.isRequiredPositional || parameterElement.hasRequired;
+  }
 }

generator/lib/src/name_provider.dart

@@ -0,0 +1,47 @@
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:recase/recase.dart';
+
+class NameProvider {
+  List<String> _names;
+
+  NameProvider(ClassElement classElement) {
+    _names = [
+      classElement.displayName,
+      ...classElement.accessors.map((accessor) => accessor.displayName).toSet(),
+      ...classElement.methods.map((method) => method.displayName),
+      ...classElement.constructors.map((constructor) => constructor.displayName).toSet()
+    ];
+  }
+
+  NameProvider._privateConstructor(List<String> names) {
+    _names = [ ...names ];
+  }
+
+  NameProvider forMethod(MethodElement methodElement) {
+    return NameProvider._privateConstructor([
+      ..._names,
+      ...methodElement.parameters.map((parameter) => parameter.displayName)
+    ]);
+  }
+
+  String provideVariableName(DartType type) {
+
+    final displayName = type.element.displayName;
+
+    final name = ReCase(displayName).camelCase;
+
+    var nameWithIndex = name;
+    var counter = 1;
+
+    while(_names.contains(nameWithIndex)) {
+      nameWithIndex = '$name$counter';
+      counter++;
+    }
+
+    _names.add(nameWithIndex);
+
+    return nameWithIndex;
+
+  }
+}

generator/pubspec.yaml

@@ -11,6 +11,7 @@ dependencies:
   code_builder: ^3.2.1
   dart_style: ^1.3.3
   analyzer: ^0.39.5
+  recase: ^3.0.0
   dartstruct:
     path: ../core
 

integration_tests/test/empty_method_mapper/empty_method_mapper.dart

@@ -10,6 +10,7 @@ class Model {
 class Dto {
   String field;
 }
+
 @Mapper()
 abstract class EmptyMethodMapper {
 

integration_tests/test/empty_method_mapper/empty_method_mapper_test.dart

@@ -10,7 +10,8 @@ void main() {
     });
 
     test('Should return null', () {
-      expect(EmptyMethodMapper.INSTANCE, isNotNull);
+      final model = Model()..field = 'test';
+      expect(EmptyMethodMapper.INSTANCE.modelToDto(model), isNotNull);
     });
 
   });