Split up some methods that became more complex due to streams to loops

Signed-off-by: Michael Edgar <[email protected]>

Author: MikeEdgar

core/src/main/java/io/smallrye/openapi/runtime/scanner/OpenApiDataObjectScanner.java

@@ -34,6 +34,7 @@
 import io.smallrye.openapi.runtime.scanner.dataobject.AnnotationTargetProcessor;
 import io.smallrye.openapi.runtime.scanner.dataobject.AugmentedIndexView;
 import io.smallrye.openapi.runtime.scanner.dataobject.DataObjectDeque;
+import io.smallrye.openapi.runtime.scanner.dataobject.DataObjectDeque.PathEntry;
 import io.smallrye.openapi.runtime.scanner.dataobject.IgnoreResolver;
 import io.smallrye.openapi.runtime.scanner.dataobject.TypeResolver;
 import io.smallrye.openapi.runtime.scanner.spi.AnnotationScannerContext;
@@ -281,15 +282,7 @@ private void depthFirstGraphSearch() {
                         reference);
 
                 processClassAnnotations(currentSchema, currentClass);
-
-                // Handle fields
-                for (TypeResolver resolver : properties.values()) {
-                    if (!resolver.isIgnored()) {
-                        AnnotationTargetProcessor.process(context, objectStack, resolver,
-                                currentPathEntry);
-                    }
-                }
-
+                processProperties(currentPathEntry, properties);
                 processInheritance(currentPathEntry);
             }
         }
@@ -328,6 +321,14 @@ private void processClassAnnotations(Schema schema, ClassInfo classInfo) {
         }
     }
 
+    private void processProperties(PathEntry currentPathEntry, Map<String, TypeResolver> properties) {
+        for (TypeResolver resolver : properties.values()) {
+            if (!resolver.isIgnored()) {
+                AnnotationTargetProcessor.process(context, objectStack, resolver, currentPathEntry);
+            }
+        }
+    }
+
     private void processInheritance(DataObjectDeque.PathEntry currentPathEntry) {
         ClassInfo currentClass = currentPathEntry.getClazz();
         Schema currentSchema = currentPathEntry.getSchema();

core/src/main/java/io/smallrye/openapi/runtime/scanner/dataobject/TypeResolver.java

@@ -15,6 +15,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.PriorityQueue;
 import java.util.Queue;
@@ -538,51 +539,23 @@ public static Map<String, TypeResolver> getAllFields(AnnotationScannerContext co
         Map<ClassInfo, Type> chain = index.inheritanceChain(leafKlazz, leaf);
         Map<String, TypeResolver> properties = new LinkedHashMap<>();
         Deque<Map<String, Type>> stack = new ArrayDeque<>();
-        boolean skipPropertyScan = false;
+        boolean skipScan = false;
         List<ClassInfo> descendants = new ArrayList<>(chain.size());
 
         for (Map.Entry<ClassInfo, Type> entry : chain.entrySet()) {
             ClassInfo currentClass = entry.getKey();
             Type currentType = entry.getValue();
-            maybeAddResolutionParams(stack, currentType, currentClass);
 
-            if (skipPropertyScan || (!currentType.equals(leaf) && TypeUtil.isAllOf(context, leafKlazz, currentType))
-                    || TypeUtil.knownJavaType(currentClass.name())) {
-                /*
-                 * Do not attempt to introspect fields of Java/JDK types or if the @Schema
-                 * annotation indicates the use of a `ref` for superclass fields.
-                 */
-                skipPropertyScan = true;
-                continue;
-            }
+            skipScan = skipCheck(skipScan, context, leaf, leafKlazz, currentType, currentClass);
 
-            // Store all field properties
-            for (FieldInfo field : JandexUtil.fields(context, currentClass)) {
-                if (acceptField(field) && field.name().chars().allMatch(Character::isJavaIdentifierPart)) {
-                    scanField(context, properties, field, stack, reference, descendants);
-                }
-            }
-
-            for (MethodInfo method : methods(context, currentClass)) {
-                if (acceptMethod(method) && method.name().chars().allMatch(Character::isJavaIdentifierPart)) {
-                    scanMethod(context, properties, method, stack, reference, descendants);
-                }
+            if (skipScan) {
+                continue;
             }
 
-            for (Type type : index.interfaces(currentClass)) {
-                if (!TypeUtil.knownJavaType(type.name())) {
-                    ClassInfo clazz = index.getClass(type);
-                    maybeAddResolutionParams(stack, type, clazz);
-
-                    if (clazz != null) {
-                        for (MethodInfo method : methods(context, clazz)) {
-                            if (method.name().chars().allMatch(Character::isJavaIdentifierPart)) {
-                                scanMethod(context, properties, method, stack, reference, descendants);
-                            }
-                        }
-                    }
-                }
-            }
+            maybeAddResolutionParams(stack, currentType, currentClass);
+            scanFields(context, currentClass, properties, stack, reference, descendants);
+            scanMethods(context, currentClass, properties, stack, reference, descendants);
+            scanInterfaces(context, currentClass, properties, stack, reference, descendants);
 
             descendants.add(currentClass);
         }
@@ -606,6 +579,63 @@ private static void maybeAddResolutionParams(Deque<Map<String, Type>> stack, Typ
         }
     }
 
+    private static boolean skipCheck(boolean skip, AnnotationScannerContext context, Type leafType,
+            ClassInfo leafKlazz,
+            Type currentType,
+            ClassInfo currentClass) {
+        if (skip || (!currentType.equals(leafType) && TypeUtil.isAllOf(context, leafKlazz, currentType))
+                || TypeUtil.knownJavaType(currentClass.name())) {
+            /*
+             * Do not attempt to introspect fields of Java/JDK types or if the @Schema
+             * annotation indicates the use of a `ref` for superclass fields.
+             */
+            skip = true;
+        }
+
+        return skip;
+    }
+
+    private static void scanFields(AnnotationScannerContext context, ClassInfo currentClass,
+            Map<String, TypeResolver> properties, Deque<Map<String, Type>> stack, AnnotationTarget reference,
+            List<ClassInfo> descendants) {
+        for (FieldInfo field : JandexUtil.fields(context, currentClass)) {
+            if (acceptField(field) && field.name().chars().allMatch(Character::isJavaIdentifierPart)) {
+                scanField(context, properties, field, stack, reference, descendants);
+            }
+        }
+    }
+
+    private static void scanMethods(AnnotationScannerContext context, ClassInfo currentClass,
+            Map<String, TypeResolver> properties, Deque<Map<String, Type>> stack, AnnotationTarget reference,
+            List<ClassInfo> descendants) {
+        for (MethodInfo method : methods(context, currentClass)) {
+            if (acceptMethod(method) && method.name().chars().allMatch(Character::isJavaIdentifierPart)) {
+                scanMethod(context, properties, method, stack, reference, descendants);
+            }
+        }
+    }
+
+    private static void scanInterfaces(AnnotationScannerContext context, ClassInfo currentClass,
+            Map<String, TypeResolver> properties, Deque<Map<String, Type>> stack, AnnotationTarget reference,
+            List<ClassInfo> descendants) {
+        AugmentedIndexView index = context.getAugmentedIndex();
+
+        for (Type type : index.interfaces(currentClass)) {
+            if (!TypeUtil.knownJavaType(type.name())) {
+                ClassInfo clazz = index.getClass(type);
+                maybeAddResolutionParams(stack, type, clazz);
+
+                if (clazz != null) {
+                    for (MethodInfo method : methods(context, clazz)) {
+                        if (method.name().chars().allMatch(Character::isJavaIdentifierPart)) {
+                            scanMethod(context, properties, method, stack, reference, descendants);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     private static List<MethodInfo> methods(AnnotationScannerContext context, ClassInfo currentClass) {
         if (context.getConfig().sortedPropertiesEnable()) {
             return currentClass.methods();