From 03b54daf0819afdf3cdd075970af6d653b4dd165 Mon Sep 17 00:00:00 2001 From: Stuart Douglas Date: Mon, 21 Mar 2022 11:10:45 +0000 Subject: [PATCH] Use loadClass rather than loadClassFromTCCL for ArC ArC does not really need this new method, as code referencing application classes will always be generated in the application itself. --- .../processor/AnnotationLiteralGenerator.java | 8 +-- .../quarkus/arc/processor/BeanGenerator.java | 50 +++++++++---------- .../arc/processor/ClientProxyGenerator.java | 4 +- .../ComponentsProviderGenerator.java | 2 +- .../arc/processor/ContextConfigurator.java | 2 +- .../arc/processor/InterceptorGenerator.java | 4 +- .../arc/processor/ObserverGenerator.java | 6 +-- .../arc/processor/SubclassGenerator.java | 4 +- .../java/io/quarkus/arc/processor/Types.java | 16 +++--- 9 files changed, 48 insertions(+), 48 deletions(-) diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/AnnotationLiteralGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/AnnotationLiteralGenerator.java index 4e2baecf7ad35..fca2939485201 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/AnnotationLiteralGenerator.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/AnnotationLiteralGenerator.java @@ -186,12 +186,12 @@ private static void generateStaticFieldsWithDefaultValues(ClassCreator annotatio ResultHandle array = staticConstructor.newArray(returnTypeName, clazzArray.length); for (int i = 0; i < clazzArray.length; ++i) { staticConstructor.writeArrayValue(array, staticConstructor.load(i), - staticConstructor.loadClassFromTCCL(clazzArray[i].name().toString())); + staticConstructor.loadClass(clazzArray[i].name().toString())); } staticConstructor.writeStaticField(fieldCreator.getFieldDescriptor(), array); } else { staticConstructor.writeStaticField(fieldCreator.getFieldDescriptor(), - staticConstructor.loadClassFromTCCL(defaultValue.asClass().name().toString())); + staticConstructor.loadClass(defaultValue.asClass().name().toString())); } } @@ -241,7 +241,7 @@ static ResultHandle loadValue(String literalClassName, FieldDescriptor.of(literalClassName, defaultValueStaticFieldName(method), method.returnType().name().toString())); } else { - retValue = valueMethod.loadClassFromTCCL(value.asClass().toString()); + retValue = valueMethod.loadClass(value.asClass().toString()); } break; case ARRAY: @@ -273,7 +273,7 @@ static ResultHandle arrayValue(String literalClassName, Type[] classArray = value.asClassArray(); retValue = valueMethod.newArray(componentType(method), valueMethod.load(classArray.length)); for (int i = 0; i < classArray.length; i++) { - valueMethod.writeArrayValue(retValue, i, valueMethod.loadClassFromTCCL(classArray[i].name() + valueMethod.writeArrayValue(retValue, i, valueMethod.loadClass(classArray[i].name() .toString())); } } diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java index 3a180975fa070..482b843c80cc9 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java @@ -205,7 +205,7 @@ Collection generateSyntheticBean(BeanInfo bean) { valHandle = constructor.newInstance(MethodDescriptor.ofConstructor(Double.class, double.class), constructor.load(((Double) entry.getValue()).doubleValue())); } else if (entry.getValue() instanceof Class) { - valHandle = constructor.loadClassFromTCCL((Class) entry.getValue()); + valHandle = constructor.loadClass((Class) entry.getValue()); } else if (entry.getValue() instanceof Boolean) { valHandle = constructor.load((Boolean) entry.getValue()); } @@ -756,7 +756,7 @@ protected MethodCreator initConstructor(ClassOutput classOutput, ClassCreator be int stereotypesIndex = 0; for (StereotypeInfo stereotype : bean.getStereotypes()) { constructor.writeArrayValue(stereotypesArray, constructor.load(stereotypesIndex++), - constructor.loadClassFromTCCL(stereotype.getTarget().name().toString())); + constructor.loadClass(stereotype.getTarget().name().toString())); } constructor.writeInstanceField( FieldDescriptor.of(beanCreator.getClassName(), FIELD_NAME_STEREOTYPES, Set.class.getName()), @@ -795,7 +795,7 @@ protected void implementDestroy(BeanInfo bean, ClassCreator beanCreator, Provide callback.declaringClass().name(), callback.name())); reflectionRegistration.registerMethod(callback); destroy.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - destroy.loadClassFromTCCL(callback.declaringClass().name().toString()), + destroy.loadClass(callback.declaringClass().name().toString()), destroy.load(callback.name()), destroy.newArray(Class.class, destroy.load(0)), destroy.getMethodParam(0), destroy.newArray(Object.class, destroy.load(0))); @@ -862,12 +862,12 @@ protected void implementDestroy(BeanInfo bean, ClassCreator beanCreator, Provide ResultHandle argsArray = destroy.newArray(Object.class, destroy.load(referenceHandles.length)); for (int i = 0; i < referenceHandles.length; i++) { destroy.writeArrayValue(paramTypesArray, i, - destroy.loadClassFromTCCL(disposerMethod.parameters().get(i).name().toString())); + destroy.loadClass(disposerMethod.parameters().get(i).name().toString())); destroy.writeArrayValue(argsArray, i, referenceHandles[i]); } reflectionRegistration.registerMethod(disposerMethod); destroy.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - destroy.loadClassFromTCCL(disposerMethod.declaringClass().name().toString()), + destroy.loadClass(disposerMethod.declaringClass().name().toString()), destroy.load(disposerMethod.name()), paramTypesArray, declaringProviderInstanceHandle, argsArray); } else { destroy.invokeVirtualMethod(MethodDescriptor.of(disposerMethod), declaringProviderInstanceHandle, @@ -1039,12 +1039,12 @@ private ResultHandle newInstanceHandle(BeanInfo bean, ClassCreator beanCreator, ResultHandle argsArray = creator.newArray(Object.class, creator.load(providerHandles.size())); for (int i = 0; i < injectionPoints.size(); i++) { creator.writeArrayValue(paramTypesArray, i, - creator.loadClassFromTCCL(injectionPoints.get(i).getType().name().toString())); + creator.loadClass(injectionPoints.get(i).getType().name().toString())); creator.writeArrayValue(argsArray, i, providerHandles.get(i)); } registration.registerMethod(constructor); return creator.invokeStaticMethod(MethodDescriptors.REFLECTIONS_NEW_INSTANCE, - creator.loadClassFromTCCL(constructor.declaringClass().name().toString()), + creator.loadClass(constructor.declaringClass().name().toString()), paramTypesArray, argsArray); } else { // new SimpleBean(foo) @@ -1067,7 +1067,7 @@ private ResultHandle newInstanceHandle(BeanInfo bean, ClassCreator beanCreator, registration.registerMethod(noArgsConstructor); return creator.invokeStaticMethod(MethodDescriptors.REFLECTIONS_NEW_INSTANCE, - creator.loadClassFromTCCL(noArgsConstructor.declaringClass().name().toString()), paramTypesArray, + creator.loadClass(noArgsConstructor.declaringClass().name().toString()), paramTypesArray, argsArray); } else { // new SimpleBean() @@ -1115,7 +1115,7 @@ void implementCreateForProducerField(ClassOutput classOutput, ClassCreator beanC String.format("Producer field %s#%s", producerField.declaringClass().name(), producerField.name())); reflectionRegistration.registerField(producerField); create.assign(instanceHandle, create.invokeStaticMethod(MethodDescriptors.REFLECTIONS_READ_FIELD, - create.loadClassFromTCCL(producerField.declaringClass().name().toString()), + create.loadClass(producerField.declaringClass().name().toString()), create.load(producerField.name()), declaringProviderInstanceHandle)); } else { @@ -1205,12 +1205,12 @@ void implementCreateForProducerMethod(ClassOutput classOutput, ClassCreator bean ResultHandle argsArray = create.newArray(Object.class, create.load(referenceHandles.length)); for (int i = 0; i < referenceHandles.length; i++) { create.writeArrayValue(paramTypesArray, i, - create.loadClassFromTCCL(producerMethod.parameters().get(i).name().toString())); + create.loadClass(producerMethod.parameters().get(i).name().toString())); create.writeArrayValue(argsArray, i, referenceHandles[i]); } reflectionRegistration.registerMethod(producerMethod); create.assign(instanceHandle, create.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - create.loadClassFromTCCL(producerMethod.declaringClass().name().toString()), + create.loadClass(producerMethod.declaringClass().name().toString()), create.load(producerMethod.name()), paramTypesArray, declaringProviderInstanceHandle, @@ -1357,10 +1357,10 @@ void implementCreateForClassBean(ClassOutput classOutput, ClassCreator beanCreat paramTypes.add(injectionPoint.getType().name().toString()); } ResultHandle[] paramsHandles = new ResultHandle[2]; - paramsHandles[0] = create.loadClassFromTCCL(providerType.className()); + paramsHandles[0] = create.loadClass(providerType.className()); ResultHandle paramsArray = create.newArray(Class.class, create.load(paramTypes.size())); for (ListIterator iterator = paramTypes.listIterator(); iterator.hasNext();) { - create.writeArrayValue(paramsArray, iterator.nextIndex(), create.loadClassFromTCCL(iterator.next())); + create.writeArrayValue(paramsArray, iterator.nextIndex(), create.loadClass(iterator.next())); } paramsHandles[1] = paramsArray; constructorHandle = create.invokeStaticMethod(MethodDescriptors.REFLECTIONS_FIND_CONSTRUCTOR, @@ -1369,7 +1369,7 @@ void implementCreateForClassBean(ClassOutput classOutput, ClassCreator beanCreat } else { // constructor = Reflections.findConstructor(Foo.class) ResultHandle[] paramsHandles = new ResultHandle[2]; - paramsHandles[0] = create.loadClassFromTCCL(providerType.className()); + paramsHandles[0] = create.loadClass(providerType.className()); paramsHandles[1] = create.newArray(Class.class, create.load(0)); constructorHandle = create.invokeStaticMethod(MethodDescriptors.REFLECTIONS_FIND_CONSTRUCTOR, paramsHandles); @@ -1456,7 +1456,7 @@ void implementCreateForClassBean(ClassOutput classOutput, ClassCreator beanCreat } reflectionRegistration.registerField(injectedField); tryBlock.invokeStaticMethod(MethodDescriptors.REFLECTIONS_WRITE_FIELD, - tryBlock.loadClassFromTCCL(injectedField.declaringClass().name().toString()), + tryBlock.loadClass(injectedField.declaringClass().name().toString()), tryBlock.load(injectedField.name()), instanceHandle, referenceHandle); } else { @@ -1503,12 +1503,12 @@ void implementCreateForClassBean(ClassOutput classOutput, ClassCreator beanCreat ResultHandle argsArray = create.newArray(Object.class, create.load(referenceHandles.length)); for (int i = 0; i < referenceHandles.length; i++) { create.writeArrayValue(paramTypesArray, i, - create.loadClassFromTCCL(initializerMethod.parameters().get(i).name().toString())); + create.loadClass(initializerMethod.parameters().get(i).name().toString())); create.writeArrayValue(argsArray, i, referenceHandles[i]); } reflectionRegistration.registerMethod(initializerMethod); create.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - create.loadClassFromTCCL(initializerMethod.declaringClass().name().toString()), + create.loadClass(initializerMethod.declaringClass().name().toString()), create.load(methodInjection.target.asMethod().name()), paramTypesArray, instanceHandle, argsArray); @@ -1565,7 +1565,7 @@ void implementCreateForClassBean(ClassOutput classOutput, ClassCreator beanCreat } reflectionRegistration.registerMethod(callback); create.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - create.loadClassFromTCCL(callback.declaringClass().name().toString()), + create.loadClass(callback.declaringClass().name().toString()), create.load(callback.name()), create.newArray(Class.class, create.load(0)), instanceHandle, create.newArray(Object.class, create.load(0))); } else { @@ -1661,7 +1661,7 @@ protected void implementGetTypes(ClassCreator beanCreator, FieldDescriptor types */ protected void implementGetScope(BeanInfo bean, ClassCreator beanCreator) { MethodCreator getScope = beanCreator.getMethodCreator("getScope", Class.class).setModifiers(ACC_PUBLIC); - getScope.returnValue(getScope.loadClassFromTCCL(bean.getScope().getDotName().toString())); + getScope.returnValue(getScope.loadClass(bean.getScope().getDotName().toString())); } /** @@ -1761,7 +1761,7 @@ protected void implementGetStereotypes(BeanInfo bean, ClassCreator beanCreator, protected void implementGetBeanClass(BeanInfo bean, ClassCreator beanCreator) { MethodCreator getBeanClass = beanCreator.getMethodCreator("getBeanClass", Class.class).setModifiers(ACC_PUBLIC); - getBeanClass.returnValue(getBeanClass.loadClassFromTCCL(bean.getBeanClass().toString())); + getBeanClass.returnValue(getBeanClass.loadClass(bean.getBeanClass().toString())); } protected void implementGetName(BeanInfo bean, ClassCreator beanCreator) { @@ -1851,7 +1851,7 @@ public static ResultHandle getJavaMemberHandle(MethodCreator constructor, if (Kind.FIELD.equals(injectionPoint.getTarget().kind())) { FieldInfo field = injectionPoint.getTarget().asField(); javaMemberHandle = constructor.invokeStaticMethod(MethodDescriptors.REFLECTIONS_FIND_FIELD, - constructor.loadClassFromTCCL(field.declaringClass().name().toString()), + constructor.loadClass(field.declaringClass().name().toString()), constructor.load(field.name())); reflectionRegistration.registerField(field); } else { @@ -1860,11 +1860,11 @@ public static ResultHandle getJavaMemberHandle(MethodCreator constructor, if (method.name().equals(Methods.INIT)) { // Reflections.findConstructor(org.foo.SimpleBean.class,java.lang.String.class) ResultHandle[] paramsHandles = new ResultHandle[2]; - paramsHandles[0] = constructor.loadClassFromTCCL(method.declaringClass().name().toString()); + paramsHandles[0] = constructor.loadClass(method.declaringClass().name().toString()); ResultHandle paramsArray = constructor.newArray(Class.class, constructor.load(method.parameters().size())); for (ListIterator iterator = method.parameters().listIterator(); iterator.hasNext();) { constructor.writeArrayValue(paramsArray, iterator.nextIndex(), - constructor.loadClassFromTCCL(iterator.next().name().toString())); + constructor.loadClass(iterator.next().name().toString())); } paramsHandles[1] = paramsArray; javaMemberHandle = constructor.invokeStaticMethod(MethodDescriptors.REFLECTIONS_FIND_CONSTRUCTOR, @@ -1872,12 +1872,12 @@ public static ResultHandle getJavaMemberHandle(MethodCreator constructor, } else { // Reflections.findMethod(org.foo.SimpleBean.class,"foo",java.lang.String.class) ResultHandle[] paramsHandles = new ResultHandle[3]; - paramsHandles[0] = constructor.loadClassFromTCCL(method.declaringClass().name().toString()); + paramsHandles[0] = constructor.loadClass(method.declaringClass().name().toString()); paramsHandles[1] = constructor.load(method.name()); ResultHandle paramsArray = constructor.newArray(Class.class, constructor.load(method.parameters().size())); for (ListIterator iterator = method.parameters().listIterator(); iterator.hasNext();) { constructor.writeArrayValue(paramsArray, iterator.nextIndex(), - constructor.loadClassFromTCCL(iterator.next().name().toString())); + constructor.loadClass(iterator.next().name().toString())); } paramsHandles[2] = paramsArray; javaMemberHandle = constructor.invokeStaticMethod(MethodDescriptors.REFLECTIONS_FIND_METHOD, paramsHandles); diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ClientProxyGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ClientProxyGenerator.java index 168b8079f5d4e..8b85ce459edd4 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ClientProxyGenerator.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ClientProxyGenerator.java @@ -210,7 +210,7 @@ Collection generate(BeanInfo bean, String beanClassName, ResultHandle paramTypesArray = forward.newArray(Class.class, forward.load(method.parameters().size())); int idx = 0; for (Type param : method.parameters()) { - forward.writeArrayValue(paramTypesArray, idx++, forward.loadClassFromTCCL(param.name().toString())); + forward.writeArrayValue(paramTypesArray, idx++, forward.loadClass(param.name().toString())); } ResultHandle argsArray = forward.newArray(Object.class, forward.load(params.length)); idx = 0; @@ -219,7 +219,7 @@ Collection generate(BeanInfo bean, String beanClassName, } reflectionRegistration.registerMethod(method); ret = forward.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - forward.loadClassFromTCCL(method.declaringClass().name().toString()), + forward.loadClass(method.declaringClass().name().toString()), forward.load(method.name()), paramTypesArray, delegate, argsArray); } else { // make sure we do not use the original method descriptor as it could point to diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ComponentsProviderGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ComponentsProviderGenerator.java index 475b0c7044ac5..8107dcdf3a83f 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ComponentsProviderGenerator.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ComponentsProviderGenerator.java @@ -115,7 +115,7 @@ Collection generate(String name, BeanDeployment beanDeployment, Map creatorClazz) valHandle = mc.newInstance(MethodDescriptor.ofConstructor(Double.class, double.class), mc.load(((Double) entry.getValue()).doubleValue())); } else if (entry.getValue() instanceof Class) { - valHandle = mc.loadClassFromTCCL((Class) entry.getValue()); + valHandle = mc.loadClass((Class) entry.getValue()); } else if (entry.getValue() instanceof Boolean) { valHandle = mc.load((Boolean) entry.getValue()); } diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/InterceptorGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/InterceptorGenerator.java index 3fda9c0f9c046..ea624b9a01d01 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/InterceptorGenerator.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/InterceptorGenerator.java @@ -240,12 +240,12 @@ private void addIntercept(MethodCreator intercept, MethodInfo interceptorMethod, interceptorMethod.name())); // Use reflection fallback ResultHandle paramTypesArray = trueBranch.newArray(Class.class, trueBranch.load(1)); - trueBranch.writeArrayValue(paramTypesArray, 0, trueBranch.loadClassFromTCCL(invocationContextClass)); + trueBranch.writeArrayValue(paramTypesArray, 0, trueBranch.loadClass(invocationContextClass)); ResultHandle argsArray = trueBranch.newArray(Object.class, trueBranch.load(1)); trueBranch.writeArrayValue(argsArray, 0, intercept.getMethodParam(2)); reflectionRegistration.registerMethod(interceptorMethod); ret = trueBranch.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - trueBranch.loadClassFromTCCL(interceptorMethod.declaringClass() + trueBranch.loadClass(interceptorMethod.declaringClass() .name() .toString()), trueBranch.load(interceptorMethod.name()), paramTypesArray, intercept.getMethodParam(1), argsArray); diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ObserverGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ObserverGenerator.java index 10fd4c9fbd1bd..ce3cf86da0e92 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ObserverGenerator.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ObserverGenerator.java @@ -260,7 +260,7 @@ protected void implementGetTransactionPhase(ClassCreator observerCreator, Observ protected void implementGetBeanClass(ClassCreator observerCreator, DotName beanClass) { MethodCreator getBeanClass = observerCreator.getMethodCreator("getBeanClass", Class.class).setModifiers(ACC_PUBLIC); - getBeanClass.returnValue(getBeanClass.loadClassFromTCCL(beanClass.toString())); + getBeanClass.returnValue(getBeanClass.loadClass(beanClass.toString())); } protected void implementGetPriority(ClassCreator observerCreator, ObserverInfo observer) { @@ -434,12 +434,12 @@ protected void implementNotify(ObserverInfo observer, ClassCreator observerCreat ResultHandle argsArray = notify.newArray(Object.class, notify.load(referenceHandles.length)); for (int i = 0; i < referenceHandles.length; i++) { notify.writeArrayValue(paramTypesArray, i, - notify.loadClassFromTCCL(observer.getObserverMethod().parameters().get(i).name().toString())); + notify.loadClass(observer.getObserverMethod().parameters().get(i).name().toString())); notify.writeArrayValue(argsArray, i, referenceHandles[i]); } reflectionRegistration.registerMethod(observer.getObserverMethod()); notify.invokeStaticMethod(MethodDescriptors.REFLECTIONS_INVOKE_METHOD, - notify.loadClassFromTCCL(observer.getObserverMethod().declaringClass().name().toString()), + notify.loadClass(observer.getObserverMethod().declaringClass().name().toString()), notify.load(observer.getObserverMethod().name()), paramTypesArray, declaringProviderInstanceHandle, argsArray); } else { diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/SubclassGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/SubclassGenerator.java index 69ddffdba3329..9fe7af99568af 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/SubclassGenerator.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/SubclassGenerator.java @@ -314,13 +314,13 @@ public ResultHandle apply(List interceptors) { // 2. Method method = Reflections.findMethod(org.jboss.weld.arc.test.interceptors.SimpleBean.class,"foo",java.lang.String.class) ResultHandle[] paramsHandles = new ResultHandle[3]; - paramsHandles[0] = constructor.loadClassFromTCCL(providerTypeName); + paramsHandles[0] = constructor.loadClass(providerTypeName); paramsHandles[1] = constructor.load(method.name()); if (!parameters.isEmpty()) { ResultHandle paramsArray = constructor.newArray(Class.class, constructor.load(parameters.size())); for (ListIterator iterator = parameters.listIterator(); iterator.hasNext();) { constructor.writeArrayValue(paramsArray, iterator.nextIndex(), - constructor.loadClassFromTCCL(iterator.next().name().toString())); + constructor.loadClass(iterator.next().name().toString())); } paramsHandles[2] = paramsArray; } else { diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/Types.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/Types.java index 50913ddd9bd10..c188fc591c1a8 100644 --- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/Types.java +++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/Types.java @@ -165,28 +165,28 @@ static void getTypeHandle(AssignableResultHandle variable, BytecodeCreator creat } else if (Kind.PRIMITIVE.equals(type.kind())) { switch (type.asPrimitiveType().primitive()) { case INT: - creator.assign(variable, creator.loadClassFromTCCL(int.class)); + creator.assign(variable, creator.loadClass(int.class)); break; case LONG: - creator.assign(variable, creator.loadClassFromTCCL(long.class)); + creator.assign(variable, creator.loadClass(long.class)); break; case BOOLEAN: - creator.assign(variable, creator.loadClassFromTCCL(boolean.class)); + creator.assign(variable, creator.loadClass(boolean.class)); break; case BYTE: - creator.assign(variable, creator.loadClassFromTCCL(byte.class)); + creator.assign(variable, creator.loadClass(byte.class)); break; case CHAR: - creator.assign(variable, creator.loadClassFromTCCL(char.class)); + creator.assign(variable, creator.loadClass(char.class)); break; case DOUBLE: - creator.assign(variable, creator.loadClassFromTCCL(double.class)); + creator.assign(variable, creator.loadClass(double.class)); break; case FLOAT: - creator.assign(variable, creator.loadClassFromTCCL(float.class)); + creator.assign(variable, creator.loadClass(float.class)); break; case SHORT: - creator.assign(variable, creator.loadClassFromTCCL(short.class)); + creator.assign(variable, creator.loadClass(short.class)); break; default: throw new IllegalArgumentException("Unsupported primitive type: " + type);