serialized parsers

pom.xml

@@ -125,7 +125,7 @@
                 <artifactId>rascal-maven-plugin</artifactId>
                 <version>${rascal-maven.version}</version>
                 <configuration>
-                    <errorsAsWarnings>false</errorsAsWarnings>
+                    <errorsAsWarnings>true</errorsAsWarnings>
                     <bin>${project.build.outputDirectory}</bin>
                     <srcs>
                         <src>${project.basedir}/src/org/rascalmpl/library</src>

src/org/rascalmpl/interpreter/utils/JavaBridge.java

@@ -15,6 +15,7 @@
 *******************************************************************************/
 package org.rascalmpl.interpreter.utils;
 
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintWriter;
@@ -30,6 +31,7 @@
 import javax.tools.JavaFileObject;
 import javax.tools.ToolProvider;
 
+import org.checkerframework.checker.units.qual.t;
 import org.rascalmpl.ast.Expression;
 import org.rascalmpl.ast.FunctionDeclaration;
 import org.rascalmpl.ast.KeywordFormal;
@@ -107,6 +109,10 @@
 	public <T> Class<T> compileJava(ISourceLocation loc, String className, String source) {
 		return compileJava(loc, className, getClass(), source);
 	}
+
+	public void compileJava(ISourceLocation loc, String className, String source, OutputStream classBytes) {
+		compileJava(loc, className, getClass(), source, classBytes);
+	}
 
 	public <T> Class<T> compileJava(ISourceLocation loc, String className, Class<?> parent, String source) {
 		try {
@@ -130,6 +136,33 @@
 		}
 	}
 
+	public Class<?> loadClass(InputStream in) throws IOException, ClassNotFoundException {
+		List<String> commandline = Arrays.asList(new String[] {"-proc:none", "-cp", config.getRascalJavaClassPathProperty()});
+		JavaCompiler<?> javaCompiler = new JavaCompiler<Object>(getClass().getClassLoader(), null, commandline);
+		return javaCompiler.load(in);
+	}
+
+	public <T> void compileJava(ISourceLocation loc, String className, Class<?> parent, String source, OutputStream classBytes) {
+		try {
+			// watch out, if you start sharing this compiler, classes will not be able to reload
+			List<String> commandline = Arrays.asList(new String[] {"-proc:none", "-cp", config.getRascalJavaClassPathProperty()});
+			JavaCompiler<T> javaCompiler = new JavaCompiler<T>(parent.getClassLoader(), null, commandline);
+			javaCompiler.compile(classBytes, className, source, null);
+		} 
+		catch (ClassCastException e) {
+			throw new JavaCompilation(e.getMessage(), e);
+		} 
+		catch (JavaCompilerException e) {
+		    if (!e.getDiagnostics().getDiagnostics().isEmpty()) {
+		        Diagnostic<? extends JavaFileObject> msg = e.getDiagnostics().getDiagnostics().iterator().next();
+		        throw new JavaCompilation(msg.getMessage(null) + " at " + msg.getLineNumber() + ", " + msg.getColumnNumber() + " with classpath [" + config.getRascalJavaClassPathProperty() + "]", e);
+		    }
+		    else {
+		        throw new JavaCompilation(e.getMessage(), e);
+		    }
+		}
+	}
+
 	private String getClassName(FunctionDeclaration declaration) {
 		Tags tags = declaration.getTags();
 

src/org/rascalmpl/interpreter/utils/JavaCompiler.java

@@ -16,6 +16,7 @@
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -28,6 +29,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
 import java.util.Set;
 
 import javax.tools.DiagnosticCollector;
@@ -41,7 +47,9 @@
 import javax.tools.StandardLocation;
 import javax.tools.ToolProvider;
 
+import org.rascalmpl.library.Prelude;
 import org.rascalmpl.uri.URIUtil;
+import org.rascalmpl.uri.jar.JarInputStreamFileTree;
 
 /**
  * Compile a String or other {@link CharSequence}, returning a Java
@@ -162,10 +170,13 @@
          final DiagnosticCollector<JavaFileObject> diagnosticsList,
          final Class<?>... types) throws JavaCompilerException,
          ClassCastException {
-      if (diagnosticsList != null)
+      if (diagnosticsList != null) {
          diagnostics = diagnosticsList;
-      else
+      }
+      else {
          diagnostics = new DiagnosticCollector<JavaFileObject>();
+      }
+
       Map<String, CharSequence> classes = new HashMap<String, CharSequence>(1);
       classes.put(qualifiedClassName, javaSource);
       Map<String, Class<T>> compiled = compile(classes, diagnostics);
@@ -245,6 +256,28 @@
       }
    }
 
+   public void compile(OutputStream classBytes, String qualifiedClassName, CharSequence classSource, final DiagnosticCollector<JavaFileObject> diagnostics) throws JavaCompilerException {
+      Map<String, CharSequence> fileMap = new HashMap<>();
+
+      try {
+         fileMap.put(qualifiedClassName, classSource);
+
+         // ignoring return class here
+         compile(fileMap, diagnostics);
+
+         // side-effect alert:
+         //     now the local classloader contains the .class file
+         classLoader.outputClassesToJar(qualifiedClassName, classBytes);
+      }
+      catch (IOException e) {
+         throw new JavaCompilerException(fileMap.keySet(), e, diagnostics);
+      }
+   }
+
+   public Class<?> load(InputStream file) throws IOException, ClassNotFoundException {
+      return classLoader.inputClassesFromJar(file);
+   }
+
    /**
     * Load a class that was generated by this instance or accessible from its
     * parent class loader. Use this method if you need access to additional
@@ -310,6 +343,8 @@
    public JavaFileManager getFileManager() {
 	  return javaFileManager;
    }
+
+
 }
 
 /**
@@ -561,6 +596,51 @@
       super(parentClassLoader);
    }
 
+   public void outputClassesToJar(String qualifiedClassName, OutputStream output) throws IOException {
+      Manifest manifest = new Manifest();
+      manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
+      manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, qualifiedClassName);
+
+      try (JarOutputStream target = new JarOutputStream(output, manifest)) {
+         for (Entry<String, JavaFileObject> entry : classes.entrySet()) {
+            String className = entry.getKey();
+            JavaFileObjectImpl file = (JavaFileObjectImpl) entry.getValue();
+            JarEntry jarEntry = new JarEntry(className);
+            jarEntry.setTime(file.getLastModified());
+            target.putNextEntry(jarEntry);
+            target.write(file.getByteCode());
+            target.closeEntry();
+         }
+      }  
+   }
+
+   public Class<?> inputClassesFromJar(InputStream in) throws IOException, ClassNotFoundException {
+      try (JarInputStream jarIn = new JarInputStream(in)) {
+         Manifest mf = jarIn.getManifest();
+         String mainClass = (String) mf.getMainAttributes().get(Attributes.Name.MAIN_CLASS);
+         JarEntry jarEntry;
+
+         if (mainClass == null) {
+            throw new IOException("missing Main-Class in jar manifest");
+         }
+
+         while ((jarEntry = jarIn.getNextJarEntry()) != null) {
+            if (!jarEntry.isDirectory()) {
+               var className = jarEntry.getName();
+               var file = new JavaFileObjectImpl(className, JavaFileObject.Kind.CLASS);
+
+               try (var fo = file.openOutputStream()) {
+                  fo.write(Prelude.consumeInputStream(jarIn));
+               }
+
+               add(className, file);
+            }
+         }
+
+         return loadClass(mainClass);
+      }
+   }
+
    /**
     * @return An collection of JavaFileObject instances for the classes in the
     *         class loader.