make --run work, modulu exit codes

it will not exit with EXIT_ERROR_CHECK_FAILURES when needed.
however, it the main function in pyret.arr will return an
appropriate error code, if we can leverage that

also: this commit fails on  no-diff-standalone

Author: awstlaur

src/arr/compiler/cli-module-loader.arr

@@ -307,13 +307,30 @@ fun compile(path, options):
   compiled
 end
 
+fun handle-compilation-errors(problems, options) block:
+  for lists.each(e from problems) block:
+    options.log-error(RED.display-to-string(e.render-reason(), torepr, empty))
+    options.log-error("\n")
+  end
+  #raise("There were compilation errors")
+  {
+    message: "There were compilation errors",
+    exit-code: 1
+  }
+end
+
 fun run(path, options):
-  prog = build-program(path, options)
-  result = L.run-program(R.make-runtime(), L.empty-realm(), prog.js-ast.to-ugly-source(), options)
-  if L.is-success-result(result):
-    print(L.render-check-results(result))
-  else:
-    print(L.render-error-message(result))
+  maybe-program = build-program(path, options)
+  cases(Either) maybe-program block:
+    | left(problems) =>
+      handle-compilation-errors(problems, options)
+    | right(program) =>
+      result = L.run-program(R.make-runtime(), L.empty-realm(), program.js-ast.to-ugly-source(), options)
+      if L.is-success-result(result):
+        L.render-check-results(result)
+      else:
+        L.render-error-message(result)
+      end
   end
 end
 
@@ -384,11 +401,7 @@ fun build-runnable-standalone(path, require-config-path, outfile, options) block
   maybe-program = build-program(path, options)
   cases(Either) maybe-program block:
     | left(problems) => 
-      for lists.each(e from problems) block:
-        options.log-error(RED.display-to-string(e.render-reason(), torepr, empty))
-        options.log-error("\n")
-      end
-      raise("There were compilation errors")
+      handle-compilation-errors(problems, options)
     | right(program) =>
       config = JSON.read-json(F.file-to-string(require-config-path)).dict.unfreeze()
       config.set-now("out", JSON.j-str(outfile))

src/arr/compiler/pyret.arr

@@ -67,18 +67,22 @@ fun main(args):
 
   cases(C.ParsedArguments) params-parsed block:
     | success(r, rest) =>
-      check-mode = not(r.has-key("no-check-mode") or r.has-key("library"))
-      allow-shadowed = r.has-key("allow-shadow")
       libs =
         if r.has-key("library"): CS.minimal-imports
         else: CS.standard-imports end
       module-dir = r.get-value("module-load-dir")
-      check-all = r.has-key("check-all")
-      type-check = r.has-key("type-check")
-      tail-calls = not(r.has-key("improper-tail-calls"))
-      compiled-dir = r.get-value("compiled-dir")
-      standalone-file = r.get-value("standalone-file")
-      display-progress = not(r.has-key("no-display-progress"))
+      user-compile-options = CS.default-compile-options.{
+        check-mode: not(r.has-key("no-check-mode") or r.has-key("library")),
+        allow-shadowed: r.has-key("allow-shadow"),
+        check-all: r.has-key("check-all"),
+        type-check: r.has-key("type-check"),
+        tail-calls: not(r.has-key("improper-tail-calls")),
+        compiled-dir: r.get-value("compiled-dir"),
+        standalone-file: r.get-value("standalone-file"),
+        display-progress: not(r.has-key("no-display-progress")),
+        collect-all: false,
+        ignore-unbound: false
+      }
       when r.has-key("builtin-js-dir"):
         B.set-builtin-js-dirs(r.get-value("builtin-js-dir"))
       end
@@ -101,17 +105,8 @@ fun main(args):
               r.get-value("build-runnable"),
               r.get-value("require-config"),
               outfile,
-              CS.default-compile-options.{
-                standalone-file: standalone-file,
-                check-mode : check-mode,
-                type-check : type-check,
-                allow-shadowed : allow-shadowed,
-                collect-all: false,
-                ignore-unbound: false,
-                proper-tail-calls: tail-calls,
-                compile-module: true,
-                compiled-cache: compiled-dir,
-                display-progress: display-progress
+              user-compile-options.{
+                compile-module: true
               })
         else if r.has-key("serve"):
           port = r.get-value("port")
@@ -134,15 +129,8 @@ fun main(args):
            |#
         else if r.has-key("build"):
           result = CLI.compile(r.get-value("build"),
-            CS.default-compile-options.{
-              check-mode : check-mode,
-              type-check : type-check,
-              allow-shadowed : allow-shadowed,
-              collect-all: false,
-              ignore-unbound: false,
-              proper-tail-calls: tail-calls,
-              compile-module: false,
-              display-progress: display-progress
+            user-compile-options.{
+              compile-module: false
             })
           failures = filter(CS.is-err, result.loadables)
           when is-link(failures):
@@ -155,12 +143,14 @@ fun main(args):
             end
           end
         else if r.has-key("run"):
-          CLI.run(r.get-value("run"), CS.default-compile-options.{
-              standalone-file: standalone-file,
-              compile-module: true,
-              display-progress: display-progress,
-              check-all: check-all
-            })
+          block:
+            result = CLI.run(r.get-value("run"), user-compile-options.{
+                  compile-module: false
+                })
+            print(result.message)
+            print("\n")
+            result.exit-code # TODO: exit process with this code
+          end
         else:
           print(C.usage-info(options).join-str("\n"))
           raise("Unknown command line options")

src/js/base/handalone.js

@@ -20,7 +20,10 @@ require(["pyret-base/js/runtime", "program"], function(runtimeLib, program) {
   var EXIT_ERROR_JS = 5;
   var EXIT_ERROR_UNKNOWN = 6;
 
-  runtime.setParam("command-line-arguments", process.argv.slice(1));
+  var commandLineArguments = process.argv.slice(1);
+  var runMode = (commandLineArguments.indexOf("--run") > 0);
+
+  runtime.setParam("command-line-arguments", commandLineArguments);
 
   var postLoadHooks = {
     "builtin://srcloc": function(srcloc) {
@@ -147,35 +150,39 @@ require(["pyret-base/js/runtime", "program"], function(runtimeLib, program) {
       runtime.setParam("current-checker", currentChecker);
     }
   };
-  postLoadHooks[main] = function(answer) {
-    var checkerLib = runtime.modules["builtin://checker"];
-    var checker = runtime.getField(runtime.getField(checkerLib, "provide-plus-types"), "values");
-    var getStack = function(err) {
-      console.error("The error is: ", err);
-      var locArray = err.val.pyretStack.map(runtime.makeSrcloc);
-      var locList = runtime.ffi.makeList(locArray);
-      return locList;
-    };
-    var getStackP = runtime.makeFunction(getStack, "get-stack");
-    var toCall = runtime.getField(checker, "render-check-results-stack");
-    var checks = runtime.getField(answer, "checks");
-    runtime.safeCall(function() {
-      return toCall.app(checks, getStackP);
-    }, function(summary) {
-      if(runtime.isObject(summary)) {
-        process.stdout.write(runtime.getField(summary, "message"));
-        process.stdout.write("\n");
-        var errs = runtime.getField(summary, "errored");
-        var failed = runtime.getField(summary, "failed");
-        if(errs !== 0 || failed !== 0) {
-          process.exit(EXIT_ERROR_CHECK_FAILURES);
-        }
-        else {
-          process.exit(EXIT_SUCCESS);
-        }
-      }
-    });
-  }
+  postLoadHooks[main] = runMode ?
+    (function(answer) {
+      //console.dir(answer);
+    }) :
+    (function(answer) {
+        var checkerLib = runtime.modules["builtin://checker"];
+        var checker = runtime.getField(runtime.getField(checkerLib, "provide-plus-types"), "values");
+        var getStack = function(err) {
+          console.error("The error is: ", err);
+          var locArray = err.val.pyretStack.map(runtime.makeSrcloc);
+          var locList = runtime.ffi.makeList(locArray);
+          return locList;
+        };
+        var getStackP = runtime.makeFunction(getStack, "get-stack");
+        var toCall = runtime.getField(checker, "render-check-results-stack");
+        var checks = runtime.getField(answer, "checks");
+        runtime.safeCall(function() {
+          return toCall.app(checks, getStackP);
+        }, function(summary) {
+          if(runtime.isObject(summary)) {
+            process.stdout.write(runtime.getField(summary, "message"));
+            process.stdout.write("\n");
+            var errs = runtime.getField(summary, "errored");
+            var failed = runtime.getField(summary, "failed");
+            if(errs !== 0 || failed !== 0) {
+              process.exit(EXIT_ERROR_CHECK_FAILURES);
+            }
+            else {
+              process.exit(EXIT_SUCCESS);
+            }
+          }
+        });
+      });
 
   function renderErrorMessageAndExit(execRt, res) {
     if (execRt.isPyretException(res.exn)) {

src/js/base/runtime.js

@@ -4901,7 +4901,7 @@ function (Namespace, jsnums, codePoint, seedrandom, util) {
             return mod.theModule.apply(null, [thisRuntime, thisRuntime.namespace, uri].concat(reqInstantiated).concat(natives));
           },
           function(r) {
-            // CONSOLE.log("Result from module: ", r);
+            //CONSOLE.log("Result from module: ", r);
             realm[uri] = r;
             if(uri in postLoadHooks) {
               return thisRuntime.safeCall(function() {

src/js/trove/load-lib.js

@@ -5,6 +5,13 @@
   nativeRequires: ["pyret-base/js/secure-loader"],
   provides: {},
   theModule: function(runtime, namespace, uri, runtimeLib, loader) {
+    var EXIT_SUCCESS = 0;
+    var EXIT_ERROR = 1;
+    var EXIT_ERROR_RENDERING_ERROR = 2;
+    var EXIT_ERROR_DISPLAYING_ERROR = 3;
+    var EXIT_ERROR_CHECK_FAILURES = 4;
+    var EXIT_ERROR_JS = 5;
+    var EXIT_ERROR_UNKNOWN = 6;
 
 
     var brandModule = runtime.namedBrander("module", ["load-lib: module brander"]);
@@ -140,16 +147,36 @@
         var getStackP = execRt.makeFunction(getStack, "get-stack");
         var checks = getModuleResultChecks(mr);
         execRt.runThunk(function() { return toCall.app(checks, getStackP); },
-          function(printedCheckResult) {
-            if(execRt.isSuccessResult(printedCheckResult)) {
-              if(execRt.isString(printedCheckResult.result)) {
-                restarter.resume(runtime.makeString(execRt.unwrap(printedCheckResult.result)));
+          function(renderedCheckResults) {
+            var resumeWith = {
+              message: "Unknown error!",
+              'exit-code': EXIT_ERROR_UNKNOWN
+            };
+
+            if(execRt.isSuccessResult(renderedCheckResults)) {
+              resumeWith.message = execRt.getField(renderedCheckResults.result, "message");
+              var errs = execRt.getField(renderedCheckResults.result, "errored");
+              var failed = execRt.getField(renderedCheckResults.result, "failed");
+              if(errs !== 0 || failed !== 0) {
+                resumeWith["exit-code"] = EXIT_ERROR_CHECK_FAILURES;
+              } else {
+                resumeWith["exit-code"] = EXIT_SUCCESS;
               }
             }
-            else if(execRt.isFailureResult(printedCheckResult)) {
-              console.error(printedCheckResult.exn.dict);
-              restarter.resume(runtime.makeString("There was an exception while formatting the check results"));
+            else if(execRt.isFailureResult(renderedCheckResults)) {
+              resumeWith.message = execRt.makeString("There was an exception while formatting the check results");
+              resumeWith["exit-code"] = EXIT_ERROR_RENDERING_ERROR;
+              //console.error(renderedCheckResults.exn.dict);
             }
+
+            // process.stdout.write(resumeWith.message);
+            // process.stdout.write("\n");
+            // process.exit(resumeWith["exit-code"]);
+
+            restarter.resume(runtime.makeObject({
+              message: runtime.makeString(resumeWith.message),
+              'exit-code': runtime.makeNumber(resumeWith["exit-code"])
+            }));
           });
       });
     }