added loading of the parser class, but it's not enough because I forg…

…ot about the nested classes

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.objectweb.asm.ClassReader;
 import org.rascalmpl.ast.Expression;
 import org.rascalmpl.ast.FunctionDeclaration;
 import org.rascalmpl.ast.KeywordFormal;
@@ -51,8 +53,10 @@
 import org.rascalmpl.interpreter.staticErrors.MissingTag;
 import org.rascalmpl.interpreter.staticErrors.NonAbstractJavaFunction;
 import org.rascalmpl.interpreter.staticErrors.UndeclaredJavaMethod;
+import org.rascalmpl.library.Prelude;
 import org.rascalmpl.types.DefaultRascalTypeVisitor;
 import org.rascalmpl.types.RascalType;
+import org.rascalmpl.uri.URIResolverRegistry;
 import org.rascalmpl.util.ListClassLoader;
 import org.rascalmpl.values.IRascalValueFactory;
 import org.rascalmpl.values.functions.IFunction;
@@ -108,6 +112,41 @@ public <T> Class<T> compileJava(ISourceLocation loc, String className, String so
 		return compileJava(loc, className, getClass(), source);
 	}
 
+	public Class<?> loadClass(ISourceLocation loc) throws IOException {
+		try (InputStream forClassName = URIResolverRegistry.getInstance().getInputStream(loc)) {
+			ClassReader cr = new ClassReader(forClassName);
+			String className = cr.getClassName();
+
+			// ad-hoc loader to just get the bytes of _this_ specific file without
+			// searching in a classpath or anything. It needs access to the parser classes 
+			// as parent.
+			ClassLoader loader = new ClassLoader(getClass().getClassLoader()) {
+				@Override
+				protected Class<?> findClass(final String name) throws ClassNotFoundException {
+					if (!name.equals(className)) {
+						return super.findClass(name);
+					}
+					else {
+						try (InputStream forClass = URIResolverRegistry.getInstance().getInputStream(loc)) {
+							byte[] bytes = Prelude.consumeInputStream(URIResolverRegistry.getInstance().getInputStream(loc));
+							return this.defineClass(null, bytes, 0, bytes.length);
+						}
+						catch (IOException e) {
+							throw new ClassNotFoundException(className);
+						}
+					}
+				}
+			};
+
+			try {
+				return (Class<?>) loader.loadClass(className);
+			}
+			catch (ClassNotFoundException e) {
+				throw new IOException(e.getMessage(), e);
+			}
+		}
+	}
+
 	public void compileJava(ISourceLocation loc, String className, String source, OutputStream classBytes) {
 		compileJava(loc, className, getClass(), source, classBytes);
 	}

src/org/rascalmpl/library/Prelude.java

@@ -1149,6 +1149,16 @@ public static String consumeInputStream(Reader in) throws IOException {
 		}
 		return res.toString();
 	}
+
+	public static byte[] consumeInputStream(InputStream in) throws IOException {
+		ByteArrayOutputStream res = new ByteArrayOutputStream();
+		byte[] chunk = new byte[FILE_BUFFER_SIZE];
+		int read;
+		while ((read = in.read(chunk, 0, chunk.length)) != -1) {
+		    res.write(chunk, 0, read);
+		}
+		return res.toByteArray();
+	}
 
 	public IValue md5HashFile(ISourceLocation sloc){
         try {
@@ -2337,7 +2347,12 @@ public void storeParsers(IValue start, ISourceLocation saveLocation) {
 	}
 
 	public IFunction loadParsers(ISourceLocation savedLocation, IBool allowAmbiguity, IBool hasSideEffects, IBool firstAmbiguity, ISet filters) {
-		return rascalValues.loadParsers(savedLocation, allowAmbiguity, hasSideEffects, firstAmbiguity, filters);
+		try {
+			return rascalValues.loadParsers(savedLocation, allowAmbiguity, hasSideEffects, firstAmbiguity, filters);
+		}
+		catch (IOException e) {
+			throw RuntimeExceptionFactory.io(e.getMessage());
+		}
 	}
 
 	// REFLECT -- copy in {@link PreludeCompiled}

src/org/rascalmpl/values/IRascalValueFactory.java

@@ -121,8 +121,9 @@ default void storeParsers(IValue start, ISourceLocation saveLocation) throws IOE
 
 	/**
 	 * Reverse of storeParsers and with the same effect as the {@see parsers} method.
+	 * @throws IOException
 	 */
-	default IFunction loadParsers(ISourceLocation saveLocation, IBool allowAmbiguity, IBool hasSideEffects, IBool firstAmbiguity, ISet filters) {
+	default IFunction loadParsers(ISourceLocation saveLocation, IBool allowAmbiguity, IBool hasSideEffects, IBool firstAmbiguity, ISet filters) throws IOException {
 		throw new UnsupportedOperationException("This Rascal value factory does not support a parser generator that can restore parsers from disk." + getClass());
 	}
 }

src/org/rascalmpl/values/RascalFunctionValueFactory.java

@@ -111,15 +111,6 @@ private Class<IGTD<IConstructor, ITree, ISourceLocation>> generateParser(IMap gr
         }
     }
 
-    private void writeParsers(IMap grammar, ISourceLocation target) throws IOException {
-        try {
-            getParserGenerator().writeNewParser(new NullRascalMonitor(), URIUtil.rootLocation("parser-generator"), "$GENERATED_PARSER$" + Math.abs(grammar.hashCode()), grammar, target);
-        } 
-        catch (ExceptionInInitializerError e) {
-            throw new ImplementationError(e.getMessage(), e);
-        }
-    }
-
     protected Class<IGTD<IConstructor, ITree, ISourceLocation>> getParserClass(IMap grammar) {
         return parserCache.get(grammar);
     }
@@ -271,6 +262,37 @@ public void storeParsers(IValue reifiedGrammar, ISourceLocation saveLocation) th
         getParserGenerator().writeNewParser(new NullRascalMonitor(), URIUtil.rootLocation("parser-generator"), "$GENERATED_PARSER$" + Math.abs(grammar.hashCode()), grammar, saveLocation);
     }
 
+    @Override
+    public IFunction loadParsers(ISourceLocation saveLocation, IBool allowAmbiguity, IBool hasSideEffects,IBool firstAmbiguity, ISet filters) throws IOException {
+        RascalTypeFactory rtf = RascalTypeFactory.getInstance();
+        TypeFactory tf = TypeFactory.getInstance();
+
+        // here the return type is parametrized and instantiated when the parser function is called with the
+        // given start non-terminal:
+        Type parameterType = tf.parameterType("U", RascalValueFactory.Tree);
+
+        Type functionType = tf.functionType(parameterType,
+            tf.tupleType(rtf.reifiedType(parameterType), tf.valueType(), tf.sourceLocationType()), 
+            tf.tupleEmpty());
+
+
+
+        final Class<IGTD<IConstructor, ITree, ISourceLocation>> parser 
+            = (Class<IGTD<IConstructor, ITree, ISourceLocation>>) ctx.getEvaluator()
+                .__getJavaBridge().loadClass(saveLocation);
+
+        AbstractAST current = ctx.getCurrentAST();
+        ISourceLocation caller = current != null ? current.getLocation() : URIUtil.rootLocation("unknown");
+
+        return function(
+            functionType, 
+            new ParametrizedParseFunction(() -> getParserGenerator(), 
+            this, 
+            caller, 
+            parser, 
+            allowAmbiguity, hasSideEffects, firstAmbiguity, filters));
+    }
+
     /**
      * This function mimicks `parsers(#start[Module]) inside lang::rascal::\syntax::Rascal.
      * so it produces a parse function for the Rascal language, where non-terminal is the