ArC: simplify generating names of generated classes

- the generated class names are binary names now, instead of internal names
  (that is, they use `.` as a separator, not `/`)
- the attempt to replace `$` as a nested type separator with `_` is removed
  (it has never been necessary and it has always been imprecise, because
  it did the replacement for only _one_ level of class nesting)
- deprecated (for removal) many unnecessary methods from `DotNames`; the only
  retained method is `packageName()`, now called `packagePrefix()`,
- the special type function passed to `ResourceClassOutput` is now explicitly
  documented to accept a binary name of the class

Author: Ladicek

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/AbstractGenerator.java

@@ -47,70 +47,59 @@ static Gizmo gizmo(ClassOutput classOutput) {
     }
 
     /**
-     * Create a generated bean name from a bean package. When bean is located
-     * in a default package (i.e. a classpath root), the target package name
-     * is empty string. This need to be taken into account when creating
-     * generated bean name because it is later used to build class file path
-     * and we do not want it to start from a slash because it will point root
-     * directory instead of a relative one. This method will address this
-     * problem.<br>
-     * <br>
-     * Example generated bean names (without quotes):
-     * <ol>
-     * <li>a <i>"io/quarcus/foo/FooService_Bean"</i>, when in io.quarcus.foo package,</li>
-     * <li>a <i>"BarService_Bean"</i>, when in default package.</li>
-     * </ol>
+     * Generates a class name from a target package, base name and suffix. When the class
+     * is located in a default package, the target package name is an empty string.
      *
-     * @param baseName a bean name (class name)
-     * @param targetPackage a package where bean is located
-     * @return Generated name
+     * @param targetPackage name of the target package
+     * @param baseName simple class name
+     * @param suffix suffix to append to the generated name
+     * @return generated name
      */
     static String generatedNameFromTarget(String targetPackage, String baseName, String suffix) {
         if (targetPackage == null || targetPackage.isEmpty()) {
             return baseName + suffix;
         } else {
-            return targetPackage.replace('.', '/') + "/" + baseName + suffix;
+            return targetPackage + "." + baseName + suffix;
         }
     }
 
-    protected String getBaseName(String beanClassName) {
-        String name = Types.getSimpleName(beanClassName);
-        return name.substring(0, name.lastIndexOf(BeanGenerator.BEAN_SUFFIX));
+    /**
+     * {@return a simple name of the given {@code beanClassName}, stripped of the {@link BeanGenerator#BEAN_SUFFIX}}
+     */
+    protected final String getBeanBaseName(String beanClassName) {
+        String simpleName = beanClassName.contains(".")
+                ? beanClassName.substring(beanClassName.lastIndexOf(".") + 1)
+                : beanClassName;
+        return simpleName.substring(0, simpleName.lastIndexOf(BeanGenerator.BEAN_SUFFIX));
     }
 
-    protected boolean isReflectionFallbackNeeded(MethodInfo method, String targetPackage) {
-        // Reflection fallback is needed for private methods and non-public methods declared on superclasses located in a different package
+    protected final boolean isReflectionFallbackNeeded(MethodInfo method, String targetPackage) {
+        if (Modifier.isPublic(method.flags())) {
+            return false;
+        }
+        // Reflection fallback is needed for:
+        // 1. private methods
         if (Modifier.isPrivate(method.flags())) {
             return true;
         }
-        if (Modifier.isProtected(method.flags()) || isPackagePrivate(method.flags())) {
-            return !DotNames.packageName(method.declaringClass().name()).equals(targetPackage);
-        }
-        return false;
+        // 2. non-public methods declared on superclasses located in a different package
+        return !DotNames.packagePrefix(method.declaringClass().name()).equals(targetPackage);
     }
 
-    protected boolean isReflectionFallbackNeeded(FieldInfo field, String targetPackage, BeanInfo bean) {
-        // Reflection fallback is needed for private fields if the transformation config is set to false
-        // and for non-public fields declared on superclasses located in a different package
+    protected final boolean isReflectionFallbackNeeded(FieldInfo field, String targetPackage, BeanInfo bean) {
+        if (Modifier.isPublic(field.flags())) {
+            return false;
+        }
+        // Reflection fallback is needed for:
+        // 1. private fields if the transformation is turned off OR if the field's declaring class != bean class
         if (Modifier.isPrivate(field.flags())) {
-            // if the transformation is turned off OR if the field's declaring class != bean class, we need reflection
             if (!bean.getDeployment().transformPrivateInjectedFields
                     || !field.declaringClass().name().equals(bean.getBeanClass())) {
                 return true;
-            } else {
-                // this is for cases when we want to perform transformation but the class with private field is also
-                // extended by another bean in completely different package - we'll still need reflection there
-                return !DotNames.packageName(field.declaringClass().name()).equals(targetPackage);
             }
         }
-        if (Modifier.isProtected(field.flags()) || isPackagePrivate(field.flags())) {
-            return !DotNames.packageName(field.declaringClass().name()).equals(targetPackage);
-        }
-        return false;
-    }
-
-    protected boolean isPackagePrivate(int mod) {
-        return !(Modifier.isPrivate(mod) || Modifier.isProtected(mod) || Modifier.isPublic(mod));
+        // 2. for non-public fields declared on superclasses located in a different package
+        return !DotNames.packagePrefix(field.declaringClass().name()).equals(targetPackage);
     }
 
 }

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java

@@ -29,7 +29,6 @@
 import jakarta.enterprise.context.spi.CreationalContext;
 import jakarta.enterprise.inject.CreationException;
 import jakarta.enterprise.inject.IllegalProductException;
-import jakarta.enterprise.inject.TransientReference;
 import jakarta.enterprise.inject.UnproxyableResolutionException;
 import jakarta.enterprise.inject.literal.InjectLiteral;
 import jakarta.enterprise.inject.spi.InterceptionType;
@@ -144,28 +143,17 @@ void precomputeGeneratedName(BeanInfo bean) {
 
     private void generateClassBeanName(BeanInfo bean) {
         ClassInfo beanClass = bean.getTarget().get().asClass();
-        String baseName;
-        if (beanClass.enclosingClass() != null) {
-            baseName = DotNames.simpleName(beanClass.enclosingClass()) + UNDERSCORE + DotNames.simpleName(beanClass);
-        } else {
-            baseName = DotNames.simpleName(beanClass);
-        }
+        String baseName = beanClass.name().withoutPackagePrefix();
         this.beanToGeneratedBaseName.put(bean, baseName);
-        String targetPackage = DotNames.packageName(bean.getProviderType().name());
+        String targetPackage = DotNames.packagePrefix(bean.getProviderType().name());
         String generatedName = generatedNameFromTarget(targetPackage, baseName, BEAN_SUFFIX);
         this.beanToGeneratedName.put(bean, generatedName);
     }
 
     private void generateProducerMethodBeanName(BeanInfo bean) {
         MethodInfo producerMethod = bean.getTarget().get().asMethod();
         ClassInfo declaringClass = producerMethod.declaringClass();
-        String declaringClassBase;
-        if (declaringClass.enclosingClass() != null) {
-            declaringClassBase = DotNames.simpleName(declaringClass.enclosingClass()) + UNDERSCORE
-                    + DotNames.simpleName(declaringClass);
-        } else {
-            declaringClassBase = DotNames.simpleName(declaringClass);
-        }
+        String declaringClassBase = declaringClass.name().withoutPackagePrefix();
 
         StringBuilder sigBuilder = new StringBuilder();
         sigBuilder.append(producerMethod.name())
@@ -178,42 +166,26 @@ private void generateProducerMethodBeanName(BeanInfo bean) {
         String baseName = declaringClassBase + PRODUCER_METHOD_SUFFIX + UNDERSCORE + producerMethod.name() + UNDERSCORE
                 + Hashes.sha1_base64(sigBuilder.toString());
         this.beanToGeneratedBaseName.put(bean, baseName);
-        String targetPackage = DotNames.packageName(declaringClass.name());
+        String targetPackage = DotNames.packagePrefix(declaringClass.name());
         String generatedName = generatedNameFromTarget(targetPackage, baseName, BEAN_SUFFIX);
         this.beanToGeneratedName.put(bean, generatedName);
     }
 
     private void generateProducerFieldBeanName(BeanInfo bean) {
         FieldInfo producerField = bean.getTarget().get().asField();
         ClassInfo declaringClass = producerField.declaringClass();
-        String declaringClassBase;
-        if (declaringClass.enclosingClass() != null) {
-            declaringClassBase = DotNames.simpleName(declaringClass.enclosingClass()) + UNDERSCORE
-                    + DotNames.simpleName(declaringClass);
-        } else {
-            declaringClassBase = DotNames.simpleName(declaringClass);
-        }
+        String declaringClassBase = declaringClass.name().withoutPackagePrefix();
 
         String baseName = declaringClassBase + PRODUCER_FIELD_SUFFIX + UNDERSCORE + producerField.name();
         this.beanToGeneratedBaseName.put(bean, baseName);
-        String targetPackage = DotNames.packageName(declaringClass.name());
+        String targetPackage = DotNames.packagePrefix(declaringClass.name());
         String generatedName = generatedNameFromTarget(targetPackage, baseName, BEAN_SUFFIX);
         this.beanToGeneratedName.put(bean, generatedName);
     }
 
     private void generateSyntheticBeanName(BeanInfo bean) {
-        StringBuilder baseNameBuilder = new StringBuilder();
-        if (bean.getImplClazz().enclosingClass() != null) {
-            baseNameBuilder.append(DotNames.simpleName(bean.getImplClazz().enclosingClass())).append(UNDERSCORE)
-                    .append(DotNames.simpleName(bean.getImplClazz()));
-        } else {
-            baseNameBuilder.append(DotNames.simpleName(bean.getImplClazz()));
-        }
-        baseNameBuilder.append(UNDERSCORE);
-        baseNameBuilder.append(bean.getIdentifier());
-        baseNameBuilder.append(UNDERSCORE);
-        baseNameBuilder.append(SYNTHETIC_SUFFIX);
-        String baseName = baseNameBuilder.toString();
+        String baseName = bean.getImplClazz().name().withoutPackagePrefix() + UNDERSCORE + bean.getIdentifier()
+                + UNDERSCORE + SYNTHETIC_SUFFIX;
         this.beanToGeneratedBaseName.put(bean, baseName);
         String targetPackage = bean.getTargetPackageName();
         this.beanToGeneratedName.put(bean, generatedNameFromTarget(targetPackage, baseName, BEAN_SUFFIX));
@@ -242,7 +214,7 @@ Collection<Resource> generate(BeanInfo bean) {
         String baseName = beanToGeneratedBaseName.get(bean);
         String targetPackage = bean.isSynthetic()
                 ? bean.getTargetPackageName()
-                : DotNames.packageName(bean.isProducer() ? clazz.name() : providerType.name());
+                : DotNames.packagePrefix(bean.isProducer() ? clazz.name() : providerType.name());
         String generatedName = beanToGeneratedName.get(bean);
         if (existingClasses.contains(generatedName)) {
             return Collections.emptyList();
@@ -263,8 +235,7 @@ Collection<Resource> generate(BeanInfo bean) {
 
     private void generateBean(Gizmo gizmo, BeanInfo bean, String generatedName, String baseName,
             String targetPackage, boolean isApplicationClass, ProviderType providerType) {
-        // TODO generated name includes `/` instead of `.`
-        gizmo.class_(generatedName.replace('/', '.'), cc -> {
+        gizmo.class_(generatedName, cc -> {
             cc.implements_(InjectableBean.class);
             cc.implements_(Supplier.class);
 
@@ -880,9 +851,7 @@ private void generateCreateForClassBean(ClassCreator cc, BeanInfo bean,
             // and also the CDI specification:
             //
             // > Invocations of initializer methods by the container are not business method invocations.
-            // TODO generated name includes `/` instead of `.`
-            ClassDesc subclass = ClassDesc.of(SubclassGenerator.generatedName(bean.getProviderType().name(), baseName)
-                    .replace('/', '.'));
+            ClassDesc subclass = ClassDesc.of(SubclassGenerator.generatedName(bean.getProviderType().name(), baseName));
             bc.invokeVirtual(ClassMethodDesc.of(subclass, SubclassGenerator.MARK_CONSTRUCTED_METHOD_NAME, void.class),
                     bc.cast(instance, subclass));
         }
@@ -1015,9 +984,7 @@ private Expr newBeanInstance(BeanInfo bean, BlockCreator bc, ProviderType provid
                 args.add(providers.get(injectionPoints.size() + interceptors.size() + i));
             }
 
-            // TODO generated name includes `/` instead of `.`
-            ClassDesc subclass = ClassDesc.of(SubclassGenerator.generatedName(bean.getProviderType().name(), baseName)
-                    .replace('/', '.'));
+            ClassDesc subclass = ClassDesc.of(SubclassGenerator.generatedName(bean.getProviderType().name(), baseName));
             return bc.new_(ConstructorDesc.of(subclass, paramTypes), args);
         } else if (constructorInjection.isPresent()) {
             if (Modifier.isPrivate(constructor.flags())) {
@@ -1561,9 +1528,8 @@ void generate(BlockCreator bc, Var instance) {
                                     // }
                                     new PreDestroyGenerator().generate(b1, instance);
                                 } else {
-                                    // TODO generated name includes `/` instead of `.`
                                     ClassDesc subclass = ClassDesc.of(SubclassGenerator.generatedName(
-                                            bean.getProviderType().name(), baseName).replace('/', '.'));
+                                            bean.getProviderType().name(), baseName));
 
                                     // if there _is_ some `@PreDestroy` interceptor, however, we'll reify the chain of `@PreDestroy`
                                     // callbacks into a `Runnable` that we pass into the interceptor chain to be called

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanInfo.java

@@ -636,7 +636,7 @@ public String getTargetPackageName() {
                 providerTypeName = providerType.name();
             }
         }
-        String packageName = DotNames.packageName(providerTypeName);
+        String packageName = DotNames.packagePrefix(providerTypeName);
         if (packageName.startsWith("java.")) {
             // It is not possible to place a class in a JDK package
             packageName = AbstractGenerator.DEFAULT_PACKAGE;
@@ -649,7 +649,7 @@ public String getClientProxyPackageName() {
             AnnotationTarget target = getTarget().get();
             DotName typeName = target.kind() == Kind.FIELD ? target.asField().type().name()
                     : target.asMethod().returnType().name();
-            String packageName = DotNames.packageName(typeName);
+            String packageName = DotNames.packagePrefix(typeName);
             if (packageName.startsWith("java.")) {
                 // It is not possible to place a class in a JDK package
                 packageName = AbstractGenerator.DEFAULT_PACKAGE;

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/Beans.java

@@ -1165,7 +1165,7 @@ private static String decapitalize(String name) {
 
     private static String getDefaultName(ClassInfo beanClass) {
         StringBuilder defaultName = new StringBuilder();
-        defaultName.append(DotNames.simpleName(beanClass));
+        defaultName.append(beanClass.simpleName());
         // URLMatcher becomes uRLMatcher
         defaultName.setCharAt(0, Character.toLowerCase(defaultName.charAt(0)));
         return defaultName.toString();

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ClientProxyGenerator.java

@@ -98,7 +98,7 @@ Collection<Resource> generate(BeanInfo bean, String beanClassName,
             return Collections.emptySet();
         }
 
-        String baseName = getBaseName(beanClassName);
+        String baseName = getBeanBaseName(beanClassName);
         String targetPackage = bean.getClientProxyPackageName();
         String generatedName = generatedNameFromTarget(targetPackage, baseName, CLIENT_PROXY_SUFFIX);
         if (existingClasses.contains(generatedName)) {
@@ -129,8 +129,7 @@ private void createClientProxy(Gizmo gizmo, BeanInfo bean, Consumer<BytecodeTran
         ClassDesc superClass = isInterface ? CD_Object : providerClassDesc;
 
         // Foo_ClientProxy extends Foo implements ClientProxy
-        // TODO generated name includes `/` instead of `.`
-        gizmo.class_(generatedName.replace('/', '.'), cc -> {
+        gizmo.class_(generatedName, cc -> {
             copyTypeParameters(providerClass, cc);
 
             GenericType.OfClass providerGenericType = genericTypeOfClass(providerType);

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ComponentsProviderGenerator.java

@@ -259,9 +259,8 @@ private void generateAddBeans(ClassCreator cc, CodeGenInfo info, Map<BeanInfo, S
                 ParamVar beanIdToBean = mc.parameter("beanIdToBean", Map.class);
                 mc.body(bc -> {
                     for (BeanInfo bean : group.beans()) {
-                        // TODO generated name includes `/` instead of `.`
                         ClassDesc beanType = beanToGeneratedName.containsKey(bean)
-                                ? ClassDesc.of(beanToGeneratedName.get(bean).replace('/', '.'))
+                                ? ClassDesc.of(beanToGeneratedName.get(bean))
                                 : null;
                         if (beanType == null) {
                             throw new IllegalStateException("No bean type found for: " + bean);
@@ -350,9 +349,8 @@ private void generateAddObservers(ClassCreator cc, CodeGenInfo info, Map<Observe
                 ParamVar observers = mc.parameter("observers", List.class);
                 mc.body(bc -> {
                     for (ObserverInfo observer : group.observers()) {
-                        // TODO generated name includes `/` instead of `.`
                         ClassDesc observerType = observerToGeneratedName.containsKey(observer)
-                                ? ClassDesc.of(observerToGeneratedName.get(observer).replace('/', '.'))
+                                ? ClassDesc.of(observerToGeneratedName.get(observer))
                                 : null;
                         if (observerType == null) {
                             throw new IllegalStateException("No observer type found for: " + observerType);