Locality

type Note = {
  text: String;
}

type Kept = {
  text: String @ global;
}

type Box = {
  mut text: String;
}

let destructure = fn(note: Note @ local) {
  let { text; } = note;
  Kept { text = text; }
};

let arm = fn(note: Note @ local) {
  match note {
    | Note { text; } -> Kept { text = text; }
  }
};

let reassign = fn(note: Note @ local) {
  let mut text = "";
  text := note.text;
  Kept { text = text; }
};

let store = fn(note: Note @ local) {
  let box = Box { text = ""; };
  box.text := note.text;
  box
};

let call = fn(note: Note @ local) {
  let read = () => note.text;
  Kept { text = read(); }
};

let annotated = fn() {
  let note: Note @ local = Note { text = "ada"; };
  Kept { text = note.text; }
};

let task = fn(note: Note @ local) {
  let text = note.text;
  spawn {
    text
  }
};

$ship check laundering/src/main.shp
error: `text` is global and this value is local
  --> laundering/src/main.shp:15:17
    |
 15 |   Kept { text = text; }
    |                 ^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: `text` is global and this value is local
  --> laundering/src/main.shp:20:39
    |
 20 |     | Note { text; } -> Kept { text = text; }
    |                                       ^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: `text` is global and this value is local
  --> laundering/src/main.shp:27:17
    |
 27 |   Kept { text = text; }
    |                 ^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: `note` is `@ local`, so the result cannot contain it
  --> laundering/src/main.shp:33:3
    |
 33 |   box
    |   ^^^ returned here
help: `@ local` promises the result does not hold this parameter: leave it unmarked (`@ linked`) to return it, or write `@ local` on the result

error: `text` is global and this value is local
  --> laundering/src/main.shp:38:17
    |
 38 |   Kept { text = read(); }
    |                 ^^^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: `text` is global and this value is local
  --> laundering/src/main.shp:43:17
    |
 43 |   Kept { text = note.text; }
    |                 ^^^^^^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: `spawn` cannot capture local binding `text`
  --> laundering/src/main.shp:49:5
    |
 49 |     text
    |     ^^^^ spawned tasks may outlive this binding
help: `spawn` is local event-loop work, not a Send boundary, but it is still an escape boundary

type Note = {
  text: String;
}

type Cache('a @ global) = {
  value: 'a;
}

type Held('a) = {
  held: 'a @ global;
}

type Slot =
  | Pinned(String @ global)
  | Empty

type! Component = {
  render: (fn(body: String) -> String) @ global;
}

let cache = fn(note: Note @ local) { Cache { value = note.text; } };
let held = fn(note: Note @ local) { Held { held = note.text; } };
let pinned = fn(note: Note @ local) { Pinned(note.text) };

let component = fn(note: Note @ local) {
  Component { render = (body) => note.text ++ body; }
};

$ship check cuts/src/main.shp
error: `value` is global and this value is local
  --> cuts/src/main.shp:21:54
    |
 21 | let cache = fn(note: Note @ local) { Cache { value = note.text; } };
    |                                                      ^^^^^^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: `held` is global and this value is local
  --> cuts/src/main.shp:22:51
    |
 22 | let held = fn(note: Note @ local) { Held { held = note.text; } };
    |                                                   ^^^^^^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: this payload is global and this value is local
  --> cuts/src/main.shp:23:46
    |
 23 | let pinned = fn(note: Note @ local) { Pinned(note.text) };
    |                                              ^^^^^^^^^ local value cannot be kept
help: store a global value in this payload, or remove `@ global` if the payload should follow the value

error: `render` is global and this value is local
  --> cuts/src/main.shp:26:24
    |
 26 |   Component { render = (body) => note.text ++ body; }
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

type Note = {
  text: String;
}

let copy = fn(note: Note @ local) { Note { text = note.text; } };

let declared = fn(note: Note @ local) -> Note {
  return! Note { text = note.text; };
};

let scratch = fn(note: Note) {
  let draft: Note @ local = Note { text = note.text; };
  return! draft;
};

let raise = fn(note: Note @ local) {
  error :bad(Note { text = note.text; });
};

let labeled = fn(note: Note, flag: Bool) {
  let draft: Note @ local = Note { text = note.text; };
  let picked = 'found: {
    if flag {
      break 'found draft;
    }
    note
  };
  picked
};

let arm = fn(note: Note, flag: Bool) {
  let draft: Note @ local = Note { text = note.text; };
  match flag {
    | True -> return draft
    | False -> note
  }
};

let fail = fn(note: Note) -> Int {
  error :bad(note);
};

let propagated = fn(note: Note) -> Int {
  let draft: Note @ local = Note { text = note.text; };
  fail(draft)
};

$ship check returns/src/main.shp
error: `note` is `@ local`, so the result cannot contain it
  --> returns/src/main.shp:5:37
    |
  5 | let copy = fn(note: Note @ local) { Note { text = note.text; } };
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^ returned here
help: `@ local` promises the result does not hold this parameter: leave it unmarked (`@ linked`) to return it, or write `@ local` on the result

error: `return!` builds this result in the caller, but the result is global
  --> returns/src/main.shp:8:11
    |
  8 |   return! Note { text = note.text; };
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^ built in the caller
help: write `@ local` on the result

error: `return!` cannot use a value allocated in this function
  --> returns/src/main.shp:13:11
    |
 13 |   return! draft;
    |           ^^^^^ allocated in this function
help: `return!` builds the result in the caller; use values that already belong to it

error: `note` is `@ local`, so an error leaving this function cannot hold it
  --> returns/src/main.shp:17:9
    |
 17 |   error :bad(Note { text = note.text; });
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ raised here
help: `@ local` promises nothing the caller sees holds this parameter: leave it unmarked (`@ linked`) to raise it

error: this value is local to this function and cannot be returned
  --> returns/src/main.shp:28:3
    |
 28 |   picked
    |   ^^^^^^ allocated in this function
help: return a value that already belongs to the caller, or build the result in the caller with `return!`

error: this value is local to this function and cannot be returned
  --> returns/src/main.shp:34:22
    |
 34 |     | True -> return draft
    |                      ^^^^^ allocated in this function
help: return a value that already belongs to the caller, or build the result in the caller with `return!`

error: this call may raise an error that holds a value local to this function
  --> returns/src/main.shp:45:3
    |
 45 |   fail(draft)
    |   ^^^^^^^^^^^ may raise with a local value
help: pass values that already belong to the caller, or handle the error here

type Note = {
  text: String;
}

type Kept = {
  text: String @ global;
}

let keep_text = fn(text) { Kept { text = text; } };
let forward = fn(text) { keep_text(text) };
let leak = fn(note: Note @ local) { forward(note.text) };

let closure = fn(note: Note @ local) {
  let keep = (text) =>
    Kept { text = text; };
  keep(note.text)
};

$ship check inference/src/main.shp
error: this argument is local and the parameter keeps it
  --> inference/src/main.shp:11:45
    |
 11 | let leak = fn(note: Note @ local) { forward(note.text) };
    |                                             ^^^^^^^^^ local value cannot be kept
  --> inference/src/main.shp:10:36
    |
 10 | let forward = fn(text) { keep_text(text) };
    |                                    ---- the parameter is kept here
help: pass a global value; this parameter is `@ global`

error: this argument is local and the parameter keeps it
  --> inference/src/main.shp:16:8
    |
 16 |   keep(note.text)
    |        ^^^^^^^^^ local value cannot be kept
  --> inference/src/main.shp:15:19
    |
 15 |     Kept { text = text; };
    |                   ---- the parameter is kept here
help: pass a global value; this parameter is `@ global`

type Kept = {
  text: String @ global;
}

let rec swap = (first: String @ global, second: String, n: Int) -> Kept =>
  if n == 0 {
    | Kept { text = first; }
    | swap(second, first, n - 1)
  };

let keep: fn(text: String) -> Kept = fn(text) { Kept { text = text; } };

module Early {
  let forward = (text: String) -> Kept => later(text);
}

let later = (text: String) -> Kept =>
  Kept { text = text; };

$ship check signatures/src/main.shp
error: `swap` keeps `second` but its signature does not say so
  --> signatures/src/main.shp:8:12
    |
  8 |     | swap(second, first, n - 1)
    |            ^^^^^^ `second` is kept here
help: recursive and forward calls see only the written signature: write `@ global` on `second`

error: `keep` keeps `text` but its annotation does not say so
  --> signatures/src/main.shp:11:63
    |
 11 | let keep: fn(text: String) -> Kept = fn(text) { Kept { text = text; } };
    |                                                               ^^^^ `text` is kept here
help: callers see only the annotation: write `@ global` on `text` there

error: `later` keeps `text` but its signature does not say so
  --> signatures/src/main.shp:18:17
    |
 18 |   Kept { text = text; };
    |                 ^^^^ `text` is kept here
help: recursive and forward calls see only the written signature: write `@ global` on `text`

type Note = {
  text: String;
}

type Kept = {
  text: String @ global;
}

type! Registry = {
  read: fn(text: String) -> Kept;
}

type! Slot =
  | Handler(fn(text: String) -> Kept)
  | Empty

let apply = fn(text, f) { f(text) };
let keep = fn(text: String @ global) { Kept { text = text; } };
let remember = fn(text) { Kept { text = text; } };

let literal = fn(note: Note) {
  apply(
    note.text,
    (text) =>
      Kept { text = text; },
  )
};

let named = fn(note: Note) { apply(note.text, remember) };

let bound = fn(note: Note) {
  let hold = (text) =>
    Kept { text = text; };
  apply(note.text, hold)
};

let field = fn() { Registry { read = keep; } };

let payload = fn() {
  Handler(
    (text) =>
      Kept { text = text; },
  )
};

let returned = fn() {
  (text) =>
    Kept { text = text; }
};

$ship check callbacks/src/main.shp
error: this callback keeps `text`, but `apply` may pass it a local value
  --> callbacks/src/main.shp:25:21
    |
 25 |       Kept { text = text; },
    |                     ^^^^ `text` is kept here
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in `apply`'s callback type, so do not keep it

error: this callback keeps `text`, but `apply` may pass it a local value
  --> callbacks/src/main.shp:19:41
    |
 19 | let remember = fn(text) { Kept { text = text; } };
    |                                         ^^^^ `text` is kept here
  --> callbacks/src/main.shp:29:47
    |
 29 | let named = fn(note: Note) { apply(note.text, remember) };
    |                                               -------- passed here
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in `apply`'s callback type, so do not keep it

error: this callback keeps `text`, but `apply` may pass it a local value
  --> callbacks/src/main.shp:33:19
    |
 33 |     Kept { text = text; };
    |                   ^^^^ `text` is kept here
  --> callbacks/src/main.shp:34:20
    |
 34 |   apply(note.text, hold)
    |                    ---- passed here
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in `apply`'s callback type, so do not keep it

error: this callback keeps `text`, but calls through `read` may pass it a local value
  --> callbacks/src/main.shp:37:38
    |
 37 | let field = fn() { Registry { read = keep; } };
    |                                      ^^^^ keeps `text`
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in the type of `read`, so do not keep it

error: this callback keeps `text`, but calls through this payload may pass it a local value
  --> callbacks/src/main.shp:42:21
    |
 42 |       Kept { text = text; },
    |                     ^^^^ `text` is kept here
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in the payload's type, so do not keep it

error: this closure keeps `text` and is used as a value
  --> callbacks/src/main.shp:48:19
    |
 48 |     Kept { text = text; }
    |                   ^^^^ `text` is kept here
help: write `@ global` on `text`; a closure used as a value tells its callers what it keeps only through its type

type Note = {
  text: String;
}

type Box = {
  mut text: String;
}

let cache = Box { text = ""; };

let through_param = fn(box: Box @ local, note: Note @ local) {
  box.text := note.text;
};

let through_alias = fn(note: Note @ local) {
  let shared = Box { text = ""; };
  let alias: Box @ local = shared;
  alias.text := note.text;
};

let into_top_level = fn(note: Note @ local) {
  cache.text := note.text;
};

let outlived = fn() {
  let mut saved = Note { text = ""; };
  let stash = fn() {
    let note: Note @ local = Note { text = "a"; };
    saved := note;
  };
  stash();
  saved.text == "a"
};

let with_temp = fn(f: fn(text: String) -> Unit) {
  let note: Note @ local = Note { text = "tmp"; };
  f(note.text)
};

let from_callback = fn(note: Note @ local) {
  let draft = Box { text = note.text; };
  with_temp(
    fn(text) {
      draft.text := text;
    },
  );
  draft.text == ""
};

$ship check stores/src/main.shp
error: `box.text` may outlive this value
  --> stores/src/main.shp:12:15
    |
 12 |   box.text := note.text;
    |               ^^^^^^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `alias.text` may outlive this value
  --> stores/src/main.shp:18:17
    |
 18 |   alias.text := note.text;
    |                 ^^^^^^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `cache.text` may outlive this value
  --> stores/src/main.shp:22:17
    |
 22 |   cache.text := note.text;
    |                 ^^^^^^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `saved` may outlive this value
  --> stores/src/main.shp:29:14
    |
 29 |     saved := note;
    |              ^^^^ stored here
help: a stored value must live as long as the value that holds it; store a global value

error: this callback keeps `text`, but `with_temp` may pass it a local value
  --> stores/src/main.shp:44:21
    |
 44 |       draft.text := text;
    |                     ^^^^ `text` is kept here
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in `with_temp`'s callback type, so do not keep it

type Note = {
  text: String;
}

type Holder = {
  items: Array(Note);
}

let saved: Array(Note) = Array.new();

let leak = fn(note: Note @ local) {
  let mine: Note @ local = Note { text = note.text; };
  Array.push(saved, mine);
};

let joined = fn(note: Note @ local, fresh: Bool) {
  let items = if fresh {
    | Array.new()
    | saved
  };
  Array.push(items, note);
};

let projected = fn(note: Note @ local) {
  let holder = Holder { items = saved; };
  Array.push(holder.items, note);
};

let nested = fn(note: Note @ local) {
  let outer: Array(Array(Note)) = Array.new();
  Array.push(outer, saved);
  Array.push(Array.get(outer, 0), note);
};

let stash = fn(note: Note @ 'm) {
  Array.push(saved, note);
};

let fill = fn(note: Note @ 'm) {
  let add = (item: Note @ 'm, into: Array(Note) @ 'm) =>
    Array.push(into, item);
  add(note, saved);
};

let fake_fresh = () -> Array(Note) @ 'm => saved;

let keep_items = fn(notes: Vector(Note) @ local) {
  Vector.iter(notes, f = (note) => Array.push(saved, note));
};

let collect_local = fn(acc: Array(Note) @ 'm) {
  let notes: Vector(Note) @ local = [Note { text = "a"; }];
  Vector.iter(notes, f = (note) => Array.push(acc, note));
};

let edited = fn(note: Note @ local) -> Vector(Note) {
  Vector.edit(
    Vector.empty(),
    f = (editor) => Vector.Editor.push(editor, note),
  )
};

let callback_local = fn() -> Vector(Note) {
  Vector.edit(
    Vector.empty(),
    f = fn(editor) {
      let mine: Note @ local = Note { text = "x"; };
      Vector.Editor.push(editor, mine);
    },
  )
};

$ship check mode-variables/src/main.shp
error: `saved` may outlive this value
  --> mode-variables/src/main.shp:13:21
    |
 13 |   Array.push(saved, mine);
    |                     ^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `items` may outlive this value
  --> mode-variables/src/main.shp:21:21
    |
 21 |   Array.push(items, note);
    |                     ^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `holder.items` may outlive this value
  --> mode-variables/src/main.shp:26:28
    |
 26 |   Array.push(holder.items, note);
    |                            ^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: the container may outlive this value
  --> mode-variables/src/main.shp:32:35
    |
 32 |   Array.push(Array.get(outer, 0), note);
    |                                   ^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `note` is `@ 'm`, so it cannot be kept
  --> mode-variables/src/main.shp:36:21
    |
 36 |   Array.push(saved, note);
    |                     ^^^^ kept here
help: `'m` names the region the caller's arguments share: store `note` only into a slot of `'m`, or write `@ global` to keep it

error: this mutable argument must be a value of `'m`
  --> mode-variables/src/main.shp:42:13
    |
 42 |   add(note, saved);
    |             ^^^^^ may outlive `'m`
help: the callee stores `'m` values into it, so pass a parameter written `@ 'm`

error: the result is `@ 'm`, but no parameter is
  --> mode-variables/src/main.shp:45:24
    |
 45 | let fake_fresh = () -> Array(Note) @ 'm => saved;
    |                        ^^^^^^^^^^^^^^^^ only a builtin returns a fresh value at a region no parameter names
help: write `@ 'm` on the parameters the result comes from, or leave the result unmarked

error: this argument is local, and the callback keeps what it is passed
  --> mode-variables/src/main.shp:48:15
    |
 48 |   Vector.iter(notes, f = (note) => Array.push(saved, note));
    |               ^^^^^ local value cannot be kept
  --> mode-variables/src/main.shp:48:54
    |
 48 |   Vector.iter(notes, f = (note) => Array.push(saved, note));
    |                                                      ---- the callback keeps it here
help: the callback's parameter shares this argument's mode variable, so keeping it keeps this argument; pass a global value, or do not keep it

error: `acc` may outlive this value
  --> mode-variables/src/main.shp:53:15
    |
 53 |   Vector.iter(notes, f = (note) => Array.push(acc, note));
    |               ^^^^^ local value cannot be kept
  --> mode-variables/src/main.shp:53:52
    |
 53 |   Vector.iter(notes, f = (note) => Array.push(acc, note));
    |                                                    ---- the callback stores it here
help: the callback's parameter shares this argument's mode variable, so storing it stores this argument; pass a value that lives as long as where it is stored

error: `note` is `@ local`, so the result cannot contain it
  --> mode-variables/src/main.shp:57:3
    |
 57 |   Vector.edit(
    |   ^ returned here
help: `@ local` promises the result does not hold this parameter: leave it unmarked (`@ linked`) to return it, or write `@ local` on the result

error: `editor` may outlive this value
  --> mode-variables/src/main.shp:68:34
    |
 68 |       Vector.Editor.push(editor, mine);
    |                                  ^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

type Table = {
  keys: Array(String) @ unique;
}

let saved: Array(String) = Array.new();
let tables: Array(Table) = Array.new();

let shared_init = fn(text: String @ local) {
  let table = Table { keys = saved; };
  Array.push(table.keys, text);
};

let aliased = (table: Table) =>
  Table { keys = table.keys; };

let copied = (table: Table) =>
  { table with };

let unannotated = fn(table: Table, text: String @ local) {
  Array.push(table.keys, text);
};

let kept_then_stored = fn(text: String @ local) {
  let table = Table { keys = Array.new(); };
  Array.push(tables, table);
  Array.push(table.keys, text);
};

let read_back = fn(text: String @ local) {
  let table = Table { keys = Array.new(); };
  Array.push(table.keys, text);
  Array.get(table.keys, 0)
};

$ship check ownership/src/main.shp
error: `keys` is `@ unique`, so it takes a fresh value
  --> ownership/src/main.shp:9:30
    |
  9 |   let table = Table { keys = saved; };
    |                              ^^^^^ something else may already hold this value
help: build it here, for example with `Array.new()`

error: `keys` is `@ unique`, so it takes a fresh value
  --> ownership/src/main.shp:14:18
    |
 14 |   Table { keys = table.keys; };
    |                  ^^^^^^^^^^ something else may already hold this value
help: build it here, for example with `Array.new()`

error: this update would share `keys`, which is `@ unique`
  --> ownership/src/main.shp:17:3
    |
 17 |   { table with };
    |   ^^^^^^^^^^^^^^ copied from the old record
help: give `keys` a fresh value in the update

error: `table.keys` may outlive this value
  --> ownership/src/main.shp:20:26
    |
 20 |   Array.push(table.keys, text);
    |                          ^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `table.keys` may outlive this value
  --> ownership/src/main.shp:26:26
    |
 26 |   Array.push(table.keys, text);
    |                          ^^^^ local value cannot be kept
help: a stored value must live as long as the value that holds it; store a global value

error: `text` is `@ local`, so the result cannot contain it
  --> ownership/src/main.shp:32:3
    |
 32 |   Array.get(table.keys, 0)
    |   ^^^^^^^^^^^^^^^^^^^^^^^^ returned here
help: `@ local` promises the result does not hold this parameter: leave it unmarked (`@ linked`) to return it, or write `@ local` on the result

module behavior Collect(struct 'bag) {
  add: pure fn!(bag: 'bag, name: String) -> Unit;
}

type Shelf = {
  names: Array(String) @ unique;
}

let saved: Array(String) = Array.new();

module behavior Collect(Shelf) {
  add = (shelf: Shelf, name: String) => Array.push(saved, name);
}

type Crate = {
  names: Array(String) @ unique;
}

module behavior Collect(Crate) {
  add = (crate: Crate @ 'm, name: String @ 'm) =>
    Array.push(crate.names, name);
}

let main = fn() {
  Bag.add(Bag.new(), "ada");
};

$ship check conformance/src/main.shp
error: implementation of `add` puts `bag` and `name` in one region `'m`, but the contract does not
  --> conformance/src/Bag.shp:8:5
    |
  8 | let add = fn(bag: t @ 'm, name: String @ 'm) {
    |     ^^^ these share `'m` here
help: callers may otherwise pass values that die sooner than what holds them: write one mode variable like `@ 'm` on these parameters in the `.shc` signature

error: `Collect(Shelf).add` keeps `name` but its behavior operation does not say so
  --> conformance/src/main.shp:12:59
    |
 12 |   add = (shelf: Shelf, name: String) => Array.push(saved, name);
    |                                                           ^^^^ `name` is kept here
help: generic code calls the member through the operation's type: write `@ global` on `name` there, or do not keep it

error: `Collect(Crate).add` puts `crate` and `name` in one region `'m`, but its behavior operation does not
  --> conformance/src/main.shp:20:9
    |
 20 |   add = (crate: Crate @ 'm, name: String @ 'm) =>
    |         ^ these share `'m` here
help: callers may otherwise pass values that die sooner than what holds them: write one mode variable like `@ 'm` on these parameters in the operation's type

type Note = {
  text: String;
}

type Kept = {
  text: String @ global;
}

type Slot =
  | Pinned(String @ global)
  | Empty

type Inner = {
  x: String;
}

type Outer = {
  inner: Inner @ global;
}

let keep_text = fn(text) { Kept { text = text; } };

let count = fn(text) {
  let kept = Kept { text = text; };
  1
};

let apply = fn(text, f) { f(text) };

let check = fn(text) -> Int {
  error :bad(text);
};

let piped = fn(note: Note @ local) { note.text |> keep_text };
let tagged = fn(note: Note @ local) { :wrapped(note.text) };
let constructor = fn(note: Note) { apply(note.text, Pinned) };

let nested = fn(note: Note @ local) {
  let outer = Outer { inner = Inner { x = ""; }; };
  { outer with inner.x = note.text; }
};

let caught = fn(note: Note @ local) {
  try check(note.text) {
    | :bad(text) -> count(text)
  }
};

let raised = fn(note: Note @ local) {
  let draft = Note { text = note.text; };
  let raise = fn() {
    error :bad(draft);
  };
  raise();
};

let defaulted = fn(note: Note @ local) {
  let make = fn(~text = note.text) { Kept { text = text; } };
  make().text == ""
};

let task = fn() {
  spawn {
    return! Note { text = "a"; };
  }
};

let keep_label = fn(~text: String) { Kept { text = text; } };
let spread = fn(note: Note @ local) { keep_label(..note) };

$ship check flows/src/main.shp
error: this argument is local and the parameter keeps it
  --> flows/src/main.shp:34:38
    |
 34 | let piped = fn(note: Note @ local) { note.text |> keep_text };
    |                                      ^^^^^^^^^ local value cannot be kept
  --> flows/src/main.shp:21:42
    |
 21 | let keep_text = fn(text) { Kept { text = text; } };
    |                                          ---- the parameter is kept here
help: pass a global value; this parameter is `@ global`

error: `note` is `@ local`, so the result cannot contain it
  --> flows/src/main.shp:35:39
    |
 35 | let tagged = fn(note: Note @ local) { :wrapped(note.text) };
    |                                       ^^^^^^^^^^^^^^^^^^^ returned here
help: `@ local` promises the result does not hold this parameter: leave it unmarked (`@ linked`) to return it, or write `@ local` on the result

error: this callback keeps its parameter, but `apply` may pass it a local value
  --> flows/src/main.shp:36:53
    |
 36 | let constructor = fn(note: Note) { apply(note.text, Pinned) };
    |                                                     ^^^^^^ keeps its parameter
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in `apply`'s callback type, so do not keep it

error: `x` is global and this value is local
  --> flows/src/main.shp:40:26
    |
 40 |   { outer with inner.x = note.text; }
    |                          ^^^^^^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: this argument is local and the parameter keeps it
  --> flows/src/main.shp:45:27
    |
 45 |     | :bad(text) -> count(text)
    |                           ^^^^ local value cannot be kept
  --> flows/src/main.shp:24:28
    |
 24 |   let kept = Kept { text = text; };
    |                            ---- the parameter is kept here
help: pass a global value; this parameter is `@ global`

error: `note` is `@ local`, so an error leaving this function cannot hold it
  --> flows/src/main.shp:54:3
    |
 54 |   raise();
    |   ^^^^^^^ raised here
help: `@ local` promises nothing the caller sees holds this parameter: leave it unmarked (`@ linked`) to raise it

error: `text` is global and this value is local
  --> flows/src/main.shp:58:52
    |
 58 |   let make = fn(~text = note.text) { Kept { text = text; } };
    |                                                    ^^^^ local value cannot be kept
help: store a global value in this field, or remove `@ global` if the field should follow the container

error: `return!` cannot build a task's result in its caller
  --> flows/src/main.shp:64:13
    |
 64 |     return! Note { text = "a"; };
    |             ^^^^^^^^^^^^^^^^^^^^ a spawned task has no caller region
help: use `return`; a task's result must be global

error: this argument is local and the parameter keeps it
  --> flows/src/main.shp:69:50
    |
 69 | let spread = fn(note: Note @ local) { keep_label(..note) };
    |                                                  ^^^^^^ local value cannot be kept
  --> flows/src/main.shp:68:52
    |
 68 | let keep_label = fn(~text: String) { Kept { text = text; } };
    |                                                    ---- the parameter is kept here
help: pass a global value; this parameter is `@ global`

type Note = {
  text: String;
}

type Kept = {
  text: String @ global;
}

type! Registry = {
  read: fn(text: String) -> Kept;
}

let registry = Registry {
  read = (text) =>
    Kept { text = text; };
};

let block = {
  let note: Note @ local = Note { text = "a"; };
  note
};

let keep_text = fn(text) { Kept { text = text; } };

test "Expect Keeps" {
  let note: Note @ local = Note { text = "a"; };
  expect keep_text(note.text).text == "a";
}

$ship check values/src/main.shp
error: this callback keeps `text`, but calls through `read` may pass it a local value
  --> values/src/main.shp:15:19
    |
 15 |     Kept { text = text; };
    |                   ^^^^ `text` is kept here
help: a callback may keep only parameters its slot marks `@ global`; that parameter is not `@ global` in the type of `read`, so do not keep it

error: a top-level value is global and this value is local
  --> values/src/main.shp:18:13
    |
 18 | let block = {
    |             ^ local value cannot be kept
help: a top-level value lives as long as the program; build it from global values

error: this argument is local and the parameter keeps it
  --> values/src/main.shp:27:20
    |
 27 |   expect keep_text(note.text).text == "a";
    |                    ^^^^^^^^^ local value cannot be kept
  --> values/src/main.shp:23:42
    |
 23 | let keep_text = fn(text) { Kept { text = text; } };
    |                                          ---- the parameter is kept here
help: pass a global value; this parameter is `@ global`

let main = fn() {
  let event = Feed.Event { title = "shipped"; };
  print(Feed.push(event));
};

$ship check hidden-retention/src/main.shp
error: implementation of `push` keeps `event` but the contract does not say so
  --> hidden-retention/src/Feed.shp:5:5
    |
  5 | let push = (event: Event @ global) -> Int => 1;
    |     ^^^^ `event` is declared `@ global` here
help: what a function keeps must be visible in its published contract: write `@ global` on `event` in the `.shc` signature

let main = fn() {
  let event = Feed.Event { title = "shipped"; };
  print(Feed.keep(event).title);
};

$ship check inferred-retention/src/main.shp
error: implementation of `keep` keeps `event` but the contract does not say so
  --> inferred-retention/src/Feed.shp:10:18
    |
 10 |   Kept { title = event.title; };
    |                  ^^^^^^^^^^^ `event` is kept here
help: what a function keeps must be visible in its published contract: write `@ global` on `event` in the `.shc` signature

let main = fn() {
  let note = Notes.Note { text = "ada"; };
  print(Notes.copy(note).text);
};

$ship check local-result/src/main.shp
error: implementation of `copy` returns a local value but the contract does not say so
  --> local-result/src/Notes.shp:5:5
    |
  5 | let copy = fn(note: Note @ local) {
    |     ^^^^ the result is `@ local`
help: write `@ local` on the result in the `.shc` signature, or return a global value