Commit 37d167f6e0e26e8dc57950cb0fa1bfa630036521 | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-08-16 22:42:50-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-08-16 22:42:50-07:00
log	37d167f6e0e26e8dc57950cb0fa1bfa630036521
tree	8b947d065ef12b189cb7a4c880c0009e7a6cd2b8
parent	0ae9023832584e256aa3b6df0f0829026141d21a

std: conform to style guidelines

26 files changed, 707 insertions(+), 686 deletions(-)

doc
- style.md
example
- cat
  - main.zig
- guess_number
  - main.zig
src
- analyze.cpp
- codegen.cpp
std
test

doc/style.md+59-3

...	@@ -5,12 +5,68 @@ this documentation along with the compiler in order to provide a point of	...	@@ -5,12 +5,68 @@ this documentation along with the compiler in order to provide a point of
5	reference, should anyone wish to point to an authority on agreed upon Zig	5	reference, should anyone wish to point to an authority on agreed upon Zig
6	coding style.	6	coding style.
7		7
		8	## Whitespace
		9
8	* 4 space indentation	10	* 4 space indentation
9	* `camelCaseFunctionName`
10	* `TitleCaseTypeName`
11	* `snake_case_variable_name`
12	* Open braces on same line, unless you need to wrap.	11	* Open braces on same line, unless you need to wrap.
13	* If a list of things is longer than 2, put each item on its own line and	12	* If a list of things is longer than 2, put each item on its own line and
14	exercise the abilty to put an extra comma at the end.	13	exercise the abilty to put an extra comma at the end.
		14	* Line length: aim for 100; use common sense.
		15
		16	## Names
		17
		18	Roughly speaking: `camelCaseFunctionName`, `TitleCaseTypeName`,
		19	`snake_case_variable_name`. More precisely:
		20
		21	* If `x` is a `struct` (or an alias of a `struct`), then `x` should be `TitleCase`.
		22	* If `x` otherwise identifies a type, `x` should have `snake_case`.
		23	* If `x` is callable, and `x`'s return type is `type`, then `x` should be `TitleCase`.
		24	* If `x` is otherwise callable, then `x` should be `camelCase`.
		25	* Otherwise, `x` should be `snake_case`.
		26
		27	Acronyms, initialisms, proper nouns, or any other word that has capitalization
		28	rules in written English are subject to naming conventions just like any other
		29	word. Even acronyms that are only 2 letters long are subject to these
		30	conventions.
		31
		32	Examples:
		33
		34	```zig
		35	const namespace_name = @import("dir_name/file_name.zig");
		36	var global_var: i32;
		37	const const_name = 42;
		38	const primitive_type_alias = f32;
		39	const string_alias = []u8;
		40
		41	struct StructName {}
		42	const StructAlias = StructName;
		43
		44	fn functionName(param_name: TypeName) {
		45	var functionPointer = functionName;
		46	functionPointer();
		47	functionPointer = otherFunction;
		48	functionPointer();
		49	}
		50	const functionAlias = functionName;
		51
		52	fn ListTemplateFunction(ChildType: type, inline fixed_size: usize) -> type {
		53	struct ShortList(T: type, n: usize) {
		54	field_name: [n]T,
		55	fn methodName() {}
		56	}
		57	return List(ChildType, fixed_size);
		58	}
		59
		60	// The word XML loses its casing when used in Zig identifiers.
		61	const xml_document =
		62	\\<?xml version="1.0" encoding="UTF-8"?>
		63	\\<document>
		64	\\</document>
		65	;
		66	struct XmlParser {}
		67
		68	// The initials BE (Big Endian) are just another word in Zig identifier names.
		69	fn readU32Be() -> u32 {}
		70	```
15		71
16	See Zig standard library for examples.	72	See Zig standard library for examples.

example/cat/main.zig+3-3

...	@@ -16,7 +16,7 @@ pub fn main(args: [][]u8) -> %void {	...	@@ -16,7 +16,7 @@ pub fn main(args: [][]u8) -> %void {
16	} else {	16	} else {
17	var is = io.InStream.open(arg) %% \|err\| {	17	var is = io.InStream.open(arg) %% \|err\| {
18	%%io.stderr.printf("Unable to open file: ");	18	%%io.stderr.printf("Unable to open file: ");
19	%%io.stderr.printf(@err_name(err));	19	%%io.stderr.printf(@errName(err));
20	%%io.stderr.printf("\n");	20	%%io.stderr.printf("\n");
21	return err;	21	return err;
22	};	22	};
...	@@ -45,7 +45,7 @@ fn cat_stream(is: io.InStream) -> %void {	...	@@ -45,7 +45,7 @@ fn cat_stream(is: io.InStream) -> %void {
45	while (true) {	45	while (true) {
46	const bytes_read = is.read(buf) %% \|err\| {	46	const bytes_read = is.read(buf) %% \|err\| {
47	%%io.stderr.printf("Unable to read from stream: ");	47	%%io.stderr.printf("Unable to read from stream: ");
48	%%io.stderr.printf(@err_name(err));	48	%%io.stderr.printf(@errName(err));
49	%%io.stderr.printf("\n");	49	%%io.stderr.printf("\n");
50	return err;	50	return err;
51	};	51	};
...	@@ -56,7 +56,7 @@ fn cat_stream(is: io.InStream) -> %void {	...	@@ -56,7 +56,7 @@ fn cat_stream(is: io.InStream) -> %void {
56		56
57	io.stdout.write(buf[0...bytes_read]) %% \|err\| {	57	io.stdout.write(buf[0...bytes_read]) %% \|err\| {
58	%%io.stderr.printf("Unable to write to stdout: ");	58	%%io.stderr.printf("Unable to write to stdout: ");
59	%%io.stderr.printf(@err_name(err));	59	%%io.stderr.printf(@errName(err));
60	%%io.stderr.printf("\n");	60	%%io.stderr.printf("\n");
61	return err;	61	return err;
62	};	62	};

example/guess_number/main.zig+5-4

 @@ -6,11 +6,12 @@ const os = std.os;
 pub fn main(args: [][]u8) -> %void {
     %%io.stdout.printf("Welcome to the Guess Number Game in Zig.\n");
-    var seed: [@sizeof(usize)]u8 = undefined;
+    var seed: [@sizeOf(usize)]u8 = undefined;
     %%os.get_random_bytes(seed);
-    var rand = Rand.init(([]usize)(seed)[0]);
+    var rand: Rand = undefined;
+    rand.init(([]usize)(seed)[0]);
-    const answer = rand.range_unsigned(u8, 0, 100) + 1;
+    const answer = rand.rangeUnsigned(u8, 0, 100) + 1;
     while (true) {
         %%io.stdout.printf("\nGuess a number between 1 and 100: ");
 @@ -21,7 +22,7 @@ pub fn main(args: [][]u8) -> %void {
             return err;
         };
-        const guess = io.parse_unsigned(u8, line_buf[0...line_len - 1], 10) %% {
+        const guess = io.parseUnsigned(u8, line_buf[0...line_len - 1], 10) %% {
             %%io.stdout.printf("Invalid number.\n");
             continue;
         };

src/analyze.cpp+1-1

...	@@ -5206,7 +5206,7 @@ static TypeTableEntry analyze_builtin_fn_call_expr(CodeGen g, ImportTableEntry	...	@@ -5206,7 +5206,7 @@ static TypeTableEntry analyze_builtin_fn_call_expr(CodeGen g, ImportTableEntry
5206	case TypeTableEntryIdNamespace:	5206	case TypeTableEntryIdNamespace:
5207	case TypeTableEntryIdGenericFn:	5207	case TypeTableEntryIdGenericFn:
5208	add_node_error(g, expr_node,	5208	add_node_error(g, expr_node,
5209	buf_sprintf("type '%s' not eligible for @typeof", buf_ptr(&type_entry->name)));	5209	buf_sprintf("type '%s' not eligible for @typeOf", buf_ptr(&type_entry->name)));
5210	return g->builtin_types.entry_invalid;	5210	return g->builtin_types.entry_invalid;
5211	case TypeTableEntryIdMetaType:	5211	case TypeTableEntryIdMetaType:
5212	case TypeTableEntryIdVoid:	5212	case TypeTableEntryIdVoid:

src/codegen.cpp+23-23

std/bootstrap.zig+8-8

...	@@ -4,7 +4,7 @@ const root = @import("@root");	...	@@ -4,7 +4,7 @@ const root = @import("@root");
4	const linux = @import("linux.zig");	4	const linux = @import("linux.zig");
5	const cstr = @import("cstr.zig");	5	const cstr = @import("cstr.zig");
6		6
7	const want_start_symbol = switch(@compile_var("os")) {	7	const want_start_symbol = switch(@compileVar("os")) {
8	linux => true,	8	linux => true,
9	else => false,	9	else => false,
10	};	10	};
...	@@ -16,7 +16,7 @@ var argv: &&u8 = undefined;	...	@@ -16,7 +16,7 @@ var argv: &&u8 = undefined;
16	#attribute("naked")	16	#attribute("naked")
17	#condition(want_start_symbol)	17	#condition(want_start_symbol)
18	export fn _start() -> unreachable {	18	export fn _start() -> unreachable {
19	switch (@compile_var("arch")) {	19	switch (@compileVar("arch")) {
20	x86_64 => {	20	x86_64 => {
21	argc = asm("mov (%%rsp), %[argc]": [argc] "=r" (-> usize));	21	argc = asm("mov (%%rsp), %[argc]": [argc] "=r" (-> usize));
22	argv = asm("lea 0x8(%%rsp), %[argv]": [argv] "=r" (-> &&u8));	22	argv = asm("lea 0x8(%%rsp), %[argv]": [argv] "=r" (-> &&u8));
...	@@ -25,12 +25,12 @@ export fn _start() -> unreachable {	...	@@ -25,12 +25,12 @@ export fn _start() -> unreachable {
25	argc = asm("mov (%%esp), %[argc]": [argc] "=r" (-> usize));	25	argc = asm("mov (%%esp), %[argc]": [argc] "=r" (-> usize));
26	argv = asm("lea 0x4(%%esp), %[argv]": [argv] "=r" (-> &&u8));	26	argv = asm("lea 0x4(%%esp), %[argv]": [argv] "=r" (-> &&u8));
27	},	27	},
28	else => @compile_err("unsupported arch"),	28	else => @compileErr("unsupported arch"),
29	}	29	}
30	call_main_and_exit()	30	callMainAndExit()
31	}	31	}
32		32
33	fn call_main() -> %void {	33	fn callMain() -> %void {
34	var args: [argc][]u8 = undefined;	34	var args: [argc][]u8 = undefined;
35	for (args) \|arg, i\| {	35	for (args) \|arg, i\| {
36	const ptr = argv[i];	36	const ptr = argv[i];
...	@@ -39,8 +39,8 @@ fn call_main() -> %void {	...	@@ -39,8 +39,8 @@ fn call_main() -> %void {
39	return root.main(args);	39	return root.main(args);
40	}	40	}
41		41
42	fn call_main_and_exit() -> unreachable {	42	fn callMainAndExit() -> unreachable {
43	call_main() %% linux.exit(1);	43	callMain() %% linux.exit(1);
44	linux.exit(0);	44	linux.exit(0);
45	}	45	}
46		46
...	@@ -48,6 +48,6 @@ fn call_main_and_exit() -> unreachable {	...	@@ -48,6 +48,6 @@ fn call_main_and_exit() -> unreachable {
48	export fn main(c_argc: i32, c_argv: &&u8) -> i32 {	48	export fn main(c_argc: i32, c_argv: &&u8) -> i32 {
49	argc = usize(c_argc);	49	argc = usize(c_argc);
50	argv = c_argv;	50	argv = c_argv;
51	call_main() %% return 1;	51	callMain() %% return 1;
52	return 0;	52	return 0;
53	}	53	}

std/compiler_rt.zig+5-5

...	@@ -5,7 +5,7 @@ const si_int = c_int;	...	@@ -5,7 +5,7 @@ const si_int = c_int;
5	const su_int = c_uint;	5	const su_int = c_uint;
6		6
7	const udwords = [2]su_int;	7	const udwords = [2]su_int;
8	const low = if (@compile_var("is_big_endian")) 1 else 0;	8	const low = if (@compileVar("is_big_endian")) 1 else 0;
9	const high = 1 - low;	9	const high = 1 - low;
10		10
11	#debug_safety(false)	11	#debug_safety(false)
...	@@ -20,8 +20,8 @@ fn du_int_to_udwords(x: du_int) -> udwords {	...	@@ -20,8 +20,8 @@ fn du_int_to_udwords(x: du_int) -> udwords {
20		20
21	#debug_safety(false)	21	#debug_safety(false)
22	export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {	22	export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {
23	const n_uword_bits = @sizeof(su_int) * CHAR_BIT;	23	const n_uword_bits = @sizeOf(su_int) * CHAR_BIT;
24	const n_udword_bits = @sizeof(du_int) * CHAR_BIT;	24	const n_udword_bits = @sizeOf(du_int) * CHAR_BIT;
25	var n = du_int_to_udwords(a);	25	var n = du_int_to_udwords(a);
26	var d = du_int_to_udwords(b);	26	var d = du_int_to_udwords(b);
27	var q: udwords = undefined;	27	var q: udwords = undefined;
...	@@ -79,7 +79,7 @@ export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {	...	@@ -79,7 +79,7 @@ export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {
79	r[high] = n[high] & (d[high] - 1);	79	r[high] = n[high] & (d[high] - 1);
80	rem = (&du_int)(&r[0]);	80	rem = (&du_int)(&r[0]);
81	}	81	}
82	return n[high] >> @ctz(@typeof(d[high]), d[high]);	82	return n[high] >> @ctz(@typeOf(d[high]), d[high]);
83	}	83	}
84	// K K	84	// K K
85	// ---	85	// ---
...	@@ -114,7 +114,7 @@ export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {	...	@@ -114,7 +114,7 @@ export fn __udivmoddi4(a: du_int, b: du_int, maybe_rem: ?&du_int) -> du_int {
114	if (d[low] == 1) {	114	if (d[low] == 1) {
115	return *(&du_int)(&n[0]);	115	return *(&du_int)(&n[0]);
116	}	116	}
117	sr = @ctz(@typeof(d[low]), d[low]);	117	sr = @ctz(@typeOf(d[low]), d[low]);
118	q[high] = n[high] >> sr;	118	q[high] = n[high] >> sr;
119	q[low] = (n[high] << (n_uword_bits - sr)) \| (n[low] >> sr);	119	q[low] = (n[high] << (n_uword_bits - sr)) \| (n[low] >> sr);
120	return *(&du_int)(&q[0]);	120	return *(&du_int)(&q[0]);

std/cstr.zig+34-34

...	@@ -24,11 +24,11 @@ pub fn cmp(a: &const u8, b: &const u8) -> i32 {	...	@@ -24,11 +24,11 @@ pub fn cmp(a: &const u8, b: &const u8) -> i32 {
24	return a[index] - b[index];	24	return a[index] - b[index];
25	}	25	}
26		26
27	pub fn to_slice_const(str: &const u8) -> []const u8 {	27	pub fn toSliceConst(str: &const u8) -> []const u8 {
28	return str[0...strlen(str)];	28	return str[0...strlen(str)];
29	}	29	}
30		30
31	pub fn to_slice(str: &u8) -> []u8 {	31	pub fn toSlice(str: &u8) -> []u8 {
32	return str[0...strlen(str)];	32	return str[0...strlen(str)];
33	}	33	}
34		34
...	@@ -46,25 +46,25 @@ pub struct CBuf {	...	@@ -46,25 +46,25 @@ pub struct CBuf {
46	}	46	}
47		47
48	/// Must deinitialize with deinit.	48	/// Must deinitialize with deinit.
49	pub fn init_from_mem(self: &CBuf, allocator: &Allocator, m: []const u8) -> %void {	49	pub fn initFromMem(self: &CBuf, allocator: &Allocator, m: []const u8) -> %void {
50	self.init(allocator);	50	self.init(allocator);
51	%return self.resize(m.len);	51	%return self.resize(m.len);
52	mem.copy(u8, self.list.items, m);	52	mem.copy(u8, self.list.items, m);
53	}	53	}
54		54
55	/// Must deinitialize with deinit.	55	/// Must deinitialize with deinit.
56	pub fn init_from_cstr(self: &CBuf, allocator: &Allocator, s: &const u8) -> %void {	56	pub fn initFromCStr(self: &CBuf, allocator: &Allocator, s: &const u8) -> %void {
57	self.init_from_mem(allocator, s[0...strlen(s)])	57	self.initFromMem(allocator, s[0...strlen(s)])
58	}	58	}
59		59
60	/// Must deinitialize with deinit.	60	/// Must deinitialize with deinit.
61	pub fn init_from_cbuf(self: &CBuf, cbuf: &const CBuf) -> %void {	61	pub fn initFromCBuf(self: &CBuf, cbuf: &const CBuf) -> %void {
62	self.init_from_mem(cbuf.list.allocator, cbuf.list.items[0...cbuf.len()])	62	self.initFromMem(cbuf.list.allocator, cbuf.list.items[0...cbuf.len()])
63	}	63	}
64		64
65	/// Must deinitialize with deinit.	65	/// Must deinitialize with deinit.
66	pub fn init_from_slice(self: &CBuf, other: &const CBuf, start: usize, end: usize) -> %void {	66	pub fn initFromSlice(self: &CBuf, other: &const CBuf, start: usize, end: usize) -> %void {
67	self.init_from_mem(other.list.allocator, other.list.items[start...end])	67	self.initFromMem(other.list.allocator, other.list.items[start...end])
68	}	68	}
69		69
70	pub fn deinit(self: &CBuf) {	70	pub fn deinit(self: &CBuf) {
...	@@ -80,66 +80,66 @@ pub struct CBuf {	...	@@ -80,66 +80,66 @@ pub struct CBuf {
80	return self.list.len - 1;	80	return self.list.len - 1;
81	}	81	}
82		82
83	pub fn append_mem(self: &CBuf, m: []const u8) -> %void {	83	pub fn appendMem(self: &CBuf, m: []const u8) -> %void {
84	const old_len = self.len();	84	const old_len = self.len();
85	%return self.resize(old_len + m.len);	85	%return self.resize(old_len + m.len);
86	mem.copy(u8, self.list.items[old_len...], m);	86	mem.copy(u8, self.list.items[old_len...], m);
87	}	87	}
88		88
89	pub fn append_cstr(self: &CBuf, s: &const u8) -> %void {	89	pub fn appendCStr(self: &CBuf, s: &const u8) -> %void {
90	self.append_mem(s[0...strlen(s)])	90	self.appendMem(s[0...strlen(s)])
91	}	91	}
92		92
93	pub fn append_char(self: &CBuf, c: u8) -> %void {	93	pub fn appendChar(self: &CBuf, c: u8) -> %void {
94	%return self.resize(self.len() + 1);	94	%return self.resize(self.len() + 1);
95	self.list.items[self.len() - 1] = c;	95	self.list.items[self.len() - 1] = c;
96	}	96	}
97		97
98	pub fn eql_mem(self: &const CBuf, m: []const u8) -> bool {	98	pub fn eqlMem(self: &const CBuf, m: []const u8) -> bool {
99	if (self.len() != m.len) return false;	99	if (self.len() != m.len) return false;
100	return mem.cmp(u8, self.list.items[0...m.len], m) == mem.Cmp.Equal;	100	return mem.cmp(u8, self.list.items[0...m.len], m) == mem.Cmp.Equal;
101	}	101	}
102		102
103	pub fn eql_cstr(self: &const CBuf, s: &const u8) -> bool {	103	pub fn eqlCStr(self: &const CBuf, s: &const u8) -> bool {
104	self.eql_mem(s[0...strlen(s)])	104	self.eqlMem(s[0...strlen(s)])
105	}	105	}
106		106
107	pub fn eql_cbuf(self: &const CBuf, other: &const CBuf) -> bool {	107	pub fn eqlCBuf(self: &const CBuf, other: &const CBuf) -> bool {
108	self.eql_mem(other.list.items[0...other.len()])	108	self.eqlMem(other.list.items[0...other.len()])
109	}	109	}
110		110
111	pub fn starts_with_mem(self: &const CBuf, m: []const u8) -> bool {	111	pub fn startsWithMem(self: &const CBuf, m: []const u8) -> bool {
112	if (self.len() < m.len) return false;	112	if (self.len() < m.len) return false;
113	return mem.cmp(u8, self.list.items[0...m.len], m) == mem.Cmp.Equal;	113	return mem.cmp(u8, self.list.items[0...m.len], m) == mem.Cmp.Equal;
114	}	114	}
115		115
116	pub fn starts_with_cbuf(self: &const CBuf, other: &const CBuf) -> bool {	116	pub fn startsWithCBuf(self: &const CBuf, other: &const CBuf) -> bool {
117	self.starts_with_mem(other.list.items[0...other.len()])	117	self.startsWithMem(other.list.items[0...other.len()])
118	}	118	}
119		119
120	pub fn starts_with_cstr(self: &const CBuf, s: &const u8) -> bool {	120	pub fn startsWithCStr(self: &const CBuf, s: &const u8) -> bool {
121	self.starts_with_mem(s[0...strlen(s)])	121	self.startsWithMem(s[0...strlen(s)])
122	}	122	}
123	}	123	}
124		124
125	#attribute("test")	125	#attribute("test")
126	fn test_simple_cbuf() {	126	fn testSimpleCBuf() {
127	var buf: CBuf = undefined;	127	var buf: CBuf = undefined;
128	buf.init(&debug.global_allocator);	128	buf.init(&debug.global_allocator);
129	assert(buf.len() == 0);	129	assert(buf.len() == 0);
130	%%buf.append_cstr(c"hello");	130	%%buf.appendCStr(c"hello");
131	%%buf.append_char(' ');	131	%%buf.appendChar(' ');
132	%%buf.append_mem("world");	132	%%buf.appendMem("world");
133	assert(buf.eql_cstr(c"hello world"));	133	assert(buf.eqlCStr(c"hello world"));
134	assert(buf.eql_mem("hello world"));	134	assert(buf.eqlMem("hello world"));
135		135
136	var buf2: CBuf = undefined;	136	var buf2: CBuf = undefined;
137	%%buf2.init_from_cbuf(&buf);	137	%%buf2.initFromCBuf(&buf);
138	assert(buf.eql_cbuf(&buf2));	138	assert(buf.eqlCBuf(&buf2));
139		139
140	assert(buf.starts_with_mem("hell"));	140	assert(buf.startsWithMem("hell"));
141	assert(buf.starts_with_cstr(c"hell"));	141	assert(buf.startsWithCStr(c"hell"));
142		142
143	%%buf2.resize(4);	143	%%buf2.resize(4);
144	assert(buf.starts_with_cbuf(&buf2));	144	assert(buf.startsWithCBuf(&buf2));
145	}	145	}

std/debug.zig+5-5

...	@@ -6,10 +6,10 @@ pub fn assert(b: bool) {	...	@@ -6,10 +6,10 @@ pub fn assert(b: bool) {
6	}	6	}
7		7
8	pub fn printStackTrace() {	8	pub fn printStackTrace() {
9	var maybe_fp: ?&const u8 = @frame_address();	9	var maybe_fp: ?&const u8 = @frameAddress();
10	while (true) {	10	while (true) {
11	const fp = maybe_fp ?? break;	11	const fp = maybe_fp ?? break;
12	const return_address = *(&const usize)(usize(fp) + @sizeof(usize));	12	const return_address = *(&const usize)(usize(fp) + @sizeOf(usize));
13	%%io.stderr.print_u64(return_address);	13	%%io.stderr.print_u64(return_address);
14	%%io.stderr.printf("\n");	14	%%io.stderr.printf("\n");
15	maybe_fp = *(&const ?&const u8)(fp);	15	maybe_fp = *(&const ?&const u8)(fp);
...	@@ -17,9 +17,9 @@ pub fn printStackTrace() {	...	@@ -17,9 +17,9 @@ pub fn printStackTrace() {
17	}	17	}
18		18
19	pub var global_allocator = Allocator {	19	pub var global_allocator = Allocator {
20	.alloc_fn = globalAlloc,	20	.allocFn = globalAlloc,
21	.realloc_fn = globalRealloc,	21	.reallocFn = globalRealloc,
22	.free_fn = globalFree,	22	.freeFn = globalFree,
23	.context = null,	23	.context = null,
24	};	24	};
25		25

std/hash_map.zig+22-22

...	@@ -4,27 +4,27 @@ const math = @import("math.zig");	...	@@ -4,27 +4,27 @@ const math = @import("math.zig");
4	const mem = @import("mem.zig");	4	const mem = @import("mem.zig");
5	const Allocator = mem.Allocator;	5	const Allocator = mem.Allocator;
6		6
7	const want_modification_safety = !@compile_var("is_release");	7	const want_modification_safety = !@compileVar("is_release");
8	const debug_u32 = if (want_modification_safety) u32 else void;	8	const debug_u32 = if (want_modification_safety) u32 else void;
9		9
10	pub fn HashMap(inline K: type, inline V: type, inline hash: fn(key: K)->u32,	10	pub fn HashMap(inline K: type, inline V: type, inline hash: fn(key: K)->u32,
11	inline eql: fn(a: K, b: K)->bool) -> type	11	inline eql: fn(a: K, b: K)->bool) -> type
12	{	12	{
13	SmallHashMap(K, V, hash, eql, @sizeof(usize))	13	SmallHashMap(K, V, hash, eql, @sizeOf(usize))
14	}	14	}
15		15
16	pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b: K)->bool, STATIC_SIZE: usize) {	16	pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b: K)->bool, static_size: usize) {
17	entries: []Entry,	17	entries: []Entry,
18	size: usize,	18	size: usize,
19	max_distance_from_start_index: usize,	19	max_distance_from_start_index: usize,
20	allocator: &Allocator,	20	allocator: &Allocator,
21	// if the hash map is small enough, we use linear search through these	21	// if the hash map is small enough, we use linear search through these
22	// entries instead of allocating memory	22	// entries instead of allocating memory
23	prealloc_entries: [STATIC_SIZE]Entry,	23	prealloc_entries: [static_size]Entry,
24	// this is used to detect bugs where a hashtable is edited while an iterator is running.	24	// this is used to detect bugs where a hashtable is edited while an iterator is running.
25	modification_count: debug_u32,	25	modification_count: debug_u32,
26		26
27	const Self = SmallHashMap(K, V, hash, eql, STATIC_SIZE);	27	const Self = SmallHashMap(K, V, hash, eql, static_size);
28		28
29	pub struct Entry {	29	pub struct Entry {
30	used: bool,	30	used: bool,
...	@@ -80,11 +80,11 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -80,11 +80,11 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
80	}	80	}
81	hm.size = 0;	81	hm.size = 0;
82	hm.max_distance_from_start_index = 0;	82	hm.max_distance_from_start_index = 0;
83	hm.increment_modification_count();	83	hm.incrementModificationCount();
84	}	84	}
85		85
86	pub fn put(hm: &Self, key: K, value: V) -> %void {	86	pub fn put(hm: &Self, key: K, value: V) -> %void {
87	hm.increment_modification_count();	87	hm.incrementModificationCount();
88		88
89	const resize = if (hm.entries.ptr == &hm.prealloc_entries[0]) {	89	const resize = if (hm.entries.ptr == &hm.prealloc_entries[0]) {
90	// preallocated entries table is full	90	// preallocated entries table is full
...	@@ -95,11 +95,11 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -95,11 +95,11 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
95	};	95	};
96	if (resize) {	96	if (resize) {
97	const old_entries = hm.entries;	97	const old_entries = hm.entries;
98	%return hm.init_capacity(hm.entries.len * 2);	98	%return hm.initCapacity(hm.entries.len * 2);
99	// dump all of the old elements into the new table	99	// dump all of the old elements into the new table
100	for (old_entries) \|*old_entry\| {	100	for (old_entries) \|*old_entry\| {
101	if (old_entry.used) {	101	if (old_entry.used) {
102	hm.internal_put(old_entry.key, old_entry.value);	102	hm.internalPut(old_entry.key, old_entry.value);
103	}	103	}
104	}	104	}
105	if (old_entries.ptr != &hm.prealloc_entries[0]) {	105	if (old_entries.ptr != &hm.prealloc_entries[0]) {
...	@@ -107,16 +107,16 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -107,16 +107,16 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
107	}	107	}
108	}	108	}
109		109
110	hm.internal_put(key, value);	110	hm.internalPut(key, value);
111	}	111	}
112		112
113	pub fn get(hm: &Self, key: K) -> ?&Entry {	113	pub fn get(hm: &Self, key: K) -> ?&Entry {
114	return hm.internal_get(key);	114	return hm.internalGet(key);
115	}	115	}
116		116
117	pub fn remove(hm: &Self, key: K) {	117	pub fn remove(hm: &Self, key: K) {
118	hm.increment_modification_count();	118	hm.incrementModificationCount();
119	const start_index = hm.key_to_index(key);	119	const start_index = hm.keyToIndex(key);
120	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index; roll_over += 1) {	120	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index; roll_over += 1) {
121	const index = (start_index + roll_over) % hm.entries.len;	121	const index = (start_index + roll_over) % hm.entries.len;
122	var entry = &hm.entries[index];	122	var entry = &hm.entries[index];
...	@@ -142,7 +142,7 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -142,7 +142,7 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
142	unreachable{} // key not found	142	unreachable{} // key not found
143	}	143	}
144		144
145	pub fn entry_iterator(hm: &Self) -> Iterator {	145	pub fn entryIterator(hm: &Self) -> Iterator {
146	return Iterator {	146	return Iterator {
147	.hm = hm,	147	.hm = hm,
148	.count = 0,	148	.count = 0,
...	@@ -151,7 +151,7 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -151,7 +151,7 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
151	};	151	};
152	}	152	}
153		153
154	fn init_capacity(hm: &Self, capacity: usize) -> %void {	154	fn initCapacity(hm: &Self, capacity: usize) -> %void {
155	hm.entries = %return hm.allocator.alloc(Entry, capacity);	155	hm.entries = %return hm.allocator.alloc(Entry, capacity);
156	hm.size = 0;	156	hm.size = 0;
157	hm.max_distance_from_start_index = 0;	157	hm.max_distance_from_start_index = 0;
...	@@ -160,16 +160,16 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -160,16 +160,16 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
160	}	160	}
161	}	161	}
162		162
163	fn increment_modification_count(hm: &Self) {	163	fn incrementModificationCount(hm: &Self) {
164	if (want_modification_safety) {	164	if (want_modification_safety) {
165	hm.modification_count +%= 1;	165	hm.modification_count +%= 1;
166	}	166	}
167	}	167	}
168		168
169	fn internal_put(hm: &Self, orig_key: K, orig_value: V) {	169	fn internalPut(hm: &Self, orig_key: K, orig_value: V) {
170	var key = orig_key;	170	var key = orig_key;
171	var value = orig_value;	171	var value = orig_value;
172	const start_index = hm.key_to_index(key);	172	const start_index = hm.keyToIndex(key);
173	var roll_over: usize = 0;	173	var roll_over: usize = 0;
174	var distance_from_start_index: usize = 0;	174	var distance_from_start_index: usize = 0;
175	while (roll_over < hm.entries.len; {roll_over += 1; distance_from_start_index += 1}) {	175	while (roll_over < hm.entries.len; {roll_over += 1; distance_from_start_index += 1}) {
...	@@ -214,8 +214,8 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -214,8 +214,8 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
214	unreachable{} // put into a full map	214	unreachable{} // put into a full map
215	}	215	}
216		216
217	fn internal_get(hm: &Self, key: K) -> ?&Entry {	217	fn internalGet(hm: &Self, key: K) -> ?&Entry {
218	const start_index = hm.key_to_index(key);	218	const start_index = hm.keyToIndex(key);
219	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index; roll_over += 1) {	219	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index; roll_over += 1) {
220	const index = (start_index + roll_over) % hm.entries.len;	220	const index = (start_index + roll_over) % hm.entries.len;
221	const entry = &hm.entries[index];	221	const entry = &hm.entries[index];
...	@@ -226,13 +226,13 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b	...	@@ -226,13 +226,13 @@ pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b
226	return null;	226	return null;
227	}	227	}
228		228
229	fn key_to_index(hm: &Self, key: K) -> usize {	229	fn keyToIndex(hm: &Self, key: K) -> usize {
230	return usize(hash(key)) % hm.entries.len;	230	return usize(hash(key)) % hm.entries.len;
231	}	231	}
232	}	232	}
233		233
234	#attribute("test")	234	#attribute("test")
235	fn basic_hash_map_test() {	235	fn basicHashMapTest() {
236	var map: HashMap(i32, i32, hash_i32, eql_i32) = undefined;	236	var map: HashMap(i32, i32, hash_i32, eql_i32) = undefined;
237	map.init(&debug.global_allocator);	237	map.init(&debug.global_allocator);
238	defer map.deinit();	238	defer map.deinit();

std/index.zig+1-1

...	@@ -9,7 +9,7 @@ pub const list = @import("list.zig");	...	@@ -9,7 +9,7 @@ pub const list = @import("list.zig");
9	pub const hash_map = @import("hash_map.zig");	9	pub const hash_map = @import("hash_map.zig");
10	pub const mem = @import("mem.zig");	10	pub const mem = @import("mem.zig");
11	pub const debug = @import("debug.zig");	11	pub const debug = @import("debug.zig");
12	pub const linux = switch(@compile_var("os")) {	12	pub const linux = switch(@compileVar("os")) {
13	linux => @import("linux.zig"),	13	linux => @import("linux.zig"),
14	else => null_import,	14	else => null_import,
15	};	15	};

std/io.zig+21-29

 @@ -63,7 +63,7 @@ pub struct OutStream {
     buffer: [buffer_size]u8,
     index: usize,
-    pub fn write_byte(os: &OutStream, b: u8) -> %void {
+    pub fn writeByte(os: &OutStream, b: u8) -> %void {
         if (os.buffer.len == os.index) %return os.flush();
         os.buffer[os.index] = b;
         os.index += 1;
 @@ -71,7 +71,7 @@ pub struct OutStream {
     pub fn write(os: &OutStream, bytes: []const u8) -> %usize {
         var src_bytes_left = bytes.len;
-        var src_index: @typeof(bytes.len) = 0;
+        var src_index: @typeOf(bytes.len) = 0;
         const dest_space_left = os.buffer.len - os.index;
         while (src_bytes_left > 0) {
 @@ -98,7 +98,7 @@ pub struct OutStream {
         if (os.index + max_u64_base10_digits >= os.buffer.len) {
             %return os.flush();
         }
-        const amt_printed = buf_print_u64(os.buffer[os.index...], x);
+        const amt_printed = bufPrintUnsigned(u64, os.buffer[os.index...], x);
         os.index += amt_printed;
         return amt_printed;
 @@ -108,7 +108,7 @@ pub struct OutStream {
         if (os.index + max_u64_base10_digits >= os.buffer.len) {
             %return os.flush();
         }
-        const amt_printed = buf_print_i64(os.buffer[os.index...], x);
+        const amt_printed = bufPrintSigned(i64, os.buffer[os.index...], x);
         os.index += amt_printed;
         return amt_printed;
 @@ -116,7 +116,7 @@ pub struct OutStream {
     pub fn flush(os: &OutStream) -> %void {
         const write_ret = linux.write(os.fd, &os.buffer[0], os.index);
-        const write_err = linux.get_errno(write_ret);
+        const write_err = linux.getErrno(write_ret);
         if (write_err > 0) {
             return switch (write_err) {
                 errno.EINVAL => unreachable{},
 @@ -135,7 +135,7 @@ pub struct OutStream {
     pub fn close(os: &OutStream) -> %void {
         const close_ret = linux.close(os.fd);
-        const close_err = linux.get_errno(close_ret);
+        const close_err = linux.getErrno(close_ret);
         if (close_err > 0) {
             return switch (close_err) {
                 errno.EIO   => error.Io,
 @@ -152,7 +152,7 @@ pub struct InStream {
     pub fn open(path: []u8) -> %InStream {
         const fd = linux.open(path, linux.O_LARGEFILE|linux.O_RDONLY, 0);
-        const fd_err = linux.get_errno(fd);
+        const fd_err = linux.getErrno(fd);
         if (fd_err > 0) {
             return switch (fd_err) {
                 errno.EFAULT => unreachable{},
 @@ -180,7 +180,7 @@ pub struct InStream {
     pub fn read(is: &InStream, buf: []u8) -> %usize {
         const amt_read = linux.read(is.fd, &buf[0], buf.len);
-        const read_err = linux.get_errno(amt_read);
+        const read_err = linux.getErrno(amt_read);
         if (read_err > 0) {
             return switch (read_err) {
                 errno.EINVAL => unreachable{},
 @@ -196,7 +196,7 @@ pub struct InStream {
     pub fn close(is: &InStream) -> %void {
         const close_ret = linux.close(is.fd);
-        const close_err = linux.get_errno(close_ret);
+        const close_err = linux.getErrno(close_ret);
         if (close_err > 0) {
             return switch (close_err) {
                 errno.EIO => error.Io,
 @@ -208,20 +208,20 @@ pub struct InStream {
     }
 }
-pub fn parse_unsigned(inline T: type, buf: []u8, radix: u8) -> %T {
+pub fn parseUnsigned(inline T: type, buf: []u8, radix: u8) -> %T {
     var x: T = 0;
     for (buf) |c| {
-        const digit = %return char_to_digit(c, radix);
+        const digit = %return charToDigit(c, radix);
-        x = %return math.mul_overflow(T, x, radix);
+        x = %return math.mulOverflow(T, x, radix);
-        x = %return math.add_overflow(T, x, digit);
+        x = %return math.addOverflow(T, x, digit);
     }
     return x;
 }
 pub error InvalidChar;
-fn char_to_digit(c: u8, radix: u8) -> %u8 {
+fn charToDigit(c: u8, radix: u8) -> %u8 {
     const value = if ('0' <= c && c <= '9') {
         c - '0'
     } else if ('A' <= c && c <= 'Z') {
 @@ -234,21 +234,17 @@ fn char_to_digit(c: u8, radix: u8) -> %u8 {
     return if (value >= radix) error.InvalidChar else value;
 }
-pub fn buf_print_signed(inline T: type, out_buf: []u8, x: T) -> usize {
+pub fn bufPrintSigned(inline T: type, out_buf: []u8, x: T) -> usize {
-    const uint = @int_type(false, T.bit_count);
+    const uint = @intType(false, T.bit_count);
     if (x < 0) {
         out_buf[0] = '-';
-        return 1 + buf_print_unsigned(uint, out_buf[1...], uint(-(x + 1)) + 1);
+        return 1 + bufPrintUnsigned(uint, out_buf[1...], uint(-(x + 1)) + 1);
     } else {
-        return buf_print_unsigned(uint, out_buf, uint(x));
+        return bufPrintUnsigned(uint, out_buf, uint(x));
     }
 }
-pub fn buf_print_i64(out_buf: []u8, x: i64) -> usize {
+pub fn bufPrintUnsigned(inline T: type, out_buf: []u8, x: T) -> usize {
-    buf_print_signed(i64, out_buf, x)
-}
-pub fn buf_print_unsigned(inline T: type, out_buf: []u8, x: T) -> usize {
     var buf: [max_u64_base10_digits]u8 = undefined;
     var a = x;
     var index: usize = buf.len;
 @@ -269,13 +265,9 @@ pub fn buf_print_unsigned(inline T: type, out_buf: []u8, x: T) -> usize {
     return len;
 }
-pub fn buf_print_u64(out_buf: []u8, x: u64) -> usize {
-    buf_print_unsigned(u64, out_buf, x)
-}
 #attribute("test")
-fn parse_u64_digit_too_big() {
+fn parseU64DigitTooBig() {
-    parse_unsigned(u64, "123a", 10) %% |err| {
+    parseUnsigned(u64, "123a", 10) %% |err| {
         if (err == error.InvalidChar) return;
         unreachable{};
     };

std/linux.zig+9-9

...	@@ -1,4 +1,4 @@	...	@@ -1,4 +1,4 @@
1	const arch = switch (@compile_var("arch")) {	1	const arch = switch (@compileVar("arch")) {
2	x86_64 => @import("linux_x86_64.zig"),	2	x86_64 => @import("linux_x86_64.zig"),
3	i386 => @import("linux_i386.zig"),	3	i386 => @import("linux_i386.zig"),
4	else => @compile_err("unsupported arch"),	4	else => @compile_err("unsupported arch"),
...	@@ -221,7 +221,7 @@ pub const AF_VSOCK = PF_VSOCK;	...	@@ -221,7 +221,7 @@ pub const AF_VSOCK = PF_VSOCK;
221	pub const AF_MAX = PF_MAX;	221	pub const AF_MAX = PF_MAX;
222		222
223	/// Get the errno from a syscall return value, or 0 for no error.	223	/// Get the errno from a syscall return value, or 0 for no error.
224	pub fn get_errno(r: usize) -> usize {	224	pub fn getErrno(r: usize) -> usize {
225	const signed_r = *(&isize)(&r);	225	const signed_r = *(&isize)(&r);
226	if (signed_r > -4096 && signed_r < 0) usize(-signed_r) else 0	226	if (signed_r > -4096 && signed_r < 0) usize(-signed_r) else 0
227	}	227	}
...	@@ -291,22 +291,22 @@ const app_mask = []u8 { 0xff, 0xff, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xff, };	...	@@ -291,22 +291,22 @@ const app_mask = []u8 { 0xff, 0xff, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xff, };
291		291
292	pub fn raise(sig: i32) -> i32 {	292	pub fn raise(sig: i32) -> i32 {
293	var set: sigset_t = undefined;	293	var set: sigset_t = undefined;
294	block_app_signals(&set);	294	blockAppSignals(&set);
295	const tid = i32(arch.syscall0(arch.SYS_gettid));	295	const tid = i32(arch.syscall0(arch.SYS_gettid));
296	const ret = i32(arch.syscall2(arch.SYS_tkill, usize(tid), usize(sig)));	296	const ret = i32(arch.syscall2(arch.SYS_tkill, usize(tid), usize(sig)));
297	restore_signals(&set);	297	restoreSignals(&set);
298	return ret;	298	return ret;
299	}	299	}
300		300
301	fn block_all_signals(set: &sigset_t) {	301	fn blockAllSignals(set: &sigset_t) {
302	arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&all_mask), usize(set), NSIG/8);	302	arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&all_mask), usize(set), NSIG/8);
303	}	303	}
304		304
305	fn block_app_signals(set: &sigset_t) {	305	fn blockAppSignals(set: &sigset_t) {
306	arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&app_mask), usize(set), NSIG/8);	306	arch.syscall4(arch.SYS_rt_sigprocmask, SIG_BLOCK, usize(&app_mask), usize(set), NSIG/8);
307	}	307	}
308		308
309	fn restore_signals(set: &sigset_t) {	309	fn restoreSignals(set: &sigset_t) {
310	arch.syscall4(arch.SYS_rt_sigprocmask, SIG_SETMASK, usize(set), 0, NSIG/8);	310	arch.syscall4(arch.SYS_rt_sigprocmask, SIG_SETMASK, usize(set), 0, NSIG/8);
311	}	311	}
312		312
...	@@ -442,7 +442,7 @@ pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags:	...	@@ -442,7 +442,7 @@ pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags:
442	// }	442	// }
443	//	443	//
444	// const socket_ret = socket(AF_UNIX, SOCK_DGRAM\|SOCK_CLOEXEC, 0);	444	// const socket_ret = socket(AF_UNIX, SOCK_DGRAM\|SOCK_CLOEXEC, 0);
445	// const socket_err = get_errno(socket_ret);	445	// const socket_err = getErrno(socket_ret);
446	// if (socket_err > 0) {	446	// if (socket_err > 0) {
447	// return error.SystemResources;	447	// return error.SystemResources;
448	// }	448	// }
...	@@ -451,7 +451,7 @@ pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags:	...	@@ -451,7 +451,7 @@ pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags:
451	// ifr.ifr_name[name.len] = 0;	451	// ifr.ifr_name[name.len] = 0;
452	// const ioctl_ret = ioctl(socket_fd, SIOCGIFINDEX, &ifr);	452	// const ioctl_ret = ioctl(socket_fd, SIOCGIFINDEX, &ifr);
453	// close(socket_fd);	453	// close(socket_fd);
454	// const ioctl_err = get_errno(ioctl_ret);	454	// const ioctl_err = getErrno(ioctl_ret);
455	// if (ioctl_err > 0) {	455	// if (ioctl_err > 0) {
456	// return error.Io;	456	// return error.Io;
457	// }	457	// }

std/list.zig+10-10

...	@@ -4,17 +4,17 @@ const mem = @import("mem.zig");	...	@@ -4,17 +4,17 @@ const mem = @import("mem.zig");
4	const Allocator = mem.Allocator;	4	const Allocator = mem.Allocator;
5		5
6	pub fn List(inline T: type) -> type {	6	pub fn List(inline T: type) -> type {
7	SmallList(T, @sizeof(usize))	7	SmallList(T, @sizeOf(usize))
8	}	8	}
9		9
10	// TODO: make sure that setting STATIC_SIZE to 0 codegens to the same code	10	// TODO: make sure that setting static_size to 0 codegens to the same code
11	// as if this were programmed without STATIC_SIZE at all.	11	// as if this were programmed without static_size at all.
12	pub struct SmallList(T: type, STATIC_SIZE: usize) {	12	pub struct SmallList(T: type, static_size: usize) {
13	const Self = SmallList(T, STATIC_SIZE);	13	const Self = SmallList(T, static_size);
14		14
15	items: []T,	15	items: []T,
16	len: usize,	16	len: usize,
17	prealloc_items: [STATIC_SIZE]T,	17	prealloc_items: [static_size]T,
18	allocator: &Allocator,	18	allocator: &Allocator,
19		19
20	pub fn init(l: &Self, allocator: &Allocator) {	20	pub fn init(l: &Self, allocator: &Allocator) {
...	@@ -31,17 +31,17 @@ pub struct SmallList(T: type, STATIC_SIZE: usize) {	...	@@ -31,17 +31,17 @@ pub struct SmallList(T: type, STATIC_SIZE: usize) {
31		31
32	pub fn append(l: &Self, item: T) -> %void {	32	pub fn append(l: &Self, item: T) -> %void {
33	const new_length = l.len + 1;	33	const new_length = l.len + 1;
34	%return l.ensure_capacity(new_length);	34	%return l.ensureCapacity(new_length);
35	l.items[l.len] = item;	35	l.items[l.len] = item;
36	l.len = new_length;	36	l.len = new_length;
37	}	37	}
38		38
39	pub fn resize(l: &Self, new_len: usize) -> %void {	39	pub fn resize(l: &Self, new_len: usize) -> %void {
40	%return l.ensure_capacity(new_len);	40	%return l.ensureCapacity(new_len);
41	l.len = new_len;	41	l.len = new_len;
42	}	42	}
43		43
44	pub fn ensure_capacity(l: &Self, new_capacity: usize) -> %void {	44	pub fn ensureCapacity(l: &Self, new_capacity: usize) -> %void {
45	const old_capacity = l.items.len;	45	const old_capacity = l.items.len;
46	var better_capacity = old_capacity;	46	var better_capacity = old_capacity;
47	while (better_capacity < new_capacity) {	47	while (better_capacity < new_capacity) {
...	@@ -59,7 +59,7 @@ pub struct SmallList(T: type, STATIC_SIZE: usize) {	...	@@ -59,7 +59,7 @@ pub struct SmallList(T: type, STATIC_SIZE: usize) {
59	}	59	}
60		60
61	#attribute("test")	61	#attribute("test")
62	fn basic_list_test() {	62	fn basicListTest() {
63	var list: List(i32) = undefined;	63	var list: List(i32) = undefined;
64	list.init(&debug.global_allocator);	64	list.init(&debug.global_allocator);
65	defer list.deinit();	65	defer list.deinit();

std/math.zig+6-34

...	@@ -4,34 +4,6 @@ pub enum Cmp {	...	@@ -4,34 +4,6 @@ pub enum Cmp {
4	Less,	4	Less,
5	}	5	}
6		6
7	pub fn f64_from_bits(bits: u64) -> f64 {
8	*(&f64)(&bits)
9	}
10
11	pub fn f64_to_bits(f: f64) -> u64 {
12	*(&u64)(&f)
13	}
14
15	pub fn f64_get_pos_inf() -> f64 {
16	f64_from_bits(0x7FF0000000000000)
17	}
18
19	pub fn f64_get_neg_inf() -> f64 {
20	f64_from_bits(0xFFF0000000000000)
21	}
22
23	pub fn f64_is_nan(f: f64) -> bool {
24	const bits = f64_to_bits(f);
25	const exp: i64 = i64((bits >> 52) & ((1 << 11) - 1));
26	const sig = (bits & ((1 << 52) - 1)) \| (1 << 52);
27
28	sig != 0 && exp == (1 << 11) - 1
29	}
30
31	pub fn f64_is_inf(f: f64) -> bool {
32	f == f64_get_neg_inf() \|\| f == f64_get_pos_inf()
33	}
34
35	pub fn min(inline T: type, x: T, y: T) -> T {	7	pub fn min(inline T: type, x: T, y: T) -> T {
36	if (x < y) x else y	8	if (x < y) x else y
37	}	9	}
...	@@ -41,15 +13,15 @@ pub fn max(inline T: type, x: T, y: T) -> T {	...	@@ -41,15 +13,15 @@ pub fn max(inline T: type, x: T, y: T) -> T {
41	}	13	}
42		14
43	pub error Overflow;	15	pub error Overflow;
44	pub fn mul_overflow(inline T: type, a: T, b: T) -> %T {	16	pub fn mulOverflow(inline T: type, a: T, b: T) -> %T {
45	var answer: T = undefined;	17	var answer: T = undefined;
46	if (@mul_with_overflow(T, a, b, &answer)) error.Overflow else answer	18	if (@mulWithOverflow(T, a, b, &answer)) error.Overflow else answer
47	}	19	}
48	pub fn add_overflow(inline T: type, a: T, b: T) -> %T {	20	pub fn addOverflow(inline T: type, a: T, b: T) -> %T {
49	var answer: T = undefined;	21	var answer: T = undefined;
50	if (@add_with_overflow(T, a, b, &answer)) error.Overflow else answer	22	if (@addWithOverflow(T, a, b, &answer)) error.Overflow else answer
51	}	23	}
52	pub fn sub_overflow(inline T: type, a: T, b: T) -> %T {	24	pub fn subOverflow(inline T: type, a: T, b: T) -> %T {
53	var answer: T = undefined;	25	var answer: T = undefined;
54	if (@sub_with_overflow(T, a, b, &answer)) error.Overflow else answer	26	if (@subWithOverflow(T, a, b, &answer)) error.Overflow else answer
55	}	27	}

std/mem.zig+11-11

...	@@ -9,34 +9,34 @@ pub error NoMem;	...	@@ -9,34 +9,34 @@ pub error NoMem;
9		9
10	pub type Context = u8;	10	pub type Context = u8;
11	pub struct Allocator {	11	pub struct Allocator {
12	alloc_fn: fn (self: &Allocator, n: usize) -> %[]u8,	12	allocFn: fn (self: &Allocator, n: usize) -> %[]u8,
13	realloc_fn: fn (self: &Allocator, old_mem: []u8, new_size: usize) -> %[]u8,	13	reallocFn: fn (self: &Allocator, old_mem: []u8, new_size: usize) -> %[]u8,
14	free_fn: fn (self: &Allocator, mem: []u8),	14	freeFn: fn (self: &Allocator, mem: []u8),
15	context: ?&Context,	15	context: ?&Context,
16		16
17	/// Aborts the program if an allocation fails.	17	/// Aborts the program if an allocation fails.
18	fn checked_alloc(self: &Allocator, inline T: type, n: usize) -> []T {	18	fn checkedAlloc(self: &Allocator, inline T: type, n: usize) -> []T {
19	alloc(self, T, n) %% \|err\| {	19	alloc(self, T, n) %% \|err\| {
20	// TODO var args printf	20	// TODO var args printf
21	%%io.stderr.write("allocation failure: ");	21	%%io.stderr.write("allocation failure: ");
22	%%io.stderr.write(@err_name(err));	22	%%io.stderr.write(@errName(err));
23	%%io.stderr.printf("\n");	23	%%io.stderr.printf("\n");
24	os.abort()	24	os.abort()
25	}	25	}
26	}	26	}
27		27
28	fn alloc(self: &Allocator, inline T: type, n: usize) -> %[]T {	28	fn alloc(self: &Allocator, inline T: type, n: usize) -> %[]T {
29	const byte_count = %return math.mul_overflow(usize, @sizeof(T), n);	29	const byte_count = %return math.mulOverflow(usize, @sizeOf(T), n);
30	([]T)(%return self.alloc_fn(self, byte_count))	30	([]T)(%return self.allocFn(self, byte_count))
31	}	31	}
32		32
33	fn realloc(self: &Allocator, inline T: type, old_mem: []T, n: usize) -> %[]T {	33	fn realloc(self: &Allocator, inline T: type, old_mem: []T, n: usize) -> %[]T {
34	const byte_count = %return math.mul_overflow(usize, @sizeof(T), n);	34	const byte_count = %return math.mulOverflow(usize, @sizeOf(T), n);
35	([]T)(%return self.realloc_fn(self, ([]u8)(old_mem), byte_count))	35	([]T)(%return self.reallocFn(self, ([]u8)(old_mem), byte_count))
36	}	36	}
37		37
38	fn free(self: &Allocator, inline T: type, mem: []T) {	38	fn free(self: &Allocator, inline T: type, mem: []T) {
39	self.free_fn(self, ([]u8)(mem));	39	self.freeFn(self, ([]u8)(mem));
40	}	40	}
41	}	41	}
42		42
...	@@ -44,7 +44,7 @@ pub struct Allocator {	...	@@ -44,7 +44,7 @@ pub struct Allocator {
44	/// dest.len must be >= source.len.	44	/// dest.len must be >= source.len.
45	pub fn copy(inline T: type, dest: []T, source: []const T) {	45	pub fn copy(inline T: type, dest: []T, source: []const T) {
46	assert(dest.len >= source.len);	46	assert(dest.len >= source.len);
47	@memcpy(dest.ptr, source.ptr, @sizeof(T) * source.len);	47	@memcpy(dest.ptr, source.ptr, @sizeOf(T) * source.len);
48	}	48	}
49		49
50	/// Return < 0, == 0, or > 0 if memory a is less than, equal to, or greater than,	50	/// Return < 0, == 0, or > 0 if memory a is less than, equal to, or greater than,

std/net.zig+43-43

...	@@ -17,7 +17,7 @@ struct Connection {	...	@@ -17,7 +17,7 @@ struct Connection {
17		17
18	pub fn send(c: Connection, buf: []const u8) -> %usize {	18	pub fn send(c: Connection, buf: []const u8) -> %usize {
19	const send_ret = linux.sendto(c.socket_fd, buf.ptr, buf.len, 0, null, 0);	19	const send_ret = linux.sendto(c.socket_fd, buf.ptr, buf.len, 0, null, 0);
20	const send_err = linux.get_errno(send_ret);	20	const send_err = linux.getErrno(send_ret);
21	switch (send_err) {	21	switch (send_err) {
22	0 => return send_ret,	22	0 => return send_ret,
23	errno.EINVAL => unreachable{},	23	errno.EINVAL => unreachable{},
...	@@ -31,7 +31,7 @@ struct Connection {	...	@@ -31,7 +31,7 @@ struct Connection {
31		31
32	pub fn recv(c: Connection, buf: []u8) -> %[]u8 {	32	pub fn recv(c: Connection, buf: []u8) -> %[]u8 {
33	const recv_ret = linux.recvfrom(c.socket_fd, buf.ptr, buf.len, 0, null, null);	33	const recv_ret = linux.recvfrom(c.socket_fd, buf.ptr, buf.len, 0, null, null);
34	const recv_err = linux.get_errno(recv_ret);	34	const recv_err = linux.getErrno(recv_ret);
35	switch (recv_err) {	35	switch (recv_err) {
36	0 => return buf[0...recv_ret],	36	0 => return buf[0...recv_ret],
37	errno.EINVAL => unreachable{},	37	errno.EINVAL => unreachable{},
...	@@ -47,7 +47,7 @@ struct Connection {	...	@@ -47,7 +47,7 @@ struct Connection {
47	}	47	}
48		48
49	pub fn close(c: Connection) -> %void {	49	pub fn close(c: Connection) -> %void {
50	switch (linux.get_errno(linux.close(c.socket_fd))) {	50	switch (linux.getErrno(linux.close(c.socket_fd))) {
51	0 => return,	51	0 => return,
52	errno.EBADF => unreachable{},	52	errno.EBADF => unreachable{},
53	errno.EINTR => return error.SigInterrupt,	53	errno.EINTR => return error.SigInterrupt,
...	@@ -76,7 +76,7 @@ pub fn lookup(hostname: []const u8, out_addrs: []Address) -> %[]Address {	...	@@ -76,7 +76,7 @@ pub fn lookup(hostname: []const u8, out_addrs: []Address) -> %[]Address {
76	unreachable{} // TODO	76	unreachable{} // TODO
77	}	77	}
78		78
79	switch (parse_ip_literal(hostname)) {	79	switch (parseIpLiteral(hostname)) {
80	Ok => \|addr\| {	80	Ok => \|addr\| {
81	out_addrs[0] = addr;	81	out_addrs[0] = addr;
82	return out_addrs[0...1];	82	return out_addrs[0...1];
...	@@ -87,9 +87,9 @@ pub fn lookup(hostname: []const u8, out_addrs: []Address) -> %[]Address {	...	@@ -87,9 +87,9 @@ pub fn lookup(hostname: []const u8, out_addrs: []Address) -> %[]Address {
87	unreachable{} // TODO	87	unreachable{} // TODO
88	}	88	}
89		89
90	pub fn connect_addr(addr: &Address, port: u16) -> %Connection {	90	pub fn connectAddr(addr: &Address, port: u16) -> %Connection {
91	const socket_ret = linux.socket(addr.family, linux.SOCK_STREAM, linux.PROTO_tcp);	91	const socket_ret = linux.socket(addr.family, linux.SOCK_STREAM, linux.PROTO_tcp);
92	const socket_err = linux.get_errno(socket_ret);	92	const socket_err = linux.getErrno(socket_ret);
93	if (socket_err > 0) {	93	if (socket_err > 0) {
94	// TODO figure out possible errors from socket()	94	// TODO figure out possible errors from socket()
95	return error.Unexpected;	95	return error.Unexpected;
...	@@ -99,22 +99,22 @@ pub fn connect_addr(addr: &Address, port: u16) -> %Connection {	...	@@ -99,22 +99,22 @@ pub fn connect_addr(addr: &Address, port: u16) -> %Connection {
99	const connect_ret = if (addr.family == linux.AF_INET) {	99	const connect_ret = if (addr.family == linux.AF_INET) {
100	var os_addr: linux.sockaddr_in = undefined;	100	var os_addr: linux.sockaddr_in = undefined;
101	os_addr.family = addr.family;	101	os_addr.family = addr.family;
102	os_addr.port = swap_if_little_endian(u16, port);	102	os_addr.port = swapIfLittleEndian(u16, port);
103	@memcpy((&u8)(&os_addr.addr), &addr.addr[0], 4);	103	@memcpy((&u8)(&os_addr.addr), &addr.addr[0], 4);
104	@memset(&os_addr.zero, 0, @sizeof(@typeof(os_addr.zero)));	104	@memset(&os_addr.zero, 0, @sizeOf(@typeOf(os_addr.zero)));
105	linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeof(linux.sockaddr_in))	105	linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeOf(linux.sockaddr_in))
106	} else if (addr.family == linux.AF_INET6) {	106	} else if (addr.family == linux.AF_INET6) {
107	var os_addr: linux.sockaddr_in6 = undefined;	107	var os_addr: linux.sockaddr_in6 = undefined;
108	os_addr.family = addr.family;	108	os_addr.family = addr.family;
109	os_addr.port = swap_if_little_endian(u16, port);	109	os_addr.port = swapIfLittleEndian(u16, port);
110	os_addr.flowinfo = 0;	110	os_addr.flowinfo = 0;
111	os_addr.scope_id = addr.scope_id;	111	os_addr.scope_id = addr.scope_id;
112	@memcpy(&os_addr.addr[0], &addr.addr[0], 16);	112	@memcpy(&os_addr.addr[0], &addr.addr[0], 16);
113	linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeof(linux.sockaddr_in6))	113	linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeOf(linux.sockaddr_in6))
114	} else {	114	} else {
115	unreachable{}	115	unreachable{}
116	};	116	};
117	const connect_err = linux.get_errno(connect_ret);	117	const connect_err = linux.getErrno(connect_ret);
118	if (connect_err > 0) {	118	if (connect_err > 0) {
119	switch (connect_err) {	119	switch (connect_err) {
120	errno.ETIMEDOUT => return error.TimedOut,	120	errno.ETIMEDOUT => return error.TimedOut,
...	@@ -135,23 +135,23 @@ pub fn connect(hostname: []const u8, port: u16) -> %Connection {	...	@@ -135,23 +135,23 @@ pub fn connect(hostname: []const u8, port: u16) -> %Connection {
135	const addrs_slice = %return lookup(hostname, addrs_buf);	135	const addrs_slice = %return lookup(hostname, addrs_buf);
136	const main_addr = &addrs_slice[0];	136	const main_addr = &addrs_slice[0];
137		137
138	return connect_addr(main_addr, port);	138	return connectAddr(main_addr, port);
139	}	139	}
140		140
141	pub error InvalidIpLiteral;	141	pub error InvalidIpLiteral;
142		142
143	pub fn parse_ip_literal(buf: []const u8) -> %Address {	143	pub fn parseIpLiteral(buf: []const u8) -> %Address {
144	switch (parse_ip4(buf)) {	144	switch (parseIp4(buf)) {
145	Ok => \|ip4\| {	145	Ok => \|ip4\| {
146	var result: Address = undefined;	146	var result: Address = undefined;
147	@memcpy(&result.addr[0], (&u8)(&ip4), @sizeof(u32));	147	@memcpy(&result.addr[0], (&u8)(&ip4), @sizeOf(u32));
148	result.family = linux.AF_INET;	148	result.family = linux.AF_INET;
149	result.scope_id = 0;	149	result.scope_id = 0;
150	return result;	150	return result;
151	},	151	},
152	else => {},	152	else => {},
153	}	153	}
154	switch (parse_ip6(buf)) {	154	switch (parseIp6(buf)) {
155	Ok => \|addr\| {	155	Ok => \|addr\| {
156	return addr;	156	return addr;
157	},	157	},
...	@@ -161,7 +161,7 @@ pub fn parse_ip_literal(buf: []const u8) -> %Address {	...	@@ -161,7 +161,7 @@ pub fn parse_ip_literal(buf: []const u8) -> %Address {
161	return error.InvalidIpLiteral;	161	return error.InvalidIpLiteral;
162	}	162	}
163		163
164	fn hex_digit(c: u8) -> u8 {	164	fn hexDigit(c: u8) -> u8 {
165	// TODO use switch with range	165	// TODO use switch with range
166	if ('0' <= c && c <= '9') {	166	if ('0' <= c && c <= '9') {
167	c - '0'	167	c - '0'
...	@@ -170,7 +170,7 @@ fn hex_digit(c: u8) -> u8 {	...	@@ -170,7 +170,7 @@ fn hex_digit(c: u8) -> u8 {
170	} else if ('a' <= c && c <= 'z') {	170	} else if ('a' <= c && c <= 'z') {
171	c - 'a' + 10	171	c - 'a' + 10
172	} else {	172	} else {
173	@max_value(u8)	173	@maxValue(u8)
174	}	174	}
175	}	175	}
176		176
...	@@ -180,7 +180,7 @@ error JunkAtEnd;	...	@@ -180,7 +180,7 @@ error JunkAtEnd;
180	error Incomplete;	180	error Incomplete;
181		181
182	#static_eval_enable(false)	182	#static_eval_enable(false)
183	fn parse_ip6(buf: []const u8) -> %Address {	183	fn parseIp6(buf: []const u8) -> %Address {
184	var result: Address = undefined;	184	var result: Address = undefined;
185	result.family = linux.AF_INET6;	185	result.family = linux.AF_INET6;
186	result.scope_id = 0;	186	result.scope_id = 0;
...	@@ -194,10 +194,10 @@ fn parse_ip6(buf: []const u8) -> %Address {	...	@@ -194,10 +194,10 @@ fn parse_ip6(buf: []const u8) -> %Address {
194	if (scope_id) {	194	if (scope_id) {
195	if (c >= '0' && c <= '9') {	195	if (c >= '0' && c <= '9') {
196	const digit = c - '0';	196	const digit = c - '0';
197	if (@mul_with_overflow(u32, result.scope_id, 10, &result.scope_id)) {	197	if (@mulWithOverflow(u32, result.scope_id, 10, &result.scope_id)) {
198	return error.Overflow;	198	return error.Overflow;
199	}	199	}
200	if (@add_with_overflow(u32, result.scope_id, digit, &result.scope_id)) {	200	if (@addWithOverflow(u32, result.scope_id, digit, &result.scope_id)) {
201	return error.Overflow;	201	return error.Overflow;
202	}	202	}
203	} else {	203	} else {
...	@@ -230,14 +230,14 @@ fn parse_ip6(buf: []const u8) -> %Address {	...	@@ -230,14 +230,14 @@ fn parse_ip6(buf: []const u8) -> %Address {
230	scope_id = true;	230	scope_id = true;
231	saw_any_digits = false;	231	saw_any_digits = false;
232	} else {	232	} else {
233	const digit = hex_digit(c);	233	const digit = hexDigit(c);
234	if (digit == @max_value(u8)) {	234	if (digit == @maxValue(u8)) {
235	return error.InvalidChar;	235	return error.InvalidChar;
236	}	236	}
237	if (@mul_with_overflow(u16, x, 16, &x)) {	237	if (@mulWithOverflow(u16, x, 16, &x)) {
238	return error.Overflow;	238	return error.Overflow;
239	}	239	}
240	if (@add_with_overflow(u16, x, digit, &x)) {	240	if (@addWithOverflow(u16, x, digit, &x)) {
241	return error.Overflow;	241	return error.Overflow;
242	}	242	}
243	saw_any_digits = true;	243	saw_any_digits = true;
...	@@ -276,7 +276,7 @@ fn parse_ip6(buf: []const u8) -> %Address {	...	@@ -276,7 +276,7 @@ fn parse_ip6(buf: []const u8) -> %Address {
276	return error.Incomplete;	276	return error.Incomplete;
277	}	277	}
278		278
279	fn parse_ip4(buf: []const u8) -> %u32 {	279	fn parseIp4(buf: []const u8) -> %u32 {
280	var result: u32 = undefined;	280	var result: u32 = undefined;
281	const out_ptr = ([]u8)((&result)[0...1]);	281	const out_ptr = ([]u8)((&result)[0...1]);
282		282
...	@@ -298,10 +298,10 @@ fn parse_ip4(buf: []const u8) -> %u32 {	...	@@ -298,10 +298,10 @@ fn parse_ip4(buf: []const u8) -> %u32 {
298	} else if (c >= '0' && c <= '9') {	298	} else if (c >= '0' && c <= '9') {
299	saw_any_digits = true;	299	saw_any_digits = true;
300	const digit = c - '0';	300	const digit = c - '0';
301	if (@mul_with_overflow(u8, x, 10, &x)) {	301	if (@mulWithOverflow(u8, x, 10, &x)) {
302	return error.Overflow;	302	return error.Overflow;
303	}	303	}
304	if (@add_with_overflow(u8, x, digit, &x)) {	304	if (@addWithOverflow(u8, x, digit, &x)) {
305	return error.Overflow;	305	return error.Overflow;
306	}	306	}
307	} else {	307	} else {
...	@@ -318,19 +318,19 @@ fn parse_ip4(buf: []const u8) -> %u32 {	...	@@ -318,19 +318,19 @@ fn parse_ip4(buf: []const u8) -> %u32 {
318		318
319		319
320	#attribute("test")	320	#attribute("test")
321	fn test_parse_ip4() {	321	fn testParseIp4() {
322	assert(%%parse_ip4("127.0.0.1") == swap_if_little_endian(u32, 0x7f000001));	322	assert(%%parseIp4("127.0.0.1") == swapIfLittleEndian(u32, 0x7f000001));
323	switch (parse_ip4("256.0.0.1")) { Overflow => {}, else => unreachable {}, }	323	switch (parseIp4("256.0.0.1")) { Overflow => {}, else => unreachable {}, }
324	switch (parse_ip4("x.0.0.1")) { InvalidChar => {}, else => unreachable {}, }	324	switch (parseIp4("x.0.0.1")) { InvalidChar => {}, else => unreachable {}, }
325	switch (parse_ip4("127.0.0.1.1")) { JunkAtEnd => {}, else => unreachable {}, }	325	switch (parseIp4("127.0.0.1.1")) { JunkAtEnd => {}, else => unreachable {}, }
326	switch (parse_ip4("127.0.0.")) { Incomplete => {}, else => unreachable {}, }	326	switch (parseIp4("127.0.0.")) { Incomplete => {}, else => unreachable {}, }
327	switch (parse_ip4("100..0.1")) { InvalidChar => {}, else => unreachable {}, }	327	switch (parseIp4("100..0.1")) { InvalidChar => {}, else => unreachable {}, }
328	}	328	}
329		329
330	#attribute("test")	330	#attribute("test")
331	fn test_parse_ip6() {	331	fn testParseIp6() {
332	{	332	{
333	const addr = %%parse_ip6("FF01:0:0:0:0:0:0:FB");	333	const addr = %%parseIp6("FF01:0:0:0:0:0:0:FB");
334	assert(addr.addr[0] == 0xff);	334	assert(addr.addr[0] == 0xff);
335	assert(addr.addr[1] == 0x01);	335	assert(addr.addr[1] == 0x01);
336	assert(addr.addr[2] == 0x00);	336	assert(addr.addr[2] == 0x00);
...	@@ -338,7 +338,7 @@ fn test_parse_ip6() {	...	@@ -338,7 +338,7 @@ fn test_parse_ip6() {
338	}	338	}
339		339
340	#attribute("test")	340	#attribute("test")
341	fn test_lookup_simple_ip() {	341	fn testLookupSimpleIp() {
342	{	342	{
343	var addrs_buf: [5]Address = undefined;	343	var addrs_buf: [5]Address = undefined;
344	const addrs = %%lookup("192.168.1.1", addrs_buf);	344	const addrs = %%lookup("192.168.1.1", addrs_buf);
...	@@ -352,16 +352,16 @@ fn test_lookup_simple_ip() {	...	@@ -352,16 +352,16 @@ fn test_lookup_simple_ip() {
352	}	352	}
353	}	353	}
354		354
355	fn swap_if_little_endian(inline T: type, x: T) -> T {	355	fn swapIfLittleEndian(inline T: type, x: T) -> T {
356	if (@compile_var("is_big_endian")) x else endian_swap(T, x)	356	if (@compileVar("is_big_endian")) x else endianSwap(T, x)
357	}	357	}
358		358
359	fn endian_swap(inline T: type, x: T) -> T {	359	fn endianSwap(inline T: type, x: T) -> T {
360	const x_slice = ([]u8)((&const x)[0...1]);	360	const x_slice = ([]u8)((&const x)[0...1]);
361	var result: T = undefined;	361	var result: T = undefined;
362	const result_slice = ([]u8)((&result)[0...1]);	362	const result_slice = ([]u8)((&result)[0...1]);
363	for (result_slice) \|*b, i\| {	363	for (result_slice) \|*b, i\| {
364	*b = x_slice[@sizeof(T) - i - 1];	364	*b = x_slice[@sizeOf(T) - i - 1];
365	}	365	}
366	return result;	366	return result;
367	}	367	}

std/os.zig+2-2

...	@@ -5,10 +5,10 @@ pub error SigInterrupt;	...	@@ -5,10 +5,10 @@ pub error SigInterrupt;
5	pub error Unexpected;	5	pub error Unexpected;
6		6
7	pub fn get_random_bytes(buf: []u8) -> %void {	7	pub fn get_random_bytes(buf: []u8) -> %void {
8	switch (@compile_var("os")) {	8	switch (@compileVar("os")) {
9	linux => {	9	linux => {
10	const ret = linux.getrandom(buf.ptr, buf.len, 0);	10	const ret = linux.getrandom(buf.ptr, buf.len, 0);
11	const err = linux.get_errno(ret);	11	const err = linux.getErrno(ret);
12	if (err > 0) {	12	if (err > 0) {
13	return switch (err) {	13	return switch (err) {
14	errno.EINVAL => unreachable{},	14	errno.EINVAL => unreachable{},

std/rand.zig+29-31

 @@ -19,15 +19,13 @@ pub const MT19937_64 = MersenneTwister(
 /// Use `init` to initialize this state.
 pub struct Rand {
-    const Rng = if (@sizeof(usize) >= 8) MT19937_64 else MT19937_32;
+    const Rng = if (@sizeOf(usize) >= 8) MT19937_64 else MT19937_32;
     rng: Rng,
     /// Initialize random state with the given seed.
-    pub fn init(seed: usize) -> Rand {
+    pub fn init(r: &Rand, seed: usize) {
-        var r: Rand = undefined;
+        r.rng.init(seed);
-        r.rng = Rng.init(seed);
-        return r;
     }
     /// Get an integer with random bits.
 @@ -35,24 +33,24 @@ pub struct Rand {
         if (T == usize) {
             return r.rng.get();
         } else {
-            var result: [@sizeof(T)]u8 = undefined;
+            var result: [@sizeOf(T)]u8 = undefined;
-            r.fill_bytes(result);
+            r.fillBytes(result);
             return ([]T)(result)[0];
         }
     }
     /// Fill `buf` with randomness.
-    pub fn fill_bytes(r: &Rand, buf: []u8) {
+    pub fn fillBytes(r: &Rand, buf: []u8) {
         var bytes_left = buf.len;
-        while (bytes_left >= @sizeof(usize)) {
+        while (bytes_left >= @sizeOf(usize)) {
             ([]usize)(buf[buf.len - bytes_left...])[0] = r.rng.get();
-            bytes_left -= @sizeof(usize);
+            bytes_left -= @sizeOf(usize);
         }
         if (bytes_left > 0) {
-            var rand_val_array : [@sizeof(usize)]u8 = undefined;
+            var rand_val_array : [@sizeOf(usize)]u8 = undefined;
             ([]usize)(rand_val_array)[0] = r.rng.get();
             while (bytes_left > 0) {
-                buf[buf.len - bytes_left] = rand_val_array[@sizeof(usize) - bytes_left];
+                buf[buf.len - bytes_left] = rand_val_array[@sizeOf(usize) - bytes_left];
                 bytes_left -= 1;
             }
         }
 @@ -61,14 +59,14 @@ pub struct Rand {
     /// Get a random unsigned integer with even distribution between `start`
     /// inclusive and `end` exclusive.
     // TODO support signed integers and then rename to "range"
-    pub fn range_unsigned(r: &Rand, inline T: type, start: T, end: T) -> T {
+    pub fn rangeUnsigned(r: &Rand, inline T: type, start: T, end: T) -> T {
         const range = end - start;
-        const leftover = @max_value(T) % range;
+        const leftover = @maxValue(T) % range;
-        const upper_bound = @max_value(T) - leftover;
+        const upper_bound = @maxValue(T) - leftover;
-        var rand_val_array : [@sizeof(T)]u8 = undefined;
+        var rand_val_array : [@sizeOf(T)]u8 = undefined;
         while (true) {
-            r.fill_bytes(rand_val_array);
+            r.fillBytes(rand_val_array);
             const rand_val = ([]T)(rand_val_array)[0];
             if (rand_val < upper_bound) {
                 return start + (rand_val % range);
 @@ -79,19 +77,19 @@ pub struct Rand {
     /// Get a floating point value in the range 0.0..1.0.
     pub fn float(r: &Rand, inline T: type) -> T {
         // TODO Implement this way instead:
-        // const int = @int_type(false, @sizeof(T) * 8);
+        // const int = @int_type(false, @sizeOf(T) * 8);
         // const mask = ((1 << @float_mantissa_bit_count(T)) - 1);
         // const rand_bits = r.rng.scalar(int) & mask;
         // return @float_compose(T, false, 0, rand_bits) - 1.0
-        const int_type = @int_type(false, @sizeof(T) * 8);
+        const int_type = @intType(false, @sizeOf(T) * 8);
         const precision = if (T == f32) {
             16777216
         } else if (T == f64) {
             9007199254740992
         } else {
-            @compile_err("unknown floating point type" ++ @type_name(T))
+            @compile_err("unknown floating point type" ++ @typeName(T))
         };
-        return T(r.range_unsigned(int_type, 0, precision)) / T(precision);
+        return T(r.rangeUnsigned(int_type, 0, precision)) / T(precision);
     }
 }
 @@ -110,8 +108,7 @@ struct MersenneTwister(
     // TODO improve compile time eval code and then allow this function to be executed at compile time.
     #static_eval_enable(false)
-    pub fn init(seed: int) -> Self {
+    pub fn init(mt: &Self, seed: int) {
-        var mt: Self = undefined;
         mt.index = n;
         var prev_value = seed;
 @@ -120,8 +117,6 @@ struct MersenneTwister(
             prev_value = int(i) +% f *% (prev_value ^ (prev_value >> (int.bit_count - 2)));
             mt.array[i] = prev_value;
         }};
-        return mt;
     }
     pub fn get(mt: &Self) -> int {
 @@ -161,8 +156,9 @@ struct MersenneTwister(
 }
 #attribute("test")
-fn test_float32() {
+fn testFloat32() {
-    var r = Rand.init(42);
+    var r: Rand = undefined;
+    r.init(42);
     {var i: usize = 0; while (i < 1000; i += 1) {
         const val = r.float(f32);
 @@ -172,16 +168,18 @@ fn test_float32() {
 }
 #attribute("test")
-fn test_MT19937_64() {
+fn testMT19937_64() {
-    const rng = MT19937_64.init(rand_test.mt64_seed);
+    var rng: MT19937_64 = undefined;
+    rng.init(rand_test.mt64_seed);
     for (rand_test.mt64_data) |value| {
         assert(value == rng.get());
     }
 }
 #attribute("test")
-fn test_MT19937_32() {
+fn testMT19937_32() {
-    const rng = MT19937_32.init(rand_test.mt32_seed);
+    var rng: MT19937_32 = undefined;
+    rng.init(rand_test.mt32_seed);
     for (rand_test.mt32_data) |value| {
         assert(value == rng.get());
     }

std/str.zig+3-3

...	@@ -1,10 +1,10 @@	...	@@ -1,10 +1,10 @@
1	const assert = @import("debug.zig").assert;	1	const assert = @import("debug.zig").assert;
2		2
3	pub fn eql(a: []const u8, b: []const u8) -> bool {	3	pub fn eql(a: []const u8, b: []const u8) -> bool {
4	slice_eql(u8, a, b)	4	sliceEql(u8, a, b)
5	}	5	}
6		6
7	pub fn slice_eql(inline T: type, a: []const T, b: []const T) -> bool {	7	pub fn sliceEql(inline T: type, a: []const T, b: []const T) -> bool {
8	if (a.len != b.len) return false;	8	if (a.len != b.len) return false;
9	for (a) \|item, index\| {	9	for (a) \|item, index\| {
10	if (b[index] != item) return false;	10	if (b[index] != item) return false;
...	@@ -13,7 +13,7 @@ pub fn slice_eql(inline T: type, a: []const T, b: []const T) -> bool {	...	@@ -13,7 +13,7 @@ pub fn slice_eql(inline T: type, a: []const T, b: []const T) -> bool {
13	}	13	}
14		14
15	#attribute("test")	15	#attribute("test")
16	fn string_equality() {	16	fn stringEquality() {
17	assert(eql("abcd", "abcd"));	17	assert(eql("abcd", "abcd"));
18	assert(!eql("abcdef", "abZdef"));	18	assert(!eql("abcdef", "abZdef"));
19	assert(!eql("abcdefg", "abcdef"));	19	assert(!eql("abcdefg", "abcdef"));

std/test_runner.zig+4-4

...	@@ -7,19 +7,19 @@ struct TestFn {	...	@@ -7,19 +7,19 @@ struct TestFn {
7		7
8	extern var zig_test_fn_list: []TestFn;	8	extern var zig_test_fn_list: []TestFn;
9		9
10	pub fn run_tests() -> %void {	10	pub fn runTests() -> %void {
11	for (zig_test_fn_list) \|test_fn, i\| {	11	for (zig_test_fn_list) \|testFn, i\| {
12	// TODO: print var args	12	// TODO: print var args
13	%%io.stderr.write("Test ");	13	%%io.stderr.write("Test ");
14	%%io.stderr.print_u64(i + 1);	14	%%io.stderr.print_u64(i + 1);
15	%%io.stderr.write("/");	15	%%io.stderr.write("/");
16	%%io.stderr.print_u64(zig_test_fn_list.len);	16	%%io.stderr.print_u64(zig_test_fn_list.len);
17	%%io.stderr.write(" ");	17	%%io.stderr.write(" ");
18	%%io.stderr.write(test_fn.name);	18	%%io.stderr.write(testFn.name);
19	%%io.stderr.write("...");	19	%%io.stderr.write("...");
20	%%io.stderr.flush();	20	%%io.stderr.flush();
21		21
22	test_fn.func();	22	testFn.func();
23		23
24		24
25	%%io.stderr.write("OK\n");	25	%%io.stderr.write("OK\n");

std/test_runner_libc.zig+1-1

...	@@ -1,6 +1,6 @@	...	@@ -1,6 +1,6 @@
1	const test_runner = @import("test_runner.zig");	1	const test_runner = @import("test_runner.zig");
2		2
3	export fn main(argc: c_int, argv: &&u8) -> c_int {	3	export fn main(argc: c_int, argv: &&u8) -> c_int {
4	test_runner.run_tests() %% return -1;	4	test_runner.runTests() %% return -1;
5	return 0;	5	return 0;
6	}	6	}

std/test_runner_nolibc.zig+1-1

...	@@ -1,5 +1,5 @@	...	@@ -1,5 +1,5 @@
1	const test_runner = @import("test_runner.zig");	1	const test_runner = @import("test_runner.zig");
2		2
3	pub fn main(args: [][]u8) -> %void {	3	pub fn main(args: [][]u8) -> %void {
4	return test_runner.run_tests();	4	return test_runner.runTests();
5	}	5	}

test/cases/sizeof_and_typeof.zig created+9

...	@@ -0,0 +1,9 @@
1	const assert = @import("std").debug.assert;
2
3	#attribute("test")
4	fn sizeofAndTypeOf() {
5	const y: @typeOf(x) = 120;
6	assert(@sizeOf(@typeOf(y)) == 2);
7	}
8	const x: u16 = 13;
9	const z: @typeOf(x) = 19;

test/run_tests.cpp+35-35

...	@@ -202,7 +202,7 @@ static TestCase add_parseh_case(const char case_name, const char *source, int	...	@@ -202,7 +202,7 @@ static TestCase add_parseh_case(const char case_name, const char *source, int
202		202
203	static void add_compiling_test_cases(void) {	203	static void add_compiling_test_cases(void) {
204	add_simple_case_libc("hello world with libc", R"SOURCE(	204	add_simple_case_libc("hello world with libc", R"SOURCE(
205	const c = @c_import(@c_include("stdio.h"));	205	const c = @cImport(@cInclude("stdio.h"));
206	export fn main(argc: c_int, argv: &&u8) -> c_int {	206	export fn main(argc: c_int, argv: &&u8) -> c_int {
207	c.puts(c"Hello, world!");	207	c.puts(c"Hello, world!");
208	return 0;	208	return 0;
...	@@ -215,12 +215,12 @@ use @import("std").io;	...	@@ -215,12 +215,12 @@ use @import("std").io;
215	use @import("foo.zig");	215	use @import("foo.zig");
216		216
217	pub fn main(args: [][]u8) -> %void {	217	pub fn main(args: [][]u8) -> %void {
218	private_function();	218	privateFunction();
219	%%stdout.printf("OK 2\n");	219	%%stdout.printf("OK 2\n");
220	}	220	}
221		221
222	fn private_function() {	222	fn privateFunction() {
223	print_text();	223	printText();
224	}	224	}
225	)SOURCE", "OK 1\nOK 2\n");	225	)SOURCE", "OK 1\nOK 2\n");
226		226
...	@@ -229,12 +229,12 @@ use @import("std").io;	...	@@ -229,12 +229,12 @@ use @import("std").io;
229		229
230	// purposefully conflicting function with main.zig	230	// purposefully conflicting function with main.zig
231	// but it's private so it should be OK	231	// but it's private so it should be OK
232	fn private_function() {	232	fn privateFunction() {
233	%%stdout.printf("OK 1\n");	233	%%stdout.printf("OK 1\n");
234	}	234	}
235		235
236	pub fn print_text() {	236	pub fn printText() {
237	private_function();	237	privateFunction();
238	}	238	}
239	)SOURCE");	239	)SOURCE");
240	}	240	}
...	@@ -316,7 +316,7 @@ pub fn main(args: [][]u8) -> %void {	...	@@ -316,7 +316,7 @@ pub fn main(args: [][]u8) -> %void {
316		316
317		317
318	add_simple_case_libc("number literals", R"SOURCE(	318	add_simple_case_libc("number literals", R"SOURCE(
319	const c = @c_import(@c_include("stdio.h"));	319	const c = @cImport(@cInclude("stdio.h"));
320		320
321	export fn main(argc: c_int, argv: &&u8) -> c_int {	321	export fn main(argc: c_int, argv: &&u8) -> c_int {
322	c.printf(c"\n");	322	c.printf(c"\n");
...	@@ -444,12 +444,12 @@ export fn main(argc: c_int, argv: &&u8) -> c_int {	...	@@ -444,12 +444,12 @@ export fn main(argc: c_int, argv: &&u8) -> c_int {
444	add_simple_case("order-independent declarations", R"SOURCE(	444	add_simple_case("order-independent declarations", R"SOURCE(
445	const io = @import("std").io;	445	const io = @import("std").io;
446	const z = io.stdin_fileno;	446	const z = io.stdin_fileno;
447	const x : @typeof(y) = 1234;	447	const x : @typeOf(y) = 1234;
448	const y : u16 = 5678;	448	const y : u16 = 5678;
449	pub fn main(args: [][]u8) -> %void {	449	pub fn main(args: [][]u8) -> %void {
450	var x_local : i32 = print_ok(x);	450	var x_local : i32 = print_ok(x);
451	}	451	}
452	fn print_ok(val: @typeof(x)) -> @typeof(foo) {	452	fn print_ok(val: @typeOf(x)) -> @typeOf(foo) {
453	%%io.stdout.printf("OK\n");	453	%%io.stdout.printf("OK\n");
454	return 0;	454	return 0;
455	}	455	}
...	@@ -482,7 +482,7 @@ pub fn main(args: [][]u8) -> %void {	...	@@ -482,7 +482,7 @@ pub fn main(args: [][]u8) -> %void {
482	)SOURCE", "9\n8\n7\n6\n0\n1\n2\n3\n9\n8\n7\n6\n0\n1\n2\n3\n");	482	)SOURCE", "9\n8\n7\n6\n0\n1\n2\n3\n9\n8\n7\n6\n0\n1\n2\n3\n");
483		483
484	add_simple_case_libc("expose function pointer to C land", R"SOURCE(	484	add_simple_case_libc("expose function pointer to C land", R"SOURCE(
485	const c = @c_import(@c_include("stdlib.h"));	485	const c = @cImport(@cInclude("stdlib.h"));
486		486
487	export fn compare_fn(a: ?&const c_void, b: ?&const c_void) -> c_int {	487	export fn compare_fn(a: ?&const c_void, b: ?&const c_void) -> c_int {
488	const a_int = (&i32)(a ?? unreachable{});	488	const a_int = (&i32)(a ?? unreachable{});
...	@@ -499,7 +499,7 @@ export fn compare_fn(a: ?&const c_void, b: ?&const c_void) -> c_int {	...	@@ -499,7 +499,7 @@ export fn compare_fn(a: ?&const c_void, b: ?&const c_void) -> c_int {
499	export fn main(args: c_int, argv: &&u8) -> c_int {	499	export fn main(args: c_int, argv: &&u8) -> c_int {
500	var array = []u32 { 1, 7, 3, 2, 0, 9, 4, 8, 6, 5 };	500	var array = []u32 { 1, 7, 3, 2, 0, 9, 4, 8, 6, 5 };
501		501
502	c.qsort((&c_void)(&array[0]), c_ulong(array.len), @sizeof(i32), compare_fn);	502	c.qsort((&c_void)(&array[0]), c_ulong(array.len), @sizeOf(i32), compare_fn);
503		503
504	for (array) \|item, i\| {	504	for (array) \|item, i\| {
505	if (item != i) {	505	if (item != i) {
...	@@ -514,7 +514,7 @@ export fn main(args: c_int, argv: &&u8) -> c_int {	...	@@ -514,7 +514,7 @@ export fn main(args: c_int, argv: &&u8) -> c_int {
514		514
515		515
516	add_simple_case_libc("casting between float and integer types", R"SOURCE(	516	add_simple_case_libc("casting between float and integer types", R"SOURCE(
517	const c = @c_import(@c_include("stdio.h"));	517	const c = @cImport(@cInclude("stdio.h"));
518	export fn main(argc: c_int, argv: &&u8) -> c_int {	518	export fn main(argc: c_int, argv: &&u8) -> c_int {
519	const small: f32 = 3.25;	519	const small: f32 = 3.25;
520	const x: f64 = small;	520	const x: f64 = small;
...	@@ -654,8 +654,8 @@ fn its_gonna_pass() -> %void { }	...	@@ -654,8 +654,8 @@ fn its_gonna_pass() -> %void { }
654		654
655		655
656	{	656	{
657	TestCase *tc = add_simple_case("@embed_file", R"SOURCE(	657	TestCase *tc = add_simple_case("@embedFile", R"SOURCE(
658	const foo_txt = @embed_file("foo.txt");	658	const foo_txt = @embedFile("foo.txt");
659	const io = @import("std").io;	659	const io = @import("std").io;
660		660
661	pub fn main(args: [][]u8) -> %void {	661	pub fn main(args: [][]u8) -> %void {
...	@@ -956,8 +956,8 @@ fn f() -> @bogus(foo) {	...	@@ -956,8 +956,8 @@ fn f() -> @bogus(foo) {
956	)SOURCE", 1, ".tmp_source.zig:2:11: error: invalid builtin function: 'bogus'");	956	)SOURCE", 1, ".tmp_source.zig:2:11: error: invalid builtin function: 'bogus'");
957		957
958	add_compile_fail_case("top level decl dependency loop", R"SOURCE(	958	add_compile_fail_case("top level decl dependency loop", R"SOURCE(
959	const a : @typeof(b) = 0;	959	const a : @typeOf(b) = 0;
960	const b : @typeof(a) = 0;	960	const b : @typeOf(a) = 0;
961	)SOURCE", 1, ".tmp_source.zig:2:1: error: 'a' depends on itself");	961	)SOURCE", 1, ".tmp_source.zig:2:1: error: 'a' depends on itself");
962		962
963	add_compile_fail_case("noalias on non pointer param", R"SOURCE(	963	add_compile_fail_case("noalias on non pointer param", R"SOURCE(
...	@@ -1012,8 +1012,8 @@ fn f(s: [10]u8) -> []u8 {	...	@@ -1012,8 +1012,8 @@ fn f(s: [10]u8) -> []u8 {
1012	}	1012	}
1013	)SOURCE", 1, ".tmp_source.zig:3:5: error: array concatenation requires constant expression");	1013	)SOURCE", 1, ".tmp_source.zig:3:5: error: array concatenation requires constant expression");
1014		1014
1015	add_compile_fail_case("c_import with bogus include", R"SOURCE(	1015	add_compile_fail_case("@cImport with bogus include", R"SOURCE(
1016	const c = @c_import(@c_include("bogus.h"));	1016	const c = @cImport(@cInclude("bogus.h"));
1017	)SOURCE", 2, ".tmp_source.zig:2:11: error: C import failed",	1017	)SOURCE", 2, ".tmp_source.zig:2:11: error: C import failed",
1018	".h:1:10: note: 'bogus.h' file not found");	1018	".h:1:10: note: 'bogus.h' file not found");
1019		1019
...	@@ -1022,12 +1022,12 @@ const x = 3;	...	@@ -1022,12 +1022,12 @@ const x = 3;
1022	const y = &x;	1022	const y = &x;
1023	)SOURCE", 1, ".tmp_source.zig:3:12: error: unable to get address of type '(integer literal)'");	1023	)SOURCE", 1, ".tmp_source.zig:3:12: error: unable to get address of type '(integer literal)'");
1024		1024
1025	add_compile_fail_case("@typeof number literal", R"SOURCE(	1025	add_compile_fail_case("@typeOf number literal", R"SOURCE(
1026	const x = 3;	1026	const x = 3;
1027	struct Foo {	1027	struct Foo {
1028	index: @typeof(x),	1028	index: @typeOf(x),
1029	}	1029	}
1030	)SOURCE", 1, ".tmp_source.zig:4:20: error: type '(integer literal)' not eligible for @typeof");	1030	)SOURCE", 1, ".tmp_source.zig:4:20: error: type '(integer literal)' not eligible for @typeOf");
1031		1031
1032	add_compile_fail_case("integer overflow error", R"SOURCE(	1032	add_compile_fail_case("integer overflow error", R"SOURCE(
1033	const x : u8 = 300;	1033	const x : u8 = 300;
...	@@ -1050,7 +1050,7 @@ struct Foo {	...	@@ -1050,7 +1050,7 @@ struct Foo {
1050	}	1050	}
1051	}	1051	}
1052		1052
1053	const member_fn_type = @typeof(Foo.member_a);	1053	const member_fn_type = @typeOf(Foo.member_a);
1054	const members = []member_fn_type {	1054	const members = []member_fn_type {
1055	Foo.member_a,	1055	Foo.member_a,
1056	Foo.member_b,	1056	Foo.member_b,
...	@@ -1101,15 +1101,15 @@ fn func() -> bogus {}	...	@@ -1101,15 +1101,15 @@ fn func() -> bogus {}
1101		1101
1102		1102
1103	add_compile_fail_case("bogus compile var", R"SOURCE(	1103	add_compile_fail_case("bogus compile var", R"SOURCE(
1104	const x = @compile_var("bogus");	1104	const x = @compileVar("bogus");
1105	)SOURCE", 1, ".tmp_source.zig:2:24: error: unrecognized compile variable: 'bogus'");	1105	)SOURCE", 1, ".tmp_source.zig:2:23: error: unrecognized compile variable: 'bogus'");
1106		1106
1107		1107
1108	add_compile_fail_case("@const_eval", R"SOURCE(	1108	add_compile_fail_case("@constEval", R"SOURCE(
1109	fn a(x: i32) {	1109	fn a(x: i32) {
1110	const y = @const_eval(x);	1110	const y = @constEval(x);
1111	}	1111	}
1112	)SOURCE", 1, ".tmp_source.zig:3:27: error: unable to evaluate constant expression");	1112	)SOURCE", 1, ".tmp_source.zig:3:26: error: unable to evaluate constant expression");
1113		1113
1114	add_compile_fail_case("non constant expression in array size outside function", R"SOURCE(	1114	add_compile_fail_case("non constant expression in array size outside function", R"SOURCE(
1115	struct Foo {	1115	struct Foo {
...	@@ -1245,8 +1245,8 @@ fn fibbonaci(x: i32) -> i32 {	...	@@ -1245,8 +1245,8 @@ fn fibbonaci(x: i32) -> i32 {
1245	".tmp_source.zig:2:37: note: called from here",	1245	".tmp_source.zig:2:37: note: called from here",
1246	".tmp_source.zig:4:40: note: quota exceeded here");	1246	".tmp_source.zig:4:40: note: quota exceeded here");
1247		1247
1248	add_compile_fail_case("@embed_file with bogus file", R"SOURCE(	1248	add_compile_fail_case("@embedFile with bogus file", R"SOURCE(
1249	const resource = @embed_file("bogus.txt");	1249	const resource = @embedFile("bogus.txt");
1250	)SOURCE", 1, ".tmp_source.zig:2:18: error: unable to find './bogus.txt'");	1250	)SOURCE", 1, ".tmp_source.zig:2:18: error: unable to find './bogus.txt'");
1251		1251
1252		1252
...	@@ -1555,23 +1555,23 @@ fn div0(a: i32, b: i32) -> i32 {	...	@@ -1555,23 +1555,23 @@ fn div0(a: i32, b: i32) -> i32 {
1555	add_debug_safety_case("exact division failure", R"SOURCE(	1555	add_debug_safety_case("exact division failure", R"SOURCE(
1556	error Whatever;	1556	error Whatever;
1557	pub fn main(args: [][]u8) -> %void {	1557	pub fn main(args: [][]u8) -> %void {
1558	const x = div_exact(10, 3);	1558	const x = divExact(10, 3);
1559	if (x == 0) return error.Whatever;	1559	if (x == 0) return error.Whatever;
1560	}	1560	}
1561	#static_eval_enable(false)	1561	#static_eval_enable(false)
1562	fn div_exact(a: i32, b: i32) -> i32 {	1562	fn divExact(a: i32, b: i32) -> i32 {
1563	@div_exact(a, b)	1563	@divExact(a, b)
1564	}	1564	}
1565	)SOURCE");	1565	)SOURCE");
1566		1566
1567	add_debug_safety_case("cast []u8 to bigger slice of wrong size", R"SOURCE(	1567	add_debug_safety_case("cast []u8 to bigger slice of wrong size", R"SOURCE(
1568	error Whatever;	1568	error Whatever;
1569	pub fn main(args: [][]u8) -> %void {	1569	pub fn main(args: [][]u8) -> %void {
1570	const x = widen_slice([]u8{1, 2, 3, 4, 5});	1570	const x = widenSlice([]u8{1, 2, 3, 4, 5});
1571	if (x.len == 0) return error.Whatever;	1571	if (x.len == 0) return error.Whatever;
1572	}	1572	}
1573	#static_eval_enable(false)	1573	#static_eval_enable(false)
1574	fn widen_slice(slice: []u8) -> []i32 {	1574	fn widenSlice(slice: []u8) -> []i32 {
1575	([]i32)(slice)	1575	([]i32)(slice)
1576	}	1576	}
1577	)SOURCE");	1577	)SOURCE");

test/self_hosted.zig+357-364

 @@ -3,29 +3,30 @@ const assert = std.debug.assert;
 const str = std.str;
 const cstr = std.cstr;
 const other = @import("other.zig");
-const cases_return_type_type = @import("cases/return_type_type.zig");
+const test_return_type_type = @import("cases/return_type_type.zig");
 const test_zeroes = @import("cases/zeroes.zig");
+const test_sizeof_and_typeof = @import("cases/sizeof_and_typeof.zig");
 // normal comment
 /// this is a documentation comment
 /// doc comment line 2
 #attribute("test")
-fn empty_function_with_comments() {}
+fn emptyFunctionWithComments() {}
 #attribute("test")
-fn if_statements() {
+fn ifStatements() {
-    should_be_equal(1, 1);
+    shouldBeEqual(1, 1);
-    first_eql_third(2, 1, 2);
+    firstEqlThird(2, 1, 2);
 }
-fn should_be_equal(a: i32, b: i32) {
+fn shouldBeEqual(a: i32, b: i32) {
     if (a != b) {
         unreachable{};
     } else {
         return;
     }
 }
-fn first_eql_third(a: i32, b: i32, c: i32) {
+fn firstEqlThird(a: i32, b: i32, c: i32) {
     if (a == b) {
         unreachable{};
     } else if (b == c) {
 @@ -40,33 +41,33 @@ fn first_eql_third(a: i32, b: i32, c: i32) {
 #attribute("test")
 fn params() {
-    assert(test_params_add(22, 11) == 33);
+    assert(testParamsAdd(22, 11) == 33);
 }
-fn test_params_add(a: i32, b: i32) -> i32 {
+fn testParamsAdd(a: i32, b: i32) -> i32 {
     a + b
 }
 #attribute("test")
-fn local_variables() {
+fn localVariables() {
-    test_loc_vars(2);
+    testLocVars(2);
 }
-fn test_loc_vars(b: i32) {
+fn testLocVars(b: i32) {
     const a: i32 = 1;
     if (a + b != 3) unreachable{};
 }
 #attribute("test")
-fn bool_literals() {
+fn boolLiterals() {
     assert(true);
     assert(!false);
 }
 #attribute("test")
-fn void_parameters() {
+fn voidParameters() {
-    void_fun(1, void{}, 2, {});
+    voidFun(1, void{}, 2, {});
 }
-fn void_fun(a : i32, b : void, c : i32, d : void) {
+fn voidFun(a : i32, b : void, c : i32, d : void) {
     const v = b;
     const vv : void = if (a == 1) {v} else {};
     assert(a + c == 3);
 @@ -74,7 +75,7 @@ fn void_fun(a : i32, b : void, c : i32, d : void) {
 }
 #attribute("test")
-fn mutable_local_variables() {
+fn mutableLocalVariables() {
     var zero : i32 = 0;
     assert(zero == 0);
 @@ -104,31 +105,31 @@ fn arrays() {
     }
     assert(accumulator == 15);
-    assert(get_array_len(array) == 5);
+    assert(getArrayLen(array) == 5);
 }
-fn get_array_len(a: []u32) -> usize {
+fn getArrayLen(a: []u32) -> usize {
     a.len
 }
 #attribute("test")
-fn short_circuit() {
+fn shortCircuit() {
     var hit_1 = false;
     var hit_2 = false;
     var hit_3 = false;
     var hit_4 = false;
-    if (true || {assert_runtime(false); false}) {
+    if (true || {assertRuntime(false); false}) {
         hit_1 = true;
     }
     if (false || { hit_2 = true; false }) {
-        assert_runtime(false);
+        assertRuntime(false);
     }
     if (true && { hit_3 = true; false }) {
-        assert_runtime(false);
+        assertRuntime(false);
     }
-    if (false && {assert_runtime(false); false}) {
+    if (false && {assertRuntime(false); false}) {
-        assert_runtime(false);
+        assertRuntime(false);
     } else {
         hit_4 = true;
     }
 @@ -139,12 +140,12 @@ fn short_circuit() {
 }
 #static_eval_enable(false)
-fn assert_runtime(b: bool) {
+fn assertRuntime(b: bool) {
     if (!b) unreachable{}
 }
 #attribute("test")
-fn modify_operators() {
+fn modifyOperators() {
     var i : i32 = 0;
     i += 5;  assert(i == 5);
     i -= 2;  assert(i == 3);
 @@ -162,7 +163,7 @@ fn modify_operators() {
 #attribute("test")
-fn separate_block_scopes() {
+fn separateBlockScopes() {
     {
         const no_conflict : i32 = 5;
         assert(no_conflict == 5);
 @@ -177,14 +178,14 @@ fn separate_block_scopes() {
 #attribute("test")
-fn void_struct_fields() {
+fn voidStructFields() {
     const foo = VoidStructFieldsFoo {
         .a = void{},
         .b = 1,
         .c = void{},
     };
     assert(foo.b == 1);
-    assert(@sizeof(VoidStructFieldsFoo) == 4);
+    assert(@sizeOf(VoidStructFieldsFoo) == 4);
 }
 struct VoidStructFieldsFoo {
     a : void,
 @@ -197,11 +198,11 @@ struct VoidStructFieldsFoo {
 #attribute("test")
 pub fn structs() {
     var foo : StructFoo = undefined;
-    @memset(&foo, 0, @sizeof(StructFoo));
+    @memset(&foo, 0, @sizeOf(StructFoo));
     foo.a += 1;
     foo.b = foo.a == 1;
-    test_foo(foo);
+    testFoo(foo);
-    test_mutation(&foo);
+    testMutation(&foo);
     assert(foo.c == 100);
 }
 struct StructFoo {
 @@ -209,10 +210,10 @@ struct StructFoo {
     b : bool,
     c : f32,
 }
-fn test_foo(foo : StructFoo) {
+fn testFoo(foo : StructFoo) {
     assert(foo.b);
 }
-fn test_mutation(foo : &StructFoo) {
+fn testMutation(foo : &StructFoo) {
     foo.c = 100;
 }
 struct Node {
 @@ -225,7 +226,7 @@ struct Val {
 }
 #attribute("test")
-fn struct_point_to_self() {
+fn structPointToSelf() {
     var root : Node = undefined;
     root.val.x = 1;
 @@ -239,7 +240,7 @@ fn struct_point_to_self() {
 }
 #attribute("test")
-fn struct_byval_assign() {
+fn structByvalAssign() {
     var foo1 : StructFoo = undefined;
     var foo2 : StructFoo = undefined;
 @@ -250,7 +251,7 @@ fn struct_byval_assign() {
     assert(foo2.a == 1234);
 }
-fn struct_initializer() {
+fn structInitializer() {
     const val = Val { .x = 42 };
     assert(val.x == 42);
 }
 @@ -260,7 +261,7 @@ const g1 : i32 = 1233 + 1;
 var g2 : i32 = 0;
 #attribute("test")
-fn global_variables() {
+fn globalVariables() {
     assert(g2 == 0);
     g2 = g1;
     assert(g2 == 1234);
 @@ -268,55 +269,55 @@ fn global_variables() {
 #attribute("test")
-fn while_loop() {
+fn whileLoop() {
     var i : i32 = 0;
     while (i < 4) {
         i += 1;
     }
     assert(i == 4);
-    assert(while_loop_1() == 1);
+    assert(whileLoop1() == 1);
 }
-fn while_loop_1() -> i32 {
+fn whileLoop1() -> i32 {
-    return while_loop_2();
+    return whileLoop2();
 }
-fn while_loop_2() -> i32 {
+fn whileLoop2() -> i32 {
     while (true) {
         return 1;
     }
 }
 #attribute("test")
-fn void_arrays() {
+fn voidArrays() {
     var array: [4]void = undefined;
     array[0] = void{};
     array[1] = array[2];
-    assert(@sizeof(@typeof(array)) == 0);
+    assert(@sizeOf(@typeOf(array)) == 0);
     assert(array.len == 4);
 }
 #attribute("test")
-fn three_expr_in_a_row() {
+fn threeExprInARow() {
-    assert_false(false || false || false);
+    assertFalse(false || false || false);
-    assert_false(true && true && false);
+    assertFalse(true && true && false);
-    assert_false(1 | 2 | 4 != 7);
+    assertFalse(1 | 2 | 4 != 7);
-    assert_false(3 ^ 6 ^ 8 != 13);
+    assertFalse(3 ^ 6 ^ 8 != 13);
-    assert_false(7 & 14 & 28 != 4);
+    assertFalse(7 & 14 & 28 != 4);
-    assert_false(9  << 1 << 2 != 9  << 3);
+    assertFalse(9  << 1 << 2 != 9  << 3);
-    assert_false(90 >> 1 >> 2 != 90 >> 3);
+    assertFalse(90 >> 1 >> 2 != 90 >> 3);
-    assert_false(100 - 1 + 1000 != 1099);
+    assertFalse(100 - 1 + 1000 != 1099);
-    assert_false(5 * 4 / 2 % 3 != 1);
+    assertFalse(5 * 4 / 2 % 3 != 1);
-    assert_false(i32(i32(5)) != 5);
+    assertFalse(i32(i32(5)) != 5);
-    assert_false(!!false);
+    assertFalse(!!false);
-    assert_false(i32(7) != --(i32(7)));
+    assertFalse(i32(7) != --(i32(7)));
 }
-fn assert_false(b: bool) {
+fn assertFalse(b: bool) {
     assert(!b);
 }
 #attribute("test")
-fn maybe_type() {
+fn maybeType() {
     const x : ?bool = true;
     if (const y ?= x) {
 @@ -344,21 +345,21 @@ fn maybe_type() {
 #attribute("test")
-fn enum_type() {
+fn enumType() {
     const foo1 = EnumTypeFoo.One {13};
     const foo2 = EnumTypeFoo.Two {EnumType { .x = 1234, .y = 5678, }};
     const bar = EnumTypeBar.B;
     assert(bar == EnumTypeBar.B);
-    assert(@member_count(EnumTypeFoo) == 3);
+    assert(@memberCount(EnumTypeFoo) == 3);
-    assert(@member_count(EnumTypeBar) == 4);
+    assert(@memberCount(EnumTypeBar) == 4);
-    const expected_foo_size = switch (@compile_var("arch")) {
+    const expected_foo_size = switch (@compileVar("arch")) {
         i386 => 20,
         x86_64 => 24,
         else => unreachable{},
     };
-    assert(@sizeof(EnumTypeFoo) == expected_foo_size);
+    assert(@sizeOf(EnumTypeFoo) == expected_foo_size);
-    assert(@sizeof(EnumTypeBar) == 1);
+    assert(@sizeOf(EnumTypeBar) == 1);
 }
 struct EnumType {
     x: u64,
 @@ -378,16 +379,16 @@ enum EnumTypeBar {
 #attribute("test")
-fn array_literal() {
+fn arrayLiteral() {
-    const HEX_MULT = []u16{4096, 256, 16, 1};
+    const hex_mult = []u16{4096, 256, 16, 1};
-    assert(HEX_MULT.len == 4);
+    assert(hex_mult.len == 4);
-    assert(HEX_MULT[1] == 256);
+    assert(hex_mult[1] == 256);
 }
 #attribute("test")
-fn const_number_literal() {
+fn constNumberLiteral() {
     const one = 1;
     const eleven = ten + one;
 @@ -397,7 +398,7 @@ const ten = 10;
 #attribute("test")
-fn error_values() {
+fn errorValues() {
     const a = i32(error.err1);
     const b = i32(error.err2);
     assert(a != b);
 @@ -408,30 +409,30 @@ error err2;
 #attribute("test")
-fn fn_call_of_struct_field() {
+fn fnCallOfStructField() {
-    assert(call_struct_field(Foo {.ptr = a_func,}) == 13);
+    assert(callStructField(Foo {.ptr = aFunc,}) == 13);
 }
 struct Foo {
     ptr: fn() -> i32,
 }
-fn a_func() -> i32 { 13 }
+fn aFunc() -> i32 { 13 }
-fn call_struct_field(foo: Foo) -> i32 {
+fn callStructField(foo: Foo) -> i32 {
     return foo.ptr();
 }
 #attribute("test")
-fn redefinition_of_error_values_allowed() {
+fn redefinitionOfErrorValuesAllowed() {
-    should_be_not_equal(error.AnError, error.SecondError);
+    shouldBeNotEqual(error.AnError, error.SecondError);
 }
 error AnError;
 error AnError;
 error SecondError;
-fn should_be_not_equal(a: error, b: error) {
+fn shouldBeNotEqual(a: error, b: error) {
     if (a == b) unreachable{}
 }
 @@ -439,21 +440,21 @@ fn should_be_not_equal(a: error, b: error) {
 #attribute("test")
-fn constant_enum_with_payload() {
+fn constantEnumWithPayload() {
     var empty = AnEnumWithPayload.Empty;
     var full = AnEnumWithPayload.Full {13};
-    should_be_empty(empty);
+    shouldBeEmpty(empty);
-    should_be_not_empty(full);
+    shouldBeNotEmpty(full);
 }
-fn should_be_empty(x: AnEnumWithPayload) {
+fn shouldBeEmpty(x: AnEnumWithPayload) {
     switch (x) {
         Empty => {},
         else => unreachable{},
     }
 }
-fn should_be_not_empty(x: AnEnumWithPayload) {
+fn shouldBeNotEmpty(x: AnEnumWithPayload) {
     switch (x) {
         Empty => unreachable{},
         else => {},
 @@ -467,7 +468,7 @@ enum AnEnumWithPayload {
 #attribute("test")
-fn continue_in_for_loop() {
+fn continueInForLoop() {
     const array = []i32 {1, 2, 3, 4, 5};
     var sum : i32 = 0;
     for (array) |x| {
 @@ -482,24 +483,24 @@ fn continue_in_for_loop() {
 #attribute("test")
-fn cast_bool_to_int() {
+fn castBoolToInt() {
     const t = true;
     const f = false;
     assert(i32(t) == i32(1));
     assert(i32(f) == i32(0));
-    non_const_cast_bool_to_int(t, f);
+    nonConstCastBoolToInt(t, f);
 }
-fn non_const_cast_bool_to_int(t: bool, f: bool) {
+fn nonConstCastBoolToInt(t: bool, f: bool) {
     assert(i32(t) == i32(1));
     assert(i32(f) == i32(0));
 }
 #attribute("test")
-fn switch_on_enum() {
+fn switchOnEnum() {
     const fruit = Fruit.Orange;
-    non_const_switch_on_enum(fruit);
+    nonConstSwitchOnEnum(fruit);
 }
 enum Fruit {
     Apple,
 @@ -507,7 +508,7 @@ enum Fruit {
     Banana,
 }
 #static_eval_enable(false)
-fn non_const_switch_on_enum(fruit: Fruit) {
+fn nonConstSwitchOnEnum(fruit: Fruit) {
     switch (fruit) {
         Apple => unreachable{},
         Orange => {},
 @@ -516,11 +517,11 @@ fn non_const_switch_on_enum(fruit: Fruit) {
 }
 #attribute("test")
-fn switch_statement() {
+fn switchStatement() {
-    non_const_switch(SwitchStatmentFoo.C);
+    nonConstSwitch(SwitchStatmentFoo.C);
 }
 #static_eval_enable(false)
-fn non_const_switch(foo: SwitchStatmentFoo) {
+fn nonConstSwitch(foo: SwitchStatmentFoo) {
     const val: i32 = switch (foo) {
         A => 1,
         B => 2,
 @@ -538,10 +539,10 @@ enum SwitchStatmentFoo {
 #attribute("test")
-fn switch_prong_with_var() {
+fn switchProngWithVar() {
-    switch_prong_with_var_fn(SwitchProngWithVarEnum.One {13});
+    switchProngWithVarFn(SwitchProngWithVarEnum.One {13});
-    switch_prong_with_var_fn(SwitchProngWithVarEnum.Two {13.0});
+    switchProngWithVarFn(SwitchProngWithVarEnum.Two {13.0});
-    switch_prong_with_var_fn(SwitchProngWithVarEnum.Meh);
+    switchProngWithVarFn(SwitchProngWithVarEnum.Meh);
 }
 enum SwitchProngWithVarEnum {
     One: i32,
 @@ -549,7 +550,7 @@ enum SwitchProngWithVarEnum {
     Meh,
 }
 #static_eval_enable(false)
-fn switch_prong_with_var_fn(a: SwitchProngWithVarEnum) {
+fn switchProngWithVarFn(a: SwitchProngWithVarEnum) {
     switch(a) {
         One => |x| {
             if (x != 13) unreachable{};
 @@ -565,54 +566,54 @@ fn switch_prong_with_var_fn(a: SwitchProngWithVarEnum) {
 #attribute("test")
-fn err_return_in_assignment() {
+fn errReturnInAssignment() {
-    %%do_err_return_in_assignment();
+    %%doErrReturnInAssignment();
 }
 #static_eval_enable(false)
-fn do_err_return_in_assignment() -> %void {
+fn doErrReturnInAssignment() -> %void {
     var x : i32 = undefined;
-    x = %return make_a_non_err();
+    x = %return makeANonErr();
 }
-fn make_a_non_err() -> %i32 {
+fn makeANonErr() -> %i32 {
     return 1;
 }
 #attribute("test")
-fn rhs_maybe_unwrap_return() {
+fn rhsMaybeUnwrapReturn() {
     const x = ?true;
     const y = x ?? return;
 }
 #attribute("test")
-fn implicit_cast_fn_unreachable_return() {
+fn implicitCastFnUnreachableReturn() {
-    wants_fn_with_void(fn_with_unreachable);
+    wantsFnWithVoid(fnWithUnreachable);
 }
-fn wants_fn_with_void(f: fn()) { }
+fn wantsFnWithVoid(f: fn()) { }
-fn fn_with_unreachable() -> unreachable {
+fn fnWithUnreachable() -> unreachable {
     unreachable {}
 }
 #attribute("test")
-fn explicit_cast_maybe_pointers() {
+fn explicitCastMaybePointers() {
     const a: ?&i32 = undefined;
     const b: ?&f32 = (?&f32)(a);
 }
 #attribute("test")
-fn const_expr_eval_on_single_expr_blocks() {
+fn constExprEvalOnSingleExprBlocks() {
-    assert(const_expr_eval_on_single_expr_blocks_fn(1, true) == 3);
+    assert(constExprEvalOnSingleExprBlocksFn(1, true) == 3);
 }
-fn const_expr_eval_on_single_expr_blocks_fn(x: i32, b: bool) -> i32 {
+fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) -> i32 {
     const literal = 3;
     const result = if (b) {
 @@ -626,9 +627,9 @@ fn const_expr_eval_on_single_expr_blocks_fn(x: i32, b: bool) -> i32 {
 #attribute("test")
-fn builtin_const_eval() {
+fn builtinConstEval() {
-    const x : i32 = @const_eval(1 + 2 + 3);
+    const x : i32 = @constEval(1 + 2 + 3);
-    assert(x == @const_eval(6));
+    assert(x == @constEval(6));
 }
 #attribute("test")
 @@ -650,7 +651,7 @@ fn slicing() {
 #attribute("test")
-fn memcpy_and_memset_intrinsics() {
+fn memcpyAndMemsetIntrinsics() {
     var foo : [20]u8 = undefined;
     var bar : [20]u8 = undefined;
 @@ -662,22 +663,22 @@ fn memcpy_and_memset_intrinsics() {
 #attribute("test")
-fn array_dot_len_const_expr() { }
+fn arrayDotLenConstExpr() { }
 struct ArrayDotLenConstExpr {
-    y: [@const_eval(some_array.len)]u8,
+    y: [@constEval(some_array.len)]u8,
 }
 const some_array = []u8 {0, 1, 2, 3};
 #attribute("test")
-fn count_leading_zeroes() {
+fn countLeadingZeroes() {
     assert(@clz(u8, 0b00001010) == 4);
     assert(@clz(u8, 0b10001010) == 0);
     assert(@clz(u8, 0b00000000) == 8);
 }
 #attribute("test")
-fn count_trailing_zeroes() {
+fn countTrailingZeroes() {
     assert(@ctz(u8, 0b10100000) == 5);
     assert(@ctz(u8, 0b10001010) == 1);
     assert(@ctz(u8, 0b00000000) == 8);
 @@ -685,7 +686,7 @@ fn count_trailing_zeroes() {
 #attribute("test")
-fn multiline_string() {
+fn multilineString() {
     const s1 =
         \\one
         \\two)
 @@ -696,7 +697,7 @@ fn multiline_string() {
 }
 #attribute("test")
-fn multiline_c_string() {
+fn multilineCString() {
     const s1 =
         c\\one
         c\\two)
 @@ -709,7 +710,7 @@ fn multiline_c_string() {
 #attribute("test")
-fn simple_generic_fn() {
+fn simpleGenericFn() {
     assert(max(i32, 3, -1) == 3);
     assert(max(f32, 0.123, 0.456) == 0.456);
     assert(add(2, 3) == 5);
 @@ -720,42 +721,42 @@ fn max(inline T: type, a: T, b: T) -> T {
 }
 fn add(inline a: i32, b: i32) -> i32 {
-    return @const_eval(a) + b;
+    return @constEval(a) + b;
 }
 #attribute("test")
-fn constant_equal_function_pointers() {
+fn constantEqualFunctionPointers() {
-    const alias = empty_fn;
+    const alias = emptyFn;
-    assert(@const_eval(empty_fn == alias));
+    assert(@constEval(emptyFn == alias));
 }
-fn empty_fn() {}
+fn emptyFn() {}
 #attribute("test")
-fn generic_malloc_free() {
+fn genericMallocFree() {
-    const a = %%mem_alloc(u8, 10);
+    const a = %%memAlloc(u8, 10);
-    mem_free(u8, a);
+    memFree(u8, a);
 }
 const some_mem : [100]u8 = undefined;
 #static_eval_enable(false)
-fn mem_alloc(inline T: type, n: usize) -> %[]T {
+fn memAlloc(inline T: type, n: usize) -> %[]T {
     return (&T)(&some_mem[0])[0...n];
 }
-fn mem_free(inline T: type, mem: []T) { }
+fn memFree(inline T: type, mem: []T) { }
 #attribute("test")
-fn call_fn_with_empty_string() {
+fn callFnWithEmptyString() {
-    accepts_string("");
+    acceptsString("");
 }
-fn accepts_string(foo: []u8) { }
+fn acceptsString(foo: []u8) { }
 #attribute("test")
-fn hex_escape() {
+fn hexEscape() {
     assert(str.eql("\x68\x65\x6c\x6c\x6f", "hello"));
 }
 @@ -763,18 +764,18 @@ fn hex_escape() {
 error AnError;
 error ALongerErrorName;
 #attribute("test")
-fn error_name_string() {
+fn errorNameString() {
-    assert(str.eql(@err_name(error.AnError), "AnError"));
+    assert(str.eql(@errName(error.AnError), "AnError"));
-    assert(str.eql(@err_name(error.ALongerErrorName), "ALongerErrorName"));
+    assert(str.eql(@errName(error.ALongerErrorName), "ALongerErrorName"));
 }
 #attribute("test")
-fn goto_and_labels() {
+fn gotoAndLabels() {
-    goto_loop();
+    gotoLoop();
     assert(goto_counter == 10);
 }
-fn goto_loop() {
+fn gotoLoop() {
     var i: i32 = 0;
     goto cond;
 loop:
 @@ -790,11 +791,11 @@ var goto_counter: i32 = 0;
 #attribute("test")
-fn goto_leave_defer_scope() {
+fn gotoLeaveDeferScope() {
-    test_goto_leave_defer_scope(true);
+    testGotoLeaveDeferScope(true);
 }
 #static_eval_enable(false)
-fn test_goto_leave_defer_scope(b: bool) {
+fn testGotoLeaveDeferScope(b: bool) {
     var it_worked = false;
     goto entry;
 @@ -810,25 +811,25 @@ entry:
 #attribute("test")
-fn cast_undefined() {
+fn castUndefined() {
     const array: [100]u8 = undefined;
     const slice = ([]u8)(array);
-    test_cast_undefined(slice);
+    testCastUndefined(slice);
 }
-fn test_cast_undefined(x: []u8) {}
+fn testCastUndefined(x: []u8) {}
 #attribute("test")
-fn cast_small_unsigned_to_larger_signed() {
+fn castSmallUnsignedToLargerSigned() {
-    assert(cast_small_unsigned_to_larger_signed_1(200) == i16(200));
+    assert(castSmallUnsignedToLargerSigned1(200) == i16(200));
-    assert(cast_small_unsigned_to_larger_signed_2(9999) == i64(9999));
+    assert(castSmallUnsignedToLargerSigned2(9999) == i64(9999));
 }
-fn cast_small_unsigned_to_larger_signed_1(x: u8) -> i16 { x }
+fn castSmallUnsignedToLargerSigned1(x: u8) -> i16 { x }
-fn cast_small_unsigned_to_larger_signed_2(x: u16) -> i64 { x }
+fn castSmallUnsignedToLargerSigned2(x: u16) -> i64 { x }
 #attribute("test")
-fn implicit_cast_after_unreachable() {
+fn implicitCastAfterUnreachable() {
     assert(outer() == 1234);
 }
 fn inner() -> i32 { 1234 }
 @@ -838,10 +839,10 @@ fn outer() -> i64 {
 #attribute("test")
-fn else_if_expression() {
+fn elseIfExpression() {
-    assert(else_if_expression_f(1) == 1);
+    assert(elseIfExpressionF(1) == 1);
 }
-fn else_if_expression_f(c: u8) -> u8 {
+fn elseIfExpressionF(c: u8) -> u8 {
     if (c == 0) {
         0
     } else if (c == 1) {
 @@ -852,14 +853,14 @@ fn else_if_expression_f(c: u8) -> u8 {
 }
 #attribute("test")
-fn err_binary_operator() {
+fn errBinaryOperator() {
-    const a = err_binary_operator_g(true) %% 3;
+    const a = errBinaryOperatorG(true) %% 3;
-    const b = err_binary_operator_g(false) %% 3;
+    const b = errBinaryOperatorG(false) %% 3;
     assert(a == 3);
     assert(b == 10);
 }
 error ItBroke;
-fn err_binary_operator_g(x: bool) -> %isize {
+fn errBinaryOperatorG(x: bool) -> %isize {
     if (x) {
         error.ItBroke
     } else {
 @@ -868,18 +869,18 @@ fn err_binary_operator_g(x: bool) -> %isize {
 }
 #attribute("test")
-fn unwrap_simple_value_from_error() {
+fn unwrapSimpleValueFromError() {
-    const i = %%unwrap_simple_value_from_error_do();
+    const i = %%unwrapSimpleValueFromErrorDo();
     assert(i == 13);
 }
-fn unwrap_simple_value_from_error_do() -> %isize { 13 }
+fn unwrapSimpleValueFromErrorDo() -> %isize { 13 }
 #attribute("test")
-fn store_member_function_in_variable() {
+fn storeMemberFunctionInVariable() {
     const instance = MemberFnTestFoo { .x = 1234, };
-    const member_fn = MemberFnTestFoo.member;
+    const memberFn = MemberFnTestFoo.member;
-    const result = member_fn(instance);
+    const result = memberFn(instance);
     assert(result == 1234);
 }
 struct MemberFnTestFoo {
 @@ -888,34 +889,34 @@ struct MemberFnTestFoo {
 }
 #attribute("test")
-fn call_member_function_directly() {
+fn callMemberFunctionDirectly() {
     const instance = MemberFnTestFoo { .x = 1234, };
     const result = MemberFnTestFoo.member(instance);
     assert(result == 1234);
 }
 #attribute("test")
-fn member_functions() {
+fn memberFunctions() {
     const r = MemberFnRand {.seed = 1234};
-    assert(r.get_seed() == 1234);
+    assert(r.getSeed() == 1234);
 }
 struct MemberFnRand {
     seed: u32,
-    pub fn get_seed(r: MemberFnRand) -> u32 {
+    pub fn getSeed(r: MemberFnRand) -> u32 {
         r.seed
     }
 }
 #attribute("test")
-fn static_function_evaluation() {
+fn staticFunctionEvaluation() {
     assert(statically_added_number == 3);
 }
-const statically_added_number = static_add(1, 2);
+const statically_added_number = staticAdd(1, 2);
-fn static_add(a: i32, b: i32) -> i32 { a + b }
+fn staticAdd(a: i32, b: i32) -> i32 { a + b }
 #attribute("test")
-fn statically_initalized_list() {
+fn staticallyInitalizedList() {
     assert(static_point_list[0].x == 1);
     assert(static_point_list[0].y == 2);
     assert(static_point_list[1].x == 3);
 @@ -925,8 +926,8 @@ struct Point {
     x: i32,
     y: i32,
 }
-const static_point_list = []Point { make_point(1, 2), make_point(3, 4) };
+const static_point_list = []Point { makePoint(1, 2), makePoint(3, 4) };
-fn make_point(x: i32, y: i32) -> Point {
+fn makePoint(x: i32, y: i32) -> Point {
     return Point {
         .x = x,
         .y = y,
 @@ -935,7 +936,7 @@ fn make_point(x: i32, y: i32) -> Point {
 #attribute("test")
-fn static_eval_recursive() {
+fn staticEvalRecursive() {
     assert(seventh_fib_number == 21);
 }
 const seventh_fib_number = fibbonaci(7);
 @@ -945,21 +946,21 @@ fn fibbonaci(x: i32) -> i32 {
 }
 #attribute("test")
-fn static_eval_while() {
+fn staticEvalWhile() {
     assert(static_eval_while_number == 1);
 }
-const static_eval_while_number = static_while_loop_1();
+const static_eval_while_number = staticWhileLoop1();
-fn static_while_loop_1() -> i32 {
+fn staticWhileLoop1() -> i32 {
-    return while_loop_2();
+    return whileLoop2();
 }
-fn static_while_loop_2() -> i32 {
+fn staticWhileLoop2() -> i32 {
     while (true) {
         return 1;
     }
 }
 #attribute("test")
-fn static_eval_list_init() {
+fn staticEvalListInit() {
     assert(static_vec3.data[2] == 1.0);
 }
 const static_vec3 = vec3(0.0, 0.0, 1.0);
 @@ -974,22 +975,22 @@ pub fn vec3(x: f32, y: f32, z: f32) -> Vec3 {
 #attribute("test")
-fn generic_fn_with_implicit_cast() {
+fn genericFnWithImplicitCast() {
-    assert(get_first_byte(u8, []u8 {13}) == 13);
+    assert(getFirstByte(u8, []u8 {13}) == 13);
-    assert(get_first_byte(u16, []u16 {0, 13}) == 0);
+    assert(getFirstByte(u16, []u16 {0, 13}) == 0);
 }
-fn get_byte(ptr: ?&u8) -> u8 {*??ptr}
+fn getByte(ptr: ?&u8) -> u8 {*??ptr}
-fn get_first_byte(inline T: type, mem: []T) -> u8 {
+fn getFirstByte(inline T: type, mem: []T) -> u8 {
-    get_byte((&u8)(&mem[0]))
+    getByte((&u8)(&mem[0]))
 }
 #attribute("test")
-fn continue_and_break() {
+fn continueAndBreak() {
-    run_continue_and_break_test();
+    runContinueAndBreakTest();
     assert(continue_and_break_counter == 8);
 }
 var continue_and_break_counter: i32 = 0;
-fn run_continue_and_break_test() {
+fn runContinueAndBreakTest() {
     var i : i32 = 0;
     while (true) {
         continue_and_break_counter += 2;
 @@ -1002,17 +1003,9 @@ fn run_continue_and_break_test() {
     assert(i == 4);
 }
-#attribute("test")
-fn sizeof_and_typeof() {
-    const y: @typeof(sizeof_and_typeof_x) = 120;
-    assert(@sizeof(@typeof(y)) == 2);
-}
-const sizeof_and_typeof_x: u16 = 13;
-const sizeof_and_typeof_z: @typeof(sizeof_and_typeof_x) = 19;
 #attribute("test")
-fn pointer_dereferencing() {
+fn pointerDereferencing() {
     var x = i32(3);
     const y = &x;
 @@ -1023,47 +1016,47 @@ fn pointer_dereferencing() {
 }
 #attribute("test")
-fn constant_expressions() {
+fn constantExpressions() {
-    var array : [ARRAY_SIZE]u8 = undefined;
+    var array : [array_size]u8 = undefined;
-    assert(@sizeof(@typeof(array)) == 20);
+    assert(@sizeOf(@typeOf(array)) == 20);
 }
-const ARRAY_SIZE : u8 = 20;
+const array_size : u8 = 20;
 #attribute("test")
-fn min_value_and_max_value() {
+fn minValueAndMaxValue() {
-    assert(@max_value(u8) == 255);
+    assert(@maxValue(u8) == 255);
-    assert(@max_value(u16) == 65535);
+    assert(@maxValue(u16) == 65535);
-    assert(@max_value(u32) == 4294967295);
+    assert(@maxValue(u32) == 4294967295);
-    assert(@max_value(u64) == 18446744073709551615);
+    assert(@maxValue(u64) == 18446744073709551615);
-    assert(@max_value(i8) == 127);
+    assert(@maxValue(i8) == 127);
-    assert(@max_value(i16) == 32767);
+    assert(@maxValue(i16) == 32767);
-    assert(@max_value(i32) == 2147483647);
+    assert(@maxValue(i32) == 2147483647);
-    assert(@max_value(i64) == 9223372036854775807);
+    assert(@maxValue(i64) == 9223372036854775807);
-    assert(@min_value(u8) == 0);
+    assert(@minValue(u8) == 0);
-    assert(@min_value(u16) == 0);
+    assert(@minValue(u16) == 0);
-    assert(@min_value(u32) == 0);
+    assert(@minValue(u32) == 0);
-    assert(@min_value(u64) == 0);
+    assert(@minValue(u64) == 0);
-    assert(@min_value(i8) == -128);
+    assert(@minValue(i8) == -128);
-    assert(@min_value(i16) == -32768);
+    assert(@minValue(i16) == -32768);
-    assert(@min_value(i32) == -2147483648);
+    assert(@minValue(i32) == -2147483648);
-    assert(@min_value(i64) == -9223372036854775808);
+    assert(@minValue(i64) == -9223372036854775808);
 }
 #attribute("test")
-fn overflow_intrinsics() {
+fn overflowIntrinsics() {
     var result: u8 = undefined;
-    assert(@add_with_overflow(u8, 250, 100, &result));
+    assert(@addWithOverflow(u8, 250, 100, &result));
-    assert(!@add_with_overflow(u8, 100, 150, &result));
+    assert(!@addWithOverflow(u8, 100, 150, &result));
     assert(result == 250);
 }
 #attribute("test")
-fn nested_arrays() {
+fn nestedArrays() {
     const array_of_strings = [][]u8 {"hello", "this", "is", "my", "thing"};
     for (array_of_strings) |s, i| {
         if (i == 0) assert(str.eql(s, "hello"));
 @@ -1075,7 +1068,7 @@ fn nested_arrays() {
 }
 #attribute("test")
-fn int_to_ptr_cast() {
+fn intToPtrCast() {
     const x = isize(13);
     const y = (&u8)(x);
     const z = usize(y);
 @@ -1083,12 +1076,12 @@ fn int_to_ptr_cast() {
 }
 #attribute("test")
-fn string_concatenation() {
+fn stringConcatenation() {
     assert(str.eql("OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
 }
 #attribute("test")
-fn constant_struct_with_negation() {
+fn constantStructWithNegation() {
     assert(vertices[0].x == -0.6);
 }
 struct Vertex {
 @@ -1106,25 +1099,25 @@ const vertices = []Vertex {
 #attribute("test")
-fn return_with_implicit_cast_from_while_loop() {
+fn returnWithImplicitCastFromWhileLoop() {
-    %%return_with_implicit_cast_from_while_loop_test();
+    %%returnWithImplicitCastFromWhileLoopTest();
 }
-fn return_with_implicit_cast_from_while_loop_test() -> %void {
+fn returnWithImplicitCastFromWhileLoopTest() -> %void {
     while (true) {
         return;
     }
 }
 #attribute("test")
-fn return_struct_byval_from_function() {
+fn returnStructByvalFromFunction() {
-    const bar = make_bar(1234, 5678);
+    const bar = makeBar(1234, 5678);
     assert(bar.y == 5678);
 }
 struct Bar {
     x: i32,
     y: i32,
 }
-fn make_bar(x: i32, y: i32) -> Bar {
+fn makeBar(x: i32, y: i32) -> Bar {
     Bar {
         .x = x,
         .y = y,
 @@ -1132,8 +1125,8 @@ fn make_bar(x: i32, y: i32) -> Bar {
 }
 #attribute("test")
-fn function_pointers() {
+fn functionPointers() {
-    const fns = []@typeof(fn1) { fn1, fn2, fn3, fn4, };
+    const fns = []@typeOf(fn1) { fn1, fn2, fn3, fn4, };
     for (fns) |f, i| {
         assert(f() == u32(i) + 5);
     }
 @@ -1146,7 +1139,7 @@ fn fn4() -> u32 {8}
 #attribute("test")
-fn statically_initalized_struct() {
+fn staticallyInitalizedStruct() {
     st_init_str_foo.x += 1;
     assert(st_init_str_foo.x == 14);
 }
 @@ -1157,7 +1150,7 @@ struct StInitStrFoo {
 var st_init_str_foo = StInitStrFoo { .x = 13, .y = true, };
 #attribute("test")
-fn statically_initialized_array_literal() {
+fn staticallyInitializedArrayLiteral() {
     const y : [4]u8 = st_init_arr_lit_x;
     assert(y[3] == 4);
 }
 @@ -1166,33 +1159,33 @@ const st_init_arr_lit_x = []u8{1,2,3,4};
 #attribute("test")
-fn pointer_to_void_return_type() {
+fn pointerToVoidReturnType() {
-    %%test_pointer_to_void_return_type();
+    %%testPointerToVoidReturnType();
 }
-fn test_pointer_to_void_return_type() -> %void {
+fn testPointerToVoidReturnType() -> %void {
-    const a = test_pointer_to_void_return_type_2();
+    const a = testPointerToVoidReturnType2();
     return *a;
 }
 const test_pointer_to_void_return_type_x = void{};
-fn test_pointer_to_void_return_type_2() -> &void {
+fn testPointerToVoidReturnType2() -> &void {
     return &test_pointer_to_void_return_type_x;
 }
 #attribute("test")
-fn call_result_of_if_else_expression() {
+fn callResultOfIfElseExpression() {
     assert(str.eql(f2(true), "a"));
     assert(str.eql(f2(false), "b"));
 }
 fn f2(x: bool) -> []u8 {
-    return (if (x) f_a else f_b)();
+    return (if (x) fA else fB)();
 }
-fn f_a() -> []u8 { "a" }
+fn fA() -> []u8 { "a" }
-fn f_b() -> []u8 { "b" }
+fn fB() -> []u8 { "b" }
 #attribute("test")
-fn const_expression_eval_handling_of_variables() {
+fn constExpressionEvalHandlingOfVariables() {
     var x = true;
     while (x) {
         x = false;
 @@ -1202,7 +1195,7 @@ fn const_expression_eval_handling_of_variables() {
 #attribute("test")
-fn constant_enum_initialization_with_differing_sizes() {
+fn constantEnumInitializationWithDifferingSizes() {
     test3_1(test3_foo);
     test3_2(test3_bar);
 }
 @@ -1240,22 +1233,22 @@ fn test3_2(f: Test3Foo) {
 #attribute("test")
-fn pub_enum() {
+fn pubEnum() {
-    pub_enum_test(other.APubEnum.Two);
+    pubEnumTest(other.APubEnum.Two);
 }
-fn pub_enum_test(foo: other.APubEnum) {
+fn pubEnumTest(foo: other.APubEnum) {
     assert(foo == other.APubEnum.Two);
 }
 #attribute("test")
-fn cast_with_imported_symbol() {
+fn castWithImportedSymbol() {
     assert(other.size_t(42) == 42);
 }
 #attribute("test")
-fn while_with_continue_expr() {
+fn whileWithContinueExpr() {
     var sum: i32 = 0;
     {var i: i32 = 0; while (i < 10; i += 1) {
         if (i == 5) continue;
 @@ -1266,22 +1259,22 @@ fn while_with_continue_expr() {
 #attribute("test")
-fn for_loop_with_pointer_elem_var() {
+fn forLoopWithPointerElemVar() {
     const source = "abcdefg";
     var target: [source.len]u8 = undefined;
     @memcpy(&target[0], &source[0], source.len);
-    mangle_string(target);
+    mangleString(target);
     assert(str.eql(target, "bcdefgh"));
 }
 #static_eval_enable(false)
-fn mangle_string(s: []u8) {
+fn mangleString(s: []u8) {
     for (s) |*c| {
         *c += 1;
     }
 }
 #attribute("test")
-fn empty_struct_method_call() {
+fn emptyStructMethodCall() {
     const es = EmptyStruct{};
     assert(es.method() == 1234);
 }
 @@ -1296,48 +1289,48 @@ fn @"weird function name"() { }
 #attribute("test")
-fn return_empty_struct_from_fn() {
+fn returnEmptyStructFromFn() {
-    test_return_empty_struct_from_fn();
+    testReturnEmptyStructFromFn();
-    test_return_empty_struct_from_fn_noeval();
+    testReturnEmptyStructFromFnNoeval();
 }
 struct EmptyStruct2 {}
-fn test_return_empty_struct_from_fn() -> EmptyStruct2 {
+fn testReturnEmptyStructFromFn() -> EmptyStruct2 {
     EmptyStruct2 {}
 }
 #static_eval_enable(false)
-fn test_return_empty_struct_from_fn_noeval() -> EmptyStruct2 {
+fn testReturnEmptyStructFromFnNoeval() -> EmptyStruct2 {
     EmptyStruct2 {}
 }
 #attribute("test")
-fn pass_slice_of_empty_struct_to_fn() {
+fn passSliceOfEmptyStructToFn() {
-    assert(test_pass_slice_of_empty_struct_to_fn([]EmptyStruct2{ EmptyStruct2{} }) == 1);
+    assert(testPassSliceOfEmptyStructToFn([]EmptyStruct2{ EmptyStruct2{} }) == 1);
 }
-fn test_pass_slice_of_empty_struct_to_fn(slice: []EmptyStruct2) -> usize {
+fn testPassSliceOfEmptyStructToFn(slice: []EmptyStruct2) -> usize {
     slice.len
 }
 #attribute("test")
-fn pointer_comparison() {
+fn pointerComparison() {
     const a = ([]u8)("a");
     const b = &a;
-    assert(ptr_eql(b, b));
+    assert(ptrEql(b, b));
 }
-fn ptr_eql(a: &[]u8, b: &[]u8) -> bool {
+fn ptrEql(a: &[]u8, b: &[]u8) -> bool {
     a == b
 }
 #attribute("test")
-fn character_literals() {
+fn characterLiterals() {
     assert('\'' == single_quote);
 }
 const single_quote = '\'';
 #attribute("test")
-fn switch_with_multiple_expressions() {
+fn switchWithMultipleExpressions() {
-    const x: i32 = switch (returns_five()) {
+    const x: i32 = switch (returnsFive()) {
         1, 2, 3 => 1,
         4, 5, 6 => 2,
         else => 3,
 @@ -1345,12 +1338,12 @@ fn switch_with_multiple_expressions() {
     assert(x == 2);
 }
 #static_eval_enable(false)
-fn returns_five() -> i32 { 5 }
+fn returnsFive() -> i32 { 5 }
 #attribute("test")
-fn switch_on_error_union() {
+fn switchOnErrorUnion() {
-    const x = switch (returns_ten()) {
+    const x = switch (returnsTen()) {
         Ok => |val| val + 1,
         ItBroke, NoMem => 1,
         CrappedOut => 2,
 @@ -1361,40 +1354,40 @@ error ItBroke;
 error NoMem;
 error CrappedOut;
 #static_eval_enable(false)
-fn returns_ten() -> %i32 { 10 }
+fn returnsTen() -> %i32 { 10 }
 #attribute("test")
-fn bool_cmp() {
+fn boolCmp() {
-    assert(test_bool_cmp(true, false) == false);
+    assert(testBoolCmp(true, false) == false);
 }
 #static_eval_enable(false)
-fn test_bool_cmp(a: bool, b: bool) -> bool { a == b }
+fn testBoolCmp(a: bool, b: bool) -> bool { a == b }
 #attribute("test")
-fn take_address_of_parameter() {
+fn takeAddressOfParameter() {
-    test_take_address_of_parameter(12.34);
+    testTakeAddressOfParameter(12.34);
-    test_take_address_of_parameter_noeval(12.34);
+    testTakeAddressOfParameterNoeval(12.34);
 }
-fn test_take_address_of_parameter(f: f32) {
+fn testTakeAddressOfParameter(f: f32) {
     const f_ptr = &f;
     assert(*f_ptr == 12.34);
 }
 #static_eval_enable(false)
-fn test_take_address_of_parameter_noeval(f: f32) {
+fn testTakeAddressOfParameterNoeval(f: f32) {
     const f_ptr = &f;
     assert(*f_ptr == 12.34);
 }
 #attribute("test")
-fn array_mult_operator() {
+fn arrayMultOperator() {
     assert(str.eql("ab" ** 5, "ababababab"));
 }
 #attribute("test")
-fn string_escapes() {
+fn stringEscapes() {
     assert(str.eql("\"", "\x22"));
     assert(str.eql("\'", "\x27"));
     assert(str.eql("\n", "\x0a"));
 @@ -1405,11 +1398,11 @@ fn string_escapes() {
 }
 #attribute("test")
-fn if_var_maybe_pointer() {
+fn ifVarMaybePointer() {
-    assert(should_be_a_plus_1(Particle {.a = 14, .b = 1, .c = 1, .d = 1}) == 15);
+    assert(shouldBeAPlus1(Particle {.a = 14, .b = 1, .c = 1, .d = 1}) == 15);
 }
 #static_eval_enable(false)
-fn should_be_a_plus_1(p: Particle) -> u64 {
+fn shouldBeAPlus1(p: Particle) -> u64 {
     var maybe_particle: ?Particle = p;
     if (const *particle ?= maybe_particle) {
         particle.a += 1;
 @@ -1427,7 +1420,7 @@ struct Particle {
 }
 #attribute("test")
-fn assign_to_if_var_ptr() {
+fn assignToIfVarPtr() {
     var maybe_bool: ?bool = true;
     if (const *b ?= maybe_bool) {
 @@ -1452,85 +1445,85 @@ fn fence() {
 }
 #attribute("test")
-fn unsigned_wrapping() {
+fn unsignedWrapping() {
-    test_unsigned_wrapping_eval(@max_value(u32));
+    testUnsignedWrappingEval(@maxValue(u32));
-    test_unsigned_wrapping_noeval(@max_value(u32));
+    testUnsignedWrappingNoeval(@maxValue(u32));
 }
-fn test_unsigned_wrapping_eval(x: u32) {
+fn testUnsignedWrappingEval(x: u32) {
     const zero = x +% 1;
     assert(zero == 0);
     const orig = zero -% 1;
-    assert(orig == @max_value(u32));
+    assert(orig == @maxValue(u32));
 }
 #static_eval_enable(false)
-fn test_unsigned_wrapping_noeval(x: u32) {
+fn testUnsignedWrappingNoeval(x: u32) {
     const zero = x +% 1;
     assert(zero == 0);
     const orig = zero -% 1;
-    assert(orig == @max_value(u32));
+    assert(orig == @maxValue(u32));
 }
 #attribute("test")
-fn signed_wrapping() {
+fn signedWrapping() {
-    test_signed_wrapping_eval(@max_value(i32));
+    testSignedWrappingEval(@maxValue(i32));
-    test_signed_wrapping_noeval(@max_value(i32));
+    testSignedWrappingNoeval(@maxValue(i32));
 }
-fn test_signed_wrapping_eval(x: i32) {
+fn testSignedWrappingEval(x: i32) {
     const min_val = x +% 1;
-    assert(min_val == @min_value(i32));
+    assert(min_val == @minValue(i32));
     const max_val = min_val -% 1;
-    assert(max_val == @max_value(i32));
+    assert(max_val == @maxValue(i32));
 }
 #static_eval_enable(false)
-fn test_signed_wrapping_noeval(x: i32) {
+fn testSignedWrappingNoeval(x: i32) {
     const min_val = x +% 1;
-    assert(min_val == @min_value(i32));
+    assert(min_val == @minValue(i32));
     const max_val = min_val -% 1;
-    assert(max_val == @max_value(i32));
+    assert(max_val == @maxValue(i32));
 }
 #attribute("test")
-fn negation_wrapping() {
+fn negationWrapping() {
-    test_negation_wrapping_eval(@min_value(i16));
+    testNegationWrappingEval(@minValue(i16));
-    test_negation_wrapping_noeval(@min_value(i16));
+    testNegationWrappingNoeval(@minValue(i16));
 }
-fn test_negation_wrapping_eval(x: i16) {
+fn testNegationWrappingEval(x: i16) {
     assert(x == -32768);
     const neg = -%x;
     assert(neg == -32768);
 }
 #static_eval_enable(false)
-fn test_negation_wrapping_noeval(x: i16) {
+fn testNegationWrappingNoeval(x: i16) {
     assert(x == -32768);
     const neg = -%x;
     assert(neg == -32768);
 }
 #attribute("test")
-fn shl_wrapping() {
+fn shlWrapping() {
-    test_shl_wrapping_eval(@max_value(u16));
+    testShlWrappingEval(@maxValue(u16));
-    test_shl_wrapping_noeval(@max_value(u16));
+    testShlWrappingNoeval(@maxValue(u16));
 }
-fn test_shl_wrapping_eval(x: u16) {
+fn testShlWrappingEval(x: u16) {
     const shifted = x <<% 1;
     assert(shifted == 65534);
 }
 #static_eval_enable(false)
-fn test_shl_wrapping_noeval(x: u16) {
+fn testShlWrappingNoeval(x: u16) {
     const shifted = x <<% 1;
     assert(shifted == 65534);
 }
 #attribute("test")
-fn shl_with_overflow() {
+fn shlWithOverflow() {
     var result: u16 = undefined;
-    assert(@shl_with_overflow(u16, 0b0010111111111111, 3, &result));
+    assert(@shlWithOverflow(u16, 0b0010111111111111, 3, &result));
-    assert(!@shl_with_overflow(u16, 0b0010111111111111, 2, &result));
+    assert(!@shlWithOverflow(u16, 0b0010111111111111, 2, &result));
     assert(result == 0b1011111111111100);
 }
 #attribute("test")
-fn c_string_concatenation() {
+fn cStringConcatenation() {
     const a = c"OK" ++ c" IT " ++ c"WORKED";
     const b = c"OK IT WORKED";
 @@ -1544,22 +1537,22 @@ fn c_string_concatenation() {
 }
 #attribute("test")
-fn generic_struct() {
+fn genericStruct() {
     var a1 = GenNode(i32) {.value = 13, .next = null,};
     var b1 = GenNode(bool) {.value = true, .next = null,};
     assert(a1.value == 13);
-    assert(a1.value == a1.get_val());
+    assert(a1.value == a1.getVal());
-    assert(b1.get_val());
+    assert(b1.getVal());
 }
 struct GenNode(T: type) {
     value: T,
     next: ?&GenNode(T),
-    fn get_val(n: &const GenNode(T)) -> T { n.value }
+    fn getVal(n: &const GenNode(T)) -> T { n.value }
 }
 #attribute("test")
-fn cast_slice_to_u8_slice() {
+fn castSliceToU8Slice() {
-    assert(@sizeof(i32) == 4);
+    assert(@sizeOf(i32) == 4);
     var big_thing_array = []i32{1, 2, 3, 4};
     const big_thing_slice: []i32 = big_thing_array;
     const bytes = ([]u8)(big_thing_slice);
 @@ -1572,14 +1565,14 @@ fn cast_slice_to_u8_slice() {
     const big_thing_again = ([]i32)(bytes);
     assert(big_thing_again[2] == 3);
     big_thing_again[2] = -1;
-    assert(bytes[8] == @max_value(u8));
+    assert(bytes[8] == @maxValue(u8));
-    assert(bytes[9] == @max_value(u8));
+    assert(bytes[9] == @maxValue(u8));
-    assert(bytes[10] == @max_value(u8));
+    assert(bytes[10] == @maxValue(u8));
-    assert(bytes[11] == @max_value(u8));
+    assert(bytes[11] == @maxValue(u8));
 }
 #attribute("test")
-fn float_division() {
+fn floatDivision() {
     assert(fdiv32(12.0, 3.0) == 4.0);
 }
 #static_eval_enable(false)
 @@ -1588,16 +1581,16 @@ fn fdiv32(a: f32, b: f32) -> f32 {
 }
 #attribute("test")
-fn exact_division() {
+fn exactDivision() {
-    assert(div_exact(55, 11) == 5);
+    assert(divExact(55, 11) == 5);
 }
 #static_eval_enable(false)
-fn div_exact(a: u32, b: u32) -> u32 {
+fn divExact(a: u32, b: u32) -> u32 {
-    @div_exact(a, b)
+    @divExact(a, b)
 }
 #attribute("test")
-fn null_literal_outside_function() {
+fn nullLiteralOutsideFunction() {
     const is_null = if (const _ ?= here_is_a_null_literal.context) false else true;
     assert(is_null);
 }
 @@ -1610,15 +1603,15 @@ const here_is_a_null_literal = SillyStruct {
 #attribute("test")
 fn truncate() {
-    assert(test_truncate(0x10fd) == 0xfd);
+    assert(testTruncate(0x10fd) == 0xfd);
 }
 #static_eval_enable(false)
-fn test_truncate(x: u32) -> u8 {
+fn testTruncate(x: u32) -> u8 {
     @truncate(u8, x)
 }
 #attribute("test")
-fn const_decls_in_struct() {
+fn constDeclsInStruct() {
     assert(GenericDataThing(3).count_plus_one == 4);
 }
 struct GenericDataThing(count: isize) {
 @@ -1626,30 +1619,30 @@ struct GenericDataThing(count: isize) {
 }
 #attribute("test")
-fn use_generic_param_in_generic_param() {
+fn useGenericParamInGenericParam() {
-    assert(a_generic_fn(i32, 3, 4) == 7);
+    assert(aGenericFn(i32, 3, 4) == 7);
 }
-fn a_generic_fn(inline T: type, inline a: T, b: T) -> T {
+fn aGenericFn(inline T: type, inline a: T, b: T) -> T {
     return a + b;
 }
 #attribute("test")
-fn namespace_depends_on_compile_var() {
+fn namespaceDependsOnCompileVar() {
     if (some_namespace.a_bool) {
         assert(some_namespace.a_bool);
     } else {
         assert(!some_namespace.a_bool);
     }
 }
-const some_namespace = switch(@compile_var("os")) {
+const some_namespace = switch(@compileVar("os")) {
     linux => @import("a.zig"),
     else => @import("b.zig"),
 };
 #attribute("test")
-fn unsigned_64_bit_division() {
+fn unsigned64BitDivision() {
     const result = div(1152921504606846976, 34359738365);
     assert(result.quotient == 33554432);
     assert(result.remainder == 100663296);
 @@ -1667,16 +1660,16 @@ struct DivResult {
 }
 #attribute("test")
-fn int_type_builtin() {
+fn intTypeBuiltin() {
-    assert(@int_type(true, 8) == i8);
+    assert(@intType(true, 8) == i8);
-    assert(@int_type(true, 16) == i16);
+    assert(@intType(true, 16) == i16);
-    assert(@int_type(true, 32) == i32);
+    assert(@intType(true, 32) == i32);
-    assert(@int_type(true, 64) == i64);
+    assert(@intType(true, 64) == i64);
-    assert(@int_type(false, 8) == u8);
+    assert(@intType(false, 8) == u8);
-    assert(@int_type(false, 16) == u16);
+    assert(@intType(false, 16) == u16);
-    assert(@int_type(false, 32) == u32);
+    assert(@intType(false, 32) == u32);
-    assert(@int_type(false, 64) == u64);
+    assert(@intType(false, 64) == u64);
     assert(i8.bit_count == 8);
     assert(i16.bit_count == 16);
 @@ -1698,15 +1691,15 @@ fn int_type_builtin() {
 }
 #attribute("test")
-fn int_to_enum() {
+fn intToEnum() {
-    test_int_to_enum_eval(3);
+    testIntToEnumEval(3);
-    test_int_to_enum_noeval(3);
+    testIntToEnumNoeval(3);
 }
-fn test_int_to_enum_eval(x: i32) {
+fn testIntToEnumEval(x: i32) {
     assert(IntToEnumNumber(x) == IntToEnumNumber.Three);
 }
 #static_eval_enable(false)
-fn test_int_to_enum_noeval(x: i32) {
+fn testIntToEnumNoeval(x: i32) {
     assert(IntToEnumNumber(x) == IntToEnumNumber.Three);
 }
 enum IntToEnumNumber {

...	@@ -4642,7 +4642,7 @@ static void define_builtin_fns(CodeGen *g) {	...	@@ -4642,7 +4642,7 @@ static void define_builtin_fns(CodeGen *g) {
4642	}	4642	}
4643	{	4643	{
4644	BuiltinFnEntry *builtin_fn = create_builtin_fn_with_arg_count(g, BuiltinFnIdReturnAddress,	4644	BuiltinFnEntry *builtin_fn = create_builtin_fn_with_arg_count(g, BuiltinFnIdReturnAddress,
4645	"return_address", 0);	4645	"returnAddress", 0);
4646	builtin_fn->return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);	4646	builtin_fn->return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);
4647		4647
4648	LLVMTypeRef fn_type = LLVMFunctionType(builtin_fn->return_type->type_ref,	4648	LLVMTypeRef fn_type = LLVMFunctionType(builtin_fn->return_type->type_ref,
...	@@ -4652,7 +4652,7 @@ static void define_builtin_fns(CodeGen *g) {	...	@@ -4652,7 +4652,7 @@ static void define_builtin_fns(CodeGen *g) {
4652	}	4652	}
4653	{	4653	{
4654	BuiltinFnEntry *builtin_fn = create_builtin_fn_with_arg_count(g, BuiltinFnIdFrameAddress,	4654	BuiltinFnEntry *builtin_fn = create_builtin_fn_with_arg_count(g, BuiltinFnIdFrameAddress,
4655	"frame_address", 0);	4655	"frameAddress", 0);
4656	builtin_fn->return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);	4656	builtin_fn->return_type = get_pointer_to_type(g, g->builtin_types.entry_u8, true);
4657		4657
4658	LLVMTypeRef fn_type = LLVMFunctionType(builtin_fn->return_type->type_ref,	4658	LLVMTypeRef fn_type = LLVMFunctionType(builtin_fn->return_type->type_ref,
...	@@ -4708,33 +4708,33 @@ static void define_builtin_fns(CodeGen *g) {	...	@@ -4708,33 +4708,33 @@ static void define_builtin_fns(CodeGen *g) {
4708		4708
4709	g->memset_fn_val = builtin_fn->fn_val;	4709	g->memset_fn_val = builtin_fn->fn_val;
4710	}	4710	}
4711	create_builtin_fn_with_arg_count(g, BuiltinFnIdSizeof, "sizeof", 1);	4711	create_builtin_fn_with_arg_count(g, BuiltinFnIdSizeof, "sizeOf", 1);
4712	create_builtin_fn_with_arg_count(g, BuiltinFnIdAlignof, "alignof", 1);	4712	create_builtin_fn_with_arg_count(g, BuiltinFnIdAlignof, "alignOf", 1);
4713	create_builtin_fn_with_arg_count(g, BuiltinFnIdMaxValue, "max_value", 1);	4713	create_builtin_fn_with_arg_count(g, BuiltinFnIdMaxValue, "maxValue", 1);
4714	create_builtin_fn_with_arg_count(g, BuiltinFnIdMinValue, "min_value", 1);	4714	create_builtin_fn_with_arg_count(g, BuiltinFnIdMinValue, "minValue", 1);
4715	create_builtin_fn_with_arg_count(g, BuiltinFnIdMemberCount, "member_count", 1);	4715	create_builtin_fn_with_arg_count(g, BuiltinFnIdMemberCount, "memberCount", 1);
4716	create_builtin_fn_with_arg_count(g, BuiltinFnIdTypeof, "typeof", 1);	4716	create_builtin_fn_with_arg_count(g, BuiltinFnIdTypeof, "typeOf", 1);
4717	create_builtin_fn_with_arg_count(g, BuiltinFnIdAddWithOverflow, "add_with_overflow", 4);	4717	create_builtin_fn_with_arg_count(g, BuiltinFnIdAddWithOverflow, "addWithOverflow", 4);
4718	create_builtin_fn_with_arg_count(g, BuiltinFnIdSubWithOverflow, "sub_with_overflow", 4);	4718	create_builtin_fn_with_arg_count(g, BuiltinFnIdSubWithOverflow, "subWithOverflow", 4);
4719	create_builtin_fn_with_arg_count(g, BuiltinFnIdMulWithOverflow, "mul_with_overflow", 4);	4719	create_builtin_fn_with_arg_count(g, BuiltinFnIdMulWithOverflow, "mulWithOverflow", 4);
4720	create_builtin_fn_with_arg_count(g, BuiltinFnIdShlWithOverflow, "shl_with_overflow", 4);	4720	create_builtin_fn_with_arg_count(g, BuiltinFnIdShlWithOverflow, "shlWithOverflow", 4);
4721	create_builtin_fn_with_arg_count(g, BuiltinFnIdCInclude, "c_include", 1);	4721	create_builtin_fn_with_arg_count(g, BuiltinFnIdCInclude, "cInclude", 1);
4722	create_builtin_fn_with_arg_count(g, BuiltinFnIdCDefine, "c_define", 2);	4722	create_builtin_fn_with_arg_count(g, BuiltinFnIdCDefine, "cDefine", 2);
4723	create_builtin_fn_with_arg_count(g, BuiltinFnIdCUndef, "c_undef", 1);	4723	create_builtin_fn_with_arg_count(g, BuiltinFnIdCUndef, "cUndef", 1);
4724	create_builtin_fn_with_arg_count(g, BuiltinFnIdCompileVar, "compile_var", 1);	4724	create_builtin_fn_with_arg_count(g, BuiltinFnIdCompileVar, "compileVar", 1);
4725	create_builtin_fn_with_arg_count(g, BuiltinFnIdConstEval, "const_eval", 1);	4725	create_builtin_fn_with_arg_count(g, BuiltinFnIdConstEval, "constEval", 1);
4726	create_builtin_fn_with_arg_count(g, BuiltinFnIdCtz, "ctz", 2);	4726	create_builtin_fn_with_arg_count(g, BuiltinFnIdCtz, "ctz", 2);
4727	create_builtin_fn_with_arg_count(g, BuiltinFnIdClz, "clz", 2);	4727	create_builtin_fn_with_arg_count(g, BuiltinFnIdClz, "clz", 2);
4728	create_builtin_fn_with_arg_count(g, BuiltinFnIdImport, "import", 1);	4728	create_builtin_fn_with_arg_count(g, BuiltinFnIdImport, "import", 1);
4729	create_builtin_fn_with_arg_count(g, BuiltinFnIdCImport, "c_import", 1);	4729	create_builtin_fn_with_arg_count(g, BuiltinFnIdCImport, "cImport", 1);
4730	create_builtin_fn_with_arg_count(g, BuiltinFnIdErrName, "err_name", 1);	4730	create_builtin_fn_with_arg_count(g, BuiltinFnIdErrName, "errName", 1);
4731	create_builtin_fn_with_arg_count(g, BuiltinFnIdEmbedFile, "embed_file", 1);	4731	create_builtin_fn_with_arg_count(g, BuiltinFnIdEmbedFile, "embedFile", 1);
4732	create_builtin_fn_with_arg_count(g, BuiltinFnIdCmpExchange, "cmpxchg", 5);	4732	create_builtin_fn_with_arg_count(g, BuiltinFnIdCmpExchange, "cmpxchg", 5);
4733	create_builtin_fn_with_arg_count(g, BuiltinFnIdFence, "fence", 1);	4733	create_builtin_fn_with_arg_count(g, BuiltinFnIdFence, "fence", 1);
4734	create_builtin_fn_with_arg_count(g, BuiltinFnIdDivExact, "div_exact", 2);	4734	create_builtin_fn_with_arg_count(g, BuiltinFnIdDivExact, "divExact", 2);
4735	create_builtin_fn_with_arg_count(g, BuiltinFnIdTruncate, "truncate", 2);	4735	create_builtin_fn_with_arg_count(g, BuiltinFnIdTruncate, "truncate", 2);
4736	create_builtin_fn_with_arg_count(g, BuiltinFnIdCompileErr, "compile_err", 1);	4736	create_builtin_fn_with_arg_count(g, BuiltinFnIdCompileErr, "compileErr", 1);
4737	create_builtin_fn_with_arg_count(g, BuiltinFnIdIntType, "int_type", 2);	4737	create_builtin_fn_with_arg_count(g, BuiltinFnIdIntType, "intType", 2);
4738	}	4738	}
4739		4739
4740	static void init(CodeGen g, Buf source_path) {	4740	static void init(CodeGen g, Buf source_path) {