Implement generic pointers

12 files changed, 307 insertions, 0 deletions

diff --git a/testsuite/compilable/generic_alias.elna b/testsuite/compilable/generic_alias.elna
new file mode 100644
index 0000000..3b431be
--- /dev/null
+++ b/testsuite/compilable/generic_alias.elna
@@ -0,0 +1,31 @@
+type
+  File = record
+    fd: Int
+  end
+
+  Node#[T] = record
+    next: ^Node#[T];
+    value: T
+  end
+
+  Ref#[T] = ^T
+
+  Boxed#[V] = record
+    inner: ^Node#[V]
+  end
+
+var
+  chain: Node#[^File]
+  aliased: Ref#[^File]
+  raw: ^^File
+  boxed: Boxed#[^File]
+
+program()
+begin
+  chain.next := nil;
+  aliased := raw;
+  raw := aliased;
+  boxed.inner := @chain
+return 0u8
+
+end.
diff --git a/testsuite/compilable/generic_arguments.elna b/testsuite/compilable/generic_arguments.elna
new file mode 100644
index 0000000..6bc5242
--- /dev/null
+++ b/testsuite/compilable/generic_arguments.elna
@@ -0,0 +1,28 @@
+type
+  File = record
+    fd: Int
+  end
+
+  Pair#[K, V] = record
+    key: K;
+    value: V
+  end
+
+var
+  entry: Pair#[^File, ^Word8]
+
+proc allocate#[T](size: Word) -> T extern
+
+proc first#[K, V](entry_ptr: ^Pair#[K, V]) -> K
+begin
+return entry_ptr^.key
+
+program()
+begin
+  entry.key := allocate#[^File](#size(File));
+  assert(#size(Pair#[^File, ^Word8]) = #size(Pointer) * 2u);
+  assert(#offset(Pair#[^File, ^Word8], value) = #size(Pointer));
+  assert(first#[^File, ^Word8](@entry) = entry.key)
+return 0u8
+
+end.
diff --git a/testsuite/compilable/generic_base_chain.elna b/testsuite/compilable/generic_base_chain.elna
new file mode 100644
index 0000000..736042b
--- /dev/null
+++ b/testsuite/compilable/generic_base_chain.elna
@@ -0,0 +1,31 @@
+type
+  File = record
+    fd: Int
+  end
+
+  Map#[K, V] = record
+    key: K;
+    value: V
+  end
+
+  Cache#[K, V] = record(Map#[^Word8, V])
+    newest: K
+  end
+
+var
+  store: Cache#[^Int, ^File]
+  byte_key: ^Word8
+  upcast: ^Map#[^Word8, ^File]
+
+proc put#[K2, V2](target: ^Map#[K2, V2]; key: K2)
+begin
+  target^.key := key
+return
+
+program()
+begin
+  upcast := @store;
+  put(@store, byte_key)
+return 0u8
+
+end.
diff --git a/testsuite/compilable/generic_inference.elna b/testsuite/compilable/generic_inference.elna
new file mode 100644
index 0000000..25faca4
--- /dev/null
+++ b/testsuite/compilable/generic_inference.elna
@@ -0,0 +1,33 @@
+type
+  File = record
+    fd: Int
+  end
+
+  Cell#[T] = record
+    held: T
+  end
+
+var
+  files: Cell#[^File]
+  bytes: Cell#[^Word8]
+  f: File
+  b: Word8
+
+proc store#[T](target: ^Cell#[T]; value: T)
+begin
+  target^.held := value
+return
+
+proc relay#[T](target: ^Cell#[T]; value: T)
+begin
+  store(target, value)
+return
+
+program()
+begin
+  store(@files, @f);
+  relay(@bytes, @b);
+  store(@files, nil)
+return 0u8
+
+end.
diff --git a/testsuite/fail_compilation/generic_arity.elna b/testsuite/fail_compilation/generic_arity.elna
new file mode 100644
index 0000000..bb234af
--- /dev/null
+++ b/testsuite/fail_compilation/generic_arity.elna
@@ -0,0 +1,13 @@
+type
+  Stack#[T] = record
+    items: T
+  end
+
+var
+  broken: Stack (* @Error Too few type arguments for generic 'Stack', expected 1, got 0 *)
+
+program()
+begin
+return 0u8
+
+end.
diff --git a/testsuite/fail_compilation/generic_base_mismatch.elna b/testsuite/fail_compilation/generic_base_mismatch.elna
new file mode 100644
index 0000000..64e0c40
--- /dev/null
+++ b/testsuite/fail_compilation/generic_base_mismatch.elna
@@ -0,0 +1,26 @@
+type
+  File = record
+    fd: Int
+  end
+  Socket = record
+    handle: Int
+  end
+
+  List#[T] = record
+    head: T
+  end
+
+  Queue#[T] = record(List#[T])
+    tail: T
+  end
+
+var
+  jobs: Queue#[^File]
+  wrong: ^List#[^Socket]
+
+program()
+begin
+  wrong := @jobs (* @Error Expected type '\^List#\[\^Socket\]', but got '\^Queue#\[\^File\]' *)
+return 0u8
+
+end.
diff --git a/testsuite/fail_compilation/generic_parameter_arithmetic.elna b/testsuite/fail_compilation/generic_parameter_arithmetic.elna
new file mode 100644
index 0000000..969c5c7
--- /dev/null
+++ b/testsuite/fail_compilation/generic_parameter_arithmetic.elna
@@ -0,0 +1,11 @@
+proc walk#[T](value: T; step: ^T)
+begin
+  step := step + 1;
+  value := value + 1 (* @Error Type parameter 'T' cannot be used in pointer arithmetic *)
+return
+
+program()
+begin
+return 0u8
+
+end.
diff --git a/testsuite/fail_compilation/generic_uninferrable.elna b/testsuite/fail_compilation/generic_uninferrable.elna
new file mode 100644
index 0000000..20d3d25
--- /dev/null
+++ b/testsuite/fail_compilation/generic_uninferrable.elna
@@ -0,0 +1,10 @@
+proc allocate#[R](size: Word) -> R extern
+
+program()
+var
+  got: ^Word8
+begin
+  got := allocate(8u) (* @Error Type parameter 'R' of 'allocate' cannot be inferred *)
+return 0u8
+
+end.
diff --git a/testsuite/runnable/generic_base.elna b/testsuite/runnable/generic_base.elna
new file mode 100644
index 0000000..c36eccf
--- /dev/null
+++ b/testsuite/runnable/generic_base.elna
@@ -0,0 +1,42 @@
+type
+  File = record
+    fd: Int
+  end
+
+  List#[T] = record
+    head: T;
+    count: Word
+  end
+
+  Queue#[T] = record(List#[T])
+    tail: T
+  end
+
+var
+  jobs: Queue#[^File]
+  seen: ^List#[^File]
+  f: File
+
+proc push#[T](target: ^List#[T]; value: T)
+begin
+  target^.head := value;
+  target^.count := target^.count + 1u
+return
+
+proc enqueue#[T](target: ^Queue#[T]; value: T)
+begin
+  push(target, value);
+  target^.tail := value
+return
+
+program()
+begin
+  seen := @jobs;
+  enqueue(@jobs, @f);
+  assert(jobs.count = 1u);
+  assert(jobs.head = @f);
+  assert(jobs.tail = @f);
+  assert(#size(Queue#[^File]) = #size(Pointer) * 3u)
+return 0u8
+
+end.
diff --git a/testsuite/runnable/generic_constructor.elna b/testsuite/runnable/generic_constructor.elna
new file mode 100644
index 0000000..201e1b1
--- /dev/null
+++ b/testsuite/runnable/generic_constructor.elna
@@ -0,0 +1,22 @@
+type
+  File = record
+    fd: Int
+  end
+
+  Stack#[T] = record
+    items: T;
+    top: Word
+  end
+
+var
+  s: Stack#[^File]
+  f: File
+
+program()
+begin
+  s := Stack#[^File]{ top: 1u, items: @f };
+  assert(s.top = 1u);
+  assert(s.items = @f)
+return 0u8
+
+end.
diff --git a/testsuite/runnable/generic_erasure.elna b/testsuite/runnable/generic_erasure.elna
new file mode 100644
index 0000000..eccc1d2
--- /dev/null
+++ b/testsuite/runnable/generic_erasure.elna
@@ -0,0 +1,31 @@
+type
+  File = record
+    fd: Int
+  end
+
+  Cell#[T] = record
+    held: T
+  end
+
+var
+  files: Cell#[^File]
+  bytes: Cell#[^Word8]
+  f: File
+  b: Word8
+
+proc store#[T](target: ^Cell#[T]; value: T)
+begin
+  target^.held := value
+return
+
+program()
+begin
+  f.fd := 7;
+  b := 3u8;
+  store#[^File](@files, @f);
+  store#[^Word8](@bytes, @b);
+  assert(files.held^.fd = 7);
+  assert(bytes.held^ = 3u8)
+return 0u8
+
+end.
diff --git a/testsuite/runnable/generic_record.elna b/testsuite/runnable/generic_record.elna
new file mode 100644
index 0000000..8a334ce
--- /dev/null
+++ b/testsuite/runnable/generic_record.elna
@@ -0,0 +1,29 @@
+type
+  File = record
+    fd: Int
+  end
+
+  Stack#[T] = record
+    items: T;
+    top: Word
+  end
+
+var
+  s: Stack#[^File]
+  f: File
+
+proc push#[T](target: ^Stack#[T]; value: T)
+begin
+  target^.items := value;
+  target^.top := target^.top + 1u
+return
+
+program()
+begin
+  s.top := 0u;
+  push#[^File](@s, @f);
+  assert(s.top = 1u);
+  assert(s.items = @f)
+return 0u8
+
+end.