flan/lib/session.ml

(** A live program: the declarations a running process was built from, plus
    every change accepted since.

    This is what makes an editor possible. [Check.program] builds a fresh
    environment from a declaration list on every call, which is exactly the
    property a session needs and the reason there is no scratch-environment
    machinery here: a form that fails to check leaves nothing behind, because
    nothing was mutated. The list is only replaced once the check has
    succeeded. Re-checking the whole program each time costs the whole frontend,
    which is under 10ms — less than the [llc] that follows it.

    Two things the session knows that no single evaluation could:

    - **which names the running process was built with.** A name it has is a
      symbol the loaded module binds to; a name it lacks goes through the
      by-name registry in runtime/flan_dev.c. Getting this wrong is silent:
      treating [print-line] as new gives it a registry cell nobody publishes,
      and the first call jumps to null. It has to come from the *checked*
      program, because [Check.program] prepends the prelude and no accumulated
      AST contains it.
    - **what the memory of that process looks like.** A cell is a bare pointer
      and carries no signature, so a redefined function whose parameters
      changed is called by every existing call site with the old ones — no link
      error, no trap, a wrong number. Struct fields and global types are the
      same class. Those are refused here, with the reason, rather than loaded.

    Not here, and deliberately: evaluating an expression. That is a separate
    primitive — synthesize a function around the form, call it, render the
    value — and it is not what redefining a name is. *)

type t = {
  file            : string;              (* resolves an import's relative path *)
  mutable decls   : Ast.decl list;       (* post-Load: flat, one namespace *)
  mutable program : Tast.program;        (* the last thing that checked *)
  mutable env     : Check.env;           (* the same, as the checker sees it *)
  host            : Tast.program;        (* what the process was built from *)
  pkgs            : Load.pkg list;       (* alias, directory, names owned *)
  mutable thunks  : int;                 (* expression evaluations so far *)
}

let fail = Loc.fail

(* Structural, and conservative: anything this does not recognise counts as
   changed. Comparing emitted text instead would be wrong — [Emit.const] on a
   string allocates a name off a per-module counter, so two different strings
   in two throwaway modules both come out as [@".str.0"] and compare equal. *)
let rec same_const (a : Tast.expr) (b : Tast.expr) =
  match (a.Tast.e, b.Tast.e) with
  | Tast.Int (x, k), Tast.Int (y, l) -> Int64.equal x y && k = l
  | Tast.Float (x, k), Tast.Float (y, l) -> Float.equal x y && k = l
  | Tast.Bool x, Tast.Bool y -> x = y
  | Tast.Str x, Tast.Str y -> String.equal x y
  | Tast.Unit, Tast.Unit -> true
  | Tast.Zero x, Tast.Zero y -> Types.equal x y
  | Tast.Arr xs, Tast.Arr ys ->
    List.length xs = List.length ys && List.for_all2 same_const xs ys
  | Tast.Make (x, xs), Tast.Make (y, ys) ->
    String.equal x y && List.length xs = List.length ys
    && List.for_all2 same_const xs ys
  | _ -> false

let create ~file =
  let l = Load.program ~file (Parse.program (Reader.read_file file)) in
  let p, env = Check.program_with_env l.Load.decls in
  ({ file; decls = l.Load.decls; program = p; env; host = p; pkgs = l.Load.pkgs;
     thunks = 0 }, l)

(* Which package a file being edited belongs to, if any.

   A form typed into sand-sim/sim.flan declares [settle], but the running
   program only ever knew it as [sim/settle]: the alias is chosen by whatever
   imported the directory, and is written nowhere in the file itself. Without
   this the form splices as a brand-new unrelated name, the evaluation reports
   success, and nothing changes — the exact failure this whole design is meant
   to make impossible.

   Derived from the path rather than sent by the editor for that same reason:
   the editor cannot know an alias the file does not mention. *)
let package_of t origin =
  match origin with
  | "" -> None
  | origin ->
    let dir =
      try Filename.dirname (Unix.realpath origin)
      with Unix.Unix_error _ -> Filename.dirname origin
    in
    let same p =
      let d =
        try Unix.realpath p.Load.dir with Unix.Unix_error _ -> p.Load.dir
      in
      String.equal d dir
    in
    (match List.filter same t.pkgs with
     | [] -> None
     | [ p ] -> Some p
     (* One directory under two aliases: both are live in the program and a
        form cannot mean both. Say so rather than picking one. *)
     | ps ->
       Loc.fail Loc.unknown
         "%s is imported under more than one alias (%s); a form here would \
          have to mean all of them"
         dir
         (String.concat ", " (List.map (fun p -> p.Load.alias) ps)))

(* A name the running process exports. Everything else is looked up by name at
   install time — see [Emit.redefinition]'s [known]. *)
let known t n =
  List.exists (fun (f : Tast.fn) -> String.equal f.Tast.name n) t.host.Tast.fns
  || List.exists
       (fun (g : Tast.global) -> String.equal g.Tast.gname n)
       t.host.Tast.globals

(* ── What a running process cannot be told ─────────────────────────── *)

(* Everything here is a change that would load cleanly and then be wrong. The
   house rule (NEXT.md, Watch for) says recognise it and refuse with the
   reason, so each one names what it would have broken. *)
let compatible ~loc (old_ : Tast.program) (new_ : Tast.program) =
  let find_fn p n =
    List.find_opt (fun (f : Tast.fn) -> String.equal f.Tast.name n) p.Tast.fns
  in
  List.iter
    (fun (f : Tast.fn) ->
       match find_fn old_ f.Tast.name with
       | None -> ()
       | Some g ->
         let same =
           List.length f.Tast.params = List.length g.Tast.params
           && List.for_all2 Types.equal f.Tast.params g.Tast.params
           && Types.equal f.Tast.ret g.Tast.ret
         in
         (* A cell holds a bare pointer. Every call site compiled before this
            change still passes the old arguments through it. *)
         if not same then
           fail loc
             "%s changes signature, from (Fn [%s] %s) to (Fn [%s] %s); \
              the calls already compiled into the running program pass the old \
              one. Restart to change it."
             f.Tast.name
             (String.concat " " (List.map Types.to_string g.Tast.params))
             (Types.to_string g.Tast.ret)
             (String.concat " " (List.map Types.to_string f.Tast.params))
             (Types.to_string f.Tast.ret))
    new_.Tast.fns;
  List.iter
    (fun (g : Tast.global) ->
       match
         List.find_opt
           (fun (h : Tast.global) -> String.equal h.Tast.gname g.Tast.gname)
           old_.Tast.globals
       with
       (* A [defconst] is folded into its call sites — into an array length, at
          worst, which is decided before any type resolves — so its value is in
          the running program's code and not only in its storage. A [defvar]'s
          initial value is the opposite case and must *not* be refused: the
          storage holds live state the program has long since moved past, which
          is the whole of "edit the code, keep the sand". Same record, opposite
          answers, told apart by [gconst]. *)
       (* Only a constant the *checker* consumed. Its value is in the shape of
          the running program — [(defconst rows (/ h c))] decides the type of
          [grid] before anything else resolves — so no store can reach it. A
          constant that is only ever read at run time is just bytes in memory:
          a dev build emits it as a mutable global and a redefinition stores
          the new value, which is how a colour table is tuned live. *)
       | Some h
         when h.Tast.gconst && g.Tast.gconst && h.Tast.gfolded
              && Types.equal g.Tast.gty h.Tast.gty
              && not (same_const g.Tast.ginit h.Tast.ginit) ->
         fail loc
           "%s is used at compile time — an array length or a type — so the \
            running program has its old value in its shape, where a reload \
            cannot reach it. Restart to change it."
           g.Tast.gname
       | Some h when not (Types.equal g.Tast.gty h.Tast.gty) ->
         (* The storage exists and has a shape. Reusing it for another one
            reads fields at the wrong offsets; allocating fresh storage would
            silently discard the state the reload exists to preserve. *)
         fail loc
           "%s changes type, from %s to %s; the running program already laid \
            that storage out. Restart to change it."
           g.Tast.gname (Types.to_string h.Tast.gty) (Types.to_string g.Tast.gty)
       | _ -> ())
    new_.Tast.globals;
  List.iter
    (fun (s : Tast.structure) ->
       match
         List.find_opt
           (fun (r : Tast.structure) -> String.equal r.Tast.sname s.Tast.sname)
           old_.Tast.structs
       with
       | Some r ->
         let fields (x : Tast.structure) =
           List.map (fun (f : Tast.field) -> (f.Tast.fname, f.Tast.fty))
             x.Tast.fields
         in
         let same =
           List.length s.Tast.fields = List.length r.Tast.fields
           && List.for_all2
                (fun (an, at) (bn, bt) -> String.equal an bn && Types.equal at bt)
                (fields s) (fields r)
         in
         (* Every value of this type in the running program has the old layout,
            including ones held in globals that the reload is preserving. *)
         if not same then
           fail loc
             "%s changes layout; the values the running program is holding have \
              the old one. Restart to change it."
             s.Tast.sname
       | None -> ())
    new_.Tast.structs

(* An enum member is erased to an [i32] literal in the caller — [:space] at a
   call site resolves to a number and is folded there — so changing one cannot
   reach code that is already compiled, exactly like a [defconst]. It has to be
   compared over declarations rather than over [Tast.program], which carries no
   enums at all for that same reason. *)
let compatible_enums ~loc old_ new_ =
  let members (ds : Ast.decl list) =
    List.filter_map
      (fun (d : Ast.decl) ->
         match d.Ast.d with Ast.Defenum (n, ms) -> Some (n, ms) | _ -> None)
      ds
  in
  let before = members old_ in
  List.iter
    (fun (n, ms) ->
       match List.assoc_opt n before with
       | Some old_ms when old_ms <> ms ->
         fail loc
           "%s changes its members; the running program folded the old values \
            into every call site that names one. Restart to change it."
           n
       | _ -> ())
    (members new_)

(* ── Accepting a change ────────────────────────────────────────────── *)

(* The redefinition unit is a list of top-level forms, so this is one path for
   both editor commands: C-c C-c sends one form, C-c C-k sends a file. *)
type change = {
  ir      : string;             (* the module to build and send *)
  names   : string list;        (* everything the forms declared *)
  fns     : string list;        (* the subset that has a body to install *)
  (* False when the module would define nothing: no body to publish and no
     storage to allocate. Building and delivering one anyway reports success
     for a change that cannot have had an effect, and costs the program a
     frame's worth of reload it did not need. *)
  installs : bool;
}

let eval ?(origin = "<eval>") t src : change =
  let forms = Reader.read_all ~file:origin src in
  (* Through [Load] like any other source, so an evaluated (import ...) means
     what it means in a file. Its expansion is what gets spliced, which is also
     why the accumulated list is the post-Load one: re-evaluating a file that
     imports something would otherwise append a second copy of the import and
     the duplicate-name pass would reject it. *)
  let incoming =
    let ds = (Load.program ~file:t.file (Parse.program forms)).Load.decls in
    match package_of t origin with
    | None -> ds
    | Some p ->
      (* Qualified exactly as the import qualified them, so a redefined
         [settle] lands on [sim/settle] and its call to [move-grain] lands on
         [sim/move-grain]. A name the package does not own — the prelude's, or
         another package's — is left alone, which is the same rule [Load] uses
         at import time and the reason both go through [qualify_decl]. *)
      let owns =
        p.Load.owns
        @ List.filter_map Ast.declared_name ds
      in
      List.map (Load.qualify_decl owns p.Load.alias) ds
  in
  let loc =
    match incoming with d :: _ -> d.Ast.dloc | [] -> Loc.unknown
  in
  let names = List.filter_map Ast.declared_name incoming in
  let replacement n =
    List.find_opt
      (fun (d : Ast.decl) -> Ast.declared_name d = Some n)
      incoming
  in
  (* Replaced in place and appended only when genuinely new, so declaration
     order — which is emission order for globals — does not shuffle on every
     evaluation. *)
  let replaced = ref [] in
  let kept =
    List.map
      (fun (d : Ast.decl) ->
         match Ast.declared_name d with
         | Some n ->
           (match replacement n with
            | Some nd -> replaced := n :: !replaced; nd
            | None -> d)
         | None -> d)
      t.decls
  in
  let added =
    List.filter
      (fun (d : Ast.decl) ->
         match Ast.declared_name d with
         | Some n -> not (List.exists (String.equal n) !replaced)
         | None -> false)
      incoming
  in
  let decls = kept @ added in
  (* Nothing above this line has changed the session. A [Loc.Error] from here
     leaves it exactly as it was. *)
  let program, env = Check.program_with_env decls in
  compatible ~loc t.program program;
  compatible_enums ~loc t.decls decls;
  let fns =
    List.filter
      (fun n ->
         List.exists
           (fun (f : Tast.fn) -> String.equal f.Tast.name n)
           program.Tast.fns)
      names
  in
  (* A constant that changed and can be published: known to the host, not
     consumed by the checker. The module stores its new value at the frame
     boundary, exactly as it stores a new function body. *)
  let consts =
    List.filter
      (fun n ->
         known t n
         && List.exists
              (fun (g : Tast.global) ->
                 String.equal g.Tast.gname n && g.Tast.gconst
                 && not g.Tast.gfolded)
              program.Tast.globals)
      names
  in
  let ir = Emit.redefinition ~dev:true ~known:(known t) ~consts program ~fns in
  let allocates =
    List.exists
      (fun (g : Tast.global) -> not (known t g.Tast.gname))
      program.Tast.globals
  in
  t.decls <- decls;
  t.program <- program;
  t.env <- env;
  { ir; names; fns; installs = fns <> [] || allocates || consts <> [] }

(* ── Evaluating an expression ──────────────────────────────────────── *)

(* [C-x C-e] is a different primitive from redefining a name, and this is where
   the difference lives: there is no name to install a body into, so the
   expression is wrapped in a function that has nowhere to be called from, and
   the module says "run this once". The agent does, at a frame boundary.

   Getting the value back does not marshal anything. The compiler knows the
   expression's type, so the thunk renders it to bytes here, at compile time,
   and hands them to the runtime — which is the only thing that *can* work,
   since a Flan value carries no header and nothing at run time could tell what
   it is. That is the layout decision's bill, paid here.

   The rendering goes to [flan_dev_result], not to stdout: stdout belongs to
   the program, it is in the hot path for anything that prints, and a dev-only
   feature must not put a branch in it. *)

let result_sym = "flan/dev-result"

let result_extern : Tast.extern =
  { Tast.ename = result_sym; esym = "flan_dev_result";
    eparams = [ Types.Slice (Types.Int Types.U8) ]; eret = Types.Unit }

(* The scalars, and nothing else yet. A struct, an (Option T) or a slice of
   structs needs a printer derived per type, which is real work; refusing by
   name is the house rule, and a wrong rendering would be the silent kind. *)
let render (e : Tast.expr) : Tast.expr =
  let loc = e.Tast.loc in
  let bytes = Types.Slice (Types.Int Types.U8) in
  let cast t x = { Tast.e = Tast.Prim (Tast.Cast t, [ x ]); ty = t; loc } in
  let prim p x = { Tast.e = Tast.Prim (p, [ x ]); ty = bytes; loc } in
  let str s = { Tast.e = Tast.Str s; ty = Types.String; loc } in
  match e.Tast.ty with
  | Types.Int Types.U64 ->
    (* i64->bytes is signed, so anything above 2^63 would render negative.
       Refusing beats a number that is quietly wrong. *)
    fail loc "no printer for u64 yet — its rendering would be signed"
  | Types.Int _ -> prim Tast.I64ToBytes (cast (Types.Int Types.I64) e)
  | Types.Enum _ ->
    (* An enum is an i32 at run time and its members are not carried into the
       backend, so this is the number and not the name. *)
    prim Tast.I64ToBytes (cast (Types.Int Types.I64) e)
  | Types.Float _ -> prim Tast.F64ToBytes (cast (Types.Float Types.F64) e)
  | Types.Bool ->
    { Tast.e = Tast.If (e, prim Tast.Bytes (str "true"), prim Tast.Bytes (str "false"));
      ty = bytes; loc }
  | Types.String -> prim Tast.Bytes e
  | Types.Slice (Types.Int Types.U8) -> e
  | Types.Unit -> prim Tast.Bytes (str "()")
  | t ->
    fail loc "no printer for %s yet — only the scalars, bool and strings render"
      (Types.to_string t)

let eval_expr ?(origin = "<eval>") t src : change =
  let form =
    match Reader.read_all ~file:origin src with
    | [ f ] -> f
    | [] -> fail Loc.unknown "nothing to evaluate"
    | _ :: f :: _ -> fail f.Form.loc "one expression at a time"
  in
  let checked, slots = Check.expression t.env (Parse.expr form) in
  let body =
    [ { Tast.e = Tast.Call (result_sym, [ render checked ]);
        ty = Types.Unit; loc = checked.Tast.loc } ]
  in
  t.thunks <- t.thunks + 1;
  let name = Printf.sprintf "eval/%d" t.thunks in
  let thunk : Tast.fn =
    { Tast.name; params = []; slots; ret = Types.Unit; body;
      floc = checked.Tast.loc }
  in
  (* Built against the program but never spliced into it: an evaluation is not
     a declaration, and adding one would leave the session carrying an eval/N
     for every expression ever typed. *)
  let program =
    { t.program with
      Tast.fns = t.program.Tast.fns @ [ thunk ];
      externs = t.program.Tast.externs @ [ result_extern ] }
  in
  let ir =
    Emit.redefinition ~dev:true ~known:(known t) ~call:name program ~fns:[ name ]
  in
  { ir; names = []; fns = []; installs = true }