[core] Skeleton for purity

It will be used in at least 3 places:

    --eval-pure
    when calling any func
    the free functions eval() and evalToDict().
      We might also want evalExpr()

Author: Andy C

core/alloc.py

@@ -1,6 +1,5 @@
 """
-alloc.py - strategies for managing SourceLine and Token
-
+alloc.py - Arena manages SourceLine and Token instances (could rename)
 """
 
 from _devbuild.gen.syntax_asdl import source_t, Token, SourceLine, loc
@@ -19,7 +18,9 @@ def SnipCodeBlock(left, right, lines):
 
     Meaning { } are not included.
 
-    Used for Hay evaluation. Similar to SnipCodeString().
+    Used for Command.sourceCode() and Hay evaluation. Similar to SnipCodeString().
+
+    TODO: This algorithm is wrong when re-parsing occurs, e.g. bacticks, aliases, a[i++]=1.
     """
     pieces = []  # type: List[str]
 

core/executor.py

@@ -209,6 +209,27 @@ def MaybeWaitOnProcessSubs(self, waiter, status_array):
 ]
 
 
+class PureExecutor(vm._Executor):
+
+    def __init__(
+            self,
+            mem,  # type: state.Mem
+            exec_opts,  # type: optview.Exec
+            mutable_opts,  # type: state.MutableOpts
+            procs,  # type: state.Procs
+            hay_state,  # type: hay_ysh.HayState
+            builtins,  # type: Dict[int, vm._Builtin]
+            tracer,  # type: dev.Tracer
+            errfmt  # type: ui.ErrorFormatter
+    ):
+        pass
+
+    def RunSimpleCommand(self, cmd_val, cmd_st, run_flags):
+        # type: (cmd_value.Argv, CommandStatus, int) -> int
+        log('RunSimpleCommand')
+        return 0
+
+
 class ShellExecutor(vm._Executor):
     """An executor combined with the OSH language evaluators in osh/ to create
     a shell interpreter."""

core/shell.py

@@ -499,6 +499,9 @@ def Main(
                                       ext_prog, waiter, tracer, job_control,
                                       job_list, fd_state, trap_state, errfmt)
 
+    pure_ex = executor.PureExecutor(mem, exec_opts, mutable_opts, procs,
+                                    hay_state, builtins, tracer, errfmt)
+
     arith_ev = sh_expr_eval.ArithEvaluator(mem, exec_opts, mutable_opts,
                                            parse_ctx, errfmt)
     bool_ev = sh_expr_eval.BoolEvaluator(mem, exec_opts, mutable_opts,
@@ -961,15 +964,16 @@ def Main(
     # Note that --eval
 
     for path, is_pure in attrs.eval_flags:
-        # TODO: respect is_pure
-        try:
-            ok, status = main_loop.EvalFile(path, fd_state, parse_ctx, cmd_ev,
-                                            lang)
-        except util.UserExit as e:
-            # Doesn't seem like we need this, and verbose_errexit isn't the right option
-            #if exec_opts.verbose_errexit():
-            #    print-stderr('oils: --eval exit')
-            return e.status
+        ex = pure_ex if is_pure else None
+        with vm.ctx_MaybePure(ex, cmd_ev, word_ev, expr_ev):
+            try:
+                ok, status = main_loop.EvalFile(path, fd_state, parse_ctx,
+                                                cmd_ev, lang)
+            except util.UserExit as e:
+                # Doesn't seem like we need this, and verbose_errexit isn't the right option
+                #if exec_opts.verbose_errexit():
+                #    print-stderr('oils: --eval exit')
+                return e.status
 
         # I/O error opening file, parse error.  Message was # already printed.
         if not ok:

core/vm.py

@@ -10,17 +10,17 @@
 from core import pyos
 from mycpp.mylib import log
 
-from typing import List, Tuple, Any, TYPE_CHECKING
+from typing import List, Tuple, Optional, Any, TYPE_CHECKING
 if TYPE_CHECKING:
     from _devbuild.gen.runtime_asdl import cmd_value, RedirValue
     from _devbuild.gen.syntax_asdl import (command, command_t, CommandSub)
     from frontend import typed_args
     from osh import sh_expr_eval
     from osh.sh_expr_eval import ArithEvaluator
     from osh.sh_expr_eval import BoolEvaluator
-    from ysh.expr_eval import ExprEvaluator
-    from osh.word_eval import NormalWordEvaluator
-    from osh.cmd_eval import CommandEvaluator
+    from ysh import expr_eval
+    from osh import word_eval
+    from osh import cmd_eval
     from osh import prompt
     from core import dev
     from core import state
@@ -109,7 +109,7 @@ def __repr__(self):
 
 
 def InitUnsafeArith(mem, word_ev, unsafe_arith):
-    # type: (state.Mem, NormalWordEvaluator, sh_expr_eval.UnsafeArith) -> None
+    # type: (state.Mem, word_eval.NormalWordEvaluator, sh_expr_eval.UnsafeArith) -> None
     """Wire up circular dependencies for UnsafeArith."""
     mem.unsafe_arith = unsafe_arith  # for 'declare -n' nameref expansion of a[i]
     word_ev.unsafe_arith = unsafe_arith  # for ${!ref} expansion of a[i]
@@ -118,10 +118,10 @@ def InitUnsafeArith(mem, word_ev, unsafe_arith):
 def InitCircularDeps(
         arith_ev,  # type: ArithEvaluator
         bool_ev,  # type: BoolEvaluator
-        expr_ev,  # type: ExprEvaluator
-        word_ev,  # type: NormalWordEvaluator
-        cmd_ev,  # type: CommandEvaluator
-        shell_ex,  # type:  _Executor
+        expr_ev,  # type: expr_eval.ExprEvaluator
+        word_ev,  # type: word_eval.NormalWordEvaluator
+        cmd_ev,  # type: cmd_eval.CommandEvaluator
+        shell_ex,  # type: _Executor
         prompt_ev,  # type: prompt.Evaluator
         global_io,  # type: Obj
         tracer,  # type: dev.Tracer
@@ -171,7 +171,7 @@ class _Executor(object):
 
     def __init__(self):
         # type: () -> None
-        self.cmd_ev = None  # type: CommandEvaluator
+        self.cmd_ev = None  # type: cmd_eval.CommandEvaluator
 
     def CheckCircularDeps(self):
         # type: () -> None
@@ -274,6 +274,54 @@ def Call(self, args):
         raise NotImplementedError()
 
 
+class ctx_MaybePure(object):
+    """Enforce purity of the shell interpreter
+
+    Use this for:
+
+      --eval-pure
+      func - pure functions
+      eval() evalToDict() - builtin pure functions, not methods
+    """
+
+    def __init__(
+        self,
+        pure_ex,  # type: Optional[_Executor]
+        cmd_ev,  # type: cmd_eval.CommandEvaluator
+        word_ev,  # type: word_eval.NormalWordEvaluator
+        expr_ev  # type: expr_eval.ExprEvaluator
+    ):
+        # type: (...) -> None
+        self.pure_ex = pure_ex
+        if not pure_ex:
+            return  # do nothing
+
+        self.saved = cmd_ev.shell_ex
+        assert self.saved is word_ev.shell_ex
+        assert self.saved is expr_ev.shell_ex
+
+        cmd_ev.shell_ex = pure_ex
+        word_ev.shell_ex = pure_ex
+        expr_ev.shell_ex = pure_ex
+
+        self.cmd_ev = cmd_ev
+        self.word_ev = word_ev
+        self.expr_ev = expr_ev
+
+    def __enter__(self):
+        # type: () -> None
+        pass
+
+    def __exit__(self, type, value, traceback):
+        # type: (Any, Any, Any) -> None
+        if not self.pure_ex:
+            return  # do nothing
+
+        self.cmd_ev.shell_ex = self.saved
+        self.word_ev.shell_ex = self.saved
+        self.expr_ev.shell_ex = self.saved
+
+
 class ctx_Redirect(object):
     """For closing files.
 

spec/ysh-method-other.test.sh

@@ -80,6 +80,7 @@ proc p ( ; ; ; block) {
 
   # Re-parsing messes this up
   echo $[src.code_str]
+  echo
 }
 
 shopt --set parse_backticks
@@ -88,5 +89,20 @@ p {
   echo "greeting `echo hi`"
 }
 
+shopt --set expand_aliases
+
+
+alias e='echo hi'
+
+p {
+  e foo
+}
+
+shopt --set parse_sh_arith
+
+p {
+  a[i++]=y
+}
+
 ## STDOUT:
 ## END

spec/ysh-usage.test.sh

@@ -51,13 +51,47 @@ flag -c: P Q
 
 ## END
 
-#### ysh --eval-pure
+#### ysh --eval-pure can evaluate funcs and procs
 
-echo TODO
+echo >pure.ysh '
+proc my-proc { echo "my-proc" }
+func myFunc() { return ("myFunc") }
+'
+
+$[ENV.SH] --eval-pure pure.ysh -c 'my-proc; echo $[myFunc()]'
 
 ## STDOUT:
+my-proc
+myFunc
 ## END
 
+#### ysh --eval-pure can't run impure
+
+echo >pure.ysh '
+proc my-proc { echo "my-proc" }
+func myFunc() { return ("myFunc") }
+'
+
+echo >impure.ysh 'my-proc; echo $[myFunc()]'
+
+# There should be an error on 'echo' - it can't even write to stdout?
+#
+# Or definitely ls
+#
+# Can this print to stdout?
+#
+# call myFunc() 
+#
+# Right now we can do this:
+# { call myFunc() } | wc -l
+
+$[ENV.SH] --eval-pure pure.ysh --eval-pure impure.ysh -c ''
+
+## status: 1
+## STDOUT:
+## END
+
+
 #### ysh --eval cannot load file
 
 $[ENV.SH] --eval nonexistent.ysh -c 'echo flag -c'