More async support

Still very experimental, and hidden behind a [set -o async] flag.

src/lib/ast.ml

···
 
 let word_components_to_string ws =
   String.concat "" (List.map word_component_to_string ws)
+
+class check_ast =
+  object (_)
+    inherit [bool] Sast.fold
+    method int _ ctx = ctx
+    method string _ ctx = ctx
+    method char _ ctx = ctx
+    method option f v ctx = Option.fold ~none:ctx ~some:(fun i -> f i ctx) v
+    method nlist__t f v ctx = Nlist.fold_left (fun acc i -> f i acc) ctx v
+
+    method nslist__t f g v ctx =
+      Nslist.fold_left (fun acc a b -> f a acc |> g b) ctx v
+
+    method list f v ctx = List.fold_left (fun acc i -> f i acc) ctx v
+  end
+
+let has_async ast =
+  let o =
+    object
+      inherit check_ast as super
+
+      method! complete_command v ctx =
+        match v with
+        | _, Some Ampersand -> true
+        | _ -> super#complete_command v ctx
+
+      method! separator_list f l ctx =
+        let v =
+          Nlist.to_list l
+          |> List.exists (function _, Ampersand -> true | _ -> false)
+        in
+        if v then v else super#separator_list f l ctx
+    end
+  in
+  o#complete_command ast false

src/lib/ast.mli

···
 val word_component_to_string : word_component -> string
 val word_components_to_string : word_cst -> string
 
+val has_async : complete_command -> bool
+(** Checks, recursively, the command to see if there is any use of the async
+    operator [&] *)
+
 module Dump : sig
   val pp : t Fmt.t
   (** Dump the program *)

src/lib/built_ins.ml

···
 module Options = struct
-  type t = { noclobber : bool; pipefail : bool }
+  type t = { noclobber : bool; pipefail : bool; async : bool }
 
-  let default = { noclobber = false; pipefail = false }
+  let default = { noclobber = false; pipefail = false; async = false }
 
-  let with_options ?noclobber ?pipefail t =
+  let with_options ?noclobber ?pipefail ?async t =
     {
       noclobber = Option.value ~default:t.noclobber noclobber;
       pipefail = Option.value ~default:t.pipefail pipefail;
+      async = Option.value ~default:t.async async;
     }
 
-  type option = Noclobber | Pipefail
+  type posix = [ `Noclobber | `Pipefail ]
+  type merry = [ `Async ]
+  type option = [ posix | merry ]
 
   let update t options =
     List.fold_left
       (fun d -> function
-        | Pipefail -> with_options ~pipefail:true d
-        | Noclobber -> with_options ~noclobber:true d)
+        | `Pipefail -> with_options ~pipefail:true d
+        | `Noclobber -> with_options ~noclobber:true d
+        | `Async -> with_options ~async:true d)
       t options
 
   let pp ppf opt =
···
       Fmt.pf ppf "%-12s %s@." name (if value then "on" else "off")
     in
     let opts =
-      let { noclobber; pipefail } = opt in
-      [ ("pipefail", pipefail); ("noclobber", noclobber) ]
+      let { noclobber; pipefail; async } = opt in
+      [ ("pipefail", pipefail); ("noclobber", noclobber); ("async", async) ]
     in
     Fmt.pf ppf "@[<v>%a@]" Fmt.(list pp_option) opts
 end
···
 type set = { update : Options.option list; print_options : bool }
 
 (* Built-in Actions *)
-type t = Cd of { path : string option } | Pwd | Exit of int | Set of set
+type t =
+  | Cd of { path : string option }
+  | Pwd
+  | Exit of int
+  | Set of set
+  | Wait of int
 
 (* Change Directory *)
 module Cd = struct
···
 
 module Set = struct
   open Cmdliner
-  open Options
 
-  let enum_map = [ ("pipefail", Pipefail); ("noclobber", Noclobber) ]
+  let enum_map =
+    [ ("pipefail", `Pipefail); ("noclobber", `Noclobber); ("async", `Async) ]
 
   let option =
     let doc = "Options." in
···
     Cmd.v info term
 end
 
+module Wait = struct
+  open Cmdliner
+
+  let pid =
+    let doc = "Process ID." in
+    Arg.(value & pos 0 int 0 & info [] ~docv:"PID" ~doc)
+
+  let t =
+    let make_wait n = Wait n in
+    let term = Term.(const make_wait $ pid) in
+    let info =
+      let doc = "Wait for a particular PID (default is 0)" in
+      Cmd.info "wait" ~doc
+    in
+    Cmd.v info term
+end
+
 let of_args (w : string list) =
   let open Cmdliner in
   let exec_cmd cmd v =
···
   | "pwd" :: _ as cmd -> exec_cmd cmd Pwd.t
   | "exit" :: _ as cmd -> exec_cmd cmd Exit.t
   | "set" :: _ as cmd -> exec_cmd cmd Set.t
+  | "wait" :: _ as cmd -> exec_cmd cmd Wait.t
   | _ -> None

src/lib/built_ins.mli

···
 module Options : sig
-  type t = { noclobber : bool; pipefail : bool }
-  type option = Noclobber | Pipefail
+  type t = { noclobber : bool; pipefail : bool; async : bool }
+  type posix = [ `Noclobber | `Pipefail ]
+  type merry = [ `Async ]
+  type option = [ posix | merry ]
 
   val default : t
-  val with_options : ?noclobber:bool -> ?pipefail:bool -> t -> t
+  val with_options : ?noclobber:bool -> ?pipefail:bool -> ?async:bool -> t -> t
   val update : t -> option list -> t
   val pp : t Fmt.t
 end
···
   | Pwd
   | Exit of int
   | Set of set
+  | Wait of int
 
 val of_args : string list -> (t, string) result option
 (** Parses a command-line to the built-ins, errors are returned if parsing. *)

src/lib/eval.ml

···
         in
         if print_options then Fmt.pr "%a%!" Built_ins.Options.pp ctx.options;
         v
+    | Wait i -> (
+        match Unix.waitpid [] i with
+        | _, WEXITED 0 -> Exit.zero ctx
+        | _, (WEXITED n | WSIGNALED n | WSTOPPED n) -> Exit.nonzero ctx n)
 
   let cwd_of_ctx ctx = S.cwd ctx.state |> Fpath.to_string |> ( / ) ctx.fs
 
···
     | Ast.ForClause fc -> handle_for_clause ctx fc
     | Ast.IfClause if_ -> handle_if_clause ctx if_
     | _ as c ->
-        Fmt.failwith "Compound command not supported: %a" yojson_pp
-          (Ast.compound_command_to_yojson c)
+        Fmt.epr "Compound command not supported: %a\n%!" yojson_pp
+          (Ast.compound_command_to_yojson c);
+        exit 127
 
   and needs_subshelling = function
     | [] -> false
···
         | [] -> (ctx, cs)
         | command :: commands -> (
             let ctx = Exit.value ctx in
+            (* For our sanity *)
+            let has_async = Ast.has_async command in
+            if has_async && not ctx.options.async then begin
+              Fmt.epr
+                "You are using asynchronous operators and [set -o async] has \
+                 not been called.\n\
+                 %!";
+              exit 1
+            end;
             let exit = execute ctx command in
             match exit with
             | Exit.Nonzero { exit_code; message; should_exit; _ } -> (

test/async.t

···
+Asynchronous jobs are tricky. For now, we disable them behind a flag in [set]. 
+
+  $ osh -c "echo hello &"
+  You are using asynchronous operators and [set -o async] has not been called.
+  [1]
+
+But we do have some support for them.
+
+  $ cat > osh.sh << EOF
+  > set -o async
+  > sleep 10000 & echo hello
+  > kill -9 \$!
+  > EOF
+
+  $ cat > test.sh << EOF
+  > sleep 10000 & echo hello
+  > kill -9 \$!
+  > EOF
+
+  $ sh test.sh
+  hello
+  $ osh osh.sh
+  hello

test/built_ins.t

···
 
   $ osh -c "exit"
   exit
+
+2. Wait
+
+  $ cat > test_bad.sh << EOF
+  > (
+  >  sleep 1 &&
+  >  echo hello > hello.txt
+  > ) &
+  > cat hello.txt
+  > EOF
+
+  $ sh test_bad.sh
+  cat: hello.txt: No such file or directory
+  [1]
+
+  $ cat > test_good.sh << EOF
+  > (
+  >  sleep 1 &&
+  >  echo hello > hello.txt
+  > ) &
+  > wait $!
+  > cat hello.txt
+  > EOF
+
+  $ sh test_good.sh
+  hello
+