From 2ab7b40f2fdf7c46177e8eb74e2ca0107a973ea5 Mon Sep 17 00:00:00 2001
From: joe-conigliaro <joe-conigliaro@users.noreply.github.com>
Date: Wed, 8 Jan 2020 01:46:57 +1100
Subject: [PATCH] v: clean up enum vals; make array_init return array

---
 vlib/compiler/main.v   |  14 ++++--
 vlib/v/gen/cgen.v      |   4 +-
 vlib/v/gen/tests/1.c   |   2 +-
 vlib/v/gen/tests/2.c   |   2 +-
 vlib/v/parser/a_type.v |  42 ++++++++--------
 vlib/v/parser/fn.v     |   2 +-
 vlib/v/parser/parser.v |  14 +++---
 vlib/v/table/type.v    |   4 +-
 vlib/v/types/types.v   | 112 ++++++++++++++++++++---------------------
 9 files changed, 102 insertions(+), 94 deletions(-)

diff --git a/vlib/compiler/main.v b/vlib/compiler/main.v
index 0e8f1bb14c..6a9ee2ffed 100644
--- a/vlib/compiler/main.v
+++ b/vlib/compiler/main.v
@@ -9,11 +9,11 @@ import (
 	strings
 	filepath
 	//compiler.x64
-	v.gen.x64
+	// v.gen.x64
 	//v.types
-	v.table
-	v.parser
-	v.gen
+	// v.table
+	// v.parser
+	// v.gen
 	time
 )
 
@@ -382,6 +382,8 @@ pub fn (v mut V) compile() {
 	v.cc()
 }
 
+pub fn (v &V) compile2() {}
+/*
 pub fn (v mut V) compile2() {
 	if os.user_os() != 'windows' && v.pref.ccompiler == 'msvc' {
 		verror('Cannot build with msvc on ${os.user_os()}')
@@ -416,7 +418,10 @@ pub fn (v mut V) compile2() {
 	v.cc()
 
 }
+*/
 
+pub fn (v &V) compile_x64() {}
+/*
 pub fn (v mut V) compile_x64() {
 	$if !linux {
 		println('v -x64 can only generate Linux binaries for now')
@@ -440,6 +445,7 @@ pub fn (v mut V) compile_x64() {
 	}
 	*/
 }
+*/
 
 fn (v mut V) generate_init() {
 	$if js {
diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v
index cf7dff44d9..1c3b9c3bfe 100644
--- a/vlib/v/gen/cgen.v
+++ b/vlib/v/gen/cgen.v
@@ -249,7 +249,7 @@ fn (g mut Gen) expr(node ast.Expr) {
 			// If expression? Assign the value to a temp var.
 			// Previously ?: was used, but it's too unreliable.
 			mut tmp := ''
-			if it.ti.kind != ._void {
+			if it.ti.kind != .void {
 				tmp = g.table.new_tmp_var()
 				// g.writeln('$it.ti.name $tmp;')
 			}
@@ -258,7 +258,7 @@ fn (g mut Gen) expr(node ast.Expr) {
 			g.writeln(') {')
 			for i, stmt in it.stmts {
 				// Assign ret value
-				if i == it.stmts.len - 1 && it.ti.kind != ._void {
+				if i == it.stmts.len - 1 && it.ti.kind != .void {
 					// g.writeln('$tmp =')
 					println(1)
 				}
diff --git a/vlib/v/gen/tests/1.c b/vlib/v/gen/tests/1.c
index 7889d0e822..e28d4c91d1 100644
--- a/vlib/v/gen/tests/1.c
+++ b/vlib/v/gen/tests/1.c
@@ -27,7 +27,7 @@ void foo(int a) {
 i < 10; i++;
 ) {
 	}
-	int nums = new_array_from_c_array(3, 3, sizeof(int), {
+	array_int nums = new_array_from_c_array(3, 3, sizeof(array_int), {
 		1, 2, 3,
 	});
 	int number = nums[0];
diff --git a/vlib/v/gen/tests/2.c b/vlib/v/gen/tests/2.c
index 90e697ec2f..7b2c674c42 100644
--- a/vlib/v/gen/tests/2.c
+++ b/vlib/v/gen/tests/2.c
@@ -65,7 +65,7 @@ void function2() {
 }
 
 void init_array() {
-	int nums = new_array_from_c_array(3, 3, sizeof(int), {
+	array_int nums = new_array_from_c_array(3, 3, sizeof(array_int), {
 		1, 2, 3,
 	});
 }
diff --git a/vlib/v/parser/a_type.v b/vlib/v/parser/a_type.v
index 44199d7f80..73542ff76d 100644
--- a/vlib/v/parser/a_type.v
+++ b/vlib/v/parser/a_type.v
@@ -12,7 +12,7 @@ pub fn (p mut Parser) parse_array_ti(nr_muls int) types.TypeIdent {
 		p.check(.rsbr)
 		elem_ti := p.parse_ti()
 		idx,name := p.table.find_or_register_array_fixed(&elem_ti, size, 1)
-		return types.new_ti(._array_fixed, name, idx, nr_muls)
+		return types.new_ti(.array_fixed, name, idx, nr_muls)
 	}
 	// array
 	p.check(.rsbr)
@@ -24,7 +24,7 @@ pub fn (p mut Parser) parse_array_ti(nr_muls int) types.TypeIdent {
 		nr_dims++
 	}
 	idx,name := p.table.find_or_register_array(&elem_ti, nr_dims)
-	return types.new_ti(._array, name, idx, nr_muls)
+	return types.new_ti(.array, name, idx, nr_muls)
 }
 
 pub fn (p mut Parser) parse_map_ti(nr_muls int) types.TypeIdent {
@@ -34,7 +34,7 @@ pub fn (p mut Parser) parse_map_ti(nr_muls int) types.TypeIdent {
 	p.check(.rsbr)
 	value_ti := p.parse_ti()
 	idx,name := p.table.find_or_register_map(&key_ti, &value_ti)
-	return types.new_ti(._map, name, idx, nr_muls)
+	return types.new_ti(.map, name, idx, nr_muls)
 }
 
 pub fn (p mut Parser) parse_multi_return_ti() types.TypeIdent {
@@ -52,14 +52,14 @@ pub fn (p mut Parser) parse_multi_return_ti() types.TypeIdent {
 	}
 	p.check(.rpar)
 	idx,name := p.table.find_or_register_multi_return(mr_tis)
-	return types.new_ti(._multi_return, name, idx, 0)
+	return types.new_ti(.multi_return, name, idx, 0)
 }
 
 pub fn (p mut Parser) parse_variadic_ti() types.TypeIdent {
 	p.check(.ellipsis)
 	variadic_ti := p.parse_ti()
 	idx,name := p.table.find_or_register_variadic(&variadic_ti)
-	return types.new_ti(._variadic, name, idx, 0)
+	return types.new_ti(.variadic, name, idx, 0)
 }
 
 pub fn (p mut Parser) parse_ti() types.TypeIdent {
@@ -98,52 +98,52 @@ pub fn (p mut Parser) parse_ti() types.TypeIdent {
 					return p.parse_map_ti(nr_muls)
 				}
 				'voidptr' {
-					return types.new_builtin_ti(._voidptr, nr_muls)
+					return types.new_builtin_ti(.voidptr, nr_muls)
 				}
 				'byteptr' {
-					return types.new_builtin_ti(._byteptr, nr_muls)
+					return types.new_builtin_ti(.byteptr, nr_muls)
 				}
 				'charptr' {
-					return types.new_builtin_ti(._charptr, nr_muls)
+					return types.new_builtin_ti(.charptr, nr_muls)
 				}
 				'i8' {
-					return types.new_builtin_ti(._i8, nr_muls)
+					return types.new_builtin_ti(.i8, nr_muls)
 				}
 				'i16' {
-					return types.new_builtin_ti(._i16, nr_muls)
+					return types.new_builtin_ti(.i16, nr_muls)
 				}
 				'int' {
-					return types.new_builtin_ti(._int, nr_muls)
+					return types.new_builtin_ti(.int, nr_muls)
 				}
 				'i64' {
-					return types.new_builtin_ti(._i64, nr_muls)
+					return types.new_builtin_ti(.i64, nr_muls)
 				}
 				'byte' {
-					return types.new_builtin_ti(._byte, nr_muls)
+					return types.new_builtin_ti(.byte, nr_muls)
 				}
 				'u16' {
-					return types.new_builtin_ti(._u16, nr_muls)
+					return types.new_builtin_ti(.u16, nr_muls)
 				}
 				'u32' {
-					return types.new_builtin_ti(._u32, nr_muls)
+					return types.new_builtin_ti(.u32, nr_muls)
 				}
 				'u64' {
-					return types.new_builtin_ti(._u64, nr_muls)
+					return types.new_builtin_ti(.u64, nr_muls)
 				}
 				'f32' {
-					return types.new_builtin_ti(._f32, nr_muls)
+					return types.new_builtin_ti(.f32, nr_muls)
 				}
 				'f64' {
 					return types.new_builtin_ti(.f64, nr_muls)
 				}
 				'string' {
-					return types.new_builtin_ti(._string, nr_muls)
+					return types.new_builtin_ti(.string, nr_muls)
 				}
 				'char' {
-					return types.new_builtin_ti(._char, nr_muls)
+					return types.new_builtin_ti(.char, nr_muls)
 				}
 				'bool' {
-					return types.new_builtin_ti(._bool, nr_muls)
+					return types.new_builtin_ti(.bool, nr_muls)
 				}
 				// struct / enum / placeholder
 				else {
@@ -153,7 +153,7 @@ pub fn (p mut Parser) parse_ti() types.TypeIdent {
 					if idx == 0 {
 						idx = p.table.add_placeholder_type(name)
 					}
-					return types.new_ti(._placeholder, name, idx, nr_muls)
+					return types.new_ti(.placeholder, name, idx, nr_muls)
 				}
 	}
 		}
diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v
index 9b0e0d13f9..a3775958b2 100644
--- a/vlib/v/parser/fn.v
+++ b/vlib/v/parser/fn.v
@@ -122,7 +122,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 				ti: ti
 				name: arg_name
 			}
-			if ti.kind == ._variadic && p.tok.kind == .comma {
+			if ti.kind == .variadic && p.tok.kind == .comma {
 				p.error('cannot use ...(variadic) with non-final parameter $arg_name')
 			}
 		}
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v
index 6976b71433..5911e46784 100644
--- a/vlib/v/parser/parser.v
+++ b/vlib/v/parser/parser.v
@@ -435,7 +435,7 @@ fn (p mut Parser) dot_expr(left ast.Expr) (ast.Expr,types.TypeIdent) {
 	/*
 				// p.next()
 				field := p.check_name()
-				if !ti.type_kind in  [._placeholder, ._struct] {
+				if !ti.type_kind in  [.placeholder, .struct_] {
 					println('kind: $ti.str()')
 					p.error('cannot access field, `$ti.type_name` is not a struct')
 				}
@@ -519,7 +519,7 @@ fn (p mut Parser) for_statement() ast.Stmt {
 		if p.tok.kind != .semicolon {
 			mut typ := types.TypeIdent{}
 			cond,typ = p.expr(0)
-			if typ.kind != ._bool {
+			if typ.kind != .bool {
 				p.error('non-bool used as for condition')
 			}
 		}
@@ -571,7 +571,7 @@ fn (p mut Parser) if_expr() (ast.Expr,types.TypeIdent) {
 	p.check(.key_if)
 	cond,cond_ti := p.expr(0)
 	// if !types.check(types.bool_ti, cond_ti) {
-	if cond_ti.kind != ._bool {
+	if cond_ti.kind != .bool {
 		p.error('non-bool used as if condition')
 	}
 	stmts := p.parse_block()
@@ -645,13 +645,15 @@ fn (p mut Parser) array_init() (ast.Expr,types.TypeIdent) {
 			p.check(.comma)
 		}
 	}
+	type_idx, type_name := p.table.find_or_register_array(val_ti, 1)
+	array_ti := types.new_ti(.array, type_name, type_idx, 0)
 	mut node := ast.Expr{}
 	node = ast.ArrayInit{
-		ti: val_ti
+		ti: array_ti
 		exprs: exprs
 	}
 	p.check(.rsbr)
-	return node,val_ti
+	return node,array_ti
 }
 
 fn (p mut Parser) parse_number_literal() (ast.Expr,types.TypeIdent) {
@@ -752,7 +754,7 @@ fn (p mut Parser) return_stmt() ast.Return {
 		}
 	}
 	mut expected_tis := [p.return_ti]
-	if p.return_ti.kind == ._multi_return {
+	if p.return_ti.kind == .multi_return {
 		mr_type := p.table.types[p.return_ti.idx] as types.MultiReturn
 		expected_tis = mr_type.tis
 	}
diff --git a/vlib/v/table/type.v b/vlib/v/table/type.v
index 2a0c81a802..8a0fea9d5a 100644
--- a/vlib/v/table/type.v
+++ b/vlib/v/table/type.v
@@ -78,7 +78,7 @@ pub fn (t mut Table) find_or_register_map(key_ti &types.TypeIdent, value_ti &typ
 }
 
 pub fn (t mut Table) find_or_register_array(elem_ti &types.TypeIdent, nr_dims int) (int,string) {
-	name := 'array_${elem_ti.name}_${nr_dims}d'
+	name := 'array_${elem_ti.name}' + if nr_dims > 1 { '_${nr_dims}d' } else { '' }
 	// existing
 	existing_idx := t.type_idxs[name]
 	if existing_idx > 0 {
@@ -100,7 +100,7 @@ pub fn (t mut Table) find_or_register_array(elem_ti &types.TypeIdent, nr_dims in
 }
 
 pub fn (t mut Table) find_or_register_array_fixed(elem_ti &types.TypeIdent, size int, nr_dims int) (int,string) {
-	name := 'array_fixed_${elem_ti.name}_${size}_${nr_dims}d'
+	name := 'array_fixed_${elem_ti.name}_${size}' + if nr_dims > 1 { '_${nr_dims}d' } else { '' }
 	// existing
 	existing_idx := t.type_idxs[name]
 	if existing_idx > 0 {
diff --git a/vlib/v/types/types.v b/vlib/v/types/types.v
index 02c1c2647d..273fa861a8 100644
--- a/vlib/v/types/types.v
+++ b/vlib/v/types/types.v
@@ -4,32 +4,32 @@
 module types
 
 pub enum Kind {
-	_placeholder
-	_void,
-	_voidptr,
-	_charptr,
-	_byteptr,
-	_const,
-	_enum,
-	_struct,
-	_int,
-	_i8,
-	_i16,
-	_i64,
-	_byte,
-	_u16,
-	_u32,
-	_u64,
-	_f32,
+	placeholder
+	void,
+	voidptr,
+	charptr,
+	byteptr,
+	const_,
+	enum_,
+	struct_,
+	int,
+	i8,
+	i16,
+	i64,
+	byte,
+	u16,
+	u32,
+	u64,
+	f32,
 	f64,
-	_string,
-	_char,
-	_bool,
-	_array,
-	_array_fixed,
-	_map,
-	_multi_return,
-	_variadic
+	string,
+	char,
+	bool,
+	array,
+	array_fixed,
+	map,
+	multi_return,
+	variadic
 }
 
 pub type Type = Placeholder | Void | Voidptr | Charptr | Byteptr | Const | Enum | Struct | 	
@@ -56,7 +56,7 @@ pub fn new_ti(kind Kind, name string, idx int, nr_muls int) TypeIdent {
 [inline]
 pub fn new_builtin_ti(kind Kind, nr_muls int) TypeIdent {
 	return TypeIdent{
-		idx: -int(kind)
+		idx: -int(kind)-1
 		kind: kind
 		name: kind.str()
 		nr_muls: nr_muls
@@ -70,12 +70,12 @@ pub fn (ti &TypeIdent) is_ptr() bool {
 
 [inline]
 pub fn (ti &TypeIdent) is_int() bool {
-	return ti.kind in [._i8, ._i16, ._int, ._i64, ._byte, ._u16, ._u32, ._u64]
+	return ti.kind in [.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64]
 }
 
 [inline]
 pub fn (ti &TypeIdent) is_float() bool {
-	return ti.kind in [._f32, .f64]
+	return ti.kind in [.f32, .f64]
 }
 
 [inline]
@@ -92,7 +92,7 @@ pub fn (ti &TypeIdent) str() string {
 }
 
 pub fn check(got, expected &TypeIdent) bool {
-	if expected.kind == ._voidptr {
+	if expected.kind == .voidptr {
 		return true
 	}
 	if expected.name == 'array' {
@@ -106,76 +106,76 @@ pub fn check(got, expected &TypeIdent) bool {
 
 pub fn (k Kind) str() string {
 	k_str := match k {
-		._placeholder{
+		.placeholder{
 			'placeholder'
 		}
-		._void{
+		.void{
 			'void'
 		}
-		._voidptr{
+		.voidptr{
 			'voidptr'
 		}
-		._charptr{
+		.charptr{
 			'charptr'
 		}
-		._byteptr{
+		.byteptr{
 			'byteptr'
 		}
-		._const{
+		.const_{
 			'const'
 		}
-		._enum{
+		.enum_{
 			'enum'
 		}
-		._struct{
+		.struct_{
 			'struct'
 		}
-		._int{
+		.int{
 			'int'
 		}
-		._i8{
+		.i8{
 			'i8'
 		}
-		._i16{
+		.i16{
 			'i16'
 		}
-		._i64{
+		.i64{
 			'i64'
 		}
-		._byte{
+		.byte{
 			'byte'
 		}
-		._u16{
+		.u16{
 			'u18'
 		}
-		._f32{
+		.f32{
 			'f32'
 		}
 		.f64{
 			'f64'
 		}
-		._string{
+		.string{
 			'string'
 		}
-		._char{
+		.char{
 			'char'
 		}
-		._bool{
+		.bool{
 			'bool'
 		}
-		._array{
+		.array{
 			'array'
 		}
-		._array_fixed{
+		.array_fixed{
 			'array_fixed'
 		}
-		._map{
+		.map{
 			'map'
 		}
-		._multi_return{
+		.multi_return{
 			'multi_return'
 		}
-		._variadic{
+		.variadic{
 			'variadic'
 		}
 		else {
@@ -396,8 +396,8 @@ pub const (
 )
 
 pub const (
-	void_ti = new_builtin_ti(._void, 0)
-	int_ti = new_builtin_ti(._int, 0)
-	string_ti = new_builtin_ti(._string, 0)
-	bool_ti = new_builtin_ti(._bool, 0)
+	void_ti = new_builtin_ti(.void, 0)
+	int_ti = new_builtin_ti(.int, 0)
+	string_ti = new_builtin_ti(.string, 0)
+	bool_ti = new_builtin_ti(.bool, 0)
 )