[builtin/ysh] Add pure functions eval() and evalExpr()

This was straightforward!  It fell out of the clean implementation.

Author: Andy C

builtin/method_io.py

@@ -44,20 +44,28 @@ class EvalExpr(vm._Callable):
     """io->evalExpr(ex) evaluates an expression 
 
     Notes compared with io->eval(cmd):
-    - there is no evalToDict variant - doesn't make sense
+    - there is no to_dict=true variant - doesn't make sense
     - Does it need in_captured_frame=true?
       - That is for "inline procs" like cd, but doesn't seem to be necessary
         for expressions.  Unless we had mutations in expressions.
     """
 
-    def __init__(self, expr_ev):
-        # type: (expr_eval.ExprEvaluator) -> None
+    def __init__(
+            self,
+            expr_ev,  # type: expr_eval.ExprEvaluator
+            pure_ex,  # type: Optional[vm._Executor]
+            cmd_ev,  # type: Optional[cmd_eval.CommandEvaluator]
+    ):
+        # type: (...) -> None
         self.expr_ev = expr_ev
+        self.pure_ex = pure_ex
+        self.cmd_ev = cmd_ev
         self.mem = expr_ev.mem
 
     def Call(self, rd):
         # type: (typed_args.Reader) -> value_t
-        unused_self = rd.PosObj()
+        if self.pure_ex is None:
+            unused_self = rd.PosObj()
         lazy = rd.PosExpr()
 
         dollar0 = rd.NamedStr("dollar0", None)
@@ -74,7 +82,8 @@ def Call(self, rd):
             with state.ctx_EnclosedFrame(self.mem, lazy.captured_frame,
                                          lazy.module_frame, None):
                 with state.ctx_Eval(self.mem, dollar0, pos_args, vars_):
-                    result = self.expr_ev.EvalExpr(lazy.e, blame_tok)
+                    with vm.ctx_MaybePure(self.pure_ex, self.cmd_ev):
+                        result = self.expr_ev.EvalExpr(lazy.e, blame_tok)
 
         return result
 
@@ -139,15 +148,17 @@ class Eval(vm._Callable):
     The CALLER must handle errors.
     """
 
-    def __init__(self, mem, cmd_ev, which):
-        # type: (state.Mem, cmd_eval.CommandEvaluator, int) -> None
+    def __init__(self, mem, cmd_ev, pure_ex, which):
+        # type: (state.Mem, cmd_eval.CommandEvaluator, Optional[vm._Executor], int) -> None
         self.mem = mem
         self.cmd_ev = cmd_ev
+        self.pure_ex = pure_ex
         self.which = which
 
     def Call(self, rd):
         # type: (typed_args.Reader) -> value_t
-        unused = rd.PosValue()
+        if self.pure_ex is None:
+            unused = rd.PosValue()
         bound = rd.PosCommand()
 
         dollar0 = rd.NamedStr("dollar0", None)
@@ -180,7 +191,8 @@ def Call(self, rd):
                                          inside=in_captured_frame):
                 # _PrintFrame('[new]', self.cmd_ev.mem.var_stack[-1])
                 with state.ctx_Eval(self.mem, dollar0, pos_args, vars_):
-                    unused_status = self.cmd_ev.EvalCommandFrag(frag)
+                    with vm.ctx_MaybePure(self.pure_ex, self.cmd_ev):
+                        unused_status = self.cmd_ev.EvalCommandFrag(frag)
 
             if bindings is not None:
                 return value.Dict(bindings)

core/executor.py

@@ -222,11 +222,7 @@ def __init__(
             tracer,  # type: dev.Tracer
             errfmt  # type: ui.ErrorFormatter
     ):
-        pass
-
-    def CheckCircularDeps(self):
-        # type: () -> None
-        pass
+        vm._Executor.__init__(self)
 
     def RunBuiltin(self, builtin_id, cmd_val):
         # type: (int, cmd_value.Argv) -> int
@@ -245,7 +241,8 @@ def RunBackgroundJob(self, node):
 
     def RunPipeline(self, node, status_out):
         # type: (command.Pipeline, CommandStatus) -> None
-        e_die("Pipelines aren't allowed in pure mode (OILS-ERR-204)", loc.Command(node))
+        e_die("Pipelines aren't allowed in pure mode (OILS-ERR-204)",
+              loc.Command(node))
 
     def RunSubshell(self, node):
         # type: (command_t) -> int
@@ -260,7 +257,8 @@ def CaptureStdout(self, node):
 
     def RunCommandSub(self, cs_part):
         # type: (CommandSub) -> str
-        e_die("Command subs aren't allowed in pure mode (OILS-ERR-204)", loc.WordPart(cs_part))
+        e_die("Command subs aren't allowed in pure mode (OILS-ERR-204)",
+              loc.WordPart(cs_part))
         return ''
 
     def RunProcessSub(self, cs_part):
@@ -337,10 +335,6 @@ def __init__(
         # group, we only need one pointer here, not some collection.
         self.fg_pipeline = None  # type: Optional[process.Pipeline]
 
-    def CheckCircularDeps(self):
-        # type: () -> None
-        assert self.cmd_ev is not None
-
     def _MakeProcess(self, node, inherit_errexit, inherit_errtrace):
         # type: (command_t, bool, bool) -> process.Process
         """Assume we will run the node in another process.

core/shell.py

@@ -524,16 +524,17 @@ def Main(
 
     # The M/ prefix means it's io->eval()
     io_methods['M/eval'] = value.BuiltinFunc(
-        method_io.Eval(mem, cmd_ev, method_io.EVAL_NULL))
-    io_methods['M/evalExpr'] = value.BuiltinFunc(method_io.EvalExpr(expr_ev))
+        method_io.Eval(mem, cmd_ev, None, method_io.EVAL_NULL))
+    io_methods['M/evalExpr'] = value.BuiltinFunc(
+        method_io.EvalExpr(expr_ev, None, None))
 
     # Identical to command sub
     io_methods['captureStdout'] = value.BuiltinFunc(
         method_io.CaptureStdout(mem, shell_ex))
 
     # TODO: remove these 2 deprecated methods
     io_methods['M/evalToDict'] = value.BuiltinFunc(
-        method_io.Eval(mem, cmd_ev, method_io.EVAL_DICT))
+        method_io.Eval(mem, cmd_ev, None, method_io.EVAL_DICT))
     io_methods['M/evalInFrame'] = value.BuiltinFunc(
         method_io.EvalInFrame(mem, cmd_ev))
 
@@ -600,7 +601,7 @@ def Main(
 
     # Wire up circular dependencies.
     vm.InitCircularDeps(arith_ev, bool_ev, expr_ev, word_ev, cmd_ev, shell_ex,
-                        prompt_ev, io_obj, tracer)
+                        pure_ex, prompt_ev, io_obj, tracer)
 
     unsafe_arith = sh_expr_eval.UnsafeArith(mem, exec_opts, mutable_opts,
                                             parse_ctx, arith_ev, errfmt)
@@ -871,6 +872,12 @@ def Main(
     # Initialize Built-in Funcs
     #
 
+    # Pure functions
+    _AddBuiltinFunc(mem, 'eval',
+                    method_io.Eval(mem, cmd_ev, pure_ex, method_io.EVAL_NULL))
+    _AddBuiltinFunc(mem, 'evalExpr',
+                    method_io.EvalExpr(expr_ev, pure_ex, cmd_ev))
+
     parse_hay = func_hay.ParseHay(fd_state, parse_ctx, mem, errfmt)
     eval_hay = func_hay.EvalHay(hay_state, mutable_opts, mem, cmd_ev)
     hay_func = func_hay.HayFunc(hay_state)
@@ -967,7 +974,7 @@ def Main(
 
     for path, is_pure in attrs.eval_flags:
         ex = pure_ex if is_pure else None
-        with vm.ctx_MaybePure(ex, cmd_ev, word_ev, expr_ev):
+        with vm.ctx_MaybePure(ex, cmd_ev):
             try:
                 ok, status = main_loop.EvalFile(path, fd_state, parse_ctx,
                                                 cmd_ev, lang)

core/test_lib.py

@@ -290,13 +290,15 @@ def InitCommandEvaluator(parse_ctx=None,
                                       hay_state, builtins, search_path,
                                       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)
 
     assert cmd_ev.mutable_opts is not None, cmd_ev
     prompt_ev = prompt.Evaluator('osh', '0.0.0', parse_ctx, mem)
 
     global_io = Obj(None, None)
     vm.InitCircularDeps(arith_ev, bool_ev, expr_ev, word_ev, cmd_ev, shell_ex,
-                        prompt_ev, global_io, tracer)
+                        pure_ex, prompt_ev, global_io, tracer)
 
     try:
         from _devbuild.gen.help_meta import TOPICS

core/vm.py

@@ -122,6 +122,7 @@ def InitCircularDeps(
         word_ev,  # type: word_eval.NormalWordEvaluator
         cmd_ev,  # type: cmd_eval.CommandEvaluator
         shell_ex,  # type: _Executor
+        pure_ex,  # type: _Executor
         prompt_ev,  # type: prompt.Evaluator
         global_io,  # type: Obj
         tracer,  # type: dev.Tracer
@@ -149,6 +150,7 @@ def InitCircularDeps(
     cmd_ev.tracer = tracer
 
     shell_ex.cmd_ev = cmd_ev
+    pure_ex.cmd_ev = cmd_ev
 
     prompt_ev.word_ev = word_ev
     prompt_ev.expr_ev = expr_ev
@@ -163,6 +165,7 @@ def InitCircularDeps(
     word_ev.CheckCircularDeps()
     cmd_ev.CheckCircularDeps()
     shell_ex.CheckCircularDeps()
+    pure_ex.CheckCircularDeps()
     prompt_ev.CheckCircularDeps()
     tracer.CheckCircularDeps()
 
@@ -175,7 +178,7 @@ def __init__(self):
 
     def CheckCircularDeps(self):
         # type: () -> None
-        pass
+        assert self.cmd_ev is not None
 
     def RunBuiltin(self, builtin_id, cmd_val):
         # type: (int, cmd_value.Argv) -> int
@@ -285,28 +288,29 @@ class ctx_MaybePure(object):
     """
 
     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
+            self,
+            pure_ex,  # type: Optional[_Executor]
+            cmd_ev,  # type: cmd_eval.CommandEvaluator
     ):
         # type: (...) -> None
         self.pure_ex = pure_ex
         if not pure_ex:
             return  # do nothing
 
+        word_ev = cmd_ev.word_ev
+        expr_ev = cmd_ev.expr_ev
+
+        # Save the Shell Executor
         self.saved = cmd_ev.shell_ex
         assert self.saved is word_ev.shell_ex
         assert self.saved is expr_ev.shell_ex
 
+        # Patch evaluators to use the Pure Executor
         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
@@ -317,9 +321,10 @@ def __exit__(self, type, value, traceback):
         if not self.pure_ex:
             return  # do nothing
 
+        # Unpatch the evaluators
         self.cmd_ev.shell_ex = self.saved
-        self.word_ev.shell_ex = self.saved
-        self.expr_ev.shell_ex = self.saved
+        self.cmd_ev.word_ev.shell_ex = self.saved
+        self.cmd_ev.expr_ev.shell_ex = self.saved
 
 
 class ctx_Redirect(object):

doc/ref/chap-builtin-func.md

@@ -373,6 +373,31 @@ Like `Match => end()`, but accesses the global match created by `~`:
       echo $[_end(0)]  # => 5
     }
 
+## Reflection
+
+### func/eval()
+
+This function is like [`io->eval()`][io/eval], but it disallows I/O.
+
+Example:
+
+    var cmd = ^(const x = 42)
+    var d = eval(cmd, to_dict=true)  # {x: 42}
+
+[io/eval]: chap-type-method.html#io/eval
+
+### func/evalExpr()
+
+This function is like [`io->evalExpr()`][io/evalExpr], but it disallows I/O.
+
+Example:
+
+    var x = 42
+    var expr = ^[x + 1]
+    var val = evalExpr(expr)  # 43
+
+[io/evalExpr]: chap-type-method.html#io/evalExpr
+
 ## Introspect
 
 ### `shvarGet()`

doc/ref/chap-index.md

@@ -43,11 +43,23 @@ The name `clear` can refer to:
 
 The name `eval` can refer to:
 
-- The [eval builtin][cmd/eval]
-- The [io method eval][io/eval]
+- The [eval builtin command][cmd/eval]
+- The [io method eval()][io/eval]
+- The [pure function eval()][func/eval]
 
 [cmd/eval]: chap-builtin-cmd.html#cmd/eval
 [io/eval]: chap-type-method.html#io/eval
+[func/eval]: chap-builtin-func.html#func/eval
+
+### evalExpr
+
+The name `eval` can refer to:
+
+- The [io method evalExpr()][io/evalExpr]
+- The [pure function evalExpr()][func/evalExpr]
+
+[io/evalExpr]: chap-type-method.html#io/evalExpr
+[func/evalExpr]: chap-builtin-func.html#func/evalExpr
 
 ### false