Refactored class resolution logic

- Introduced `ResolvedClass` for encapsulating class and method resolution.
- Enhanced `ResolverContext` to manage class loading and reuse resolved classes.
- Streamlined test execution and parsing logic in `MetaIRTestExecutor` and associated tests.

Author: mirkosertic

src/main/java/de/mirkosertic/metair/ir/ResolvedClass.java

@@ -0,0 +1,31 @@
+package de.mirkosertic.metair.ir;
+
+import java.lang.classfile.ClassFile;
+import java.lang.classfile.ClassModel;
+
+public class ResolvedClass {
+
+    private final ResolverContext resolverContext;
+    private ClassFile classFile;
+    private ClassModel classModel;
+    private boolean loaded;
+
+    public ResolvedClass(final ResolverContext resolverContext) {
+        this.loaded = false;
+        this.resolverContext = resolverContext;
+    }
+
+    public boolean isLoaded() {
+        return loaded;
+    }
+
+    public void loaded(final ClassFile classFile, final ClassModel classModel) {
+        this.classFile = classFile;
+        this.classModel = classModel;
+        this.loaded = true;
+    }
+
+    public ClassModel classModel() {
+        return classModel;
+    }
+}

src/main/java/de/mirkosertic/metair/ir/ResolverContext.java

@@ -1,10 +1,51 @@
 package de.mirkosertic.metair.ir;
 
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.classfile.ClassFile;
+import java.lang.classfile.ClassModel;
 import java.lang.constant.ClassDesc;
 import java.lang.constant.MethodTypeDesc;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
 
 public class ResolverContext {
 
+    private final ClassLoader classLoader;
+    private final Map<String, ResolvedClass> resolvedClasses;
+
+    public ResolverContext(final ClassLoader aClassLoader) {
+        this.classLoader = aClassLoader;
+        this.resolvedClasses = new HashMap<>();
+    }
+
+    public ResolverContext() {
+        this(ResolverContext.class.getClassLoader());
+    }
+
+    public ResolvedClass resolveClass(final String className) throws IOException {
+        final ResolvedClass resolved = resolvedClasses.computeIfAbsent(className, k -> new ResolvedClass(this));
+
+        if (!resolved.isLoaded()) {
+            final URL resource = classLoader.getResource(className.replace('.', File.separatorChar) + ".class");
+            if (resource == null) {
+                throw new IllegalStateException("Cannot find class file for " + className);
+            }
+
+            try (final InputStream inputStream = resource.openStream()) {
+                final byte[] data = inputStream.readAllBytes();
+
+                final ClassFile cf = ClassFile.of();
+                final ClassModel model = cf.parse(data);
+
+                resolved.loaded(cf, model);
+            }
+        }
+        return resolved;
+    }
+
     public IRType.MetaClass resolveType(final ClassDesc desc) {
         return IRType.MetaClass.of(desc);
     }

src/main/java/de/mirkosertic/metair/ir/test/MetaIRTestExecutor.java

@@ -1,17 +1,14 @@
 package de.mirkosertic.metair.ir.test;
 
+import de.mirkosertic.metair.ir.ResolvedClass;
+import de.mirkosertic.metair.ir.ResolverContext;
 import org.junit.platform.engine.ExecutionRequest;
 import org.junit.platform.engine.TestDescriptor;
 import org.junit.platform.engine.TestExecutionResult;
 import org.junit.platform.engine.support.descriptor.EngineDescriptor;
 
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.classfile.ClassFile;
 import java.lang.classfile.ClassModel;
 import java.lang.classfile.MethodModel;
-import java.net.URL;
 import java.nio.file.Path;
 
 public class MetaIRTestExecutor {
@@ -42,28 +39,19 @@ private void executeMethod(final ExecutionRequest request, final MethodTestDescr
         try {
             final Class<?> origin = descriptor.getTestClass();
 
-            final URL resource = origin.getClassLoader().getResource(origin.getName().replace('.', File.separatorChar) + ".class");
-            if (resource == null) {
-                throw new IllegalStateException("Cannot find class file for " + origin.getName());
-            }
-
-            try (final InputStream inputStream = resource.openStream()) {
-                final byte[] data = inputStream.readAllBytes();
+            final ResolverContext ctx = new ResolverContext();
+            final ResolvedClass resolvedClass = ctx.resolveClass(origin.getName());
 
-                final ClassFile cf = ClassFile.of();
-                final ClassModel model = cf.parse(data);
+            final ClassModel model = resolvedClass.classModel();
 
-                for (final MethodModel method : model.methods()) {
+            for (final MethodModel method : model.methods()) {
 
-                    if (method.methodName().stringValue().equals(descriptor.getMethodName())) {
+                if (method.methodName().stringValue().equals(descriptor.getMethodName())) {
 
-                        final Path targetDir = request.getOutputDirectoryProvider().createOutputDirectory(descriptor);
+                    final Path targetDir = request.getOutputDirectoryProvider().createOutputDirectory(descriptor);
 
-                        new MetaIRTestHelper(targetDir).analyzeAndReport(model, method);
-                    }
+                    new MetaIRTestHelper(targetDir).analyzeAndReport(model, method);
                 }
-            } catch (final IOException e) {
-                throw new RuntimeException("Failed to load class data for " + origin.getName(), e);
             }
 
             request.getEngineExecutionListener().executionFinished(descriptor, TestExecutionResult.successful());

src/test/java/de/mirkosertic/metair/ir/SelfParsingProjectTest.java

@@ -62,26 +62,22 @@ public void testSingleMethod1() {
 
     @TestFactory
     public List<DynamicContainer> testAllProjectClasses() {
+
+        final ResolverContext resolverContext = new ResolverContext();
+
         return ReflectionSupport.findAllClassesInPackage("de.mirkosertic", _ -> true, s -> true).stream().map(aClass -> {
 
             final List<DynamicTest> tests = new ArrayList<>();
 
-            final URL resource = aClass.getClassLoader().getResource(aClass.getName().replace('.', File.separatorChar) + ".class");
-            if (resource == null) {
-                throw new IllegalStateException("Cannot find class file for " + aClass.getName());
-            }
-
-            try (final InputStream inputStream = resource.openStream()) {
-                final byte[] data = inputStream.readAllBytes();
+            try {
+                final ResolvedClass resolvedClass = resolverContext.resolveClass(aClass.getName());
 
-                final ClassFile cf = ClassFile.of();
-                final ClassModel model = cf.parse(data);
+                final ClassModel model = resolvedClass.classModel();
 
                 for (final MethodModel method : model.methods()) {
 
                     tests.add(DynamicTest.dynamicTest(method.methodName().stringValue() + " " + method.methodType().stringValue(), () -> {
                         try {
-                            final ResolverContext resolverContext = new ResolverContext();
                             final MethodAnalyzer analyzer = new MethodAnalyzer(resolverContext, IRType.MetaClass.of(model.thisClass().asSymbol()), method);
                         } catch (final IllegalParsingStateException e) {
                             final MethodAnalyzer analyzer = e.getAnalyzer();
@@ -100,12 +96,12 @@ public List<DynamicContainer> testAllProjectClasses() {
                         }
                     }));
                 }
-            } catch (final IOException e) {
+
+            } catch (final Exception e) {
                 throw new RuntimeException("Failed to load class data for " + aClass.getName(), e);
             }
 
             return DynamicContainer.dynamicContainer(aClass.getName(), tests);
-
         }).toList();
     }
 }