Merge pull request #2729 from usethesource/fix/add-parser-load-test

fix/add parser load test

Author: jurgenvinju

src/org/rascalmpl/library/lang/rascal/grammar/definition/Modules.rsc

@@ -15,6 +15,8 @@ import lang::rascal::grammar::definition::Literals;
 import lang::rascal::grammar::definition::Names;
 import Grammar;
 import Set;
+import IO;
+import util::Monitor;
 
 @memo
 @synopsis{Converts internal module representation of Rascal interpreter to single grammar definition}
@@ -57,6 +59,9 @@ public Grammar fuse(GrammarDefinition def) {
         result = (compose(result, \mod.grammar) | compose(it, def.modules[i].grammar) | i <- deps[nm], def.modules[i]?);
         todo += (\mod.extends - done);
     }
+    else {
+      warning("Fuse algorithm misses module definition for dependency <nm>", |unknown:///|);
+    }
   }
 
   return result;
@@ -74,11 +79,11 @@ public tuple[str, set[str], set[str]] getModuleMetaInf(Module \mod) {
   // Tags tags "module" QualifiedName name ModuleParameters params Import* imports
   switch (\mod) {
     case \default(parameters(_, QualifiedName name, _, Import* is),_) :
-    return <deslash("<name>"), { "<i>" | \default(\default(QualifiedName i)) <- is } 
-                    , { "<i>" | \extend(\default(QualifiedName i)) <- is }>;
+    return <deslash("<name>"), { deslash("<i>") | \default(\default(QualifiedName i)) <- is } 
+                    , { deslash("<i>") | \extend(\default(QualifiedName i)) <- is }>;
     case \default(\default(_, QualifiedName name, Import* is), _) : 
-    return <deslash("<name>"), { "<i>" |  \default(\default(QualifiedName i)) <- is } 
-                    , { "<i>" | \extend(\default(QualifiedName i)) <- is }>; 
+    return <deslash("<name>"), { deslash("<i>") |  \default(\default(QualifiedName i)) <- is } 
+                    , { deslash("<i>") | \extend(\default(QualifiedName i)) <- is }>; 
   }
 
   throw "unexpected module syntax <\mod>";

src/org/rascalmpl/library/lang/rascal/grammar/storage/ModuleParserStorage.rsc

@@ -20,13 +20,11 @@ the `.rsc` respective file.
 * loading modules without having to first load and use a parser generator can be up 1000 times faster.
 }
 @pitfalls{
-:::warning
-This caching feature is _static_. There is no automated cache clearance.
+* This caching feature is _static_. There is no automated cache clearance.
 If your grammars change, any saved `.parsers` files do not change with it. 
 It is advised that you programmatically execute this compiler at deployment time
 to store the `.parsers` file _only_ in deployed `jar` files. That way, you can not
 be bitten by a concrete syntax parser that is out of date at development time.
-:::
 }
 @license{
   Copyright (c) 2009-2023 NWO-I CWI
@@ -50,6 +48,7 @@ import ParseTree;
 import Grammar;
 import IO;
 import Exception;
+import String;
 
 @synopsis{For all modules in pcfg.srcs this will produce a `.parsers` stored parser capable of parsing concrete syntax fragment in said module.}
 @description{
@@ -114,7 +113,7 @@ void storeParsersForModules(set[loc] moduleFiles, PathConfig pcfg) {
 
 void storeParsersForModules(set[Module] modules, PathConfig pcfg) {
     for (m <- modules) {
-        storeParserForModule("<m.header.name>", m@\loc, modules, pcfg);
+        storeParserForModule(deslash("<m.header.name>"), m@\loc, modules, pcfg);
     }
 }
 
@@ -123,6 +122,9 @@ void storeParserForModule(str main, loc file, set[Module] modules, PathConfig pc
     // with import and extend. Each main module has a different grammar because of this.
     def = modules2definition(main, modules);
 
+println("storeParserForModule def:");
+iprintln(def);
+
     // here the layout semantics comes really into action
     gr = resolve(fuse(layouts(def)));
 

src/org/rascalmpl/library/lang/rascal/tests/functionality/storedParsers/ExampleModule.rsc

@@ -0,0 +1,13 @@
+module lang::rascal::tests::functionality::storedParsers::ExampleModule
+
+import lang::pico::\syntax::Main;
+import util::Math;
+import ValueIO;
+
+int compute((Expression) `<Expression a> + <Expression b>`) = compute(a) + compute(b);
+int compute((Expression) `<Natural c>`) = readTextValueString(#int, "<c>");
+
+test bool testCompute() {
+    example = (Expression) `1 + 1`;
+    return compute(example) == 2;
+}

src/org/rascalmpl/library/lang/rascal/tests/functionality/storedParsers/StoredParserTests.rsc

@@ -0,0 +1,47 @@
+module lang::rascal::tests::functionality::storedParsers::StoredParserTests
+
+import lang::rascal::grammar::storage::ModuleParserStorage;
+import util::Reflective;
+import util::Eval;
+import IO;
+import Location;
+import util::PathConfig;
+
+void prepareStorage(PathConfig pcfg) {
+    storeParsersForModules(
+        {
+            resolveLocation(|project://rascal/src/org/rascalmpl/library/lang/rascal/tests/functionality/storedParsers/ExampleModule.rsc|),
+            resolveLocation(|project://rascal/src/org/rascalmpl/library/lang/pico/syntax/Main.rsc|)
+        },
+        pcfg);
+}
+
+test bool testStorageAndUse() {
+    pcfg = getProjectPathConfig(|project://rascal|);
+    prepareStorage(pcfg);
+
+    // first we run in the source environment. There is no cached parser 
+    // there necause it is written to the target folder
+    rt = createRascalRuntime(pcfg=pcfg);
+    rt.eval(#void, "import lang::rascal::tests::functionality::storedParsers::ExampleModule;");
+    
+    // a bit of fiddling to allow the Rascal project itself to be a testbed for this configuration
+    modLoc = srcsFile("lang::rascal::tests::functionality::storedParsers::ExampleModule", pcfg, fileConfig());
+    generatedPath = pcfg.bin + relativize(pcfg.srcs, modLoc)[extension="parsers"].path;
+    targetLibrary = pcfg.bin + "org/rascalmpl/library";
+    requiredPath = ((pcfg.bin + "org/rascalmpl/library") + relativize(pcfg.srcs, modLoc).path)[extension="parsers"];
+    println(requiredPath);
+    copy(generatedPath, requiredPath);
+
+    // we create a runtime which includes the generate .parser file, and we run again
+    pcfg.srcs = [pcfg.bin + "org/rascalmpl/library"];
+    rt = createRascalRuntime(pcfg=pcfg);
+    rt.eval(#void, "import lang::rascal::tests::functionality::storedParsers::ExampleModule;");
+
+    return result(true) := rt.eval(#bool, "testCompute()");
+}
+
+
+
+
+