compiler: remove remaining switch statements and show a warning

vlib/compiler/cgen.v

@@ -271,18 +271,18 @@ fn build_thirdparty_obj_file(path string, moduleflags []CFlag) {
 }
 
 fn os_name_to_ifdef(name string) string {
-	switch name {
+	match name {
-		case 'windows': return '_WIN32'
+		 'windows' { return '_WIN32'}
-		case 'mac': return '__APPLE__'
+		 'mac' { return '__APPLE__'}
-		case 'linux': return '__linux__'
+		 'linux' { return '__linux__'}
-		case 'freebsd': return '__FreeBSD__'
+		 'freebsd' { return '__FreeBSD__'}
-		case 'openbsd': return '__OpenBSD__'
+		 'openbsd'{  return '__OpenBSD__'}
-		case 'netbsd': return '__NetBSD__'
+		 'netbsd'{ return '__NetBSD__'}
-		case 'dragonfly': return '__DragonFly__'
+		 'dragonfly'{ return '__DragonFly__'}
-		case 'msvc': return '_MSC_VER'
+		 'msvc'{ return '_MSC_VER'}
-		case 'android': return '__BIONIC__'
+		 'android'{ return '__BIONIC__'}
-		case 'js': return '_VJS'
+		 'js' {return '_VJS'}
-		case 'solaris': return '__sun'
+		 'solaris'{ return '__sun'}
 	}
 	verror('bad os ifdef name "$name"')
 	return ''

vlib/compiler/compile_errors.v

@@ -270,6 +270,8 @@ fn (s mut Scanner) eat_single_newline(){
 	if s.text[ s.pos ] == `\r` { s.pos ++ return }
 }
 
+///////////////////////////////
+
 const (
 	match_arrow_warning = '=> is no longer needed in match statements, use\n' +
 'match foo {
@@ -277,4 +279,6 @@ const (
 	2 { baz }
 	else { ... }
 }'
+
+	//make_receiver_mutable =
 )

vlib/compiler/gen_c.v

@@ -512,22 +512,22 @@ fn type_default(typ string) string {
 		return '{0}'
 	}
 	// Default values for other types are not needed because of mandatory initialization
-	switch typ {
+	match typ {
-	case 'bool': return '0'
+	'bool'{ return '0'}
-	case 'string': return 'tos((byte *)"", 0)'
+	'string'{ return 'tos3("")'}
-	case 'i8': return '0'
+	'i8'{ return '0'}
-	case 'i16': return '0'
+	'i16'{ return '0'}
-	case 'i64': return '0'
+	'i64'{ return '0'}
-	case 'u16': return '0'
+	'u16'{ return '0'}
-	case 'u32': return '0'
+	'u32'{ return '0'}
-	case 'u64': return '0'
+	'u64'{ return '0'}
-	case 'byte': return '0'
+	'byte'{ return '0'}
-	case 'int': return '0'
+	'int'{ return '0'}
-	case 'rune': return '0'
+	'rune'{ return '0'}
-	case 'f32': return '0.0'
+	'f32'{ return '0.0'}
-	case 'f64': return '0.0'
+	'f64'{ return '0.0'}
-	case 'byteptr': return '0'
+	'byteptr'{ return '0'}
-	case 'voidptr': return '0'
+	'voidptr'{ return '0'}
 	}
 	return '{0}'
 }

vlib/compiler/main.v

@@ -1081,21 +1081,22 @@ pub fn cescaped_path(s string) string {
 }
 
 pub fn os_from_string(os string) OS {
-	switch os {
+	match os {
-		case 'linux': return .linux
+		'linux' { return .linux}
-		case 'windows': return .windows
+		'windows' { return .windows}
-		case 'mac': return .mac
+		'mac' { return .mac}
-		case 'freebsd': return .freebsd
+		'freebsd' { return .freebsd}
-		case 'openbsd': return .openbsd
+		'openbsd' { return .openbsd}
-		case 'netbsd': return .netbsd
+		'netbsd' { return .netbsd}
-		case 'dragonfly': return .dragonfly
+		'dragonfly' { return .dragonfly}
-		case 'js': return .js
+		'js' { return .js}
-		case 'solaris': return .solaris
+		'solaris' { return .solaris}
-		case 'android': return .android
+		'android' { return .android}
-		case 'msvc':
+		'msvc' {
 			// notice that `-os msvc` became `-cc msvc`
 			verror('use the flag `-cc msvc` to build using msvc')
 		}
+	}
 	println('bad os $os') // todo panic?
 	return .linux
 }

vlib/compiler/parser.v

@@ -658,10 +658,10 @@ fn (p mut Parser) interface_method(field_name, receiver string) &Fn {
 }
 
 fn key_to_type_cat(tok TokenKind) TypeCategory {
-	switch tok {
+	match tok {
-	case TokenKind.key_interface:  return TypeCategory.interface_
+	.key_interface {  return TypeCategory.interface_ }
-	case TokenKind.key_struct: return TypeCategory.struct_
+	.key_struct { return TypeCategory.struct_ }
-	case TokenKind.key_union: return TypeCategory.union_
+	.key_union { return TypeCategory.union_ }
 	//TokenKind.key_ => return .interface_
 	}
 	verror('Unknown token: $tok')
@@ -2447,8 +2447,8 @@ fn (p mut Parser) term() string {
 fn (p mut Parser) unary() string {
 	mut typ := ''
 	tok := p.tok
-	switch tok {
+	match tok {
-	case TokenKind.not:
+	.not {
 		p.gen('!')
 		p.check(.not)
 		// typ should be bool type
@@ -2456,29 +2456,32 @@ fn (p mut Parser) unary() string {
 		if typ != 'bool' {
 			p.error('operator ! requires bool type, not `$typ`')
 		}
-
+	}
-	case TokenKind.bit_not:
+	.bit_not {
 		p.gen('~')
 		p.check(.bit_not)
 		typ = p.bool_expression()
-	default:
+	}
+	else {
 		typ = p.factor()
 	}
+	}
 	return typ
 }
 
 fn (p mut Parser) factor() string {
 	mut typ := ''
 	tok := p.tok
-	switch tok {
+	match tok {
-	case .key_none:
+	.key_none {
 		if !p.expected_type.starts_with('Option_') {
 			p.error('need "$p.expected_type" got none')
 		}
 		p.gen('opt_none()')
 		p.check(.key_none)
 		return p.expected_type
-	case TokenKind.number:
+	}
+	.number {
 		typ = 'int'
 		// Check if float (`1.0`, `1e+3`) but not if is hexa
 		if (p.lit.contains('.') || (p.lit.contains('e') || p.lit.contains('E'))) &&
@@ -2496,13 +2499,15 @@ fn (p mut Parser) factor() string {
 		}
 		p.gen(p.lit)
 		p.fgen(p.lit)
-	case TokenKind.minus:
+	}
+	.minus {
 		p.gen('-')
 		p.fgen('-')
 		p.next()
 		return p.factor()
 		// Variable
-	case TokenKind.key_sizeof:
+	}
+	.key_sizeof {
 		p.gen('sizeof(')
 		p.fgen('sizeof(')
 		p.next()
@@ -2512,10 +2517,12 @@ fn (p mut Parser) factor() string {
 		p.gen('$sizeof_typ)')
 		p.fgen('$sizeof_typ)')
 		return 'int'
-	case TokenKind.amp, TokenKind.dot, TokenKind.mul:
+	}
+	.amp, .dot, .mul {
 		// (dot is for enum vals: `.green`)
 		return p.name_expr()
-	case TokenKind.name:
+	}
+	.name {
 		// map[string]int
 		if p.lit == 'map' && p.peek() == .lsbr {
 			return p.map_init()
@@ -2532,7 +2539,8 @@ fn (p mut Parser) factor() string {
 		//}
 		typ = p.name_expr()
 		return typ
-	case TokenKind.key_default:
+	}
+	.key_default {
 		p.next()
 		p.next()
 		name := p.check_name()
@@ -2542,7 +2550,8 @@ fn (p mut Parser) factor() string {
 		p.gen('default(T)')
 		p.next()
 		return 'T'
-	case TokenKind.lpar:
+	}
+	.lpar {
 		//p.gen('(/*lpar*/')
 		p.gen('(')
 		p.check(.lpar)
@@ -2556,41 +2565,50 @@ fn (p mut Parser) factor() string {
 		p.ptr_cast = false
 		p.gen(')')
 		return typ
-	case TokenKind.chartoken:
+	}
+	.chartoken {
 		p.char_expr()
 		typ = 'byte'
 		return typ
-	case TokenKind.str:
+	}
+	.str {
 		p.string_expr()
 		typ = 'string'
 		return typ
-	case TokenKind.key_false:
+	}
+	.key_false {
 		typ = 'bool'
 		p.gen('0')
 		p.fgen('false')
-	case TokenKind.key_true:
+	}
+	.key_true {
 		typ = 'bool'
 		p.gen('1')
 		p.fgen('true')
-	case TokenKind.lsbr:
+	}
+	.lsbr {
 		// `[1,2,3]` or `[]` or `[20]byte`
 		// TODO have to return because arrayInit does next()
 		// everything should do next()
 		return p.array_init()
-	case TokenKind.lcbr:
+	}
+	.lcbr {
 		// `m := { 'one': 1 }`
 		if p.peek() == .str {
 			return p.map_init()
 		}
 		// { user | name :'new name' }
 		return p.assoc()
-	case TokenKind.key_if:
+	}
+	.key_if {
 		typ = p.if_st(true, 0)
 		return typ
-	case TokenKind.key_match:
+	}
+	.key_match {
 		typ = p.match_statement(true)
 		return typ
-	default:
+	}
+	else {
 		if p.pref.is_verbose || p.pref.is_debug {
 			next := p.peek()
 			println('prev=${p.prev_tok.str()}')
@@ -2598,6 +2616,7 @@ fn (p mut Parser) factor() string {
 		}
 		p.error('unexpected token: `${p.tok.str()}`')
 	}
+	}
 	p.next()// TODO everything should next()
 	return typ
 }
@@ -3316,6 +3335,8 @@ fn (p mut Parser) for_st() {
 }
 
 fn (p mut Parser) switch_statement() {
+	p.warn('`switch` statement has been deprecated, use `match` instead:\n' +
+		'https://vlang.io/docs#match')
 	if p.tok == .key_switch {
 		p.check(.key_switch)
 	} else {

vlib/compiler/scanner.v

@@ -306,8 +306,8 @@ fn (s mut Scanner) scan() ScanRes {
 		return scan_res(.number, num)
 	}
 	// all other tokens
-	switch c {
+	match c {
-	case `+`:
+	`+` {
 		if nextc == `+` {
 			s.pos++
 			return scan_res(.inc, '')
@@ -317,7 +317,8 @@ fn (s mut Scanner) scan() ScanRes {
 			return scan_res(.plus_assign, '')
 		}
 		return scan_res(.plus, '')
-	case `-`:
+	}
+	`-` {
 		if nextc == `-` {
 			s.pos++
 			return scan_res(.dec, '')
@@ -327,47 +328,62 @@ fn (s mut Scanner) scan() ScanRes {
 			return scan_res(.minus_assign, '')
 		}
 		return scan_res(.minus, '')
-	case `*`:
+	}
+	`*` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.mult_assign, '')
 		}
 		return scan_res(.mul, '')
-	case `^`:
+	}
+	`^` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.xor_assign, '')
 		}
 		return scan_res(.xor, '')
-	case `%`:
+	}
+	 `%` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.mod_assign, '')
 		}
 		return scan_res(.mod, '')
-	case `?`:
+	}
+	`?` {
 		return scan_res(.question, '')
-	case single_quote, double_quote:
+	}
+	 single_quote, double_quote {
 		return scan_res(.str, s.ident_string())
-	case `\``: // ` // apostrophe balance comment. do not remove
+		}
+	 `\`` { // ` // apostrophe balance comment. do not remove
 		return scan_res(.chartoken, s.ident_char())
-	case `(`:
+		}
+	 `(` {
+	 	
 		return scan_res(.lpar, '')
-	case `)`:
+	 }
+	 `)` {
 		return scan_res(.rpar, '')
-	case `[`:
+	 }
+	 `[` {
 		return scan_res(.lsbr, '')
-	case `]`:
+	 }
+	 `]` {
 		return scan_res(.rsbr, '')
-	case `{`:
+	 }
+	 `{` {
 		// Skip { in ${ in strings
+		// }
 		if s.inside_string {
 			return s.scan()
 		}
 		return scan_res(.lcbr, '')
-	case `$`:
+	}
+	 `$` {
 		return scan_res(.dollar, '')
-	case `}`:
+	 }
+	 `}` {
 		// s = `hello $name !`
 		// s = `hello ${name} !`
 		if s.inside_string {
@@ -382,7 +398,8 @@ fn (s mut Scanner) scan() ScanRes {
 		else {
 			return scan_res(.rcbr, '')
 		}
-	case `&`:
+	 }
+	 `&` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.and_assign, '')
@@ -392,7 +409,8 @@ fn (s mut Scanner) scan() ScanRes {
 			return scan_res(.and, '')
 		}
 		return scan_res(.amp, '')
-	case `|`:
+	 }
+	 `|` {
 		if nextc == `|` {
 			s.pos++
 			return scan_res(.logical_or, '')
@@ -402,9 +420,11 @@ fn (s mut Scanner) scan() ScanRes {
 			return scan_res(.or_assign, '')
 		}
 		return scan_res(.pipe, '')
-	case `,`:
+	 }
+	 `,` {
 		return scan_res(.comma, '')
-	case `@`:
+	 }
+	 `@` {
 		s.pos++
 		name := s.ident_name()
 		// @FN => will be substituted with the name of the current V function
@@ -424,6 +444,7 @@ fn (s mut Scanner) scan() ScanRes {
 			s.error('@ must be used before keywords (e.g. `@type string`)')
 		}
 		return scan_res(.name, name)
+	}
 	/*
 	case `\r`:
 		if nextc == `\n` {
@@ -431,11 +452,13 @@ fn (s mut Scanner) scan() ScanRes {
 			s.last_nl_pos = s.pos
 			return scan_res(.nl, '')
 		}
+	 }
 	case `\n`:
 		s.last_nl_pos = s.pos
 		return scan_res(.nl, '')
+	 }
 	*/
-	case `.`:
+	 `.` {
 		if nextc == `.` {
 			s.pos++
 			if s.text[s.pos+1] == `.` {
@@ -445,7 +468,8 @@ fn (s mut Scanner) scan() ScanRes {
 			return scan_res(.dotdot, '')
 		}
 		return scan_res(.dot, '')
-	case `#`:
+	}
+	 `#` {
 		start := s.pos + 1
 		s.ignore_line()
 		if nextc == `!` {
@@ -456,7 +480,8 @@ fn (s mut Scanner) scan() ScanRes {
 		}
 		hash := s.text.substr(start, s.pos)
 		return scan_res(.hash, hash.trim_space())
-	case `>`:
+	 }
+	 `>` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.ge, '')
@@ -472,7 +497,8 @@ fn (s mut Scanner) scan() ScanRes {
 		else {
 			return scan_res(.gt, '')
 		}
-	case 0xE2:
+	 }
+	 0xE2 {
 		//case `≠`:
 		if nextc == 0x89 && s.text[s.pos + 2] == 0xA0 {
 			s.pos += 2
@@ -488,7 +514,8 @@ fn (s mut Scanner) scan() ScanRes {
 			s.pos += 2
 			return scan_res(.ge, '')
 		}
-	case `<`:
+	 }
+	 `<` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.le, '')
@@ -504,7 +531,8 @@ fn (s mut Scanner) scan() ScanRes {
 		else {
 			return scan_res(.lt, '')
 		}
-	case `=`:
+	 }
+	 `=` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.eq, '')
@@ -516,7 +544,8 @@ fn (s mut Scanner) scan() ScanRes {
 		else {
 			return scan_res(.assign, '')
 		}
-	case `:`:
+	 }
+	 `:` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.decl_assign, '')
@@ -524,9 +553,11 @@ fn (s mut Scanner) scan() ScanRes {
 		else {
 			return scan_res(.colon, '')
 		}
-	case `;`:
+	 }
+	 `;` {
 		return scan_res(.semicolon, '')
-	case `!`:
+	 }
+	 `!` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.ne, '')
@@ -534,9 +565,11 @@ fn (s mut Scanner) scan() ScanRes {
 		else {
 			return scan_res(.not, '')
 		}
-	case `~`:
+	 }
+	 `~` {
 		return scan_res(.bit_not, '')
-	case `/`:
+	}
+	 `/` {
 		if nextc == `=` {
 			s.pos++
 			return scan_res(.div_assign, '')
@@ -582,6 +615,7 @@ fn (s mut Scanner) scan() ScanRes {
 		}
 		return scan_res(.div, '')
 	 }
+	}
 	$if windows {
 		if c == `\0` {
 			return scan_res(.eof, '')

vlib/compiler/table.v

@@ -803,13 +803,13 @@ fn (table &Table) cgen_name_type_pair(name, typ string) string {
 
 fn is_valid_int_const(val, typ string) bool {
 	x := val.int()
-	switch typ {
+	match typ {
-	case 'byte': return 0 <= x && x <= 255
+	 'byte' { return 0 <= x && x <= 255 }
-	case 'u16': return 0 <= x && x <= 65535
+	 'u16' { return 0 <= x && x <= 65535 }
 	//case 'u32': return 0 <= x && x <= math.MaxU32
 	//case 'u64': return 0 <= x && x <= math.MaxU64
 	//////////////
-	case 'i8': return -128 <= x && x <= 127
+	 'i8' { return -128 <= x && x <= 127 }
 	/*
 	case 'i16': return math.min_i16 <= x && x <= math.max_i16
 	case 'int': return math.min_i32 <= x && x <= math.max_i32
@@ -826,24 +826,25 @@ fn (p mut Parser) typ_to_fmt(typ string, level int) string {
 	if t.cat == .enum_ {
 		return '%d'
 	}
-	switch typ {
+	match typ {
-	case 'string': return '%.*s'
+		'string' { return '%.*s'}
 		//case 'bool': return '%.*s'
-	case 'ustring': return '%.*s'
+		'ustring' { return '%.*s'}
-	case 'byte', 'bool', 'int', 'char', 'byte', 'i16', 'i8': return '%d'
+		'byte', 'bool', 'int', 'char', 'byte', 'i16', 'i8' { return '%d'}
-	case 'u16', 'u32': return '%u'
+		'u16', 'u32' { return '%u'}
-	case 'f64', 'f32': return '%f'
+		'f64', 'f32' { return '%f'}
-	case 'i64': return '%lld'
+		'i64' { return '%lld'}
-	case 'u64': return '%llu'
+		'u64' { return '%llu'}
-	case 'byte*', 'byteptr': return '%s'
+		'byte*', 'byteptr' { return '%s'}
 			// case 'array_string': return '%s'
 			// case 'array_int': return '%s'
-	case 'void': p.error('cannot interpolate this value')
+		'void' { p.error('cannot interpolate this value')}
-	default:
+		else {
 			if typ.ends_with('*') {
 				return '%p'
 			}
 		}
+	}
 	if t.parent != '' && level == 0 {
 		return p.typ_to_fmt(t.parent, level+1)
 	}

vlib/os/os.v

@@ -380,34 +380,33 @@ pub fn system(cmd string) int {
 
 pub fn sigint_to_signal_name(si int) string {
 	// POSIX signals:
-	switch si {
+	match si {
-	case  1: return 'SIGHUP'
+		1 {return 'SIGHUP'}
-	case  2: return 'SIGINT'
+		2 {return 'SIGINT'}
-	case  3: return 'SIGQUIT'
+		3 {return 'SIGQUIT'}
-	case  4: return 'SIGILL'
+		4 {return 'SIGILL'}
-	case  6: return 'SIGABRT'
+		6 {return 'SIGABRT'}
-	case  8: return 'SIGFPE'
+		8 {return 'SIGFPE'}
-	case  9: return 'SIGKILL'
+		9 {return 'SIGKILL'}
-	case 11: return 'SIGSEGV'
+		11 {return 'SIGSEGV'}
-	case 13: return 'SIGPIPE'
+		13 {return 'SIGPIPE'}
-	case 14: return 'SIGALRM'
+		14 {return 'SIGALRM'}
-	case 15: return 'SIGTERM'
+		15 {return 'SIGTERM'}
 	}
-	///////////////////////////////////
 	$if linux {
 		// From `man 7 signal` on linux:
-		switch si {
+		match si {
-		case 30,10,16: return 'SIGUSR1'
+			30,10,16{ return 'SIGUSR1'}
-		case 31,12,17: return 'SIGUSR2'
+			31,12,17{ return 'SIGUSR2'}
-		case 20,17,18: return 'SIGCHLD'
+			20,17,18{ return 'SIGCHLD'}
-		case 19,18,25: return 'SIGCONT'
+			19,18,25{ return 'SIGCONT'}
-		case 17,19,23: return 'SIGSTOP'
+			17,19,23{ return 'SIGSTOP'}
-		case 18,20,24: return 'SIGTSTP'
+			18,20,24{ return 'SIGTSTP'}
-		case 21,21,26: return 'SIGTTIN'
+			21,21,26{ return 'SIGTTIN'}
-		case 22,22,27: return 'SIGTTOU'
+			22,22,27{ return 'SIGTTOU'}
 			///////////////////////////////
-		case 5: return 'SIGTRAP'
+			5{ return 'SIGTRAP'}
-		case 7: return 'SIGBUS'		
+			7{ return 'SIGBUS'		}
 		}
 	}
 	return 'unknown'