Simplify the 'factory' MethodHandle signatures to drop 'dependency' types from them

I thought modeling native types would be better but on reflection it just adds complexity for little gain.  So turn all generated factories into `(InternalContext)->Object` types.  This eliminates a bunch of `asType` adapters and should improve linkage performance a bit (not that this is a huge concern), but the major benefit is just simplicity.

Performance is an interesting question here.  In principle we are just adding 'no op' cast to `Object` on constructor and provides method invocations, and then `checkCast` instructions at constructor and method parameter injection points.  So the waste is those extra `cast` operations.  However, in the JVM those are nearly free (simple pointer check, can often be elided as part of normal invocation type checking). So my guess is that this is a no-op performance wise.  Some limited benchmarking of `@Provides` and `@Inject` constructors bears this out.

PiperOrigin-RevId: 740791709

Author: lukesandberg

core/src/com/google/inject/internal/BoundProviderFactory.java

@@ -67,15 +67,13 @@ public T get(InternalContext context, Dependency<?> dependency, boolean linked)
   public MethodHandle getHandle(LinkageContext context, Dependency<?> dependency, boolean linked) {
     return context.makeHandle(
         this,
-        dependency,
         () ->
             InternalMethodHandles.catchInternalProvisionExceptionAndRethrowWithSource(
-                    circularGetHandle(
-                        providerFactory.getHandle(context, PROVIDER_DEPENDENCY, /* linked= */ true),
-                        dependency,
-                        provisionCallback),
-                    providerKey)
-                .asType(InternalMethodHandles.makeFactoryType(dependency)));
+                circularGetHandle(
+                    providerFactory.getHandle(context, PROVIDER_DEPENDENCY, /* linked= */ true),
+                    dependency,
+                    provisionCallback),
+                providerKey));
   }
 
   @Override

core/src/com/google/inject/internal/ConstantFactory.java

@@ -53,7 +53,7 @@ public Provider<T> makeProvider(InjectorImpl injector, Dependency<?> dependency)
       @Override
       public MethodHandle getHandle(
           LinkageContext context, Dependency<?> dependency, boolean linked) {
-        var returnNull = MethodHandles.empty(InternalMethodHandles.makeFactoryType(dependency));
+        var returnNull = InternalMethodHandles.constantFactoryGetHandle(null);
         if (dependency.isNullable()) {
           // Just return a constant null handle.
           return returnNull;
@@ -93,7 +93,7 @@ public Provider<T> makeProvider(InjectorImpl injector, Dependency<?> dependency)
 
   @Override
   public MethodHandle getHandle(LinkageContext context, Dependency<?> dependency, boolean linked) {
-    return InternalMethodHandles.constantFactoryGetHandle(dependency, instance);
+    return InternalMethodHandles.constantFactoryGetHandle(instance);
   }
 
   @Override

core/src/com/google/inject/internal/ConstantProviderInternalFactory.java

@@ -47,9 +47,6 @@ public T get(InternalContext context, Dependency<?> dependency, boolean linked)
   @Override
   public MethodHandle getHandle(LinkageContext context, Dependency<?> dependency, boolean linked) {
     return circularGetHandleImmediate(
-            InternalMethodHandles.constantFactoryGetHandle(jakarta.inject.Provider.class, provider),
-            dependency,
-            provisionCallback)
-        .asType(InternalMethodHandles.makeFactoryType(dependency));
+        InternalMethodHandles.constantFactoryGetHandle(provider), dependency, provisionCallback);
   }
 }

core/src/com/google/inject/internal/ConstructionProxy.java

@@ -38,6 +38,8 @@ interface ConstructionProxy<T> {
   /**
    * Returns the method handle for the constructor, using the supplied handles to provide
    * parameters.
+   *
+   * <p>The returned handle has {@link InternalMethodHandles#FACTORY_TYPE} as its signature.
    */
   MethodHandle getConstructHandle(MethodHandle[] parameterHandles);
 

core/src/com/google/inject/internal/ConstructorBindingImpl.java

@@ -322,7 +322,6 @@ public MethodHandle getHandle(
       }
       return context.makeHandle(
           this,
-          dependency,
           () -> constructorInjector.getConstructHandle(context, dependency, provisionCallback));
     }
 

core/src/com/google/inject/internal/ConstructorInjector.java

@@ -16,7 +16,7 @@
 
 package com.google.inject.internal;
 
-import static com.google.inject.internal.InternalMethodHandles.castReturnToObject;
+import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.inject.internal.ProvisionListenerStackCallback.ProvisionCallback;
@@ -102,6 +102,11 @@ MethodHandle getConstructHandle(
     var handle =
         constructionProxy.getConstructHandle(
             SingleParameterInjector.getAllHandles(linkageContext, parameterInjectors));
+    checkState(
+        handle.type().equals(InternalMethodHandles.FACTORY_TYPE),
+        "expected %s but got %s",
+        InternalMethodHandles.FACTORY_TYPE,
+        handle.type());
     // If there are members injectors  we call `finishConstructionAndSetReference` so that
     // cycle detection can find the newly constructed reference.
     if (membersInjector != null) {
@@ -116,7 +121,7 @@ MethodHandle getConstructHandle(
               membersHandle);
       // Then execute thje membersHandle after constructing the object (and calling
       // finishConstructionAndSetReference)
-      handle = MethodHandles.foldArguments(membersHandle, castReturnToObject(handle));
+      handle = MethodHandles.foldArguments(membersHandle, handle);
     } else {
       // Otherwise we are done!
       handle = InternalMethodHandles.finishConstruction(handle, circularFactoryId);

core/src/com/google/inject/internal/DefaultConstructionProxyFactory.java

@@ -17,8 +17,8 @@
 package com.google.inject.internal;
 
 import static com.google.inject.internal.InternalMethodHandles.castReturnTo;
+import static com.google.inject.internal.InternalMethodHandles.castReturnToObject;
 import static java.lang.invoke.MethodType.methodType;
-import static java.util.Arrays.stream;
 
 import com.google.common.collect.ImmutableMap;
 import com.google.inject.spi.InjectionPoint;
@@ -133,20 +133,14 @@ public MethodHandle getConstructHandle(MethodHandle[] parameterHandles) {
           InternalMethodHandles.BIFUNCTION_APPLY_HANDLE
               .bindTo(fastConstructor)
               .asType(methodType(Object.class, Object.class, Object[].class));
-      handle = MethodHandles.insertArguments(handle, 0, (Object) null);
+      handle = MethodHandles.insertArguments(handle, 0, (Object) null); // no receiver type.
       handle = handle.asCollector(Object[].class, parameterHandles.length);
-      handle =
-          MethodHandles.filterArguments(
-              handle,
-              0,
-              stream(parameterHandles)
-                  .map(InternalMethodHandles::castReturnToObject)
-                  .toArray(MethodHandle[]::new));
+      // Pass all the parameters to the constructor.
+      handle = MethodHandles.filterArguments(handle, 0, parameterHandles);
+      // merge all the internalcontext parameters into a single object factory.
       handle =
           MethodHandles.permuteArguments(
-              handle,
-              methodType(Object.class, InternalContext.class),
-              new int[parameterHandles.length]);
+              handle, InternalMethodHandles.FACTORY_TYPE, new int[parameterHandles.length]);
       return handle;
     }
   }
@@ -197,15 +191,15 @@ public T newInstance(Object... arguments) throws InvocationTargetException {
     @Override
     public MethodHandle getConstructHandle(MethodHandle[] parameterHandles) {
       var type = target.type();
+      // Adapt the parameter handles to the constructor signature.
       var typedHandles =
           IntStream.range(0, parameterHandles.length)
               .mapToObj(i -> castReturnTo(parameterHandles[i], type.parameterType(i)))
               .toArray(MethodHandle[]::new);
       var handle = MethodHandles.filterArguments(target, 0, typedHandles);
+      handle = castReturnToObject(handle); // satisfy the signature of the factory type.
       return MethodHandles.permuteArguments(
-          handle,
-          methodType(type.returnType(), InternalContext.class),
-          new int[typedHandles.length]);
+          handle, InternalMethodHandles.FACTORY_TYPE, new int[typedHandles.length]);
     }
   }
 }

core/src/com/google/inject/internal/InitializableFactory.java

@@ -48,7 +48,7 @@ public T get(InternalContext context, Dependency<?> dependency, boolean linked)
 
   @Override
   public MethodHandle getHandle(LinkageContext context, Dependency<?> dependency, boolean linked) {
-    return InternalMethodHandles.initializableFactoryGetHandle(initializable, dependency);
+    return InternalMethodHandles.initializableFactoryGetHandle(initializable);
   }
 
   @Override

core/src/com/google/inject/internal/InjectorImpl.java

@@ -406,8 +406,7 @@ public Provider<Provider<T>> makeProvider(InjectorImpl injector, Dependency<?> d
         @Override
         public MethodHandle getHandle(
             LinkageContext context, Dependency<?> dependency, boolean linked) {
-          return InternalMethodHandles.constantFactoryGetHandle(
-              Provider.class, providedBinding.getProvider());
+          return InternalMethodHandles.constantFactoryGetHandle(providedBinding.getProvider());
         }
       };
     }

core/src/com/google/inject/internal/InjectorShell.java

@@ -286,7 +286,7 @@ public Provider<Injector> makeProvider(InjectorImpl injector, Dependency<?> depe
     @Override
     public MethodHandle getHandle(
         LinkageContext context, Dependency<?> dependency, boolean linked) {
-      return InternalMethodHandles.constantFactoryGetHandle(dependency, injector);
+      return InternalMethodHandles.constantFactoryGetHandle(injector);
     }
 
     @Override
@@ -335,7 +335,7 @@ public Provider<Logger> makeProvider(InjectorImpl injector, Dependency<?> depend
     @Override
     public MethodHandle getHandle(
         LinkageContext context, Dependency<?> dependency, boolean linked) {
-      return InternalMethodHandles.constantFactoryGetHandle(dependency, makeLogger(dependency));
+      return InternalMethodHandles.constantFactoryGetHandle(makeLogger(dependency));
     }
 
     private static Logger makeLogger(Dependency<?> dependency) {

core/src/com/google/inject/internal/InternalFactory.java

@@ -60,8 +60,7 @@ default Provider<T> makeProvider(InjectorImpl injector, Dependency<?> dependency
   default MethodHandle getHandle(LinkageContext context, Dependency<?> dependency, boolean linked) {
     // The default implementation simply delegates to the `get` method.
     MethodHandle handle = InternalMethodHandles.INTERNAL_FACTORY_GET_HANDLE.bindTo(this);
-    return MethodHandles.insertArguments(handle, 1, dependency, linked)
-        .asType(InternalMethodHandles.makeFactoryType(dependency));
+    return MethodHandles.insertArguments(handle, 1, dependency, linked);
   }
 
   /**

core/src/com/google/inject/internal/InternalFactoryToScopedProviderAdapter.java

@@ -17,8 +17,6 @@
 package com.google.inject.internal;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.inject.internal.InternalMethodHandles.castReturnTo;
-import static com.google.inject.internal.InternalMethodHandles.castReturnToObject;
 import static com.google.inject.internal.InternalMethodHandles.findVirtualOrDie;
 import static java.lang.invoke.MethodType.methodType;
 
@@ -98,7 +96,7 @@ public MethodHandle getHandle(LinkageContext context, Dependency<?> dependency,
         MethodHandles.foldArguments(
             invokeProvider,
             MethodHandles.insertArguments(INTERNAL_CONTEXT_SET_DEPENDENCY_HANDLE, 1, dependency));
-    return castReturnTo(invokeProvider, dependency.getKey().getTypeLiteral().getRawType());
+    return invokeProvider;
   }
 
   private static final MethodHandle INTERNAL_CONTEXT_SET_DEPENDENCY_HANDLE =
@@ -166,8 +164,11 @@ public MethodHandle getHandle(
 
     private static MethodHandle getHandleForConstant(
         Dependency<?> dependency, Object source, Object value) {
-      var handle = InternalMethodHandles.constantFactoryGetHandle(dependency, value);
-      handle = InternalMethodHandles.nullCheckResult(handle, source, dependency);
+      var handle = InternalMethodHandles.constantFactoryGetHandle(value);
+      // Since this is a constant, we only need to null check if it is actually null.
+      if (value == null) {
+        handle = InternalMethodHandles.nullCheckResult(handle, source, dependency);
+      }
       return handle;
     }
 
@@ -195,14 +196,12 @@ static final class SingletonCallSite extends MutableCallSite {
         // This will allow us to eventually 'fold' the result into the callsite.
         // (InternalContext, InternalContext) -> Object
         var invokeBootstrap =
-            MethodHandles.filterArguments(
-                BOOTSTRAP_CALL_MH.bindTo(this), 1, castReturnToObject(actualGetHandle));
-
-        // (InternalContext, InternalContext) -> T
-        invokeBootstrap = castReturnTo(invokeBootstrap, actualGetHandle.type().returnType());
-        // (InternalContext) -> T
+            MethodHandles.filterArguments(BOOTSTRAP_CALL_MH.bindTo(this), 1, actualGetHandle);
+        // Merge the two internalContext parameters into one.
+        // (InternalContext) -> Object
         invokeBootstrap =
-            MethodHandles.permuteArguments(invokeBootstrap, actualGetHandle.type(), new int[2]);
+            MethodHandles.permuteArguments(
+                invokeBootstrap, InternalMethodHandles.FACTORY_TYPE, new int[2]);
         setTarget(invokeBootstrap);
       }