Rudimentary generator inplace

ejson/lib/src/decoding.dart

@@ -22,7 +22,7 @@ const commonDecoders = {
   UndefinedOr: _decodeUndefinedOr,
 };
 
-var customDecoders = const <Type, Function>{};
+var customDecoders = <Type, Function>{};
 
 // if registerSerializableTypes not called
 final decoders = () {

ejson/lib/src/encoding.dart

@@ -3,7 +3,7 @@ import 'package:type_plus/type_plus.dart';
 import 'types.dart';
 
 // No custom encoders, if registerSerializableTypes not called
-var customEncoders = const <Type, Function>{};
+var customEncoders = <Type, Function>{};
 
 var relaxed = false;
 

ejson/lib/src/generator/generator.dart

@@ -1,17 +1,59 @@
+import 'dart:async';
+
 import 'package:analyzer/dart/element/element.dart';
 import 'package:build/build.dart';
 import 'package:ejson/ejson.dart';
 import 'package:source_gen/source_gen.dart';
 
 /// @nodoc
-class EJsonGenerator extends GeneratorForAnnotation<EJson> {
+class EJsonGenerator extends Generator {
+  const EJsonGenerator();
+
+  TypeChecker get typeChecker => TypeChecker.fromRuntime(EJson);
+
   @override
-  String generateForAnnotatedElement(
-    Element element,
-    ConstantReader annotation,
-    BuildStep buildStep,
-  ) {
-    if (element is ConstructorElement) {}
-    return '';
+  FutureOr<String> generate(LibraryReader library, BuildStep buildStep) async {
+    final ctors = library.classes.map(
+      (c) => c.constructors.singleWhere(
+        (c) =>
+            typeChecker.firstAnnotationOf(c, throwOnUnresolved: false) != null,
+      ),
+    );
+    return ctors.map((ctor) {
+      final cls = ctor.enclosingElement;
+      final className = ctor.enclosingElement.name;
+
+      log.info('Generating EJson for $className');
+      return '''
+        EJsonValue encode$className($className value) {
+          return {
+            ${ctor.parameters.map((p) => "'${p.name}': value.${p.name}.toEJson()").join('\n')}
+          };
+        }
+
+        $className decode$className(EJsonValue ejson) {
+          return switch (ejson) {
+            ${decodePattern(ctor.parameters)} => $className(
+              ${ctor.parameters.map((p) => "${p.name}.to<${p.type}>()").join(',\n')}
+            ),
+            _ => raiseInvalidEJson(ejson),
+          };
+        }
+
+        extension ${className}EJsonEncoderExtension on $className {
+          @pragma('vm:prefer-inline')
+          EJsonValue toEJson() => encode$className(this);
+        }
+      ''';
+    }).join('\n\n');
+  }
+}
+
+String decodePattern(Iterable<ParameterElement> parameters) {
+  if (parameters.isEmpty) {
+    return 'Map m when m.isEmpty';
   }
+  return parameters
+      .map((p) => "{'${p.name}': EJsonValue ${p.name}}")
+      .join(',\n');
 }