General code cleanup for future development

di-benchmarks/src/jmh/java/org/panda_lang/utilities/inject/InstanceConstructionWithFieldsBenchmark.java

@@ -33,15 +33,15 @@
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
 public class InstanceConstructionWithFieldsBenchmark {
 
-    private static class Entity {
+    public static class Entity {
 
         private final int id;
         private final String name;
 
         @Inject
-        private EntityData data;
+        public EntityData data;
         @Inject
-        private EntityStorage storage;
+        public EntityStorage storage;
 
         public Entity(int id, String name) {
             this.name = name;
@@ -50,7 +50,7 @@ public Entity(int id, String name) {
 
     }
 
-    private static class EntityData {
+    public static class EntityData {
 
         private final int coins;
         private final float health;
@@ -130,6 +130,8 @@ public void setup() throws Exception {
                 resources.on(EntityData.class).assignInstance(this.entityDataSupplier);
                 resources.on(EntityStorage.class).assignInstance(this.entityStorage);
             });
+
+            CodegenFieldsInjector<Entity> entityCodegenFieldsInjector = new CodegenFieldsInjector<>(new InjectorProcessor(this.entityInjector), this.entityInjector.forConstructor(Entity.class));
         }
 
     }

di-codegen/src/main/java/org/panda_lang/utilities/inject/CodegenCache.java

@@ -0,0 +1,9 @@
+package org.panda_lang.utilities.inject;
+
+import java.util.Map;
+
+final class CodegenCache {
+
+    private CodegenCache() { }
+
+}

di-codegen/src/main/java/org/panda_lang/utilities/inject/CodegenConstructorInjector.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2020 Dzikoysk
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.panda_lang.utilities.inject;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.implementation.MethodCall;
+import net.bytebuddy.implementation.bytecode.assign.Assigner;
+import net.bytebuddy.matcher.ElementMatchers;
+import panda.utilities.ObjectUtils;
+
+final class CodegenConstructorInjector<T> implements ConstructorInjector<T> {
+
+    private static final Object[] EMPTY = new Object[0];
+
+    private static final AtomicInteger ID = new AtomicInteger();
+
+    private final InjectorProcessor processor;
+    private final Constructor<T> constructor;
+    private final boolean empty;
+    private final InjectorCache cache;
+
+    private final Function<Object[], Object> generated;
+
+    CodegenConstructorInjector(InjectorProcessor processor, Constructor<T> constructor) throws Exception {
+        this.processor = processor;
+        this.constructor = constructor;
+        this.empty = constructor.getParameterCount() == 0;
+        this.cache = InjectorCache.of(processor, constructor);
+
+        this.generated = generate(constructor);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public T newInstance(Object... injectorArgs) throws Exception {
+        return (T) this.generated.apply(
+                this.empty
+                        ? EMPTY
+                        : this.processor.fetchValues(this.cache, injectorArgs)
+        );
+    }
+
+    private static Function<Object[], Object> generate(Constructor<?> constructor) throws Exception {
+        Class<?> declaringClass = constructor.getDeclaringClass();
+        if (!Modifier.isPublic(declaringClass.getModifiers())) {
+            throw new IllegalStateException(declaringClass + " has to be public");
+        }
+
+        if (!Modifier.isPublic(constructor.getModifiers())) {
+            throw new IllegalStateException(constructor + " has to be public");
+        }
+
+        ByteBuddy byteBuddy = new ByteBuddy();
+        DynamicType.Unloaded<?> classPackage = byteBuddy
+                .makePackage(declaringClass.getPackage().getName())
+                .make();
+
+        Class<?> loaded = byteBuddy.subclass(Object.class)
+                .implement(GeneratedFunction.class)
+                .name(declaringClass.getName() + "$" + constructor.getName() + "$" + ID.incrementAndGet())
+                .method(ElementMatchers.named("apply"))
+                .intercept(MethodCall.invoke(constructor)
+                        .onArgument(0)
+                        .withArgumentArrayElements(1)
+                        .withAssigner(Assigner.DEFAULT, Assigner.Typing.DYNAMIC))
+                .make()
+                .include(classPackage)
+                .load(declaringClass.getClassLoader())
+                .getLoaded();
+
+        return ObjectUtils.cast(loaded.getDeclaredConstructor().newInstance());
+    }
+
+    @Override
+    public Constructor<T> getConstructor() {
+        return this.constructor;
+    }
+
+    @FunctionalInterface
+    public interface GeneratedFunction extends Function<Object[], Object> {
+
+    }
+
+}

di-codegen/src/main/java/org/panda_lang/utilities/inject/CodegenFieldsInjector.java

@@ -0,0 +1,120 @@
+package org.panda_lang.utilities.inject;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.BiConsumer;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.implementation.FieldAccessor;
+import net.bytebuddy.implementation.MethodDelegation;
+import net.bytebuddy.implementation.bind.annotation.AllArguments;
+import net.bytebuddy.matcher.ElementMatchers;
+import panda.utilities.ArrayUtils;
+
+public class CodegenFieldsInjector<T> implements FieldsInjector<T> {
+
+    private static final AtomicInteger ID = new AtomicInteger();
+
+    private final InjectorProcessor processor;
+    private final ConstructorInjector<T> constructorInjector;
+    private final Class<?> declaringClass;
+
+    private final BiConsumer<Object, Object[]> generated;
+
+    CodegenFieldsInjector(InjectorProcessor processor, ConstructorInjector<T> constructorInjector) throws Exception {
+        this.processor = processor;
+        this.constructorInjector = constructorInjector;
+        this.declaringClass = constructorInjector.getConstructor().getDeclaringClass();
+
+        this.generated = generate(this.declaringClass);
+    }
+
+    @Override
+    public T newInstance(Object... injectorArgs) throws Exception {
+        T instance = this.constructorInjector.newInstance(injectorArgs);
+
+        Field[] fields = ClassCache.getInjectorFields(this.declaringClass);
+        Object[] values = new Object[fields.length];
+        for (int i = 0; i < fields.length; i++) {
+            values[i] = this.processor.fetchValue(new PropertyField(fields[i]), injectorArgs);
+        }
+        this.generated.accept(instance, values);
+
+        return instance;
+    }
+
+    @Override
+    public Constructor<T> getConstructor() {
+        return this.constructorInjector.getConstructor();
+    }
+
+    private static BiConsumer<Object, Object[]> generate(Class<?> declaringClass) throws Exception {
+        if (!Modifier.isPublic(declaringClass.getModifiers())) {
+            throw new IllegalStateException(declaringClass + " has to be public");
+        }
+
+        Field[] fields = ClassCache.getInjectorFields(declaringClass);
+        for (Field field : fields) {
+            int modifiers = field.getModifiers();
+            if (!Modifier.isPublic(modifiers)) {
+                throw new IllegalStateException(field + " has to be public");
+            } else if (Modifier.isFinal(modifiers)) {
+                throw new IllegalStateException(field + " cannot be final");
+            }
+        }
+
+        ByteBuddy byteBuddy = new ByteBuddy();
+        DynamicType.Unloaded<?> classPackage = byteBuddy
+                .makePackage(declaringClass.getPackage().getName())
+                .make();
+
+
+        /*DynamicType.Builder.MethodDefinition.ExceptionDefinition<Object> init = byteBuddy.subclass(Object.class)
+                .implement(GeneratedConsumer.class)
+                .name(declaringClass.getName() + "$init$" + ID.incrementAndGet())
+                .method(ElementMatchers.named("accept"))
+                .withoutCode()
+                .defineMethod("init", void.class, Modifier.PUBLIC)
+                .withParameters(ArrayUtils.merge(new Type[]{declaringClass}, Arrays.stream(fields).map(Field::getType).toArray(Class[]::new)))
+                .intercept(FieldAccessor.ofField("instance").setsArgumentAt(0));
+
+        DynamicType.Unloaded<Object> unloaded = init
+                .intercept(MethodDelegation.to(FieldAccessor.ofField("instance")))
+                .make();*/
+
+        return (instance, values) -> {
+
+        };
+    }
+
+    public static class Interceptor {
+
+        private final Field[] fields;
+
+        public Interceptor(Field[] fields) {
+            this.fields = fields;
+        }
+
+        public void intercept(@AllArguments Object[] args) throws IllegalAccessException {
+            Object instance = args[0];
+            Object[] values = Arrays.copyOfRange(args, 1, args.length);
+
+            for (int i = 0; i < values.length; i++) {
+                Field field = this.fields[i];
+                field.setAccessible(true);
+                field.set(instance, values[i]);
+            }
+
+        }
+
+    }
+
+    @FunctionalInterface
+    public interface GeneratedConsumer extends BiConsumer<Object, Object[]> { }
+
+}

di-codegen/src/main/java/org/panda_lang/utilities/inject/GeneratedMethodInjector.java → di-codegen/src/main/java/org/panda_lang/utilities/inject/CodegenMethodInjector.java

@@ -27,30 +27,36 @@
 import net.bytebuddy.matcher.ElementMatchers;
 import panda.utilities.ObjectUtils;
 
-final class GeneratedMethodInjector implements MethodInjector {
+final class CodegenMethodInjector implements MethodInjector {
 
     private static final Object[] EMPTY = new Object[0];
 
     private static final AtomicInteger ID = new AtomicInteger();
 
     private final InjectorProcessor processor;
     private final Method method;
-    private final BiFunction<Object, Object[], Object> function;
     private final InjectorCache cache;
     private final boolean empty;
 
-    GeneratedMethodInjector(InjectorProcessor processor, Method method) throws Exception {
+    private final BiFunction<Object, Object[], Object> generated;
+
+    CodegenMethodInjector(InjectorProcessor processor, Method method) throws Exception {
         this.processor = processor;
         this.method = method;
-        this.function = generate(method);
         this.cache = InjectorCache.of(processor, method);
         this.empty = method.getParameterCount() == 0;
+
+        this.generated = generate(method);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public <T> T invoke(Object instance, Object... injectorArgs) throws Exception {
-        return (T) this.function.apply(instance, this.empty ? EMPTY : this.processor.fetchValues(this.cache, injectorArgs));
+        return (T) this.generated.apply(instance,
+                this.empty
+                        ? EMPTY
+                        : this.processor.fetchValues(this.cache, injectorArgs)
+        );
     }
 
     private static BiFunction<Object, Object[], Object> generate(Method method) throws Exception {

di-codegen/src/main/java/org/panda_lang/utilities/inject/CodegenMethodInjectorFactory.java

@@ -6,7 +6,7 @@ public final class CodegenMethodInjectorFactory implements MethodInjectorFactory
 
     @Override
     public MethodInjector createMethodInjector(InjectorProcessor processor, Method method) throws Exception {
-        return new GeneratedMethodInjector(processor, method);
+        return new CodegenMethodInjector(processor, method);
     }
 
 }

di-codegen/src/test/java/org/panda_lang/utilities/inject/DependencyInjectionTest.java

@@ -78,7 +78,7 @@ void testInjector() {
             assertEquals(DYNAMIC, (Integer) injector.fork(resources -> resources.on(int.class).assignInstance(DYNAMIC)).invokeMethod(testForkedInjector, instance));
 
             MethodInjector generatedMethodInjector = injector.fork(resources -> resources.on(int.class).assignInstance(DYNAMIC)).forGeneratedMethod(testForkedInjector);
-            assertTrue(generatedMethodInjector instanceof GeneratedMethodInjector);
+            assertTrue(generatedMethodInjector instanceof CodegenMethodInjector);
             assertEquals(DYNAMIC, (Integer) generatedMethodInjector.invoke(instance));
         });
 

di/src/main/java/org/panda_lang/utilities/inject/ClassCache.java

@@ -8,6 +8,7 @@
 import java.util.Arrays;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.panda_lang.utilities.inject.annotations.AutoConstruct;
 import org.panda_lang.utilities.inject.annotations.Inject;
 import panda.std.Pair;
@@ -16,6 +17,7 @@
 /**
  * Utility class for caching class data (fields, methods, etc.) to improve performance.
  */
+@ApiStatus.Internal
 final class ClassCache {
 
     private static final Map<Class<?>, Constructor<?>> CACHED_CONSTRUCTORS = new ConcurrentHashMap<>();