From 7bd1039a49e5fd771569cd1b5bca5b076d464a5f Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Fri, 22 May 2020 14:54:30 +0100
Subject: [PATCH] Selector Call Expressions: `x->y(123)  ==  x.y(x, 123)`

---
 examples/demo/demo.odin | 2011 +--------------------------------------
 src/check_expr.cpp      |  205 +++-
 src/check_stmt.cpp      |   12 +
 src/ir.cpp              |    7 +
 src/llvm_backend.cpp    |    7 +
 src/parser.cpp          |   24 +-
 src/parser.hpp          |    1 +
 7 files changed, 244 insertions(+), 2023 deletions(-)

diff --git a/examples/demo/demo.odin b/examples/demo/demo.odin
index e6882fbcc..be20e690a 100644
--- a/examples/demo/demo.odin
+++ b/examples/demo/demo.odin
@@ -1,1997 +1,40 @@
 package main
 
 import "core:fmt"
-import "core:mem"
-import "core:os"
-import "core:thread"
-import "core:time"
-import "core:reflect"
-import "core:runtime"
-import "intrinsics"
 
+Foo :: struct {
+	call0: proc(f: ^Foo, x: int) -> bool,
+	call1: proc(f: Foo,  x: int) -> bool,
 
-/*
-	The Odin programming language is fast, concise, readable, pragmatic and open sourced.
-	It is designed with the intent of replacing C with the following goals:
-	 * simplicity
-	 * high performance
-	 * built for modern systems
-	 * joy of programming
-
-	# Installing Odin
-	Getting Started - https://odin-lang.org/docs/install/
-		Instructions for downloading and install the Odin compiler and libraries.
-
-	# Learning Odin
-	Overview of Odin - https://odin-lang.org/docs/overview/
-		An overview of the Odin programming language.
-	Frequently Asked Questions (FAQ) - https://odin-lang.org/docs/faq/
-		Answers to common questions about Odin.
-*/
-
-the_basics :: proc() {
-	fmt.println("\n# the basics");
-
-	{ // The Basics
-		fmt.println("Hellope");
-
-		// Lexical elements and literals
-		// A comment
-
-		my_integer_variable: int; // A comment for documentaton
-
-		// Multi-line comments begin with /* and end with */. Multi-line comments can
-		// also be nested (unlike in C):
-		/*
-			You can have any text or code here and
-			have it be commented.
-			/*
-				NOTE: comments can be nested!
-			*/
-		*/
-
-		// String literals are enclosed in double quotes and character literals in single quotes.
-		// Special characters are escaped with a backslash \
-
-		some_string := "This is a string";
-		_ = 'A'; // unicode codepoint literal
-		_ = '\n';
-		_ = "C:\\Windows\\notepad.exe";
-		// Raw string literals are enclosed with single back ticks
-		_ = `C:\Windows\notepad.exe`;
-
-		// The length of a string in bytes can be found using the built-in `len` procedure:
-		_ = len("Foo");
-		_ = len(some_string);
-
-
-		// Numbers
-
-		// Numerical literals are written similar to most other programming languages.
-		// A useful feature in Odin is that underscores are allowed for better
-		// readability: 1_000_000_000 (one billion). A number that contains a dot is a
-		// floating point literal: 1.0e9 (one billion). If a number literal is suffixed
-		// with i, is an imaginary number literal: 2i (2 multiply the square root of -1).
-
-		// Binary literals are prefixed with 0b, octal literals with 0o, and hexadecimal
-		// literals 0x. A leading zero does not produce an octal constant (unlike C).
-
-		// In Odin, if a number constant is possible to be represented by a type without
-		// precision loss, it will automatically convert to that type.
-
-		x: int = 1.0; // A float literal but it can be represented by an integer without precision loss
-		// Constant literals are “untyped” which means that they can implicitly convert to a type.
-
-		y: int; // `y` is typed of type `int`
-		y = 1;  // `1` is an untyped integer literal which can implicitly convert to `int`
-
-		z: f64; // `z` is typed of type `f64` (64-bit floating point number)
-		z = 1;  // `1` is an untyped integer literals which can be implicity conver to `f64`
-				// No need for any suffixes or decimal places like in other languages
-				// CONSTANTS JUST WORK!!!
-
-
-		// Assignment statements
-		h: int = 123; // declares a new variable `h` with type `int` and assigns a value to it
-		h = 637; // assigns a new value to `h`
-
-		// `=` is the assignment operator
-
-		// You can assign multiple variables with it:
-		a, b := 1, "hello"; // declares `a` and `b` and infers the types from the assignments
-		b, a = "byte", 0;
-
-		// Note: `:=` is two tokens, `:` and `=`. The following are equivalent,
-		/*
-			i: int = 123;
-			i:     = 123;
-			i := 123;
-		*/
-
-		// Constant declarations
-		// Constants are entities (symbols) which have an assigned value.
-		// The constant’s value cannot be changed.
-		// The constant’s value must be able to be evaluated at compile time:
-		X :: "what"; // constant `X` has the untyped string value "what"
-
-		// Constants can be explicitly typed like a variable declaration:
-		Y : int : 123;
-		Z :: Y + 7; // constant computations are possible
-
-		_ = my_integer_variable;
-		_ = x;
-	}
+	bar: int,
 }
 
-control_flow :: proc() {
-	fmt.println("\n# control flow");
-	{ // Control flow
-		// For loop
-		// Odin has only one loop statement, the `for` loop
-
-		// Basic for loop
-		for i := 0; i < 10; i += 1 {
-			fmt.println(i);
-		}
-
-		// NOTE: Unlike other languages like C, there are no parentheses `( )` surrounding the three components.
-		// Braces `{ }` or a `do` are always required>
-		for i := 0; i < 10; i += 1 { }
-		for i := 0; i < 10; i += 1 do fmt.print();
-
-		// The initial and post statements are optional
-		i := 0;
-		for ; i < 10; {
-			i += 1;
-		}
-
-		// These semicolons can be dropped. This `for` loop is equivalent to C's `while` loop
-		i = 0;
-		for i < 10 {
-			i += 1;
-		}
-
-		// If the condition is omitted, this produces an infinite loop:
-		for {
-			break;
-		}
-
-		// Range-based for loop
-		// The basic for loop
-		for j := 0; j < 10; j += 1 {
-			fmt.println(j);
-		}
-		// can also be written
-		for j in 0..<10 {
-			fmt.println(j);
-		}
-		for j in 0..9 {
-			fmt.println(j);
-		}
-
-		// Certain built-in types can be iterated over
-		some_string := "Hello, 世界";
-		for character in some_string { // Strings are assumed to be UTF-8
-			fmt.println(character);
-		}
-
-		some_array := [3]int{1, 4, 9};
-		for value in some_array {
-			fmt.println(value);
-		}
-
-		some_slice := []int{1, 4, 9};
-		for value in some_slice {
-			fmt.println(value);
-		}
-
-		some_dynamic_array := [dynamic]int{1, 4, 9};
-		defer delete(some_dynamic_array);
-		for value in some_dynamic_array {
-			fmt.println(value);
-		}
-
-
-		some_map := map[string]int{"A" = 1, "C" = 9, "B" = 4};
-		defer delete(some_map);
-		for key in some_map {
-			fmt.println(key);
-		}
-
-		// Alternatively a second index value can be added
-		for character, index in some_string {
-			fmt.println(index, character);
-		}
-		for value, index in some_array {
-			fmt.println(index, value);
-		}
-		for value, index in some_slice {
-			fmt.println(index, value);
-		}
-		for value, index in some_dynamic_array {
-			fmt.println(index, value);
-		}
-		for key, value in some_map {
-			fmt.println(key, value);
-		}
-
-		// The iterated values are copies and cannot be written to.
-		// The following idiom is useful for iterating over a container in a by-reference manner:
-		for _, idx in some_slice {
-			some_slice[idx] = (idx+1)*(idx+1);
-		}
-
-
-		// If statements
-		x := 123;
-		if x >= 0 {
-			fmt.println("x is positive");
-		}
-
-		if y := -34; y < 0 {
-			fmt.println("y is negative");
-		}
-
-		if y := 123; y < 0 {
-			fmt.println("y is negative");
-		} else if y == 0 {
-			fmt.println("y is zero");
-		} else {
-			fmt.println("y is positive");
-		}
-
-		// Switch statement
-		// A switch statement is another way to write a sequence of if-else statements.
-		// In Odin, the default case is denoted as a case without any expression.
-
-		switch arch := ODIN_ARCH; arch {
-		case "386":
-			fmt.println("32-bit");
-		case "amd64":
-			fmt.println("64-bit");
-		case: // default
-			fmt.println("Unsupported architecture");
-		}
-
-		// Odin’s `switch` is like one in C or C++, except that Odin only runs the selected case.
-		// This means that a `break` statement is not needed at the end of each case.
-		// Another important difference is that the case values need not be integers nor constants.
-
-		// To achieve a C-like fall through into the next case block, the keyword `fallthrough` can be used.
-		one_angry_dwarf :: proc() -> int {
-			fmt.println("one_angry_dwarf was called");
-			return 1;
-		}
-
-		switch j := 0; j {
-		case 0:
-		case one_angry_dwarf():
-		}
-
-		// A switch statement without a condition is the same as `switch true`.
-		// This can be used to write a clean and long if-else chain and have the
-		// ability to break if needed
-
-		switch {
-		case x < 0:
-			fmt.println("x is negative");
-		case x == 0:
-			fmt.println("x is zero");
-		case:
-			fmt.println("x is positive");
-		}
-
-		// A `switch` statement can also use ranges like a range-based loop:
-		switch c := 'j'; c {
-		case 'A'..'Z', 'a'..'z', '0'..'9':
-			fmt.println("c is alphanumeric");
-		}
-
-		switch x {
-		case 0..<10:
-			fmt.println("units");
-		case 10..<13:
-			fmt.println("pre-teens");
-		case 13..<20:
-			fmt.println("teens");
-		case 20..<30:
-			fmt.println("twenties");
-		}
-	}
-
-	{ // Defer statement
-		// A defer statement defers the execution of a statement until the end of
-		// the scope it is in.
-
-		// The following will print 4 then 234:
-		{
-			x := 123;
-			defer fmt.println(x);
-			{
-				defer x = 4;
-				x = 2;
-			}
-			fmt.println(x);
-
-			x = 234;
-		}
-
-		// You can defer an entire block too:
-		{
-			bar :: proc() {}
-
-			defer {
-				fmt.println("1");
-				fmt.println("2");
-			}
-
-			cond := false;
-			defer if cond {
-				bar();
-			}
-		}
-
-		// Defer statements are executed in the reverse order that they were declared:
-		{
-			defer fmt.println("1");
-			defer fmt.println("2");
-			defer fmt.println("3");
-		}
-		// Will print 3, 2, and then 1.
-
-		if false {
-			f, err := os.open("my_file.txt");
-			if err != 0 {
-				// handle error
-			}
-			defer os.close(f);
-			// rest of code
-		}
-	}
-
-	{ // When statement
-		/*
-			The when statement is almost identical to the if statement but with some differences:
-
-			* Each condition must be a constant expression as a when
-			  statement is evaluated at compile time.
-			* The statements within a branch do not create a new scope
-			* The compiler checks the semantics and code only for statements
-			  that belong to the first condition that is true
-			* An initial statement is not allowed in a when statement
-			* when statements are allowed at file scope
-		*/
-
-		// Example
-		when ODIN_ARCH == "386" {
-			fmt.println("32 bit");
-		} else when ODIN_ARCH == "amd64" {
-			fmt.println("64 bit");
-		} else {
-			fmt.println("Unsupported architecture");
-		}
-		// The when statement is very useful for writing platform specific code.
-		// This is akin to the #if construct in C’s preprocessor however, in Odin,
-		// it is type checked.
-	}
-
-	{ // Branch statements
-		cond, cond1, cond2 := false, false, false;
-		one_step :: proc() { fmt.println("one_step"); }
-		beyond :: proc() { fmt.println("beyond"); }
-
-		// Break statement
-		for cond {
-			switch {
-			case:
-				if cond {
-					break; // break out of the `switch` statement
-				}
-			}
-
-			break; // break out of the `for` statement
-		}
-
-		loop: for cond1 {
-			for cond2 {
-				break loop; // leaves both loops
-			}
-		}
-
-		// Continue statement
-		for cond {
-			if cond2 {
-				continue;
-			}
-			fmt.println("Hellope");
-		}
-
-		// Fallthrough statement
-
-		// Odin’s switch is like one in C or C++, except that Odin only runs the selected
-		// case. This means that a break statement is not needed at the end of each case.
-		// Another important difference is that the case values need not be integers nor
-		// constants.
-
-		// fallthrough can be used to explicitly fall through into the next case block:
-
-		switch i := 0; i {
-		case 0:
-			one_step();
-			fallthrough;
-		case 1:
-			beyond();
-		}
-	}
+test0 :: proc(f: ^Foo, x: int) -> bool {
+	fmt.println(#procedure, x);
+	return true;
 }
 
-
-named_proc_return_parameters :: proc() {
-	fmt.println("\n# named proc return parameters");
-
-	foo0 :: proc() -> int {
-		return 123;
-	}
-	foo1 :: proc() -> (a: int) {
-		a = 123;
-		return;
-	}
-	foo2 :: proc() -> (a, b: int) {
-		// Named return values act like variables within the scope
-		a = 321;
-		b = 567;
-		return b, a;
-	}
-	fmt.println("foo0 =", foo0()); // 123
-	fmt.println("foo1 =", foo1()); // 123
-	fmt.println("foo2 =", foo2()); // 567 321
-}
-
-
-explicit_procedure_overloading :: proc() {
-	fmt.println("\n# explicit procedure overloading");
-
-	add_ints :: proc(a, b: int) -> int {
-		x := a + b;
-		fmt.println("add_ints", x);
-		return x;
-	}
-	add_floats :: proc(a, b: f32) -> f32 {
-		x := a + b;
-		fmt.println("add_floats", x);
-		return x;
-	}
-	add_numbers :: proc(a: int, b: f32, c: u8) -> int {
-		x := int(a) + int(b) + int(c);
-		fmt.println("add_numbers", x);
-		return x;
-	}
-
-	add :: proc{add_ints, add_floats, add_numbers};
-
-	add(int(1), int(2));
-	add(f32(1), f32(2));
-	add(int(1), f32(2), u8(3));
-
-	add(1, 2);     // untyped ints coerce to int tighter than f32
-	add(1.0, 2.0); // untyped floats coerce to f32 tighter than int
-	add(1, 2, 3);  // three parameters
-
-	// Ambiguous answers
-	// add(1.0, 2);
-	// add(1, 2.0);
-}
-
-struct_type :: proc() {
-	fmt.println("\n# struct type");
-	// A struct is a record type in Odin. It is a collection of fields.
-	// Struct fields are accessed by using a dot:
-	{
-		Vector2 :: struct {
-			x: f32,
-			y: f32,
-		};
-		v := Vector2{1, 2};
-		v.x = 4;
-		fmt.println(v.x);
-
-		// Struct fields can be accessed through a struct pointer:
-
-		v = Vector2{1, 2};
-		p := &v;
-		p.x = 1335;
-		fmt.println(v);
-
-		// We could write p^.x, however, it is to nice abstract the ability
-		// to not explicitly dereference the pointer. This is very useful when
-		// refactoring code to use a pointer rather than a value, and vice versa.
-	}
-	{
-		// A struct literal can be denoted by providing the struct’s type
-		// followed by {}. A struct literal must either provide all the
-		// arguments or none:
-		Vector3 :: struct {
-			x, y, z: f32,
-		};
-		v: Vector3;
-		v = Vector3{}; // Zero value
-		v = Vector3{1, 4, 9};
-
-		// You can list just a subset of the fields if you specify the
-		// field by name (the order of the named fields does not matter):
-		v = Vector3{z=1, y=2};
-		assert(v.x == 0);
-		assert(v.y == 2);
-		assert(v.z == 1);
-	}
-	{
-		// Structs can tagged with different memory layout and alignment requirements:
-
-		a :: struct #align 4   {}; // align to 4 bytes
-		b :: struct #packed    {}; // remove padding between fields
-		c :: struct #raw_union {}; // all fields share the same offset (0). This is the same as C's union
-	}
-
-}
-
-
-union_type :: proc() {
-	fmt.println("\n# union type");
-	{
-		val: union{int, bool};
-		val = 137;
-		if i, ok := val.(int); ok {
-			fmt.println(i);
-		}
-		val = true;
-		fmt.println(val);
-
-		val = nil;
-
-		switch v in val {
-		case int:  fmt.println("int",  v);
-		case bool: fmt.println("bool", v);
-		case:      fmt.println("nil");
-		}
-	}
-	{
-		// There is a duality between `any` and `union`
-		// An `any` has a pointer to the data and allows for any type (open)
-		// A `union` has as binary blob to store the data and allows only certain types (closed)
-		// The following code is with `any` but has the same syntax
-		val: any;
-		val = 137;
-		if i, ok := val.(int); ok {
-			fmt.println(i);
-		}
-		val = true;
-		fmt.println(val);
-
-		val = nil;
-
-		switch v in val {
-		case int:  fmt.println("int",  v);
-		case bool: fmt.println("bool", v);
-		case:      fmt.println("nil");
-		}
-	}
-
-	Vector3 :: distinct [3]f32;
-	Quaternion :: distinct quaternion128;
-
-	// More realistic examples
-	{
-		// NOTE(bill): For the above basic examples, you may not have any
-		// particular use for it. However, my main use for them is not for these
-		// simple cases. My main use is for hierarchical types. Many prefer
-		// subtyping, embedding the base data into the derived types. Below is
-		// an example of this for a basic game Entity.
-
-		Entity :: struct {
-			id:          u64,
-			name:        string,
-			position:    Vector3,
-			orientation: Quaternion,
-
-			derived: any,
-		};
-
-		Frog :: struct {
-			using entity: Entity,
-			jump_height:  f32,
-		};
-
-		Monster :: struct {
-			using entity: Entity,
-			is_robot:     bool,
-			is_zombie:    bool,
-		};
-
-		// See `parametric_polymorphism` procedure for details
-		new_entity :: proc($T: typeid) -> ^Entity {
-			t := new(T);
-			t.derived = t^;
-			return t;
-		}
-
-		entity := new_entity(Monster);
-
-		switch e in entity.derived {
-		case Frog:
-			fmt.println("Ribbit");
-		case Monster:
-			if e.is_robot  do fmt.println("Robotic");
-			if e.is_zombie do fmt.println("Grrrr!");
-			fmt.println("I'm a monster");
-		}
-	}
-
-	{
-		// NOTE(bill): A union can be used to achieve something similar. Instead
-		// of embedding the base data into the derived types, the derived data
-		// in embedded into the base type. Below is the same example of the
-		// basic game Entity but using an union.
-
-		Entity :: struct {
-			id:          u64,
-			name:        string,
-			position:    Vector3,
-			orientation: Quaternion,
-
-			derived: union {Frog, Monster},
-		};
-
-		Frog :: struct {
-			using entity: ^Entity,
-			jump_height:  f32,
-		};
-
-		Monster :: struct {
-			using entity: ^Entity,
-			is_robot:     bool,
-			is_zombie:    bool,
-		};
-
-		// See `parametric_polymorphism` procedure for details
-		new_entity :: proc($T: typeid) -> ^Entity {
-			t := new(Entity);
-			t.derived = T{entity = t};
-			return t;
-		}
-
-		entity := new_entity(Monster);
-
-		switch e in entity.derived {
-		case Frog:
-			fmt.println("Ribbit");
-		case Monster:
-			if e.is_robot  do fmt.println("Robotic");
-			if e.is_zombie do fmt.println("Grrrr!");
-		}
-
-		// NOTE(bill): As you can see, the usage code has not changed, only its
-		// memory layout. Both approaches have their own advantages but they can
-		// be used together to achieve different results. The subtyping approach
-		// can allow for a greater control of the memory layout and memory
-		// allocation, e.g. storing the derivatives together. However, this is
-		// also its disadvantage. You must either preallocate arrays for each
-		// derivative separation (which can be easily missed) or preallocate a
-		// bunch of "raw" memory; determining the maximum size of the derived
-		// types would require the aid of metaprogramming. Unions solve this
-		// particular problem as the data is stored with the base data.
-		// Therefore, it is possible to preallocate, e.g. [100]Entity.
-
-		// It should be noted that the union approach can have the same memory
-		// layout as the any and with the same type restrictions by using a
-		// pointer type for the derivatives.
-
-		/*
-			Entity :: struct {
-				...
-				derived: union{^Frog, ^Monster},
-			}
-
-			Frog :: struct {
-				using entity: Entity,
-				...
-			}
-			Monster :: struct {
-				using entity: Entity,
-				...
-
-			}
-			new_entity :: proc(T: type) -> ^Entity {
-				t := new(T);
-				t.derived = t;
-				return t;
-			}
-		*/
-	}
-}
-
-using_statement :: proc() {
-	fmt.println("\n# using statement");
-	// using can used to bring entities declared in a scope/namespace
-	// into the current scope. This can be applied to import declarations,
-	// import names, struct fields, procedure fields, and struct values.
-
-	Vector3 :: struct{x, y, z: f32};
-	{
-		Entity :: struct {
-			position: Vector3,
-			orientation: quaternion128,
-		};
-
-		// It can used like this:
-		foo0 :: proc(entity: ^Entity) {
-			fmt.println(entity.position.x, entity.position.y, entity.position.z);
-		}
-
-		// The entity members can be brought into the procedure scope by using it:
-		foo1 :: proc(entity: ^Entity) {
-			using entity;
-			fmt.println(position.x, position.y, position.z);
-		}
-
-		// The using can be applied to the parameter directly:
-		foo2 :: proc(using entity: ^Entity) {
-			fmt.println(position.x, position.y, position.z);
-		}
-
-		// It can also be applied to sub-fields:
-		foo3 :: proc(entity: ^Entity) {
-			using entity.position;
-			fmt.println(x, y, z);
-		}
-	}
-	{
-		// We can also apply the using statement to the struct fields directly,
-		// making all the fields of position appear as if they on Entity itself:
-		Entity :: struct {
-			using position: Vector3,
-			orientation: quaternion128,
-		};
-		foo :: proc(entity: ^Entity) {
-			fmt.println(entity.x, entity.y, entity.z);
-		}
-
-
-		// Subtype polymorphism
-		// It is possible to get subtype polymorphism, similar to inheritance-like
-		// functionality in C++, but without the requirement of vtables or unknown
-		// struct layout:
-
-		Colour :: struct {r, g, b, a: u8};
-		Frog :: struct {
-			ribbit_volume: f32,
-			using entity: Entity,
-			colour: Colour,
-		};
-
-		frog: Frog;
-		// Both work
-		foo(&frog.entity);
-		foo(&frog);
-		frog.x = 123;
-
-		// Note: using can be applied to arbitrarily many things, which allows
-		// the ability to have multiple subtype polymorphism (but also its issues).
-
-		// Note: using’d fields can still be referred by name.
-	}
-	{ // using on an enum declaration
-
-		using Foo :: enum {A, B, C};
-
-		f0 := A;
-		f1 := B;
-		f2 := C;
-		fmt.println(f0, f1, f2);
-		fmt.println(len(Foo));
-	}
-}
-
-
-implicit_context_system :: proc() {
-	fmt.println("\n# implicit context system");
-	// In each scope, there is an implicit value named context. This
-	// context variable is local to each scope and is implicitly passed
-	// by pointer to any procedure call in that scope (if the procedure
-	// has the Odin calling convention).
-
-	// The main purpose of the implicit context system is for the ability
-	// to intercept third-party code and libraries and modify their
-	// functionality. One such case is modifying how a library allocates
-	// something or logs something. In C, this was usually achieved with
-	// the library defining macros which could be overridden so that the
-	// user could define what he wanted. However, not many libraries
-	// supported this in many languages by default which meant intercepting
-	// third-party code to see what it does and to change how it does it is
-	// not possible.
-
-	c := context; // copy the current scope's context
-
-	context.user_index = 456;
-	{
-		context.allocator = my_custom_allocator();
-		context.user_index = 123;
-		what_a_fool_believes(); // the `context` for this scope is implicitly passed to `what_a_fool_believes`
-	}
-
-	// `context` value is local to the scope it is in
-	assert(context.user_index == 456);
-
-	what_a_fool_believes :: proc() {
-		c := context; // this `context` is the same as the parent procedure that it was called from
-		// From this example, context.user_index == 123
-		// An context.allocator is assigned to the return value of `my_custom_allocator()`
-		assert(context.user_index == 123);
-
-		// The memory management procedure use the `context.allocator` by
-		// default unless explicitly specified otherwise
-		china_grove := new(int);
-		free(china_grove);
-
-		_ = c;
-	}
-
-	my_custom_allocator :: mem.nil_allocator;
-	_ = c;
-
-	// By default, the context value has default values for its parameters which is
-	// decided in the package runtime. What the defaults are are compiler specific.
-
-	// To see what the implicit context value contains, please see the following
-	// definition in package runtime.
-}
-
-parametric_polymorphism :: proc() {
-	fmt.println("\n# parametric polymorphism");
-
-	print_value :: proc(value: $T) {
-		fmt.printf("print_value: %T %v\n", value, value);
-	}
-
-	v1: int    = 1;
-	v2: f32    = 2.1;
-	v3: f64    = 3.14;
-	v4: string = "message";
-
-	print_value(v1);
-	print_value(v2);
-	print_value(v3);
-	print_value(v4);
-
-	fmt.println();
-
-	add :: proc(p, q: $T) -> T {
-		x: T = p + q;
-		return x;
-	}
-
-	a := add(3, 4);
-	fmt.printf("a: %T = %v\n", a, a);
-
-	b := add(3.2, 4.3);
-	fmt.printf("b: %T = %v\n", b, b);
-
-	// This is how `new` is implemented
-	alloc_type :: proc($T: typeid) -> ^T {
-		t := cast(^T)alloc(size_of(T), align_of(T));
-		t^ = T{}; // Use default initialization value
-		return t;
-	}
-
-	copy_slice :: proc(dst, src: []$T) -> int {
-		n := min(len(dst), len(src));
-		if n > 0 {
-			mem.copy(&dst[0], &src[0], n*size_of(T));
-		}
-		return n;
-	}
-
-	double_params :: proc(a: $A, b: $B) -> A {
-		return a + A(b);
-	}
-
-	fmt.println(double_params(12, 1.345));
-
-
-
-	{ // Polymorphic Types and Type Specialization
-		Table_Slot :: struct(Key, Value: typeid) {
-			occupied: bool,
-			hash:     u32,
-			key:      Key,
-			value:    Value,
-		};
-		TABLE_SIZE_MIN :: 32;
-		Table :: struct(Key, Value: typeid) {
-			count:     int,
-			allocator: mem.Allocator,
-			slots:     []Table_Slot(Key, Value),
-		};
-
-		// Only allow types that are specializations of a (polymorphic) slice
-		make_slice :: proc($T: typeid/[]$E, len: int) -> T {
-			return make(T, len);
-		}
-
-		// Only allow types that are specializations of `Table`
-		allocate :: proc(table: ^$T/Table, capacity: int) {
-			c := context;
-			if table.allocator.procedure != nil do c.allocator = table.allocator;
-			context = c;
-
-			table.slots = make_slice(type_of(table.slots), max(capacity, TABLE_SIZE_MIN));
-		}
-
-		expand :: proc(table: ^$T/Table) {
-			c := context;
-			if table.allocator.procedure != nil do c.allocator = table.allocator;
-			context = c;
-
-			old_slots := table.slots;
-			defer delete(old_slots);
-
-			cap := max(2*len(table.slots), TABLE_SIZE_MIN);
-			allocate(table, cap);
-
-			for s in old_slots do if s.occupied {
-				put(table, s.key, s.value);
-			}
-		}
-
-		// Polymorphic determination of a polymorphic struct
-		// put :: proc(table: ^$T/Table, key: T.Key, value: T.Value) {
-		put :: proc(table: ^Table($Key, $Value), key: Key, value: Value) {
-			hash := get_hash(key); // Ad-hoc method which would fail in a different scope
-			index := find_index(table, key, hash);
-			if index < 0 {
-				if f64(table.count) >= 0.75*f64(len(table.slots)) {
-					expand(table);
-				}
-				assert(table.count <= len(table.slots));
-
-				index = int(hash % u32(len(table.slots)));
-
-				for table.slots[index].occupied {
-					if index += 1; index >= len(table.slots) {
-						index = 0;
-					}
-				}
-
-				table.count += 1;
-			}
-
-			slot := &table.slots[index];
-			slot.occupied = true;
-			slot.hash     = hash;
-			slot.key      = key;
-			slot.value    = value;
-		}
-
-
-		// find :: proc(table: ^$T/Table, key: T.Key) -> (T.Value, bool) {
-		find :: proc(table: ^Table($Key, $Value), key: Key) -> (Value, bool) {
-			hash := get_hash(key);
-			index := find_index(table, key, hash);
-			if index < 0 {
-				return Value{}, false;
-			}
-			return table.slots[index].value, true;
-		}
-
-		find_index :: proc(table: ^Table($Key, $Value), key: Key, hash: u32) -> int {
-			if len(table.slots) <= 0 do return -1;
-
-			index := int(hash % u32(len(table.slots)));
-			for table.slots[index].occupied {
-				if table.slots[index].hash == hash {
-					if table.slots[index].key == key {
-						return index;
-					}
-				}
-
-				if index += 1; index >= len(table.slots) {
-					index = 0;
-				}
-			}
-
-			return -1;
-		}
-
-		get_hash :: proc(s: string) -> u32 { // fnv32a
-			h: u32 = 0x811c9dc5;
-			for i in 0..<len(s) {
-				h = (h ~ u32(s[i])) * 0x01000193;
-			}
-			return h;
-		}
-
-
-		table: Table(string, int);
-
-		for i in 0..36 do put(&table, "Hellope", i);
-		for i in 0..42 do put(&table, "World!",  i);
-
-		found, _ := find(&table, "Hellope");
-		fmt.printf("`found` is %v\n", found);
-
-		found, _ = find(&table, "World!");
-		fmt.printf("`found` is %v\n", found);
-
-		// I would not personally design a hash table like this in production
-		// but this is a nice basic example
-		// A better approach would either use a `u64` or equivalent for the key
-		// and let the user specify the hashing function or make the user store
-		// the hashing procedure with the table
-	}
-
-	{ // Parametric polymorphic union
-		Error :: enum {
-			Foo0,
-			Foo1,
-			Foo2,
-			Foo3,
-		};
-		Para_Union :: union(T: typeid) {T, Error};
-		r: Para_Union(int);
-		fmt.println(typeid_of(type_of(r)));
-
-		fmt.println(r);
-		r = 123;
-		fmt.println(r);
-		r = Error.Foo0; // r = .Foo0; is allow too, see implicit selector expressions below
-		fmt.println(r);
-	}
-
-	{ // Polymorphic names
-		foo :: proc($N: $I, $T: typeid) -> (res: [N]T) {
-			// `N` is the constant value passed
-			// `I` is the type of N
-			// `T` is the type passed
-			fmt.printf("Generating an array of type %v from the value %v of type %v\n",
-					   typeid_of(type_of(res)), N, typeid_of(I));
-			for i in 0..<N {
-				res[i] = T(i*i);
-			}
-			return;
-		}
-
-		T :: int;
-		array := foo(4, T);
-		for v, i in array {
-			assert(v == T(i*i));
-		}
-
-		// Matrix multiplication
-		mul :: proc(a: [$M][$N]$T, b: [N][$P]T) -> (c: [M][P]T) {
-			for i in 0..<M {
-				for j in 0..<P {
-					for k in 0..<N {
-						c[i][j] += a[i][k] * b[k][j];
-					}
-				}
-			}
-			return;
-		}
-
-		x := [2][3]f32{
-			{1, 2, 3},
-			{3, 2, 1},
-		};
-		y := [3][2]f32{
-			{0, 8},
-			{6, 2},
-			{8, 4},
-		};
-		z := mul(x, y);
-		assert(z == {{36, 24}, {20, 32}});
-	}
-}
-
-
-prefix_table := [?]string{
-	"White",
-	"Red",
-	"Green",
-	"Blue",
-	"Octarine",
-	"Black",
-};
-
-threading_example :: proc() {
-	fmt.println("\n# threading_example");
-
-	{ // Basic Threads
-		fmt.println("\n## Basic Threads");
-			worker_proc :: proc(t: ^thread.Thread) {
-			for iteration in 1..5 {
-				fmt.printf("Thread %d is on iteration %d\n", t.user_index, iteration);
-				fmt.printf("`%s`: iteration %d\n", prefix_table[t.user_index], iteration);
-				time.sleep(1 * time.Millisecond);
-			}
-		}
-
-		threads := make([dynamic]^thread.Thread, 0, len(prefix_table));
-		defer delete(threads);
-
-		for in prefix_table {
-			if t := thread.create(worker_proc); t != nil {
-				t.init_context = context;
-				t.use_init_context = true;
-				t.user_index = len(threads);
-				append(&threads, t);
-				thread.start(t);
-			}
-		}
-
-		for len(threads) > 0 {
-			for i := 0; i < len(threads); /**/ {
-				if t := threads[i]; thread.is_done(t) {
-					fmt.printf("Thread %d is done\n", t.user_index);
-					thread.destroy(t);
-
-					ordered_remove(&threads, i);
-				} else {
-					i += 1;
-				}
-			}
-		}
-	}
-
-	{ // Thread Pool
-		fmt.println("\n## Thread Pool");
-		task_proc :: proc(t: ^thread.Task) {
-			index := t.user_index % len(prefix_table);
-			for iteration in 1..5 {
-				fmt.printf("Worker Task %d is on iteration %d\n", t.user_index, iteration);
-				fmt.printf("`%s`: iteration %d\n", prefix_table[index], iteration);
-				time.sleep(1 * time.Millisecond);
-			}
-		}
-
-		pool: thread.Pool;
-		thread.pool_init(pool=&pool, thread_count=3);
-		defer thread.pool_destroy(&pool);
-
-
-		for i in 0..<30 {
-			thread.pool_add_task(pool=&pool, procedure=task_proc, data=nil, user_index=i);
-		}
-
-		thread.pool_start(&pool);
-		thread.pool_wait_and_process(&pool);
-	}
-}
-
-
-array_programming :: proc() {
-	fmt.println("\n# array programming");
-	{
-		a := [3]f32{1, 2, 3};
-		b := [3]f32{5, 6, 7};
-		c := a * b;
-		d := a + b;
-		e := 1 +  (c - d) / 2;
-		fmt.printf("%.1f\n", e); // [0.5, 3.0, 6.5]
-	}
-
-	{
-		a := [3]f32{1, 2, 3};
-		b := swizzle(a, 2, 1, 0);
-		assert(b == [3]f32{3, 2, 1});
-
-		c := swizzle(a, 0, 0);
-		assert(c == [2]f32{1, 1});
-		assert(c == 1);
-	}
-
-	{
-		Vector3 :: distinct [3]f32;
-		a := Vector3{1, 2, 3};
-		b := Vector3{5, 6, 7};
-		c := (a * b)/2 + 1;
-		d := c.x + c.y + c.z;
-		fmt.printf("%.1f\n", d); // 22.0
-
-		cross :: proc(a, b: Vector3) -> Vector3 {
-			i := swizzle(a, 1, 2, 0) * swizzle(b, 2, 0, 1);
-			j := swizzle(a, 2, 0, 1) * swizzle(b, 1, 2, 0);
-			return i - j;
-		}
-
-		blah :: proc(a: Vector3) -> f32 {
-			return a.x + a.y + a.z;
-		}
-
-		x := cross(a, b);
-		fmt.println(x);
-		fmt.println(blah(x));
-	}
-}
-
-map_type :: proc() {
-	fmt.println("\n# map type");
-
-	m := make(map[string]int);
-	defer delete(m);
-
-	m["Bob"] = 2;
-	m["Ted"] = 5;
-	fmt.println(m["Bob"]);
-
-	delete_key(&m, "Ted");
-
-	// If an element of a key does not exist, the zero value of the
-	// element will be returned. To check to see if an element exists
-	// can be done in two ways:
-	elem, ok := m["Bob"];
-	exists := "Bob" in m;
-	_, _ = elem, ok;
-	_ = exists;
-}
-
-implicit_selector_expression :: proc() {
-	fmt.println("\n# implicit selector expression");
-
-	Foo :: enum {A, B, C};
-
-	f: Foo;
-	f = Foo.A;
-	f = .A;
-
-	BAR :: bit_set[Foo]{.B, .C};
-
-	switch f {
-	case .A:
-		fmt.println("HITHER");
-	case .B:
-		fmt.println("NEVER");
-	case .C:
-		fmt.println("FOREVER");
-	}
-
-	my_map := make(map[Foo]int);
-	defer delete(my_map);
-
-	my_map[.A] = 123;
-	my_map[Foo.B] = 345;
-
-	fmt.println(my_map[.A] + my_map[Foo.B] + my_map[.C]);
-}
-
-
-partial_switch :: proc() {
-	fmt.println("\n# partial_switch");
-	{ // enum
-		Foo :: enum {
-			A,
-			B,
-			C,
-			D,
-		};
-
-		f := Foo.A;
-		switch f {
-		case .A: fmt.println("A");
-		case .B: fmt.println("B");
-		case .C: fmt.println("C");
-		case .D: fmt.println("D");
-		case:    fmt.println("?");
-		}
-
-		#partial switch f {
-		case .A: fmt.println("A");
-		case .D: fmt.println("D");
-		}
-	}
-	{ // union
-		Foo :: union {int, bool};
-		f: Foo = 123;
-		switch in f {
-		case int:  fmt.println("int");
-		case bool: fmt.println("bool");
-		case:
-		}
-
-		#partial switch in f {
-		case bool: fmt.println("bool");
-		}
-	}
-}
-
-cstring_example :: proc() {
-	fmt.println("\n# cstring_example");
-
-	W :: "Hellope";
-	X :: cstring(W);
-	Y :: string(X);
-
-	w := W;
-	_ = w;
-	x: cstring = X;
-	y: string = Y;
-	z := string(x);
-	fmt.println(x, y, z);
-	fmt.println(len(x), len(y), len(z));
-	fmt.println(len(W), len(X), len(Y));
-	// IMPORTANT NOTE for cstring variables
-	// len(cstring) is O(N)
-	// cast(string)cstring is O(N)
-}
-
-bit_set_type :: proc() {
-	fmt.println("\n# bit_set type");
-
-	{
-		using Day :: enum {
-			Sunday,
-			Monday,
-			Tuesday,
-			Wednesday,
-			Thursday,
-			Friday,
-			Saturday,
-		};
-
-		Days :: distinct bit_set[Day];
-		WEEKEND :: Days{Sunday, Saturday};
-
-		d: Days;
-		d = {Sunday, Monday};
-		e := d | WEEKEND;
-		e |= {Monday};
-		fmt.println(d, e);
-
-		ok := Saturday in e; // `in` is only allowed for `map` and `bit_set` types
-		fmt.println(ok);
-		if Saturday in e {
-			fmt.println("Saturday in", e);
-		}
-		X :: Saturday in WEEKEND; // Constant evaluation
-		fmt.println(X);
-		fmt.println("Cardinality:", card(e));
-	}
-	{
-		x: bit_set['A'..'Z'];
-		#assert(size_of(x) == size_of(u32));
-		y: bit_set[0..8; u16];
-		fmt.println(typeid_of(type_of(x))); // bit_set[A..Z]
-		fmt.println(typeid_of(type_of(y))); // bit_set[0..8; u16]
-
-		incl(&x, 'F');
-		assert('F' in x);
-		excl(&x, 'F');
-		assert('F' not_in x);
-
-		y |= {1, 4, 2};
-		assert(2 in y);
-	}
-	{
-		Letters :: bit_set['A'..'Z'];
-		a := Letters{'A', 'B'};
-		b := Letters{'A', 'B', 'C', 'D', 'F'};
-		c := Letters{'A', 'B'};
-
-		assert(a <= b); // 'a' is a subset of 'b'
-		assert(b >= a); // 'b' is a superset of 'a'
-		assert(a < b);  // 'a' is a strict subset of 'b'
-		assert(b > a);  // 'b' is a strict superset of 'a'
-
-		assert(!(a < c)); // 'a' is a not strict subset of 'c'
-		assert(!(c > a)); // 'c' is a not strict superset of 'a'
-	}
-}
-
-deferred_procedure_associations :: proc() {
-	fmt.println("\n# deferred procedure associations");
-
-	@(deferred_out=closure)
-	open :: proc(s: string) -> bool {
-		fmt.println(s);
-		return true;
-	}
-
-	closure :: proc(ok: bool) {
-		fmt.println("Goodbye?", ok);
-	}
-
-	if open("Welcome") {
-		fmt.println("Something in the middle, mate.");
-	}
-}
-
-reflection :: proc() {
-	fmt.println("\n# reflection");
-
-	Foo :: struct {
-		x: int    `tag1`,
-		y: string `json:"y_field"`,
-		z: bool, // no tag
-	};
-
-	id := typeid_of(Foo);
-	names := reflect.struct_field_names(id);
-	types := reflect.struct_field_types(id);
-	tags  := reflect.struct_field_tags(id);
-
-	assert(len(names) == len(types) && len(names) == len(tags));
-
-	fmt.println("Foo :: struct {");
-	for tag, i in tags {
-		name, type := names[i], types[i];
-		if tag != "" {
-			fmt.printf("\t%s: %T `%s`,\n", name, type, tag);
-		} else {
-			fmt.printf("\t%s: %T,\n", name, type);
-		}
-	}
-	fmt.println("}");
-
-
-	for tag, i in tags {
-		if val, ok := reflect.struct_tag_lookup(tag, "json"); ok {
-			fmt.printf("json: %s -> %s\n", names[i], val);
-		}
-	}
-}
-
-quaternions :: proc() {
-	// Not just an April Fool's Joke any more, but a fully working thing!
-	fmt.println("\n# quaternions");
-
-	{ // Quaternion operations
-		q := 1 + 2i + 3j + 4k;
-		r := quaternion(5, 6, 7, 8);
-		t := q * r;
-		fmt.printf("(%v) * (%v) = %v\n", q, r, t);
-		v := q / r;
-		fmt.printf("(%v) / (%v) = %v\n", q, r, v);
-		u := q + r;
-		fmt.printf("(%v) + (%v) = %v\n", q, r, u);
-		s := q - r;
-		fmt.printf("(%v) - (%v) = %v\n", q, r, s);
-	}
-	{ // The quaternion types
-		q128: quaternion128; // 4xf32
-		q256: quaternion256; // 4xf64
-		q128 = quaternion(1, 0, 0, 0);
-		q256 = 1; // quaternion(1, 0, 0, 0);
-	}
-	{ // Built-in procedures
-		q := 1 + 2i + 3j + 4k;
-		fmt.println("q =", q);
-		fmt.println("real(q) =", real(q));
-		fmt.println("imag(q) =", imag(q));
-		fmt.println("jmag(q) =", jmag(q));
-		fmt.println("kmag(q) =", kmag(q));
-		fmt.println("conj(q) =", conj(q));
-		fmt.println("abs(q)  =", abs(q));
-	}
-	{ // Conversion of a complex type to a quaternion type
-		c := 1 + 2i;
-		q := quaternion256(c);
-		fmt.println(c);
-		fmt.println(q);
-	}
-	{ // Memory layout of Quaternions
-		q := 1 + 2i + 3j + 4k;
-		a := transmute([4]f64)q;
-		fmt.println("Quaternion memory layout: xyzw/(ijkr)");
-		fmt.println(q); // 1.000+2.000i+3.000j+4.000k
-		fmt.println(a); // [2.000, 3.000, 4.000, 1.000]
-	}
-}
-
-inline_for_statement :: proc() {
-	fmt.println("\n#inline for statements");
-
-	// 'inline for' works the same as if the 'inline' prefix did not
-	// exist but these ranged loops are explicitly unrolled which can
-	// be very very useful for certain optimizations
-
-	fmt.println("Ranges");
-	inline for x, i in 1..<4 {
-		fmt.println(x, i);
-	}
-
-	fmt.println("Strings");
-	inline for r, i in "Hello, 世界" {
-		fmt.println(r, i);
-	}
-
-	fmt.println("Arrays");
-	inline for elem, idx in ([4]int{1, 4, 9, 16}) {
-		fmt.println(elem, idx);
-	}
-
-
-	Foo_Enum :: enum {
-		A = 1,
-		B,
-		C = 6,
-		D,
-	};
-	fmt.println("Enum types");
-	inline for elem, idx in Foo_Enum {
-		fmt.println(elem, idx);
-	}
-}
-
-where_clauses :: proc() {
-	fmt.println("\n#procedure 'where' clauses");
-
-	{ // Sanity checks
-		simple_sanity_check :: proc(x: [2]int)
-			where len(x) > 1,
-				  type_of(x) == [2]int {
-			fmt.println(x);
-		}
-	}
-	{ // Parametric polymorphism checks
-		cross_2d :: proc(a, b: $T/[2]$E) -> E
-			where intrinsics.type_is_numeric(E) {
-			return a.x*b.y - a.y*b.x;
-		}
-		cross_3d :: proc(a, b: $T/[3]$E) -> T
-			where intrinsics.type_is_numeric(E) {
-			x := a.y*b.z - a.z*b.y;
-			y := a.z*b.x - a.x*b.z;
-			z := a.x*b.y - a.y*b.z;
-			return T{x, y, z};
-		}
-
-		a := [2]int{1, 2};
-		b := [2]int{5, -3};
-		fmt.println(cross_2d(a, b));
-
-		x := [3]f32{1, 4, 9};
-		y := [3]f32{-5, 0, 3};
-		fmt.println(cross_3d(x, y));
-
-		// Failure case
-		// i := [2]bool{true, false};
-		// j := [2]bool{false, true};
-		// fmt.println(cross_2d(i, j));
-
-	}
-
-	{ // Procedure groups usage
-		foo :: proc(x: [$N]int) -> bool
-			where N > 2 {
-			fmt.println(#procedure, "was called with the parameter", x);
-			return true;
-		}
-
-		bar :: proc(x: [$N]int) -> bool
-			where 0 < N,
-				  N <= 2 {
-			fmt.println(#procedure, "was called with the parameter", x);
-			return false;
-		}
-
-		baz :: proc{foo, bar};
-
-		x := [3]int{1, 2, 3};
-		y := [2]int{4, 9};
-		ok_x := baz(x);
-		ok_y := baz(y);
-		assert(ok_x == true);
-		assert(ok_y == false);
-	}
-
-	{ // Record types
-		Foo :: struct(T: typeid, N: int)
-			where intrinsics.type_is_integer(T),
-				  N > 2 {
-			x: [N]T,
-			y: [N-2]T,
-		};
-
-		T :: i32;
-		N :: 5;
-		f: Foo(T, N);
-		#assert(size_of(f) == (N+N-2)*size_of(T));
-	}
-}
-
-
-when ODIN_OS == "windows" do foreign import kernel32 "system:kernel32.lib"
-
-foreign_system :: proc() {
-	fmt.println("\n#foreign system");
-	when ODIN_OS == "windows" {
-		// It is sometimes necessarily to interface with foreign code,
-		// such as a C library. In Odin, this is achieved through the
-		// foreign system. You can “import” a library into the code
-		// using the same semantics as a normal import declaration.
-
-		// This foreign import declaration will create a
-		// “foreign import name” which can then be used to associate
-		// entities within a foreign block.
-
-		foreign kernel32 {
-			ExitProcess :: proc "stdcall" (exit_code: u32) ---
-		}
-
-		// Foreign procedure declarations have the cdecl/c calling
-		// convention by default unless specified otherwise. Due to
-		// foreign procedures do not have a body declared within this
-		// code, you need append the --- symbol to the end to distinguish
-		// it as a procedure literal without a body and not a procedure type.
-
-		// The attributes system can be used to change specific properties
-		// of entities declared within a block:
-
-		@(default_calling_convention = "std")
-		foreign kernel32 {
-			@(link_name="GetLastError") get_last_error :: proc() -> i32 ---
-		}
-
-		// Example using the link_prefix attribute
-		@(default_calling_convention = "std")
-		@(link_prefix = "Get")
-		foreign kernel32 {
-			LastError :: proc() -> i32 ---
-		}
-	}
-}
-
-ranged_fields_for_array_compound_literals :: proc() {
-	fmt.println("\n#ranged fields for array compound literals");
-	{ // Normal Array Literal
-		foo := [?]int{1, 4, 9, 16};
-		fmt.println(foo);
-	}
-	{ // Indexed
-		foo := [?]int{
-			3 = 16,
-			1 = 4,
-			2 = 9,
-			0 = 1,
-		};
-		fmt.println(foo);
-	}
-	{ // Ranges
-		i := 2;
-		foo := [?]int {
-			0 = 123,
-			5..9 = 54,
-			10..<16 = i*3 + (i-1)*2,
-		};
-		#assert(len(foo) == 16);
-		fmt.println(foo); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
-	}
-	{ // Slice and Dynamic Array support
-		i := 2;
-		foo_slice := []int {
-			0 = 123,
-			5..9 = 54,
-			10..<16 = i*3 + (i-1)*2,
-		};
-		assert(len(foo_slice) == 16);
-		fmt.println(foo_slice); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
-
-		foo_dynamic_array := [dynamic]int {
-			0 = 123,
-			5..9 = 54,
-			10..<16 = i*3 + (i-1)*2,
-		};
-		assert(len(foo_dynamic_array) == 16);
-		fmt.println(foo_dynamic_array); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
-	}
-}
-
-deprecated_attribute :: proc() {
-	@(deprecated="Use foo_v2 instead")
-	foo_v1 :: proc(x: int) {
-		fmt.println("foo_v1");
-	}
-	foo_v2 :: proc(x: int) {
-		fmt.println("foo_v2");
-	}
-
-	// NOTE: Uncomment to see the warning messages
-	// foo_v1(1);
-}
-
-range_statements_with_multiple_return_values :: proc() {
-	// IMPORTANT NOTE(bill, 2019-11-02): This feature is subject to be changed/removed
-	fmt.println("\n#range statements with multiple return values");
-	My_Iterator :: struct {
-		index: int,
-		data:  []i32,
-	};
-	make_my_iterator :: proc(data: []i32) -> My_Iterator {
-		return My_Iterator{data = data};
-	}
-	my_iterator :: proc(it: ^My_Iterator) -> (val: i32, idx: int, cond: bool) {
-		if cond = it.index < len(it.data); cond {
-			val = it.data[it.index];
-			idx = it.index;
-			it.index += 1;
-		}
-		return;
-	}
-
-	data := make([]i32, 6);
-	for _, i in data {
-		data[i] = i32(i*i);
-	}
-
-	{
-		it := make_my_iterator(data);
-		for val in my_iterator(&it) {
-			fmt.println(val);
-		}
-	}
-	{
-		it := make_my_iterator(data);
-		for val, idx in my_iterator(&it) {
-			fmt.println(val, idx);
-		}
-	}
-	{
-		it := make_my_iterator(data);
-		for {
-			val, _, cond := my_iterator(&it);
-			if !cond do break;
-			fmt.println(val);
-		}
-	}
-}
-
-
-soa_struct_layout :: proc() {
-	// IMPORTANT NOTE(bill, 2019-11-03): This feature is subject to be changed/removed
-	// NOTE(bill): Most likely #soa [N]T
-	fmt.println("\n#SOA Struct Layout");
-
-	{
-		Vector3 :: struct {x, y, z: f32};
-
-		N :: 2;
-		v_aos: [N]Vector3;
-		v_aos[0].x = 1;
-		v_aos[0].y = 4;
-		v_aos[0].z = 9;
-
-		fmt.println(len(v_aos));
-		fmt.println(v_aos[0]);
-		fmt.println(v_aos[0].x);
-		fmt.println(&v_aos[0].x);
-
-		v_aos[1] = {0, 3, 4};
-		v_aos[1].x = 2;
-		fmt.println(v_aos[1]);
-		fmt.println(v_aos);
-
-		v_soa: #soa[N]Vector3;
-
-		v_soa[0].x = 1;
-		v_soa[0].y = 4;
-		v_soa[0].z = 9;
-
-
-		// Same syntax as AOS and treat as if it was an array
-		fmt.println(len(v_soa));
-		fmt.println(v_soa[0]);
-		fmt.println(v_soa[0].x);
-		fmt.println(&v_soa[0].x);
-		v_soa[1] = {0, 3, 4};
-		v_soa[1].x = 2;
-		fmt.println(v_soa[1]);
-
-		// Can use SOA syntax if necessary
-		v_soa.x[0] = 1;
-		v_soa.y[0] = 4;
-		v_soa.z[0] = 9;
-		fmt.println(v_soa.x[0]);
-
-		// Same pointer addresses with both syntaxes
-		assert(&v_soa[0].x == &v_soa.x[0]);
-
-
-		// Same fmt printing
-		fmt.println(v_aos);
-		fmt.println(v_soa);
-	}
-	{
-		// Works with arrays of length <= 4 which have the implicit fields xyzw/rgba
-		Vector3 :: distinct [3]f32;
-
-		N :: 2;
-		v_aos: [N]Vector3;
-		v_aos[0].x = 1;
-		v_aos[0].y = 4;
-		v_aos[0].z = 9;
-
-		v_soa: #soa[N]Vector3;
-
-		v_soa[0].x = 1;
-		v_soa[0].y = 4;
-		v_soa[0].z = 9;
-	}
-	{
-		// SOA Slices
-		// Vector3 :: struct {x, y, z: f32};
-		Vector3 :: struct {x: i8, y: i16, z: f32};
-
-		N :: 3;
-		v: #soa[N]Vector3;
-		v[0].x = 1;
-		v[0].y = 4;
-		v[0].z = 9;
-
-		s: #soa[]Vector3;
-		s = v[:];
-		assert(len(s) == N);
-		fmt.println(s);
-		fmt.println(s[0].x);
-
-		a := s[1:2];
-		assert(len(a) == 1);
-		fmt.println(a);
-
-		d: #soa[dynamic]Vector3;
-
-		append_soa(&d, Vector3{1, 2, 3}, Vector3{4, 5, 9}, Vector3{-4, -4, 3});
-		fmt.println(d);
-		fmt.println(len(d));
-		fmt.println(cap(d));
-		fmt.println(d[:]);
-	}
-}
-
-constant_literal_expressions :: proc() {
-	fmt.println("\n#constant literal expressions");
-
-	Bar :: struct {x, y: f32};
-	Foo :: struct {a, b: int, using c: Bar};
-
-	FOO_CONST :: Foo{b = 2, a = 1, c = {3, 4}};
-
-
-	fmt.println(FOO_CONST.a);
-	fmt.println(FOO_CONST.b);
-	fmt.println(FOO_CONST.c);
-	fmt.println(FOO_CONST.c.x);
-	fmt.println(FOO_CONST.c.y);
-	fmt.println(FOO_CONST.x); // using works as expected
-	fmt.println(FOO_CONST.y);
-
-	fmt.println("-------");
-
-	ARRAY_CONST :: [3]int{1 = 4, 2 = 9, 0 = 1};
-
-	fmt.println(ARRAY_CONST[0]);
-	fmt.println(ARRAY_CONST[1]);
-	fmt.println(ARRAY_CONST[2]);
-
-	fmt.println("-------");
-
-	FOO_ARRAY_DEFAULTS :: [3]Foo{{}, {}, {}};
-	fmt.println(FOO_ARRAY_DEFAULTS[2].x);
-
-	fmt.println("-------");
-
-	Baz :: enum{A=5, B, C, D};
-	ENUM_ARRAY_CONST :: [Baz]int{.A .. .C = 1, .D = 16};
-
-	fmt.println(ENUM_ARRAY_CONST[.A]);
-	fmt.println(ENUM_ARRAY_CONST[.B]);
-	fmt.println(ENUM_ARRAY_CONST[.C]);
-	fmt.println(ENUM_ARRAY_CONST[.D]);
-
-	fmt.println("-------");
-
-	Partial_Baz :: enum{A=5, B, C, D=16};
-	#assert(len(Partial_Baz) < len(#partial [Partial_Baz]int));
-	PARTIAL_ENUM_ARRAY_CONST :: #partial [Partial_Baz]int{.A .. .C = 1, .D = 16};
-
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.A]);
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.B]);
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.C]);
-	fmt.println(PARTIAL_ENUM_ARRAY_CONST[.D]);
-
-	fmt.println("-------");
-
-
-	STRING_CONST :: "Hellope!";
-
-	fmt.println(STRING_CONST[0]);
-	fmt.println(STRING_CONST[2]);
-	fmt.println(STRING_CONST[3]);
-
-	fmt.println(STRING_CONST[0:5]);
-	fmt.println(STRING_CONST[3:][:4]);
-}
-
-union_maybe :: proc() {
-	fmt.println("\n#union #maybe");
-
-	Maybe :: union(T: typeid) #maybe {T};
-
-	i: Maybe(u8);
-	p: Maybe(^u8); // No tag is stored for pointers, nil is the sentinel value
-
-	#assert(size_of(i) == size_of(u8) + size_of(u8));
-	#assert(size_of(p) == size_of(^u8));
-
-	i = 123;
-	x := i.?;
-	y, y_ok := p.?;
-	p = &x;
-	z, z_ok := p.?;
-
-	fmt.println(i, p);
-	fmt.println(x, &x);
-	fmt.println(y, y_ok);
-	fmt.println(z, z_ok);
-}
-
-dummy_procedure :: proc() {
-	fmt.println("dummy_procedure");
-}
-
-explicit_context_definition :: proc "c" () {
-	// Try commenting the following statement out below
-	context = runtime.default_context();
-
-	fmt.println("\n#explicit context definition");
-	dummy_procedure();
-}
-
-relative_data_types :: proc() {
-	fmt.println("\n#relative data types");
-
-	x: int = 123;
-	ptr: #relative(i16) ^int;
-	ptr = &x;
-	fmt.println(ptr^);
-
-	arr := [3]int{1, 2, 3};
-	s := arr[:];
-	rel_slice: #relative(i16) []int;
-	rel_slice = s;
-	fmt.println(rel_slice);
-	fmt.println(rel_slice[:]);
-	fmt.println(rel_slice[1]);
+test1 :: proc(f: Foo, x: int) -> bool {
+	fmt.println(#procedure, x);
+	return false;
 }
 
 main :: proc() {
-	when true {
-		the_basics();
-		control_flow();
-		named_proc_return_parameters();
-		explicit_procedure_overloading();
-		struct_type();
-		union_type();
-		using_statement();
-		implicit_context_system();
-		parametric_polymorphism();
-		array_programming();
-		map_type();
-		implicit_selector_expression();
-		partial_switch();
-		cstring_example();
-		bit_set_type();
-		deferred_procedure_associations();
-		reflection();
-		quaternions();
-		inline_for_statement();
-		where_clauses();
-		foreign_system();
-		ranged_fields_for_array_compound_literals();
-		deprecated_attribute();
-		range_statements_with_multiple_return_values();
-		threading_example();
-		soa_struct_layout();
-		constant_literal_expressions();
-		union_maybe();
-		explicit_context_definition();
-		relative_data_types();
-	}
+	f := &Foo{
+		call0 = test0,
+		call1 = test1,
+	};
+
+	f->call0(123); // f.call0(f,  123);
+	f->call1(456); // f.call1(f^, 456);
+	f->call0(x=456); // f.call0(f=f, x=456);
+
+	v := Foo{
+		call0 = test0,
+		call1 = test1,
+	};
+
+	v->call0(123); // v.call0(&v, 123);
+	v->call1(456); // v.call1(v,  456);
+	v->call1(x=456); // f.call1(f=v, x=456);
 }
diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 8def4d6ed..b19976de7 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -6525,7 +6525,7 @@ bool evaluate_where_clauses(CheckerContext *ctx, Ast *call_expr, Scope *scope, A
 }
 
 
-CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type *proc_type, Ast *call) {
+CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type *proc_type, Ast *call, Array<Ast *> const &args) {
 	ast_node(ce, CallExpr, call);
 
 	CallArgumentCheckerType *call_checker = check_call_arguments_internal;
@@ -6537,13 +6537,13 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type
 	if (is_call_expr_field_value(ce)) {
 		call_checker = check_named_call_arguments;
 
-		operands = array_make<Operand>(heap_allocator(), ce->args.count);
+		operands = array_make<Operand>(heap_allocator(), args.count);
 
 		// NOTE(bill): This is give type hints for the named parameters
 		// in order to improve the type inference system
 
 		StringMap<Type *> type_hint_map = {}; // Key: String
-		string_map_init(&type_hint_map, heap_allocator(), 2*ce->args.count);
+		string_map_init(&type_hint_map, heap_allocator(), 2*args.count);
 		defer (string_map_destroy(&type_hint_map));
 
 		Type *ptype = nullptr;
@@ -6620,8 +6620,8 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type
 		}
 
 
-		for_array(i, ce->args) {
-			Ast *arg = ce->args[i];
+		for_array(i, args) {
+			Ast *arg = args[i];
 			ast_node(fv, FieldValue, arg);
 			Ast *field = fv->field;
 
@@ -6637,7 +6637,7 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type
 			check_expr_or_type(c, &operands[i], fv->value, type_hint);
 		}
 	} else {
-		operands = array_make<Operand>(heap_allocator(), 0, 2*ce->args.count);
+		operands = array_make<Operand>(heap_allocator(), 0, 2*args.count);
 		Entity **lhs = nullptr;
 		isize lhs_count = -1;
 		bool is_variadic = false;
@@ -6645,7 +6645,7 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type
 			lhs = populate_proc_parameter_list(c, proc_type, &lhs_count, &is_variadic);
 		}
 		if (operand->mode != Addressing_ProcGroup) {
-			check_unpack_arguments(c, lhs, lhs_count, &operands, ce->args, false, is_variadic);
+			check_unpack_arguments(c, lhs, lhs_count, &operands, args, false, is_variadic);
 		}
 	}
 
@@ -6667,7 +6667,7 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type
 			isize lhs_count = -1;
 			bool is_variadic = false;
 			lhs = populate_proc_parameter_list(c, e->type, &lhs_count, &is_variadic);
-			check_unpack_arguments(c, lhs, lhs_count, &operands, ce->args, false, is_variadic);
+			check_unpack_arguments(c, lhs, lhs_count, &operands, args, false, is_variadic);
 
 
 			CallArgumentData data = {};
@@ -6740,7 +6740,7 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type
 		}
 
 
-		check_unpack_arguments(c, lhs, lhs_count, &operands, ce->args, false, false);
+		check_unpack_arguments(c, lhs, lhs_count, &operands, args, false, false);
 
 		if (lhs != nullptr) {
 			gb_free(heap_allocator(), lhs);
@@ -7269,33 +7269,36 @@ CallArgumentError check_polymorphic_record_type(CheckerContext *c, Operand *oper
 
 
 
-ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Type *type_hint) {
-	ast_node(ce, CallExpr, call);
-	if (ce->proc != nullptr &&
-	    ce->proc->kind == Ast_BasicDirective) {
-		ast_node(bd, BasicDirective, ce->proc);
+ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Ast *proc, Array<Ast *> const &args, ProcInlining inlining, Type *type_hint) {
+	if (proc != nullptr &&
+	    proc->kind == Ast_BasicDirective) {
+		ast_node(bd, BasicDirective, proc);
 		String name = bd->name;
 		if (name == "location" || name == "assert" || name == "panic" || name == "defined" || name == "config" || name == "load") {
 			operand->mode = Addressing_Builtin;
 			operand->builtin_id = BuiltinProc_DIRECTIVE;
-			operand->expr = ce->proc;
+			operand->expr = proc;
 			operand->type = t_invalid;
-			add_type_and_value(&c->checker->info, ce->proc, operand->mode, operand->type, operand->value);
+			add_type_and_value(&c->checker->info, proc, operand->mode, operand->type, operand->value);
 		} else {
 			GB_PANIC("Unhandled #%.*s", LIT(name));
 		}
-		if (ce->inlining != ProcInlining_none) {
+		if (inlining != ProcInlining_none) {
 			error(call, "Inlining operators are not allowed on built-in procedures");
 		}
 	} else {
-		check_expr_or_type(c, operand, ce->proc);
+		if (proc != nullptr) {
+			check_expr_or_type(c, operand, proc);
+		} else {
+			GB_ASSERT(operand->expr != nullptr);
+		}
 	}
 
-	if (ce->args.count > 0) {
+	if (args.count > 0) {
 		bool fail = false;
-		bool first_is_field_value = (ce->args[0]->kind == Ast_FieldValue);
-		for_array(i, ce->args) {
-			Ast *arg = ce->args[i];
+		bool first_is_field_value = (args[0]->kind == Ast_FieldValue);
+		for_array(i, args) {
+			Ast *arg = args[i];
 			bool mix = false;
 			if (first_is_field_value) {
 				mix = arg->kind != Ast_FieldValue;
@@ -7316,8 +7319,8 @@ ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Type *t
 	}
 
 	if (operand->mode == Addressing_Invalid) {
-		for_array(i, ce->args) {
-			Ast *arg = ce->args[i];
+		for_array(i, args) {
+			Ast *arg = args[i];
 			if (arg->kind == Ast_FieldValue) {
 				arg = arg->FieldValue.value;
 			}
@@ -7352,12 +7355,12 @@ ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Type *t
 			defer (gb_string_free(str));
 
 			operand->mode = Addressing_Invalid;
-			isize arg_count = ce->args.count;
+			isize arg_count = args.count;
 			switch (arg_count) {
 			case 0:  error(call, "Missing argument in conversion to '%s'", str);   break;
 			default: error(call, "Too many arguments in conversion to '%s'", str); break;
 			case 1: {
-				Ast *arg = ce->args[0];
+				Ast *arg = args[0];
 				if (arg->kind == Ast_FieldValue) {
 					error(call, "'field = value' cannot be used in a type conversion");
 					arg = arg->FieldValue.value;
@@ -7412,7 +7415,7 @@ ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Type *t
 		}
 	}
 
-	CallArgumentData data = check_call_arguments(c, operand, proc_type, call);
+	CallArgumentData data = check_call_arguments(c, operand, proc_type, call, args);
 	Type *result_type = data.result_type;
 	gb_zero_item(operand);
 	operand->expr = call;
@@ -7460,15 +7463,17 @@ ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Type *t
 		}
 	}
 
-	switch (ce->inlining) {
+	switch (inlining) {
 		case ProcInlining_inline: {
-			Entity *e = entity_from_expr(ce->proc);
-			if (e != nullptr && e->kind == Entity_Procedure) {
-				DeclInfo *decl = e->decl_info;
-				if (decl->proc_lit) {
-					ast_node(pl, ProcLit, decl->proc_lit);
-					if (pl->inlining == ProcInlining_no_inline) {
-						error(call, "'inline' cannot be applied to a procedure that has be marked as 'no_inline'");
+			if (proc != nullptr) {
+				Entity *e = entity_from_expr(proc);
+				if (e != nullptr && e->kind == Entity_Procedure) {
+					DeclInfo *decl = e->decl_info;
+					if (decl->proc_lit) {
+						ast_node(pl, ProcLit, decl->proc_lit);
+						if (pl->inlining == ProcInlining_no_inline) {
+							error(call, "'inline' cannot be applied to a procedure that has be marked as 'no_inline'");
+						}
 					}
 				}
 			}
@@ -9097,6 +9102,117 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type
 		node->viral_state_flags |= se->expr->viral_state_flags;
 	case_end;
 
+	case_ast_node(se, SelectorCallExpr, node);
+		// IMPORTANT NOTE(bill, 2020-05-22): This is a complete hack to get a shorthand which is extremely useful for vtables
+		// COM APIs is a great example of where this kind of thing is extremely useful
+		// General idea:
+		//
+		//     x->y(123)  ==  x.y(x, 123)
+		//
+		// How this has been implemented at the moment is quite hacky but it's done so to reduce need for huge backend changes
+		// Just regenerating a new AST aids things
+		//
+		// TODO(bill): Is this a good hack or not?
+		//
+		// NOTE(bill, 2020-05-22): I'm going to regret this decision, ain't I?
+
+		Operand x = {};
+		ExprKind kind = check_expr_base(c, &x, se->expr, nullptr);
+		if (x.mode == Addressing_Invalid || x.type == t_invalid) {
+			o->mode = Addressing_Invalid;
+			o->type = t_invalid;
+			o->expr = node;
+			return kind;
+		}
+		if (!is_type_proc(x.type)) {
+			gbString type_str = type_to_string(x.type);
+			error(se->call, "Selector call expressions expect a procedure type for the call, got '%s'", type_str);
+			gb_string_free(type_str);
+
+			o->mode = Addressing_Invalid;
+			o->type = t_invalid;
+			o->expr = node;
+			return Expr_Stmt;
+		}
+
+		ast_node(ce, CallExpr, se->call);
+
+		GB_ASSERT(x.expr->kind == Ast_SelectorExpr);
+
+		Ast *first_arg = x.expr->SelectorExpr.expr;
+		GB_ASSERT(first_arg != nullptr);
+
+		Type *pt = base_type(x.type);
+		GB_ASSERT(pt->kind == Type_Proc);
+		Type *first_type = nullptr;
+		String first_arg_name = {};
+		if (pt->Proc.param_count > 0) {
+			Entity *f = pt->Proc.params->Tuple.variables[0];
+			first_type = f->type;
+			first_arg_name = f->token.string;
+		}
+		if (first_arg_name.len == 0) {
+			first_arg_name = str_lit("_");
+		}
+
+		Operand y = {};
+		y.mode = first_arg->tav.mode;
+		y.type = first_arg->tav.type;
+		y.value = first_arg->tav.value;
+		if (check_is_assignable_to(c, &y, first_type)) {
+			// Do nothing, it's valid
+		} else {
+			Operand z = y;
+			z.type = type_deref(y.type);
+			if (check_is_assignable_to(c, &z, first_type)) {
+				// NOTE(bill): AST GENERATION HACK!
+				Token op = {Token_Pointer};
+				first_arg = ast_deref_expr(first_arg->file, first_arg, op);
+			} else if (y.mode == Addressing_Variable) {
+				Operand w = y;
+				w.type = alloc_type_pointer(y.type);
+				if (check_is_assignable_to(c, &w, first_type)) {
+					// NOTE(bill): AST GENERATION HACK!
+					Token op = {Token_And};
+					first_arg = ast_unary_expr(first_arg->file, op, first_arg);
+				}
+			}
+		}
+
+		if (ce->args.count > 0) {
+			bool fail = false;
+			bool first_is_field_value = (ce->args[0]->kind == Ast_FieldValue);
+			for_array(i, ce->args) {
+				Ast *arg = ce->args[i];
+				bool mix = false;
+				if (first_is_field_value) {
+					mix = arg->kind != Ast_FieldValue;
+				} else {
+					mix = arg->kind == Ast_FieldValue;
+				}
+				if (mix) {
+					fail = true;
+					break;
+				}
+			}
+			if (!fail && first_is_field_value) {
+				Token op = {Token_Eq};
+				AstFile *f = first_arg->file;
+				first_arg = ast_field_value(f, ast_ident(f, make_token_ident(first_arg_name)), first_arg, op);
+			}
+		}
+
+
+
+		auto modified_args = array_make<Ast *>(heap_allocator(), ce->args.count+1);
+		modified_args[0] = first_arg;
+		array_copy(&modified_args, ce->args, 1);
+		ce->args = modified_args;
+		se->modified_call = true;
+
+		check_expr_with_type_hint(c, o, se->call, type_hint);
+	case_end;
+
 
 	case_ast_node(ise, ImplicitSelectorExpr, node);
 		o->type = t_invalid;
@@ -9487,7 +9603,7 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type
 
 
 	case_ast_node(ce, CallExpr, node);
-		return check_call_expr(c, o, node, type_hint);
+		return check_call_expr(c, o, node, ce->proc, ce->args, ce->inlining, type_hint);
 	case_end;
 
 	case_ast_node(de, DerefExpr, node);
@@ -9758,7 +9874,7 @@ gbString write_expr_to_string(gbString str, Ast *node) {
 
 	case_ast_node(se, SelectorExpr, node);
 		str = write_expr_to_string(str, se->expr);
-		str = gb_string_append_rune(str, '.');
+		str = string_append_token(str, se->token);
 		str = write_expr_to_string(str, se->selector);
 	case_end;
 
@@ -9767,6 +9883,21 @@ gbString write_expr_to_string(gbString str, Ast *node) {
 		str = write_expr_to_string(str, se->selector);
 	case_end;
 
+	case_ast_node(se, SelectorCallExpr, node);
+		str = write_expr_to_string(str, se->expr);
+		str = gb_string_appendc(str, "(");
+		ast_node(ce, CallExpr, se->call);
+		isize start = se->modified_call ? 1 : 0;
+		for (isize i = start; i < ce->args.count; i++) {
+			Ast *arg = ce->args[i];
+			if (i > start) {
+				str = gb_string_appendc(str, ", ");
+			}
+			str = write_expr_to_string(str, arg);
+		}
+		str = gb_string_appendc(str, ")");
+	case_end;
+
 	case_ast_node(ta, TypeAssertion, node);
 		str = write_expr_to_string(str, ta->expr);
 		str = gb_string_appendc(str, ".(");
diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp
index 92155cc5e..6672ea204 100644
--- a/src/check_stmt.cpp
+++ b/src/check_stmt.cpp
@@ -1272,6 +1272,18 @@ void check_stmt_internal(CheckerContext *ctx, Ast *node, u32 flags) {
 					}
 				}
 				return;
+			} else if (operand.expr->kind == Ast_SelectorCallExpr) {
+				AstSelectorCallExpr *se = &operand.expr->SelectorCallExpr;
+				ast_node(ce, CallExpr, se->call);
+				Type *t = type_of_expr(ce->proc);
+				if (is_type_proc(t)) {
+					if (t->Proc.require_results) {
+						gbString expr_str = expr_to_string(ce->proc);
+						error(node, "'%s' requires that its results must be handled", expr_str);
+						gb_string_free(expr_str);
+					}
+				}
+				return;
 			}
 			gbString expr_str = expr_to_string(operand.expr);
 			error(node, "Expression is not used: '%s'", expr_str);
diff --git a/src/ir.cpp b/src/ir.cpp
index 2127de7b4..b8b2bd46e 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -7678,6 +7678,13 @@ irValue *ir_build_expr_internal(irProcedure *proc, Ast *expr) {
 		return ir_add_module_constant(proc->module, tv.type, tv.value);
 	case_end;
 
+	case_ast_node(se, SelectorCallExpr, expr);
+		GB_ASSERT(se->modified_call);
+		TypeAndValue tav = type_and_value_of_expr(expr);
+		GB_ASSERT(tav.mode != Addressing_Invalid);
+		return ir_addr_load(proc, ir_build_addr(proc, se->call));
+	case_end;
+
 	case_ast_node(te, TernaryExpr, expr);
 		ir_emit_comment(proc, str_lit("TernaryExpr"));
 
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index c0d23019e..f3ec62c89 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -9025,6 +9025,13 @@ lbValue lb_build_expr(lbProcedure *p, Ast *expr) {
 		return lb_const_value(p->module, tv.type, tv.value);
 	case_end;
 
+	case_ast_node(se, SelectorCallExpr, expr);
+		GB_ASSERT(se->modified_call);
+		TypeAndValue tav = type_and_value_of_expr(expr);
+		GB_ASSERT(tav.mode != Addressing_Invalid);
+		return lb_addr_load(p, lb_build_addr(p, se->call));
+	case_end;
+
 	case_ast_node(te, TernaryExpr, expr);
 		LLVMValueRef incoming_values[2] = {};
 		LLVMBasicBlockRef incoming_blocks[2] = {};
diff --git a/src/parser.cpp b/src/parser.cpp
index 664aeb56d..8bde4a403 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -24,6 +24,11 @@ Token ast_token(Ast *node) {
 			return ast_token(node->SelectorExpr.selector);
 		}
 		return node->SelectorExpr.token;
+	case Ast_SelectorCallExpr:
+		if (node->SelectorCallExpr.expr != nullptr) {
+			return ast_token(node->SelectorCallExpr.expr);
+		}
+		return node->SelectorCallExpr.token;
 	case Ast_ImplicitSelectorExpr:
 		if (node->ImplicitSelectorExpr.selector != nullptr) {
 			return ast_token(node->ImplicitSelectorExpr.selector);
@@ -174,6 +179,10 @@ Ast *clone_ast(Ast *node) {
 	case Ast_ImplicitSelectorExpr:
 		n->ImplicitSelectorExpr.selector = clone_ast(n->ImplicitSelectorExpr.selector);
 		break;
+	case Ast_SelectorCallExpr:
+		n->SelectorCallExpr.expr = clone_ast(n->SelectorCallExpr.expr);
+		n->SelectorCallExpr.call = clone_ast(n->SelectorCallExpr.call);
+		break;
 	case Ast_IndexExpr:
 		n->IndexExpr.expr  = clone_ast(n->IndexExpr.expr);
 		n->IndexExpr.index = clone_ast(n->IndexExpr.index);
@@ -546,6 +555,14 @@ Ast *ast_implicit_selector_expr(AstFile *f, Token token, Ast *selector) {
 	return result;
 }
 
+Ast *ast_selector_call_expr(AstFile *f, Token token, Ast *expr, Ast *call) {
+	Ast *result = alloc_ast_node(f, Ast_SelectorCallExpr);
+	result->SelectorCallExpr.token = token;
+	result->SelectorCallExpr.expr = expr;
+	result->SelectorCallExpr.call = call;
+	return result;
+}
+
 
 Ast *ast_index_expr(AstFile *f, Ast *expr, Ast *index, Token open, Token close) {
 	Ast *result = alloc_ast_node(f, Ast_IndexExpr);
@@ -2417,8 +2434,11 @@ Ast *parse_atom_expr(AstFile *f, Ast *operand, bool lhs) {
 
 		case Token_ArrowRight: {
 			Token token = advance_token(f);
-			syntax_error(token, "Selector expressions use '.' rather than '->'");
-			operand = ast_selector_expr(f, token, operand, parse_ident(f));
+			// syntax_error(token, "Selector expressions use '.' rather than '->'");
+
+			Ast *sel = ast_selector_expr(f, token, operand, parse_ident(f));
+			Ast *call = parse_call_expr(f, sel);
+			operand = ast_selector_call_expr(f, token, sel, call);
 			break;
 		}
 
diff --git a/src/parser.hpp b/src/parser.hpp
index bfe290c8f..00e299ba5 100644
--- a/src/parser.hpp
+++ b/src/parser.hpp
@@ -271,6 +271,7 @@ AST_KIND(_ExprBegin,  "",  bool) \
 	AST_KIND(ParenExpr,    "parentheses expression", struct { Ast *expr; Token open, close; }) \
 	AST_KIND(SelectorExpr, "selector expression",    struct { Token token; Ast *expr, *selector; }) \
 	AST_KIND(ImplicitSelectorExpr, "implicit selector expression",    struct { Token token; Ast *selector; }) \
+	AST_KIND(SelectorCallExpr, "selector call expression",    struct { Token token; Ast *expr, *call; bool modified_call; }) \
 	AST_KIND(IndexExpr,    "index expression",       struct { Ast *expr, *index; Token open, close; }) \
 	AST_KIND(DerefExpr,    "dereference expression", struct { Token op; Ast *expr; }) \
 	AST_KIND(SliceExpr,    "slice expression", struct { \