path: root/tests/spec/compiler_contracts.json

[
  {
    "group": "modules",
    "name": "explicit runtime export",
    "accept": true,
    "source": "include rt; fn main() { rt.put_n(7); return 0; }"
  },
  {
    "group": "modules",
    "name": "no implicit runtime",
    "accept": false,
    "source": "fn main() { put_n(7); return 0; }"
  },
  {
    "group": "modules",
    "name": "runtime needs include",
    "accept": false,
    "source": "fn main() { rt.put_n(7); return 0; }"
  },
  {
    "group": "modules",
    "name": "import does not unqualify runtime",
    "accept": false,
    "source": "include rt; fn main() { put_n(7); return 0; }"
  },
  {
    "group": "modules",
    "name": "explicit compiler export",
    "accept": true,
    "source": "include run; fn main() { run.evals(\"return 0;\"); return 0; }"
  },
  {
    "group": "modules",
    "name": "compiler needs include",
    "accept": false,
    "source": "fn main() { run.evals(\"return 0;\"); return 0; }"
  },
  {
    "group": "modules",
    "name": "no bare compiler exports",
    "accept": false,
    "source": "include run; fn main() { evals(\"return 0;\"); return 0; }"
  },
  {
    "group": "modules",
    "name": "core reserved for vm",
    "accept": false,
    "source": "include core; fn main() { core.evals(\"return 0;\"); return 0; }"
  },
  {
    "group": "modules",
    "name": "explicit vm export",
    "accept": true,
    "source": "include core; fn main() { return core.syscall(9, 0, 0, 0) > 0; }"
  },
  {
    "group": "modules",
    "name": "server needs include",
    "accept": false,
    "source": "fn main() { return lsp.hid('a'); }"
  },
  {
    "group": "modules",
    "name": "unknown module",
    "accept": false,
    "source": "include imaginary; fn main() { return 0; }"
  },
  {
    "group": "modules",
    "name": "unknown export",
    "accept": false,
    "source": "include rt; fn main() { return rt.imaginary(); }"
  },
  {
    "group": "modules",
    "name": "no import bypass with unchecked",
    "accept": false,
    "source": "unchecked fn main() { put_s(\"hi\"); return 0; }"
  },
  {
    "group": "modules",
    "name": "runtime allocator remains typed",
    "accept": true,
    "source": "include rt; fn main() { let p = rt.new(int, 3); p[0] = 7; rt.put_n(p[0]); return 0; }"
  },
  {
    "group": "modules",
    "name": "explicit standard library",
    "accept": true,
    "source": "include std; include rt; fn main() { rt.put_n(std.Text.atoi(\"4\")); return 0; }"
  },
  {
    "group": "modules",
    "name": "dependency imports do not leak",
    "accept": false,
    "source": "include std; fn main() { rt.put_n(std.Text.atoi(\"4\")); return 0; }"
  },
  {
    "group": "modules",
    "name": "namespace alias does not shadow local",
    "accept": true,
    "source": "fn main() { int rt = 7; return rt; }"
  },
  {
    "group": "strings",
    "name": "word string parameter",
    "accept": true,
    "source": "char* echo(char* s) { return s; } fn main() { let s = echo(\"hi\"); return s[0]; }"
  },
  {
    "group": "strings",
    "name": "packed string parameter",
    "accept": true,
    "source": "bstr echo(bstr s) { return s; } fn main() { let s = echo(b\"hi\"); return s[0]; }"
  },
  {
    "group": "strings",
    "name": "packed and word strings are distinct",
    "accept": false,
    "source": "typecheck on; char* echo(char* s) { return s; } fn main() { return echo(b\"hi\")[0]; }"
  },
  {
    "group": "strings",
    "name": "word and packed strings are distinct",
    "accept": false,
    "source": "typecheck on; bstr echo(bstr s) { return s; } fn main() { return echo(\"hi\")[0]; }"
  },
  {
    "group": "strings",
    "name": "string is not raw word",
    "accept": false,
    "source": "typecheck on; word identity(word n) { return n; } fn main() { return identity(b\"hi\"); }"
  },
  {
    "group": "strings",
    "name": "grouped string inference",
    "accept": true,
    "source": "fn main() { let a = \"hi\", b = b\"hi\"; return a[0] + b[0]; }"
  },
  {
    "group": "strings",
    "name": "inferred word string remains assignable",
    "accept": true,
    "source": "include rt; typecheck on; fn main() { let s = \"hi\"; s = \"ok\"; rt.put_n(s[1]); return 0; }",
    "output": "107"
  },
  {
    "group": "strings",
    "name": "inferred packed string remains assignable",
    "accept": true,
    "source": "include rt; typecheck on; fn main() { let s = b\"hi\"; s = b\"ok\"; rt.put_n(s[1]); return 0; }",
    "output": "107"
  },
  {
    "group": "strings",
    "name": "inferred string types reject cross-assignment",
    "accept": false,
    "source": "typecheck on; fn main() { let s = \"hi\"; s = b\"ok\"; return 0; }"
  },
  {
    "group": "ownership",
    "name": "global receives local owner",
    "accept": true,
    "source": "include rt; int* saved; fn main() { let p = rt.new(int); p[0] = 7; saved = p; return saved[0]; }"
  },
  {
    "group": "ownership",
    "name": "global source is consumed",
    "accept": false,
    "source": "include rt; int* saved; fn main() { let p = rt.new(int); saved = p; return p[0]; }"
  },
  {
    "group": "ownership",
    "name": "borrowed source cannot transfer",
    "accept": false,
    "source": "int* saved; fn store(int*.m p) { saved = p; } fn main() { return 0; }"
  },
  {
    "group": "ownership",
    "name": "consumed source cannot transfer twice",
    "accept": false,
    "source": "include rt; int* a, b; fn main() { let p = rt.new(int); a = p; b = p; return 0; }"
  },
  {
    "group": "ownership",
    "name": "temporary borrowed result cleanup",
    "accept": true,
    "source": "include rt; char*.u make() { let p = rt.new(char, 2); p[0] = 120; p[1] = 0; return p; } fn main() { rt.put_s(make()); return 0; }"
  },
  {
    "group": "closure",
    "name": "explicit integer result",
    "accept": true,
    "source": "fn main() { let double = fn:int(int a) { return a * 2; }; return double(4); }"
  },
  {
    "group": "closure",
    "name": "incompatible explicit result",
    "accept": false,
    "source": "typecheck on; fn main() { let f = fn:int() { return \"hi\"; }; return f(); }"
  },
  {
    "group": "closure",
    "name": "captured state is shared",
    "accept": true,
    "source": "include rt; fn main() { int n = 0; let f = fn:int() { n++; return n; }; rt.put_n(f()); rt.put_n(f()); rt.put_n(n); return 0; }",
    "output": "122"
  },
  {
    "group": "stdlib",
    "name": "word string search",
    "accept": true,
    "source": "include std; fn main() { return std.Text.ends(\"abcd\", \"cd\"); }"
  },
  {
    "group": "stdlib",
    "name": "packed string search",
    "accept": true,
    "source": "include std; fn main() { return std.Bytes.ends(b\"abcd\", b\"cd\"); }"
  },
  {
    "group": "stdlib",
    "name": "word string trimming",
    "accept": true,
    "source": "include std; include rt; fn main() { rt.put_s(std.Text.trim(\" hi \")); return 0; }",
    "output": "hi"
  },
  {
    "group": "stdlib",
    "name": "word string substring",
    "accept": true,
    "source": "include std; include rt; fn main() { rt.put_s(std.Text.substr(\"abcd\", 1, 2)); return 0; }",
    "output": "bc"
  },
  {
    "group": "stdlib",
    "name": "negative substring bounds",
    "accept": true,
    "source": "include std; fn main() { return std.Text.substr(\"abcd\", -1, 2) == 0; }"
  },
  {
    "group": "runtime",
    "name": "word copying borrowed buffers",
    "accept": true,
    "source": "include rt; fn main() { int a[2] = {1, 2}, b[2]; rt.copy_w(b, a, 2); return b[1]; }"
  },
  {
    "group": "runtime",
    "name": "explicit free consumes owner",
    "accept": false,
    "source": "include rt; fn main() { let p = rt.new(int); rt.free(p); return p[0]; }"
  },
  {
    "group": "runtime",
    "name": "borrow cannot free owner",
    "accept": false,
    "source": "include rt; fn f(int*.m p) { rt.free(p); } fn main() { return 0; }"
  },
  {
    "group": "runtime",
    "name": "growable array owns transferred child",
    "accept": true,
    "source": "include rt; fn main() { let a = rt.new(int*[?]); let p = rt.new(int); p[0] = 7; push(a, p); return a[0][0]; }"
  },
  {
    "group": "runtime",
    "name": "transferred child cannot outlive array",
    "accept": false,
    "source": "include rt; int* saved; fn main() { let a = rt.new(int*[?]); let p = rt.new(int); push(a, p); saved = p; return 0; }"
  },
  {
    "group": "runtime",
    "name": "collection retains reachable objects",
    "accept": true,
    "source": "include rt; fn main() { let p = rt.new(int); p[0] = 7; rt.gc(); return p[0]; }"
  },
  {
    "group": "runtime",
    "name": "zero-sized copy is safe",
    "accept": true,
    "source": "include rt; fn main() { return rt.copy_w(0, 0, 0); }"
  },
  {
    "group": "arguments",
    "name": "explicit discard owns cleanup",
    "accept": true,
    "source": "include rt; fn ignore(int*.d _) { return 0; } fn main() { let before = rt.live_objects(); ignore(rt.new(int)); rt.put_n(rt.live_objects() - before); return 0; }",
    "output": "0"
  },
  {
    "group": "arguments",
    "name": "discard does not disable arity checking",
    "accept": false,
    "source": "fn ignore(int _, int _) { return 0; } fn main() { return ignore(1); }"
  },
  {
    "group": "arguments",
    "name": "duplicate discard names are permitted",
    "accept": true,
    "source": "fn ignore(int _, int _) { return 0; } fn main() { return ignore(1, 2); }"
  },
  {
    "group": "modules",
    "name": "multiple explicit imports",
    "accept": true,
    "source": "include rt, run, core; fn main() { rt.put_n(core.syscall(9, 0, 0, 0) > 0); run.evals(\"return 0;\"); return 0; }"
  },
  {
    "group": "modules",
    "name": "repeated imports are idempotent",
    "accept": true,
    "source": "include rt, rt, run; include rt; fn main() { rt.put_n(1); return 0; }"
  },
  {
    "group": "modules",
    "name": "unknown import within list",
    "accept": false,
    "source": "include rt, imaginary, run; fn main() { return 0; }"
  },
  {
    "group": "modules",
    "name": "missing entry within list",
    "accept": false,
    "source": "include rt,,run; fn main() { return 0; }"
  },
  {
    "group": "callbacks",
    "name": "explicit borrowed callback parameter",
    "accept": true,
    "source": "include rt; int first(int*.m p) { return p[0]; } fn main() { int(int*.m) f = first; return f(rt.new(1)); }"
  },
  {
    "group": "callbacks",
    "name": "borrowed callback cannot consume source",
    "accept": false,
    "source": "include rt; fn bad(int*.m p) { rt.free(p); } fn main() { int(int*.m) f = bad; return 0; }"
  },
  {
    "group": "modules",
    "name": "local struct shadows module name",
    "accept": true,
    "source": "struct point { int x; }; fn main() { point rt; rt.x = 7; return rt.x; }"
  },
  {
    "group": "strings",
    "name": "capture returns a char string",
    "accept": true,
    "source": "include rt, std; typecheck on; fn main() { char* s = std.capture.start(); rt.put_s(\"hi\"); s = std.capture.end(s); rt.put_s(s); return 0; }",
    "output": "hi"
  },
  {
    "group": "modules",
    "name": "boot export needs its namespace",
    "accept": false,
    "source": "fn main() { return start; }"
  },
  {
    "group": "strings",
    "name": "inferred packed result stays indexable",
    "accept": true,
    "source": "include rt; fn text() { return b\"hi\"; } fn main() { let s = text(); rt.put_n(s[0]); return 0; }",
    "output": "104"
  },
  {
    "group": "strings",
    "name": "typed argument with inferred packed return",
    "accept": true,
    "source": "include rt; typecheck on; fn echo(bstr s) { return s; } fn main() { let s = echo(b\"hi\"); rt.put_n(s[1]); return 0; }",
    "output": "105"
  },
  {
    "group": "strings",
    "name": "inferred word string result stays indexable",
    "accept": true,
    "source": "include rt; fn text() { return \"hi\"; } fn main() { let s = text(); rt.put_n(s[0]); return 0; }",
    "output": "104"
  },
  {
    "group": "enums",
    "name": "tagged enum constructors and repeated discard fields",
    "accept": true,
    "source": "include rt; enum pair { item { int x; int y; }, other }; fn main() { let p = pair.item(1, 2); switch(p) { case item(_, _): rt.put_n(p.item_x + p.item_y); case _: rt.put_n(0); } rt.free(d*p); return 0; }",
    "output": "3"
  },
  {
    "group": "modules",
    "name": "icon exports are loaded by explicit include",
    "accept": true,
    "source": "include rt, run, icon; fn main() { let q = run.tokens(\"return 7;\"); let frame = icon.begin(q); icon.resume(frame, 4); int result = icon.result(frame); rt.put_n(result); icon.close(d*frame); return 0; }",
    "output": "7"
  },
  {
    "group": "modules",
    "name": "icon access requires include",
    "accept": false,
    "source": "include rt, run; fn main() { return icon.error(); }"
  },
  {
    "group": "modules",
    "name": "icon implementation names remain private",
    "accept": false,
    "source": "include rt, run, icon; fn main() { return icon_value(0, 0); }"
  },
  {
    "group": "modules",
    "name": "repeated icon include is idempotent",
    "accept": true,
    "source": "include rt, run, icon, icon; fn main() { let q = run.tokens(\"return 1;\"); rt.put_n(icon.validate(q)); return 0; }",
    "output": "1"
  },
  {
    "group": "qualifiers",
    "name": "fixed const array",
    "accept": true,
    "source": "include rt; fn main() { fixed const int[3] a = {2,3,4}; rt.put_n(a[1]); }",
    "output": "3"
  },
  {
    "group": "qualifiers",
    "name": "const fixed array",
    "accept": true,
    "source": "include rt; fn main() { const fixed int[3] a = {2,3,4}; rt.put_n(a[1]); }",
    "output": "3"
  },
  {
    "group": "qualifiers",
    "name": "fixed const global array",
    "accept": true,
    "source": "include rt; fixed const int[2] data = {8,9}; fn main() { rt.put_n(data[1]); }",
    "output": "9"
  },
  {
    "group": "qualifiers",
    "name": "fixed const array rejects element write",
    "accept": false,
    "source": "fn main() { fixed const int[2] a = {1,2}; a[0] = 3; }"
  },
  {
    "group": "qualifiers",
    "name": "const fixed rejects resize",
    "accept": false,
    "source": "include rt; fn main() { const fixed int[?] a = rt.new(fixed int[?],2); a.resize(3); }"
  },
  {
    "group": "qualifiers",
    "name": "const fixed cannot be rebound",
    "accept": false,
    "source": "include rt; fn main() { const fixed int[?] a = rt.new(fixed int[?],2); a = rt.new(fixed int[?],3); }"
  },
  {
    "group": "qualifiers",
    "name": "fixed mutable remains writable",
    "accept": true,
    "source": "include rt; fn main() { fixed int[2] a = {1,2}; a[0] = 3; rt.put_n(a[0]); }",
    "output": "3"
  },
  {
    "group": "qualifiers",
    "name": "const fixed borrow cannot mutate storage",
    "accept": false,
    "source": "fn mutate(int* p) { p[0] = 9; } fn main() { const fixed int[2] a = {1,2}; mutate(a); }"
  },
  {
    "group": "qualifiers",
    "name": "readonly parameter accepts const fixed",
    "accept": true,
    "source": "include rt; int first(const fixed int[2] a) { return a[0]; } fn main() { const fixed int[2] a = {7,8}; rt.put_n(first(a)); }",
    "output": "7"
  },
  {
    "group": "inference",
    "name": "typed callee constrains untyped caller",
    "accept": true,
    "source": "include rt; int seed(int n) { return n + 1; } fn caller(n) { let result = seed(n); return result; } fn main() { rt.put_n(caller(4)); }",
    "output": "5"
  },
  {
    "group": "inference",
    "name": "recursive anchored return",
    "accept": true,
    "source": "include rt; int seed(int n) { return n; } fn recursive(n) { if (n <= 0) return seed(n); return recursive(n - 1); } fn main() { rt.put_n(recursive(3)); }",
    "output": "0"
  },
  {
    "group": "qualifiers",
    "name": "readonly array alias cannot remove qualifier",
    "accept": false,
    "source": "fn main() { fixed const int[2] a = {1,2}; int* alias = a; alias[0] = 8; }"
  },
  {
    "group": "qualifiers",
    "name": "readonly array alias preserves qualifier",
    "accept": true,
    "source": "include rt; fn main() { fixed const int[2] a = {1,2}; let alias = a; rt.put_n(alias[0]); }",
    "output": "1"
  },
  {
    "group": "qualifiers",
    "name": "readonly inferred alias cannot write",
    "accept": false,
    "source": "fn main() { fixed const int[2] a = {1,2}; let alias = a; alias[0] = 8; }"
  },
  {
    "group": "qualifiers",
    "name": "fixed const compound write rejected without typecheck",
    "accept": false,
    "source": "typecheck off; fn main() { fixed const int[2] a = {1,2}; a[0] += 2; }"
  },
  {
    "group": "qualifiers",
    "name": "fixed const increment rejected",
    "accept": false,
    "source": "fn main() { fixed const int[2] a = {1,2}; a[0]++; }"
  },
  {
    "group": "qualifiers",
    "name": "readonly packed fixed array",
    "accept": true,
    "source": "include rt; fn main() { fixed const u8[] a = {2,3}; rt.put_n(a[1]); }",
    "output": "3"
  },
  {
    "group": "runtime",
    "name": "owned readfile grows and returns exact character data",
    "accept": true,
    "source": "include rt; fn main() { char* text = rt.readfile(\"tests/data/readfile_growth.txt\"); rt.put_n(rt.len_w(text)); rt.put_c(32); rt.put_n(text[1029]); rt.put_c(32); rt.put_n(text[1030]); }",
    "output": "1031 57 10"
  },
  {
    "group": "runtime",
    "name": "readfile missing path returns null",
    "accept": true,
    "source": "include rt; fn main() { char* text = rt.readfile(\"tests/data/missing-readfile-contract.txt\"); rt.put_n(text == 0); }",
    "output": "1"
  },
  {
    "group": "runtime",
    "name": "owned file contents cannot be used after release",
    "accept": false,
    "source": "include rt; fn main() { char* text = rt.readfile(\"tests/data/readfile_growth.txt\"); rt.free(text); return text[0]; }"
  }
]