performance: cache inputClassLoader corresponding to sourceClasspath (#…

…990)

src/main/java/spoon/support/StandardEnvironment.java

@@ -333,6 +333,12 @@ public void setTabulationSize(int tabulationSize) {
  }
 
  private ClassLoader classloader;
+ /*
+ * cache class loader which loads classes from source class path
+ * we must cache it to make all the loaded classes compatible
+ * The cache is reset when setSourceClasspath(...) is called
+ */
+ private ClassLoader inputClassloader;
 
  @Override
  public void setInputClassLoader(ClassLoader aClassLoader) {
@@ -355,7 +361,10 @@ public ClassLoader getInputClassLoader() {
  if (classloader != null) {
  return classloader;
  }
- return new URLClassLoader(urlClasspath(), Thread.currentThread().getContextClassLoader());
+ if (inputClassloader == null) {
+ inputClassloader = new URLClassLoader(urlClasspath(), Thread.currentThread().getContextClassLoader());
+ }
+ return inputClassloader;
  }
 
  @Override
@@ -389,6 +398,7 @@ public String[] getSourceClasspath() {
  public void setSourceClasspath(String[] sourceClasspath) {
  verifySourceClasspath(sourceClasspath);
  this.sourceClasspath = sourceClasspath;
+ this.inputClassloader = null;
  }
 
  private void verifySourceClasspath(String[] sourceClasspath) throws InvalidClassPathException {

src/test/java/spoon/test/compilation/CompilationTest.java

@@ -4,6 +4,7 @@
 import org.junit.Assert;
 import org.junit.Test;
 import spoon.Launcher;
+import spoon.SpoonModelBuilder;
 import spoon.compiler.SpoonCompiler;
 import spoon.reflect.code.BinaryOperatorKind;
 import spoon.reflect.code.CtBinaryOperator;
@@ -19,6 +20,7 @@
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.visitor.CtScanner;
 import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.support.compiler.FileSystemFolder;
 import spoon.support.compiler.jdt.JDTBasedSpoonCompiler;
 import spoon.support.compiler.jdt.JDTBatchCompiler;
 import spoon.support.SpoonClassNotFoundException;
@@ -263,6 +265,7 @@ public void testPrecompile() {
  }
 
 
+ @Test
  public void testClassLoader() throws Exception {
  // contract: the environment exposes a classloader configured by the spoonclass path
  Launcher launcher = new Launcher();
@@ -286,6 +289,62 @@ public void testClassLoader() throws Exception {
  Class c = launcher.getEnvironment().getInputClassLoader().loadClass("spoontest.a.ClassA");
  assertEquals("spoontest.a.ClassA", c.getName());
  }
+
+ @Test
+ public void testSingleClassLoader() throws Exception {
+ /*
+ * contract: the environment exposes a classloader configured by the spoonclass path, 
+ * there is one class loader, so the loaded classes are compatible
+ */
+ Launcher launcher = new Launcher();
+ launcher.addInputResource(new FileSystemFolder("./src/test/resources/classloader-test"));
+ File outputBinDirectory = new File("./target/classloader-test");
+ if (!outputBinDirectory.exists()) {
+ outputBinDirectory.mkdirs();
+ }
+ launcher.setBinaryOutputDirectory(outputBinDirectory);
+ launcher.getModelBuilder().build();
+
+ CtTypeReference<?> mIFoo = launcher.getFactory().Type().createReference("spoontest.IFoo");
+ CtTypeReference<?> mFoo = launcher.getFactory().Type().createReference("spoontest.Foo");
+ assertTrue("Foo subtype of IFoo", mFoo.isSubtypeOf(mIFoo));
+
+ launcher.getModelBuilder().compile(SpoonModelBuilder.InputType.FILES);
+
+ //Create new launcher which uses classes compiled by previous launcher.
+ //It simulates the classes without sources, which has to be accessed using reflection
+ launcher = new Launcher();
+
+ // not in the classpath
+ try {
+ Class.forName("spoontest.IFoo");
+ fail();
+ } catch (ClassNotFoundException expected) {
+ }
+
+ // not in the spoon classpath before setting it
+ try {
+ launcher.getEnvironment().getInputClassLoader().loadClass("spoontest.IFoo");
+ fail();
+ } catch (ClassNotFoundException expected) {
+ }
+
+ launcher.getEnvironment().setSourceClasspath(new String[]{outputBinDirectory.getAbsolutePath()});
+
+ mIFoo = launcher.getFactory().Type().createReference("spoontest.IFoo");
+ mFoo = launcher.getFactory().Type().createReference("spoontest.Foo");
+ //if it fails then it is because each class is loaded by different class loader
+ assertTrue("Foo subtype of IFoo", mFoo.isSubtypeOf(mIFoo));
+
+
+ // not in the spoon classpath before setting it
+ Class<?> ifoo = launcher.getEnvironment().getInputClassLoader().loadClass("spoontest.IFoo");
+ Class<?> foo = launcher.getEnvironment().getInputClassLoader().loadClass("spoontest.Foo");
+
+ assertTrue(ifoo.isAssignableFrom(foo));
+ assertTrue(ifoo.getClassLoader()==foo.getClassLoader());
+ }
+
 
  @Test
  public void testExoticClassLoader() throws Exception {

src/test/resources/classloader-test/spoontest/Foo.java

@@ -0,0 +1,8 @@
+package spoontest;
+
+public class Foo implements IFoo
+{
+ public Foo()
+ {
+ }
+}

src/test/resources/classloader-test/spoontest/IFoo.java

@@ -0,0 +1,6 @@
+package spoontest;
+
+public interface IFoo
+{
+
+}