diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
index 20298aa07c..a9e686d523 100644
--- a/vlib/v/ast/ast.v
+++ b/vlib/v/ast/ast.v
@@ -7,23 +7,23 @@ import v.token
 import v.table
 import v.errors
 
-pub __type TypeDecl = AliasTypeDecl | FnTypeDecl | UnionSumTypeDecl
+pub type TypeDecl = AliasTypeDecl | FnTypeDecl | SumTypeDecl
 
-pub __type Expr = AnonFn | ArrayInit | AsCast | Assoc | AtExpr | BoolLiteral | CTempVar |
+pub type Expr = AnonFn | ArrayInit | AsCast | Assoc | AtExpr | BoolLiteral | CTempVar |
 	CallExpr | CastExpr | ChanInit | CharLiteral | Comment | ComptimeCall | ConcatExpr | EnumVal |
 	FloatLiteral | Ident | IfExpr | IfGuardExpr | IndexExpr | InfixExpr | IntegerLiteral |
 	Likely | LockExpr | MapInit | MatchExpr | None | OrExpr | ParExpr | PostfixExpr | PrefixExpr |
 	RangeExpr | SelectExpr | SelectorExpr | SizeOf | SqlExpr | StringInterLiteral | StringLiteral |
 	StructInit | Type | TypeOf | UnsafeExpr
 
-pub __type Stmt = AssertStmt | AssignStmt | Block | BranchStmt | CompFor | ConstDecl |
-	DeferStmt | EnumDecl | ExprStmt | FnDecl | ForCStmt | ForInStmt | ForStmt | GlobalDecl |
-	GoStmt | GotoLabel | GotoStmt | HashStmt | Import | InterfaceDecl | Module | Return |
-	SqlStmt | StructDecl | TypeDecl
+pub type Stmt = AssertStmt | AssignStmt | Block | BranchStmt | CompFor | ConstDecl | DeferStmt |
+	EnumDecl | ExprStmt | FnDecl | ForCStmt | ForInStmt | ForStmt | GlobalDecl | GoStmt |
+	GotoLabel | GotoStmt | HashStmt | Import | InterfaceDecl | Module | Return | SqlStmt |
+	StructDecl | TypeDecl
 
 // NB: when you add a new Expr or Stmt type with a .pos field, remember to update
 // the .position() token.Position methods too.
-pub __type ScopeObject = ConstField | GlobalField | Var
+pub type ScopeObject = ConstField | GlobalField | Var
 
 pub struct Type {
 pub:
@@ -430,7 +430,7 @@ pub mut:
 	share       table.ShareType
 }
 
-pub __type IdentInfo = IdentFn | IdentVar
+pub type IdentInfo = IdentFn | IdentVar
 
 pub enum IdentKind {
 	unresolved
@@ -457,7 +457,7 @@ pub mut:
 }
 
 pub fn (i &Ident) var_info() IdentVar {
-	match union mut i.info {
+	match mut i.info {
 		IdentVar {
 			return i.info
 		}
@@ -558,18 +558,17 @@ pub mut:
 
 pub struct MatchExpr {
 pub:
-	tok_kind       token.Kind
-	cond           Expr
-	branches       []MatchBranch
-	pos            token.Position
-	is_mut         bool // `match mut ast_node {`
-	is_union_match bool // TODO: remove
+	tok_kind      token.Kind
+	cond          Expr
+	branches      []MatchBranch
+	pos           token.Position
+	is_mut        bool // `match mut ast_node {`
 pub mut:
-	is_expr        bool // returns a value
-	return_type    table.Type
-	cond_type      table.Type // type of `x` in `match x {`
-	expected_type  table.Type // for debugging only
-	is_sum_type    bool
+	is_expr       bool // returns a value
+	return_type   table.Type
+	cond_type     table.Type // type of `x` in `match x {`
+	expected_type table.Type // for debugging only
+	is_sum_type   bool
 }
 
 pub struct MatchBranch {
@@ -747,7 +746,7 @@ pub:
 }
 
 // New implementation of sum types
-pub struct UnionSumTypeDecl {
+pub struct SumTypeDecl {
 pub:
 	name      string
 	is_pub    bool
@@ -1047,7 +1046,7 @@ pub mut:
 
 [inline]
 pub fn (expr Expr) is_blank_ident() bool {
-	match union expr {
+	match expr {
 		Ident { return expr.kind == .blank_ident }
 		else { return false }
 	}
@@ -1055,7 +1054,7 @@ pub fn (expr Expr) is_blank_ident() bool {
 
 pub fn (expr Expr) position() token.Position {
 	// all uncommented have to be implemented
-	match union expr {
+	match expr {
 		// KEKW2
 		AnonFn {
 			return expr.decl.pos
@@ -1091,7 +1090,7 @@ pub fn (expr Expr) position() token.Position {
 }
 
 pub fn (expr Expr) is_lvalue() bool {
-	match union expr {
+	match expr {
 		Ident { return true }
 		CTempVar { return true }
 		IndexExpr { return expr.left.is_lvalue() }
@@ -1102,7 +1101,7 @@ pub fn (expr Expr) is_lvalue() bool {
 }
 
 pub fn (expr Expr) is_expr() bool {
-	match union expr {
+	match expr {
 		IfExpr { return expr.is_expr }
 		MatchExpr { return expr.is_expr }
 		else {}
@@ -1112,7 +1111,7 @@ pub fn (expr Expr) is_expr() bool {
 
 // check if stmt can be an expression in C
 pub fn (stmt Stmt) check_c_expr() ? {
-	match union stmt {
+	match stmt {
 		AssignStmt {
 			return
 		}
@@ -1137,11 +1136,11 @@ pub:
 }
 
 pub fn (stmt Stmt) position() token.Position {
-	match union stmt {
+	match stmt {
 		AssertStmt, AssignStmt, Block, BranchStmt, CompFor, ConstDecl, DeferStmt, EnumDecl, ExprStmt, FnDecl, ForCStmt, ForInStmt, ForStmt, GotoLabel, GotoStmt, Import, Return, StructDecl, GlobalDecl, HashStmt, InterfaceDecl, Module, SqlStmt { return stmt.pos }
 		GoStmt { return stmt.call_expr.position() }
-		TypeDecl { match union stmt {
-				AliasTypeDecl, FnTypeDecl, UnionSumTypeDecl { return stmt.pos }
+		TypeDecl { match stmt {
+				AliasTypeDecl, FnTypeDecl, SumTypeDecl { return stmt.pos }
 			} }
 		// Please, do NOT use else{} here.
 		// This match is exhaustive *on purpose*, to help force
diff --git a/vlib/v/ast/scope.v b/vlib/v/ast/scope.v
index 4d1e67b07f..74bc34069a 100644
--- a/vlib/v/ast/scope.v
+++ b/vlib/v/ast/scope.v
@@ -73,7 +73,7 @@ pub fn (s &Scope) is_known(name string) bool {
 
 pub fn (s &Scope) find_var(name string) ?&Var {
 	if obj := s.find(name) {
-		match union obj {
+		match obj {
 			Var { return &obj }
 			else {}
 		}
@@ -83,7 +83,7 @@ pub fn (s &Scope) find_var(name string) ?&Var {
 
 pub fn (s &Scope) find_const(name string) ?&ConstField {
 	if obj := s.find(name) {
-		match union obj {
+		match obj {
 			ConstField { return &obj }
 			else {}
 		}
@@ -101,7 +101,7 @@ pub fn (s &Scope) known_var(name string) bool {
 pub fn (mut s Scope) update_var_type(name string, typ table.Type) {
 	s.end_pos = s.end_pos // TODO mut bug
 	mut obj := s.objects[name]
-	match union mut obj {
+	match mut obj {
 		Var {
 			if obj.typ == typ {
 				return
@@ -182,7 +182,7 @@ pub fn (sc &Scope) show(depth int, max_depth int) string {
 	}
 	out += '$indent# $sc.start_pos - $sc.end_pos\n'
 	for _, obj in sc.objects {
-		match union obj {
+		match obj {
 			ConstField { out += '$indent  * const: $obj.name - $obj.typ\n' }
 			Var { out += '$indent  * var: $obj.name - $obj.typ\n' }
 			else {}
diff --git a/vlib/v/ast/str.v b/vlib/v/ast/str.v
index ea8738983d..98dde37f56 100644
--- a/vlib/v/ast/str.v
+++ b/vlib/v/ast/str.v
@@ -129,7 +129,7 @@ pub fn (lit &StringInterLiteral) get_fspec_braces(i int) (string, bool) {
 	if !needs_braces {
 		mut sub_expr := lit.exprs[i]
 		for {
-			match union mut sub_expr {
+			match mut sub_expr {
 				Ident {
 					if sub_expr.name[0] == `@` {
 						needs_braces = true
@@ -176,7 +176,7 @@ pub fn (lit &StringInterLiteral) get_fspec_braces(i int) (string, bool) {
 
 // string representation of expr
 pub fn (x Expr) str() string {
-	match union x {
+	match x {
 		CTempVar {
 			return x.orig.str()
 		}
@@ -302,7 +302,7 @@ pub fn (node &BranchStmt) str() string {
 }
 
 pub fn (node Stmt) str() string {
-	match union node {
+	match node {
 		AssignStmt {
 			mut out := ''
 			for i, left in node.left {
diff --git a/vlib/v/checker/check_types.v b/vlib/v/checker/check_types.v
index 03c53b7ad0..688384ac4e 100644
--- a/vlib/v/checker/check_types.v
+++ b/vlib/v/checker/check_types.v
@@ -325,7 +325,7 @@ pub fn (c &Checker) get_default_fmt(ftyp table.Type, typ table.Type) byte {
 		}
 		if ftyp in [table.string_type, table.bool_type] ||
 			sym.kind in
-			[.enum_, .array, .array_fixed, .struct_, .map, .multi_return, .union_sum_type] || ftyp.has_flag(.optional) ||
+			[.enum_, .array, .array_fixed, .struct_, .map, .multi_return, .sum_type] || ftyp.has_flag(.optional) ||
 			sym.has_method('str') {
 			return `s`
 		} else {
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
index 66f5b7dafc..f23fffd59b 100644
--- a/vlib/v/checker/checker.v
+++ b/vlib/v/checker/checker.v
@@ -95,7 +95,7 @@ pub fn (mut c Checker) check(ast_file &ast.File) {
 
 pub fn (mut c Checker) check_scope_vars(sc &ast.Scope) {
 	for _, obj in sc.objects {
-		match union obj {
+		match obj {
 			ast.Var {
 				if !c.pref.is_repl {
 					if !obj.is_used && obj.name[0] != `_` {
@@ -178,7 +178,7 @@ const (
 fn (mut c Checker) check_file_in_main(file ast.File) bool {
 	mut has_main_fn := false
 	for stmt in file.stmts {
-		match union stmt {
+		match stmt {
 			ast.ConstDecl {
 				if stmt.is_pub {
 					c.warn('const $no_pub_in_main_warning', stmt.pos)
@@ -237,7 +237,7 @@ fn (mut c Checker) check_file_in_main(file ast.File) bool {
 					if stmt.is_pub {
 						c.warn('type alias `$stmt.name` $no_pub_in_main_warning', stmt.pos)
 					}
-				} else if stmt is ast.UnionSumTypeDecl {
+				} else if stmt is ast.SumTypeDecl {
 					if stmt.is_pub {
 						c.warn('sum type `$stmt.name` $no_pub_in_main_warning', stmt.pos)
 					}
@@ -278,7 +278,7 @@ fn (mut c Checker) check_valid_pascal_case(name string, identifier string, pos t
 }
 
 pub fn (mut c Checker) type_decl(node ast.TypeDecl) {
-	match union node {
+	match node {
 		ast.AliasTypeDecl {
 			// TODO Replace `c.file.mod.name != 'time'` by `it.language != .v` once available
 			if c.file.mod.name != 'time' && c.file.mod.name != 'builtin' {
@@ -311,7 +311,7 @@ pub fn (mut c Checker) type_decl(node ast.TypeDecl) {
 				}
 			}
 		}
-		ast.UnionSumTypeDecl {
+		ast.SumTypeDecl {
 			c.check_valid_pascal_case(node.name, 'sum type', node.pos)
 			for typ in node.sub_types {
 				mut sym := c.table.get_type_symbol(typ)
@@ -445,7 +445,7 @@ pub fn (mut c Checker) struct_init(mut struct_init ast.StructInit) table.Type {
 		c.error('unknown type', struct_init.pos)
 	}
 	type_sym := c.table.get_type_symbol(struct_init.typ)
-	if type_sym.kind == .union_sum_type && struct_init.fields.len == 1 {
+	if type_sym.kind == .sum_type && struct_init.fields.len == 1 {
 		sexpr := struct_init.fields[0].expr.str()
 		c.error('cast to sum type using `${type_sym.source_name}($sexpr)` not `$type_sym.source_name{$sexpr}`',
 			struct_init.pos)
@@ -726,7 +726,7 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type {
 					}
 				}
 				if infix_expr.op in [.div, .mod] {
-					match union mut infix_expr.right {
+					match mut infix_expr.right {
 						ast.FloatLiteral {
 							if infix_expr.right.val.f64() == 0.0 {
 								oper := if infix_expr.op == .div { 'division' } else { 'modulo' }
@@ -793,10 +793,10 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type {
 				c.error('$infix_expr.op.str(): type `$typ_sym.source_name` does not exist',
 					type_expr.pos)
 			}
-			if left.kind !in [.interface_, .union_sum_type] {
+			if left.kind !in [.interface_, .sum_type] {
 				c.error('`$infix_expr.op.str()` can only be used with interfaces and sum types',
 					infix_expr.pos)
-			} else if mut left.info is table.UnionSumType {
+			} else if mut left.info is table.SumType {
 				if type_expr.typ !in left.info.variants {
 					c.error('`$left.source_name` has no variant `$right.source_name`',
 						infix_expr.pos)
@@ -856,9 +856,9 @@ pub fn (mut c Checker) infix_expr(mut infix_expr ast.InfixExpr) table.Type {
 			infix_expr.pos)
 	}
 	// sum types can't have any infix operation except of "is", is is checked before and doesn't reach this
-	if c.table.type_kind(left_type) == .union_sum_type {
+	if c.table.type_kind(left_type) == .sum_type {
 		c.error('cannot use operator `$infix_expr.op` with `$left.name`', infix_expr.pos)
-	} else if c.table.type_kind(right_type) == .union_sum_type {
+	} else if c.table.type_kind(right_type) == .sum_type {
 		c.error('cannot use operator `$infix_expr.op` with `$right.name`', infix_expr.pos)
 	}
 	// Dual sides check (compatibility check)
@@ -890,7 +890,7 @@ fn (mut c Checker) fail_if_immutable(expr ast.Expr) (string, token.Position) {
 	mut to_lock := '' // name of variable that needs lock
 	mut pos := token.Position{} // and its position
 	mut explicit_lock_needed := false
-	match union mut expr {
+	match mut expr {
 		ast.CastExpr {
 			// TODO
 			return '', pos
@@ -1047,7 +1047,7 @@ pub fn (mut c Checker) call_expr(mut call_expr ast.CallExpr) table.Type {
 fn (mut c Checker) check_map_and_filter(is_map bool, elem_typ table.Type, call_expr ast.CallExpr) {
 	elem_sym := c.table.get_type_symbol(elem_typ)
 	arg_expr := call_expr.args[0].expr
-	match union arg_expr {
+	match arg_expr {
 		ast.AnonFn {
 			if arg_expr.decl.params.len > 1 {
 				c.error('function needs exactly 1 argument', call_expr.pos)
@@ -1098,7 +1098,7 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type {
 		c.error('optional type cannot be called directly', call_expr.left.position())
 		return table.void_type
 	}
-	if left_type_sym.kind == .union_sum_type && method_name == 'type_name' {
+	if left_type_sym.kind == .sum_type && method_name == 'type_name' {
 		return table.string_type
 	}
 	// TODO: remove this for actual methods, use only for compiler magic
@@ -1138,7 +1138,7 @@ pub fn (mut c Checker) call_method(mut call_expr ast.CallExpr) table.Type {
 			arg_sym := c.table.get_type_symbol(arg_type)
 			// FIXME: match expr failed for now
 			mut ret_type := 0
-			match union mut arg_sym.info {
+			match mut arg_sym.info {
 				table.FnType { ret_type = arg_sym.info.func.return_type }
 				else { ret_type = arg_type }
 			}
@@ -1677,7 +1677,7 @@ pub fn (mut c Checker) check_or_expr(or_expr ast.OrExpr, ret_type table.Type, ex
 	}
 	last_stmt := or_expr.stmts[stmts_len - 1]
 	if ret_type != table.void_type {
-		match union last_stmt {
+		match last_stmt {
 			ast.ExprStmt {
 				last_stmt_typ := c.expr(last_stmt.expr)
 				type_fits := c.check_types(last_stmt_typ, ret_type)
@@ -1712,7 +1712,7 @@ pub fn (mut c Checker) check_or_expr(or_expr ast.OrExpr, ret_type table.Type, ex
 			}
 		}
 	} else {
-		match union last_stmt {
+		match last_stmt {
 			ast.ExprStmt {
 				if last_stmt.typ == table.void_type {
 					return
@@ -1735,7 +1735,7 @@ pub fn (mut c Checker) check_or_expr(or_expr ast.OrExpr, ret_type table.Type, ex
 }
 
 fn is_expr_panic_or_exit(expr ast.Expr) bool {
-	match union expr {
+	match expr {
 		ast.CallExpr { return expr.name in ['panic', 'exit'] }
 		else { return false }
 	}
@@ -1746,7 +1746,7 @@ pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) table.T
 	c.prevent_sum_type_unwrapping_once = false
 	// T.name, typeof(expr).name
 	mut name_type := 0
-	match union mut selector_expr.expr {
+	match mut selector_expr.expr {
 		ast.Ident {
 			if selector_expr.expr.name == 'T' {
 				name_type = table.Type(c.table.find_type_idx('T')).set_flag(.generic)
@@ -1788,7 +1788,7 @@ pub fn (mut c Checker) selector_expr(mut selector_expr ast.SelectorExpr) table.T
 			c.error('field `${sym.source_name}.$field_name` is not public', selector_expr.pos)
 		}
 		field_sym := c.table.get_type_symbol(field.typ)
-		if field_sym.kind == .union_sum_type {
+		if field_sym.kind == .sum_type {
 			if !prevent_sum_type_unwrapping_once {
 				scope := c.file.scope.innermost(selector_expr.pos.pos)
 				if scope_field := scope.find_struct_field(utyp, field_name) {
@@ -1947,7 +1947,7 @@ pub fn (mut c Checker) enum_decl(decl ast.EnumDecl) {
 			}
 		}
 		if field.has_expr {
-			match union field.expr {
+			match field.expr {
 				ast.IntegerLiteral {
 					val := field.expr.val.i64()
 					if val < int_min || val > int_max {
@@ -2107,7 +2107,7 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) {
 			// left_type = c.expr(left)
 		}
 		assign_stmt.left_types << left_type
-		match union mut left {
+		match mut left {
 			ast.Ident {
 				if left.kind == .blank_ident {
 					left_type = right_type
@@ -2132,7 +2132,7 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) {
 					ident_var_info.typ = left_type
 					left.info = ident_var_info
 					if left_type != 0 {
-						match union mut left.obj {
+						match mut left.obj {
 							ast.Var { left.obj.typ = left_type }
 							ast.GlobalField { left.obj.typ = left_type }
 							else {}
@@ -2282,7 +2282,7 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type {
 		if array_init.has_default {
 			c.expr(array_init.default_expr)
 		}
-		if sym.kind == .union_sum_type {
+		if sym.kind == .sum_type {
 			if array_init.has_len && !array_init.has_default {
 				c.error('cannot initalize sum type array without default value', array_init.elem_type_pos)
 			}
@@ -2367,7 +2367,7 @@ pub fn (mut c Checker) array_init(mut array_init ast.ArrayInit) table.Type {
 		// [50]byte
 		mut fixed_size := 1
 		init_expr := array_init.exprs[0]
-		match union init_expr {
+		match init_expr {
 			ast.IntegerLiteral {
 				fixed_size = init_expr.val.int()
 			}
@@ -2409,7 +2409,7 @@ fn const_int_value(cfield ast.ConstField) ?int {
 }
 
 fn is_const_integer(cfield ast.ConstField) ?ast.IntegerLiteral {
-	match union cfield.expr {
+	match cfield.expr {
 		ast.IntegerLiteral { return cfield.expr }
 		else {}
 	}
@@ -2435,7 +2435,7 @@ fn (mut c Checker) stmt(node ast.Stmt) {
 		eprintln('checking file: ${c.file.path:-30} | stmt pos: ${stmt_pos.str():-45} | stmt')
 	}
 	// c.expected_type = table.void_type
-	match union mut node {
+	match mut node {
 		ast.AssertStmt {
 			cur_exp_typ := c.expected_type
 			assert_type := c.expr(node.expr)
@@ -2769,7 +2769,7 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
 		c.error('checker: too many expr levels: $c.expr_level ', node.position())
 		return table.void_type
 	}
-	match union mut node {
+	match mut node {
 		ast.CTempVar {
 			return node.typ
 		}
@@ -2787,7 +2787,7 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
 			node.expr_type = c.expr(node.expr)
 			expr_type_sym := c.table.get_type_symbol(node.expr_type)
 			type_sym := c.table.get_type_symbol(node.typ)
-			if expr_type_sym.kind == .union_sum_type {
+			if expr_type_sym.kind == .sum_type {
 				if type_sym.kind == .placeholder {
 					// Unknown type used in the right part of `as`
 					c.error('unknown type `$type_sym.source_name`', node.pos)
@@ -2799,12 +2799,12 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
 				}
 			} else {
 				mut s := 'cannot cast non-sum type `$expr_type_sym.source_name` using `as`'
-				if type_sym.kind == .union_sum_type {
+				if type_sym.kind == .sum_type {
 					s += ' - use e.g. `${type_sym.source_name}(some_expr)` instead.'
 				}
 				c.error(s, node.pos)
 			}
-			if expr_type_sym.kind == .union_sum_type {
+			if expr_type_sym.kind == .sum_type {
 				return node.typ
 			}
 			return node.typ.to_ptr()
@@ -3054,7 +3054,7 @@ pub fn (mut c Checker) cast_expr(mut node ast.CastExpr) table.Type {
 		c.error('can not cast type `byte` to string, use `${node.expr.str()}.str()` instead.',
 			node.pos)
 	}
-	if to_type_sym.kind == .union_sum_type {
+	if to_type_sym.kind == .sum_type {
 		if node.expr_type in [table.any_int_type, table.any_flt_type] {
 			node.expr_type = c.promote_num(node.expr_type, if node.expr_type == table.any_int_type { table.int_type } else { table.f64_type })
 		}
@@ -3209,7 +3209,7 @@ pub fn (mut c Checker) ident(mut ident ast.Ident) table.Type {
 		}
 		start_scope := c.file.scope.innermost(ident.pos.pos)
 		if obj := start_scope.find(ident.name) {
-			match union mut obj {
+			match mut obj {
 				ast.GlobalField {
 					ident.kind = .global
 					ident.info = ast.IdentVar{
@@ -3276,7 +3276,7 @@ pub fn (mut c Checker) ident(mut ident ast.Ident) table.Type {
 			name = '${ident.mod}.$ident.name'
 		}
 		if obj := c.file.global_scope.find(name) {
-			match union mut obj {
+			match mut obj {
 				ast.ConstField {
 					mut typ := obj.typ
 					if typ == 0 {
@@ -3365,7 +3365,7 @@ pub fn (mut c Checker) match_expr(mut node ast.MatchExpr) table.Type {
 		c.error('compiler bug: match 0 cond type', node.pos)
 	}
 	cond_type_sym := c.table.get_type_symbol(cond_type)
-	if cond_type_sym.kind !in [.interface_, .union_sum_type] {
+	if cond_type_sym.kind !in [.interface_, .sum_type] {
 		node.is_sum_type = false
 	}
 	c.match_exprs(mut node, cond_type_sym)
@@ -3390,7 +3390,7 @@ pub fn (mut c Checker) match_expr(mut node ast.MatchExpr) table.Type {
 		// If the last statement is an expression, return its type
 		if branch.stmts.len > 0 {
 			mut stmt := branch.stmts[branch.stmts.len - 1]
-			match union mut stmt {
+			match mut stmt {
 				ast.ExprStmt {
 					ret_type = c.expr(stmt.expr)
 					stmt.typ = ret_type
@@ -3479,7 +3479,7 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, type_sym table.TypeSymbol
 				}
 				continue
 			}
-			match union expr {
+			match expr {
 				ast.Type {
 					key = c.table.type_to_str(expr.typ)
 					expr_types << expr
@@ -3505,7 +3505,7 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, type_sym table.TypeSymbol
 				// c.type_implements(expr_type, c.expected_type, expr.position())
 				expr_pos := expr.position()
 				c.type_implements(expr_type, c.expected_type, expr_pos)
-			} else if mut cond_type_sym.info is table.UnionSumType {
+			} else if mut cond_type_sym.info is table.SumType {
 				if expr_type !in cond_type_sym.info.variants {
 					expr_str := c.table.type_to_str(expr_type)
 					expect_str := c.table.type_to_str(c.expected_type)
@@ -3520,7 +3520,7 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, type_sym table.TypeSymbol
 		}
 		// when match is sum type matching, then register smart cast for every branch
 		if expr_types.len > 0 {
-			if cond_type_sym.kind == .union_sum_type {
+			if cond_type_sym.kind == .sum_type {
 				mut expr_type := table.Type(0)
 				if expr_types.len > 1 {
 					mut agg_name := strings.new_builder(20)
@@ -3608,8 +3608,8 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, type_sym table.TypeSymbol
 	// by listing all variants or values
 	mut is_exhaustive := true
 	mut unhandled := []string{}
-	match union mut type_sym.info {
-		table.UnionSumType {
+	match mut type_sym.info {
+		table.SumType {
 			for v in type_sym.info.variants {
 				v_str := c.table.type_to_str(v)
 				if v_str !in branch_exprs {
@@ -3673,7 +3673,7 @@ pub fn (mut c Checker) select_expr(mut node ast.SelectExpr) table.Type {
 	node.expected_type = c.expected_type
 	for branch in node.branches {
 		c.stmt(branch.stmt)
-		match union branch.stmt {
+		match branch.stmt {
 			ast.ExprStmt {
 				if branch.is_timeout {
 					if !branch.stmt.typ.is_int() {
@@ -3694,7 +3694,7 @@ pub fn (mut c Checker) select_expr(mut node ast.SelectExpr) table.Type {
 			}
 			ast.AssignStmt {
 				expr := branch.stmt.right[0]
-				match union expr {
+				match expr {
 					ast.PrefixExpr {
 						if expr.right !is ast.Ident &&
 							expr.right !is ast.SelectorExpr && expr.right !is ast.IndexExpr {
@@ -3812,7 +3812,7 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type {
 					is_variable := if mut infix.left is ast.Ident { infix.left.kind == .variable } else { true }
 					// Register shadow variable or `as` variable with actual type
 					if is_variable {
-						if left_sym.kind in [.interface_, .union_sum_type] {
+						if left_sym.kind in [.interface_, .sum_type] {
 							mut is_mut := false
 							mut scope := c.file.scope.innermost(branch.body_pos.pos)
 							if mut infix.left is ast.Ident {
@@ -3821,7 +3821,7 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type {
 									is_mut = v.is_mut
 									sum_type_casts << v.sum_type_casts
 								}
-								if left_sym.kind == .union_sum_type {
+								if left_sym.kind == .sum_type {
 									// smartcast either if the value is immutable or if the mut argument is explicitly given
 									if !is_mut || branch.is_mut_name {
 										sum_type_casts << right_expr.typ
@@ -3861,7 +3861,7 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type {
 								// smartcast either if the value is immutable or if the mut argument is explicitly given
 								if ((!is_root_mut && !is_mut) ||
 									branch.is_mut_name) &&
-									left_sym.kind == .union_sum_type {
+									left_sym.kind == .sum_type {
 									sum_type_casts << right_expr.typ
 									scope.register_struct_field(ast.ScopeStructField{
 										struct_type: infix.left.expr_type
@@ -3990,7 +3990,7 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type {
 // saying whether that branch's contents should be skipped (targets a different os for example)
 fn (mut c Checker) comp_if_branch(cond ast.Expr, pos token.Position) bool {
 	// TODO: better error messages here
-	match union cond {
+	match cond {
 		ast.ParExpr {
 			return c.comp_if_branch(cond.expr, pos)
 		}
@@ -4506,7 +4506,7 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) {
 		if sym.kind == .interface_ {
 			c.error('interfaces cannot be used as method receiver', node.receiver_pos)
 		}
-		if sym.kind == .union_sum_type && node.name == 'type_name' {
+		if sym.kind == .sum_type && node.name == 'type_name' {
 			c.error('method overrides built-in sum type method', node.pos)
 		}
 		// if sym.has_method(node.name) {
diff --git a/vlib/v/checker/tests/sum_type_assign_non_variant_err.vv b/vlib/v/checker/tests/sum_type_assign_non_variant_err.vv
index cabf2fc306..98dcaac1bb 100644
--- a/vlib/v/checker/tests/sum_type_assign_non_variant_err.vv
+++ b/vlib/v/checker/tests/sum_type_assign_non_variant_err.vv
@@ -1,9 +1,9 @@
-__type Expr = IfExpr | CallExpr | MatchExpr
+type Expr = IfExpr | CallExpr | MatchExpr
 struct MatchExpr {}
 struct IfExpr {}
 struct CallExpr {}
 
-__type Stmt = Expr | AnotherThing
+type Stmt = Expr | AnotherThing
 struct AnotherThing {}
 
 fn main() {
diff --git a/vlib/v/checker/tests/sum_type_infix_err.vv b/vlib/v/checker/tests/sum_type_infix_err.vv
index ff8a352710..b4c40748f3 100644
--- a/vlib/v/checker/tests/sum_type_infix_err.vv
+++ b/vlib/v/checker/tests/sum_type_infix_err.vv
@@ -1,4 +1,4 @@
-__type Abc = int | string
+type Abc = int | string
 
 fn main() {
 	x := Abc(0)
diff --git a/vlib/v/checker/tests/sum_type_mutable_cast_err.vv b/vlib/v/checker/tests/sum_type_mutable_cast_err.vv
index 8d135d465c..1244a49b2c 100644
--- a/vlib/v/checker/tests/sum_type_mutable_cast_err.vv
+++ b/vlib/v/checker/tests/sum_type_mutable_cast_err.vv
@@ -1,4 +1,4 @@
-__type Abc = int | string
+type Abc = int | string
 
 struct Bar {
 mut:
diff --git a/vlib/v/doc/doc.v b/vlib/v/doc/doc.v
index 76ff1e4619..c1b7c663ce 100644
--- a/vlib/v/doc/doc.v
+++ b/vlib/v/doc/doc.v
@@ -122,7 +122,7 @@ pub fn (mut d Doc) stmt(stmt ast.Stmt, filename string) ?DocNode {
 	if node.name.len == 0 && node.comment.len == 0 && node.content.len == 0 {
 		return error('empty stmt')
 	}
-	match union stmt {
+	match stmt {
 		ast.ConstDecl {
 			node.kind = .const_group
 			node.parent_name = 'Constants'
diff --git a/vlib/v/doc/utils.v b/vlib/v/doc/utils.v
index 02652ec9e6..d788413f2a 100644
--- a/vlib/v/doc/utils.v
+++ b/vlib/v/doc/utils.v
@@ -77,7 +77,7 @@ fn (mut d Doc) convert_pos(filename string, pos token.Position) DocPos {
 }
 
 pub fn (mut d Doc) stmt_signature(stmt ast.Stmt) string {
-	match union stmt {
+	match stmt {
 		ast.Module {
 			return 'module $stmt.name'
 		}
@@ -93,10 +93,10 @@ pub fn (mut d Doc) stmt_signature(stmt ast.Stmt) string {
 }
 
 pub fn (d Doc) stmt_name(stmt ast.Stmt) string {
-	match union stmt {
+	match stmt {
 		ast.FnDecl, ast.StructDecl, ast.EnumDecl, ast.InterfaceDecl { return stmt.name }
-		ast.TypeDecl { match union stmt {
-				ast.FnTypeDecl, ast.AliasTypeDecl, ast.UnionSumTypeDecl { return stmt.name }
+		ast.TypeDecl { match stmt {
+				ast.FnTypeDecl, ast.AliasTypeDecl, ast.SumTypeDecl { return stmt.name }
 			} }
 		ast.ConstDecl { return '' } // leave it blank
 		else { return '' }
diff --git a/vlib/v/eval/eval.v b/vlib/v/eval/eval.v
index 35f231a27e..aee1475909 100644
--- a/vlib/v/eval/eval.v
+++ b/vlib/v/eval/eval.v
@@ -8,7 +8,7 @@ import v.checker
 import v.table
 import v.pref
 
-pub __type Object = int | string
+pub type Object = int | string
 
 pub struct Eval {
 mut:
@@ -33,14 +33,14 @@ pub fn (mut e Eval) eval(file ast.File, table &table.Table) string {
 }
 
 fn print_object(o Object) {
-	match union o {
+	match o {
 		int { println(o) }
 		else { println('unknown object') }
 	}
 }
 
 pub fn (o Object) str() string {
-	match union o {
+	match o {
 		int { return o.str() }
 		else { println('unknown object') }
 	}
diff --git a/vlib/v/fmt/fmt.v b/vlib/v/fmt/fmt.v
index 8cad2bf8c4..2775cdba54 100644
--- a/vlib/v/fmt/fmt.v
+++ b/vlib/v/fmt/fmt.v
@@ -245,7 +245,7 @@ pub fn (mut f Fmt) stmt(node ast.Stmt) {
 	if f.is_debug {
 		eprintln('stmt: ${node.position():-42} | node: ${typeof(node):-20}')
 	}
-	match union node {
+	match node {
 		ast.AssignStmt {
 			f.comments(node.comments, {})
 			for i, left in node.left {
@@ -491,7 +491,7 @@ pub fn (mut f Fmt) stmt(node ast.Stmt) {
 
 pub fn (mut f Fmt) type_decl(node ast.TypeDecl) {
 	mut comments := []ast.Comment{}
-	match union node {
+	match node {
 		ast.AliasTypeDecl {
 			if node.is_pub {
 				f.write('pub ')
@@ -544,11 +544,11 @@ pub fn (mut f Fmt) type_decl(node ast.TypeDecl) {
 			}
 			comments << node.comments
 		}
-		ast.UnionSumTypeDecl {
+		ast.SumTypeDecl {
 			if node.is_pub {
 				f.write('pub ')
 			}
-			f.write('__type $node.name = ')
+			f.write('type $node.name = ')
 			mut sum_type_names := []string{}
 			for t in node.sub_types {
 				sum_type_names << f.table.type_to_str(t)
@@ -741,7 +741,7 @@ pub fn (mut f Fmt) expr(node ast.Expr) {
 	if f.is_debug {
 		eprintln('expr: ${node.position():-42} | node: ${typeof(node):-20} | $node.str()')
 	}
-	match union mut node {
+	match mut node {
 		ast.CTempVar {
 			eprintln('ast.CTempVar of $node.orig.str() should be generated/used only in cgen')
 		}
@@ -1342,7 +1342,7 @@ pub fn (mut f Fmt) infix_expr(node ast.InfixExpr) {
 	}
 	f.expr_bufs << f.out.str()
 	mut penalty := 3
-	match union mut node.left {
+	match mut node.left {
 		ast.InfixExpr {
 			if int(token.precedences[node.left.op]) > int(token.precedences[node.op]) {
 				penalty--
@@ -1353,7 +1353,7 @@ pub fn (mut f Fmt) infix_expr(node ast.InfixExpr) {
 		}
 		else {}
 	}
-	match union node.right {
+	match node.right {
 		ast.InfixExpr { penalty-- }
 		ast.ParExpr { penalty = 1 }
 		else {}
@@ -1528,9 +1528,6 @@ pub fn (mut f Fmt) call_expr(node ast.CallExpr) {
 
 pub fn (mut f Fmt) match_expr(it ast.MatchExpr) {
 	f.write('match ')
-	if it.is_union_match {
-		f.write('union ')
-	}
 	if it.is_mut {
 		f.write('mut ')
 	}
@@ -1652,7 +1649,7 @@ fn (mut f Fmt) write_language_prefix(lang table.Language) {
 }
 
 fn stmt_is_single_line(stmt ast.Stmt) bool {
-	match union stmt {
+	match stmt {
 		ast.ExprStmt { return expr_is_single_line(stmt.expr) }
 		ast.Return { return true }
 		ast.AssignStmt { return true }
@@ -1661,7 +1658,7 @@ fn stmt_is_single_line(stmt ast.Stmt) bool {
 }
 
 fn expr_is_single_line(expr ast.Expr) bool {
-	match union expr {
+	match expr {
 		ast.IfExpr { return false }
 		ast.Comment { return false }
 		else {}
diff --git a/vlib/v/fmt/tests/integer_literal_keep.vv b/vlib/v/fmt/tests/integer_literal_keep.vv
index b97d52fbd2..4a77e68bdf 100644
--- a/vlib/v/fmt/tests/integer_literal_keep.vv
+++ b/vlib/v/fmt/tests/integer_literal_keep.vv
@@ -4,7 +4,7 @@ struct IfExpr {
 struct MatchExpr {
 }
 
-__type Expr = IfExpr | MatchExpr
+type Expr = IfExpr | MatchExpr
 
 fn sum_types(a []Expr) {
 }
diff --git a/vlib/v/fmt/tests/struct_keep.vv b/vlib/v/fmt/tests/struct_keep.vv
index 0c70c5edc1..45409ad3eb 100644
--- a/vlib/v/fmt/tests/struct_keep.vv
+++ b/vlib/v/fmt/tests/struct_keep.vv
@@ -15,7 +15,7 @@ fn handle_users(users []User) {
 fn (u &User) foo(u2 &User) {
 }
 
-__type Expr = IfExpr | IntegerLiteral
+type Expr = IfExpr | IntegerLiteral
 
 fn exprs(e []Expr) {
 	println(e.len)
diff --git a/vlib/v/fmt/tests/sum_smartcast_keep.vv b/vlib/v/fmt/tests/sum_smartcast_keep.vv
index 62946ee72f..eacdcbd45d 100644
--- a/vlib/v/fmt/tests/sum_smartcast_keep.vv
+++ b/vlib/v/fmt/tests/sum_smartcast_keep.vv
@@ -6,7 +6,7 @@ mut:
 struct S2 {
 }
 
-__type Sum = S1 | S2
+type Sum = S1 | S2
 
 fn f(sum Sum) {
 	if mut sum is S1 {
diff --git a/vlib/v/fmt/tests/types_expected.vv b/vlib/v/fmt/tests/types_expected.vv
index 9c1a2453f5..454fa522ca 100644
--- a/vlib/v/fmt/tests/types_expected.vv
+++ b/vlib/v/fmt/tests/types_expected.vv
@@ -1,11 +1,11 @@
 // Sumtype
-__type FooBar = Bar | Foo
+type FooBar = Bar | Foo
 
-pub __type PublicBar = Bar | Foo | FooBar
+pub type PublicBar = Bar | Foo | FooBar
 
-__type Uint = byte | u16 | u32 | u64
+type Uint = byte | u16 | u32 | u64 // This should stay on the same line
 
-__type Float = f32 | f64
+type Float = f32 | f64
 
 // Alias type
 type MyInt = int
diff --git a/vlib/v/fmt/tests/types_input.vv b/vlib/v/fmt/tests/types_input.vv
index 3e23987d42..6a5f9472e5 100644
--- a/vlib/v/fmt/tests/types_input.vv
+++ b/vlib/v/fmt/tests/types_input.vv
@@ -6,7 +6,7 @@
 
 type   Uint =   u16 | u64
 	| u32
-	    | byte
+	    | byte // This should stay on the same line
 type
 Float =
 	f32 |
diff --git a/vlib/v/gen/auto_str_methods.v b/vlib/v/gen/auto_str_methods.v
index cff75760eb..b31ada8056 100644
--- a/vlib/v/gen/auto_str_methods.v
+++ b/vlib/v/gen/auto_str_methods.v
@@ -47,7 +47,7 @@ fn (mut g Gen) gen_str_for_type_with_styp(typ table.Type, styp string) string {
 			eprintln('> gen_str_for_type_with_styp: |typ: ${typ:5}, ${sym.name:20}|has_str: ${sym_has_str_method:5}|expects_ptr: ${str_method_expects_ptr:5}|nr_args: ${str_nr_args:1}|fn_name: ${str_fn_name:20}')
 		}
 		g.str_types << already_generated_key
-		match union mut sym.info {
+		match mut sym.info {
 			table.Alias {
 				if sym.info.is_import {
 					g.gen_str_default(sym, styp, str_fn_name)
@@ -73,7 +73,7 @@ fn (mut g Gen) gen_str_for_type_with_styp(typ table.Type, styp string) string {
 			table.MultiReturn {
 				g.gen_str_for_multi_return(sym.info, styp, str_fn_name)
 			}
-			table.UnionSumType {
+			table.SumType {
 				g.gen_str_for_union_sum_type(sym.info, styp, str_fn_name)
 			}
 			else {
@@ -438,7 +438,7 @@ fn struct_auto_str_func(sym table.TypeSymbol, field_type table.Type, fn_name str
 			return '${fn_name}($obj)'
 		}
 		return 'indent_${fn_name}($obj, indent_count + 1)'
-	} else if sym.kind in [.array, .array_fixed, .map, .union_sum_type] {
+	} else if sym.kind in [.array, .array_fixed, .map, .sum_type] {
 		if has_custom_str {
 			return '${fn_name}(it->${c_name(field_name)})'
 		}
@@ -482,7 +482,7 @@ fn (mut g Gen) gen_str_for_enum(info table.Enum, styp string, str_fn_name string
 	g.auto_str_funcs.writeln('}')
 }
 
-fn (mut g Gen) gen_str_for_union_sum_type(info table.UnionSumType, styp string, str_fn_name string) {
+fn (mut g Gen) gen_str_for_union_sum_type(info table.SumType, styp string, str_fn_name string) {
 	mut gen_fn_names := map[string]string{}
 	for typ in info.variants {
 		sym := g.table.get_type_symbol(typ)
diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v
index 730d3a6f56..6494d3c717 100644
--- a/vlib/v/gen/cgen.v
+++ b/vlib/v/gen/cgen.v
@@ -371,8 +371,8 @@ pub fn (mut g Gen) write_typeof_functions() {
 	g.writeln('')
 	g.writeln('// >> typeof() support for sum types')
 	for typ in g.table.types {
-		if typ.kind == .union_sum_type {
-			sum_info := typ.info as table.UnionSumType
+		if typ.kind == .sum_type {
+			sum_info := typ.info as table.SumType
 			tidx := g.table.find_type_idx(typ.name)
 			g.writeln('char * v_typeof_unionsumtype_${tidx}(int sidx) { /* $typ.name */ ')
 			g.writeln('	switch(sidx) {')
@@ -785,7 +785,7 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 	}
 	// println('cgen.stmt()')
 	// g.writeln('//// stmt start')
-	match union node {
+	match node {
 		ast.AssertStmt {
 			g.write_v_source_line_info(node.pos)
 			g.gen_assert_stmt(node)
@@ -1266,18 +1266,19 @@ fn (mut g Gen) union_expr_with_cast(expr ast.Expr, got_type table.Type, expected
 			got_styp := g.typ(got_type)
 			got_idx := got_type.idx()
 			got_sym := g.table.get_type_symbol(got_type)
+			// TODO: do we need 1-3?
 			if expected_is_ptr && got_is_ptr {
 				exp_der_styp := g.typ(expected_deref_type)
-				g.write('/* union sum type cast 1 */ ($exp_styp) memdup(&($exp_der_styp){._$got_type = ')
+				g.write('/* sum type cast 1 */ ($exp_styp) memdup(&($exp_der_styp){._$got_type = ')
 				g.expr(expr)
 				g.write(', .typ = $got_type /* $got_sym.name */}, sizeof($exp_der_styp))')
 			} else if expected_is_ptr {
 				exp_der_styp := g.typ(expected_deref_type)
-				g.write('/* union sum type cast 2 */ ($exp_styp) memdup(&($exp_der_styp){._$got_type = memdup(&($got_styp[]){')
+				g.write('/* sum type cast 2 */ ($exp_styp) memdup(&($exp_der_styp){._$got_type = memdup(&($got_styp[]){')
 				g.expr(expr)
 				g.write('}, sizeof($got_styp)), .typ = $got_type /* $got_sym.name */}, sizeof($exp_der_styp))')
 			} else if got_is_ptr {
-				g.write('/* union sum type cast 3 */ ($exp_styp){._$got_idx = ')
+				g.write('/* sum type cast 3 */ ($exp_styp){._$got_idx = ')
 				g.expr(expr)
 				g.write(', .typ = $got_type /* $got_sym.name */}')
 			} else {
@@ -1299,7 +1300,7 @@ fn (mut g Gen) union_expr_with_cast(expr ast.Expr, got_type table.Type, expected
 					g.prevent_sum_type_unwrapping_once = true
 					g.expr(expr)
 				} else {
-					g.write('/* union sum type cast 4 */ ($exp_styp){._$got_type = memdup(&($got_styp[]){')
+					g.write('/* sum type cast 4 */ ($exp_styp){._$got_type = memdup(&($got_styp[]){')
 					g.expr(expr)
 					g.write('}, sizeof($got_styp)), .typ = $got_type /* $got_sym.name */}')
 				}
@@ -1328,7 +1329,7 @@ fn (mut g Gen) union_expr_with_cast(expr ast.Expr, got_type table.Type, expected
 // use instead of expr() when you need to cast to sum type (can add other casts also)
 fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type table.Type, expected_type table.Type) {
 	sym := g.table.get_type_symbol(expected_type)
-	if sym.kind == .union_sum_type {
+	if sym.kind == .sum_type {
 		g.union_expr_with_cast(expr, got_type, expected_type)
 		return
 	}
@@ -1454,7 +1455,7 @@ fn (mut g Gen) gen_assert_metainfo(a ast.AssertStmt) string {
 	g.writeln('\t${metaname}.line_nr = $line_nr;')
 	g.writeln('\t${metaname}.fn_name = ${ctoslit(fn_name)};')
 	g.writeln('\t${metaname}.src = ${cnewlines(ctoslit(src))};')
-	match union mut a.expr {
+	match mut a.expr {
 		ast.InfixExpr {
 			g.writeln('\t${metaname}.op = ${ctoslit(a.expr.op.str())};')
 			g.writeln('\t${metaname}.llabel = ${cnewlines(ctoslit(a.expr.left.str()))};')
@@ -1477,7 +1478,7 @@ fn (mut g Gen) gen_assert_metainfo(a ast.AssertStmt) string {
 
 fn (mut g Gen) gen_assert_single_expr(e ast.Expr, t table.Type) {
 	unknown_value := '*unknown value*'
-	match union e {
+	match e {
 		ast.CastExpr, ast.IndexExpr, ast.MatchExpr {
 			g.write(ctoslit(unknown_value))
 		}
@@ -1529,7 +1530,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 	op := if assign_stmt.op == .decl_assign { token.Kind.assign } else { assign_stmt.op }
 	is_decl := assign_stmt.op == .decl_assign
 	right_expr := assign_stmt.right[0]
-	match union right_expr {
+	match right_expr {
 		ast.CallExpr { return_type = right_expr.return_type }
 		ast.MatchExpr { return_type = right_expr.return_type }
 		ast.IfExpr { return_type = right_expr.typ }
@@ -1639,7 +1640,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 	// TODO: non idents on left (exprs)
 	if assign_stmt.has_cross_var {
 		for i, left in assign_stmt.left {
-			match union left {
+			match left {
 				ast.Ident {
 					left_typ := assign_stmt.left_types[i]
 					left_sym := g.table.get_type_symbol(left_typ)
@@ -1746,7 +1747,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 		styp := g.typ(var_type)
 		mut is_fixed_array_init := false
 		mut has_val := false
-		match union val {
+		match val {
 			ast.ArrayInit {
 				is_fixed_array_init = val.is_fixed
 				has_val = val.has_val
@@ -1947,7 +1948,7 @@ fn (mut g Gen) gen_assign_stmt(assign_stmt ast.AssignStmt) {
 
 fn (mut g Gen) gen_cross_tmp_variable(left []ast.Expr, val ast.Expr) {
 	val_ := val
-	match union val {
+	match val {
 		ast.Ident {
 			mut has_var := false
 			for lx in left {
@@ -2082,7 +2083,7 @@ fn (mut g Gen) autofree_scope_vars2(scope &ast.Scope, start_pos int, end_pos int
 		return
 	}
 	for _, obj in scope.objects {
-		match union obj {
+		match obj {
 			ast.Var {
 				g.writeln('// var $obj.name pos=$obj.pos.pos')
 				// if var.typ == 0 {
@@ -2194,7 +2195,7 @@ fn (mut g Gen) gen_anon_fn_decl(it ast.AnonFn) {
 fn (mut g Gen) expr(node ast.Expr) {
 	// println('cgen expr() line_nr=$node.pos.line_nr')
 	// NB: please keep the type names in the match here in alphabetical order:
-	match union node {
+	match node {
 		ast.AnonFn {
 			// TODO: dont fiddle with buffers
 			g.gen_anon_fn_decl(node)
@@ -2277,7 +2278,7 @@ fn (mut g Gen) expr(node ast.Expr) {
 					g.expr(node.arg)
 				}
 				g.write(')')
-			} else if sym.kind == .union_sum_type {
+			} else if sym.kind == .sum_type {
 				g.expr_with_cast(node.expr, node.expr_type, node.typ)
 			} else if sym.kind == .struct_ && !node.typ.is_ptr() && !(sym.info as table.Struct).is_typedef {
 				styp := g.typ(node.typ)
@@ -2544,7 +2545,7 @@ fn (mut g Gen) expr(node ast.Expr) {
 			mut sum_type_deref_field := ''
 			if field := g.table.struct_find_field(sym, node.field_name) {
 				field_sym := g.table.get_type_symbol(field.typ)
-				if field_sym.kind == .union_sum_type {
+				if field_sym.kind == .sum_type {
 					if !prevent_sum_type_unwrapping_once {
 						// check first if field is sum type because scope searching is expensive
 						scope := g.file.scope.innermost(node.pos.pos)
@@ -2633,7 +2634,7 @@ fn (mut g Gen) type_name(type_ table.Type) {
 
 fn (mut g Gen) typeof_expr(node ast.TypeOf) {
 	sym := g.table.get_type_symbol(node.expr_type)
-	if sym.kind == .union_sum_type {
+	if sym.kind == .sum_type {
 		// When encountering a .sum_type, typeof() should be done at runtime,
 		// because the subtype of the expression may change:
 		sum_type_idx := node.expr_type.idx()
@@ -2665,7 +2666,7 @@ fn (mut g Gen) typeof_expr(node ast.TypeOf) {
 }
 
 fn (mut g Gen) enum_expr(node ast.Expr) {
-	match union node {
+	match node {
 		ast.EnumVal { g.write(node.val) }
 		else { g.expr(node) }
 	}
@@ -3075,7 +3076,7 @@ fn (mut g Gen) match_expr_sumtype(node ast.MatchExpr, is_expr bool, cond_var str
 				}
 				g.write(cond_var)
 				// branch_sym := g.table.get_type_symbol(branch.typ)
-				if sym.kind == .union_sum_type {
+				if sym.kind == .sum_type {
 					dot_or_ptr := if node.cond_type.is_ptr() { '->' } else { '.' }
 					g.write(dot_or_ptr)
 					g.write('typ == ')
@@ -3210,7 +3211,7 @@ fn (mut g Gen) select_expr(node ast.SelectExpr) {
 			exception_branch = j
 			timeout_expr = (branch.stmt as ast.ExprStmt).expr
 		} else {
-			match union branch.stmt {
+			match branch.stmt {
 				ast.ExprStmt {
 					// send expression
 					expr := branch.stmt.expr as ast.InfixExpr
@@ -3406,8 +3407,8 @@ fn (mut g Gen) match_sumtype_has_no_struct_and_contains(node ast.Ident) bool {
 	for i, expr in g.match_sumtype_exprs {
 		if expr is ast.Ident && node.name == (expr as ast.Ident).name {
 			info := g.match_sumtype_syms[i].info
-			match union info {
-				table.UnionSumType {
+			match info {
+				table.SumType {
 					for typ in info.variants {
 						if g.table.get_type_symbol(typ).kind == .struct_ {
 							return false
@@ -3522,7 +3523,7 @@ fn (mut g Gen) if_expr(node ast.IfExpr) {
 				g.writeln('\tint errcode = ${cvar_name}.ecode;')
 			}
 		} else {
-			match union branch.cond {
+			match branch.cond {
 				ast.IfGuardExpr {
 					var_name := guard_vars[i]
 					g.write('if ($var_name = ')
@@ -3574,7 +3575,7 @@ fn (mut g Gen) if_expr(node ast.IfExpr) {
 }
 
 fn (mut g Gen) index_expr(node ast.IndexExpr) {
-	match union node.index {
+	match node.index {
 		ast.RangeExpr {
 			sym := g.table.get_type_symbol(node.left_type)
 			if sym.kind == .string {
@@ -3835,7 +3836,7 @@ fn (mut g Gen) index_expr(node ast.IndexExpr) {
 
 [inline]
 fn (g &Gen) expr_is_multi_return_call(expr ast.Expr) bool {
-	match union expr {
+	match expr {
 		ast.CallExpr { return g.table.get_type_symbol(expr.return_type).kind == .multi_return }
 		else { return false }
 	}
@@ -4060,7 +4061,7 @@ fn (mut g Gen) const_decl(node ast.ConstDecl) {
 			}
 		} else {
 		*/
-		match union field.expr {
+		match field.expr {
 			ast.CharLiteral, ast.FloatLiteral, ast.IntegerLiteral {
 				g.const_decl_simple_define(name, val)
 			}
@@ -4546,7 +4547,7 @@ fn (mut g Gen) write_types(types []table.TypeSymbol) {
 		}
 		// sym := g.table.get_type_symbol(typ)
 		mut name := util.no_dots(typ.name)
-		match union mut typ.info {
+		match mut typ.info {
 			table.Struct {
 				if typ.info.generic_types.len > 0 {
 					continue
@@ -4595,7 +4596,7 @@ fn (mut g Gen) write_types(types []table.TypeSymbol) {
 			table.Alias {
 				// table.Alias { TODO
 			}
-			table.UnionSumType {
+			table.SumType {
 				g.typedefs.writeln('typedef struct $name $name;')
 				g.type_definitions.writeln('')
 				g.type_definitions.writeln('// Union sum type $name = ')
@@ -4646,7 +4647,7 @@ fn (g &Gen) sort_structs(typesa []table.TypeSymbol) []table.TypeSymbol {
 		}
 		// create list of deps
 		mut field_deps := []string{}
-		match union mut t.info {
+		match mut t.info {
 			table.ArrayFixed {
 				dep := g.table.get_type_symbol(t.info.elem_type).name
 				if dep in type_names {
@@ -4707,7 +4708,7 @@ fn (mut g Gen) gen_expr_to_string(expr ast.Expr, etype table.Type) ?bool {
 		g.expr(expr)
 		return true
 	} else if sym.kind == .enum_ {
-		is_var := match union expr {
+		is_var := match expr {
 			ast.SelectorExpr, ast.Ident { true }
 			else { false }
 		}
@@ -4722,7 +4723,7 @@ fn (mut g Gen) gen_expr_to_string(expr ast.Expr, etype table.Type) ?bool {
 			g.write('")')
 		}
 	} else if sym_has_str_method || sym.kind in
-		[.array, .array_fixed, .map, .struct_, .multi_return, .union_sum_type] {
+		[.array, .array_fixed, .map, .struct_, .multi_return, .sum_type] {
 		is_p := typ.is_ptr()
 		val_type := if is_p { typ.deref() } else { typ }
 		str_fn_name := g.gen_str_for_type(val_type)
@@ -4806,7 +4807,7 @@ fn (mut g Gen) gen_array_map(node ast.CallExpr) {
 	g.writeln('.data)[$i];')
 	g.write('\t$ret_elem_type ti = ')
 	expr := node.args[0].expr
-	match union expr {
+	match expr {
 		ast.AnonFn {
 			g.gen_anon_fn_decl(expr)
 			g.write('${expr.decl.name}(it)')
@@ -4961,7 +4962,7 @@ fn (mut g Gen) gen_array_filter(node ast.CallExpr) {
 	g.writeln('.data)[i];')
 	g.write('if (')
 	expr := node.args[0].expr
-	match union expr {
+	match expr {
 		ast.AnonFn {
 			g.gen_anon_fn_decl(expr)
 			g.write('${expr.decl.name}(it)')
@@ -5157,7 +5158,7 @@ fn (mut g Gen) or_block(var_name string, or_block ast.OrExpr, return_type table.
 }
 
 fn (mut g Gen) type_of_call_expr(node ast.Expr) string {
-	match union node {
+	match node {
 		ast.CallExpr { return g.typ(node.return_type) }
 		else { return typeof(node) }
 	}
@@ -5390,7 +5391,7 @@ fn (mut g Gen) type_default(typ_ table.Type) string {
 		else {}
 	}
 	return match sym.kind {
-		.interface_, .union_sum_type, .array_fixed, .multi_return { '{0}' }
+		.interface_, .sum_type, .array_fixed, .multi_return { '{0}' }
 		.alias { g.type_default((sym.info as table.Alias).parent_type) }
 		else { '0' }
 	}
@@ -5545,7 +5546,7 @@ fn (mut g Gen) as_cast(node ast.AsCast) {
 	// g.insert_before('
 	styp := g.typ(node.typ)
 	expr_type_sym := g.table.get_type_symbol(node.expr_type)
-	if expr_type_sym.kind == .union_sum_type {
+	if expr_type_sym.kind == .sum_type {
 		dot := if node.expr_type.is_ptr() { '->' } else { '.' }
 		g.write('/* as */ *($styp*)__as_cast((')
 		g.expr(node.expr)
@@ -5577,7 +5578,7 @@ fn (mut g Gen) is_expr(node ast.InfixExpr) {
 		sub_sym := g.table.get_type_symbol(sub_type.typ)
 		g.write('_${c_name(sym.name)}_${c_name(sub_sym.name)}_index')
 		return
-	} else if sym.kind == .union_sum_type {
+	} else if sym.kind == .sum_type {
 		g.write('typ $eq ')
 	}
 	g.expr(node.right)
@@ -5644,7 +5645,7 @@ fn (g &Gen) type_to_fmt(typ table.Type) string {
 		return '%g\\000' // g removes trailing zeros unlike %f
 	} else if sym.kind == .u64 {
 		return '%lld\\000'
-	} else if sym.kind == .union_sum_type {
+	} else if sym.kind == .sum_type {
 		return '%.*s\\000'
 	}
 	return '%d\\000'
diff --git a/vlib/v/gen/comptime.v b/vlib/v/gen/comptime.v
index 31a966a376..1243bdbe4d 100644
--- a/vlib/v/gen/comptime.v
+++ b/vlib/v/gen/comptime.v
@@ -174,7 +174,7 @@ fn (mut g Gen) comp_if(node ast.IfExpr) {
 }
 
 fn (mut g Gen) comp_if_expr(cond ast.Expr) {
-	match union cond {
+	match cond {
 		ast.ParExpr {
 			g.write('(')
 			g.comp_if_expr(cond.expr)
diff --git a/vlib/v/gen/fn.v b/vlib/v/gen/fn.v
index f385900148..4d7486fce3 100644
--- a/vlib/v/gen/fn.v
+++ b/vlib/v/gen/fn.v
@@ -366,7 +366,7 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
 			else {}
 		}
 	}
-	if left_sym.kind == .union_sum_type && node.name == 'type_name' {
+	if left_sym.kind == .sum_type && node.name == 'type_name' {
 		g.write('tos3( /* $left_sym.name */ v_typeof_unionsumtype_${node.receiver_type}( (')
 		g.expr(node.left)
 		g.write(').typ ))')
@@ -569,7 +569,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 				g.writeln('); ${print_method}($tmp); string_free(&$tmp); //MEM2 $styp')
 			} else {
 				expr := node.args[0].expr
-				is_var := match union expr {
+				is_var := match expr {
 					ast.SelectorExpr { true }
 					ast.Ident { true }
 					else { false }
@@ -685,7 +685,7 @@ fn (mut g Gen) autofree_call_pregen(node ast.CallExpr) {
 			// instead of `string t = ...`, and we need to mark this variable as unused,
 			// so that it's freed after the call. (Used tmp arg vars are not freed to avoid double frees).
 			if x := scope.find(t) {
-				match union mut x {
+				match mut x {
 					ast.Var { x.is_used = false }
 					else {}
 				}
@@ -740,7 +740,7 @@ fn (mut g Gen) autofree_call_postgen(node_pos int) {
 	// g.write('/* postgen */')
 	scope := g.file.scope.innermost(node_pos)
 	for _, obj in scope.objects {
-		match union mut obj {
+		match mut obj {
 			ast.Var {
 				// if var.typ == 0 {
 				// // TODO why 0?
@@ -887,7 +887,7 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type table.Type) {
 			}
 			arg_typ_sym := g.table.get_type_symbol(arg.typ)
 			expected_deref_type := if expected_type.is_ptr() { expected_type.deref() } else { expected_type }
-			is_sum_type := g.table.get_type_symbol(expected_deref_type).kind == .union_sum_type
+			is_sum_type := g.table.get_type_symbol(expected_deref_type).kind == .sum_type
 			if !((arg_typ_sym.kind == .function) || is_sum_type) {
 				g.write('(voidptr)&/*qq*/')
 			}
diff --git a/vlib/v/gen/js/js.v b/vlib/v/gen/js/js.v
index 6aa63df590..9e7600c8c7 100644
--- a/vlib/v/gen/js/js.v
+++ b/vlib/v/gen/js/js.v
@@ -164,7 +164,7 @@ pub fn (mut g JsGen) push_pub_var(s string) {
 
 pub fn (mut g JsGen) find_class_methods(stmts []ast.Stmt) {
 	for stmt in stmts {
-		match union stmt {
+		match stmt {
 			ast.FnDecl {
 				if stmt.is_method {
 					// Found struct method, store it to be generated along with the class.
@@ -257,7 +257,7 @@ pub fn (mut g JsGen) typ(t table.Type) string {
 			joined := types.join(', ')
 			styp = '[$joined]'
 		}
-		.union_sum_type {
+		.sum_type {
 			// TODO: Implement sumtypes
 			styp = 'union_sym_type'
 		}
@@ -433,7 +433,7 @@ fn (mut g JsGen) stmts(stmts []ast.Stmt) {
 
 fn (mut g JsGen) stmt(node ast.Stmt) {
 	g.stmt_start_pos = g.out.len
-	match union node {
+	match node {
 		ast.AssertStmt {
 			g.gen_assert_stmt(node)
 		}
@@ -519,7 +519,7 @@ fn (mut g JsGen) stmt(node ast.Stmt) {
 }
 
 fn (mut g JsGen) expr(node ast.Expr) {
-	match union node {
+	match node {
 		ast.CTempVar {
 			g.write('/* ast.CTempVar: node.name */')
 		}
@@ -1004,7 +1004,7 @@ fn (mut g JsGen) gen_for_stmt(it ast.ForStmt) {
 
 fn (mut g JsGen) gen_go_stmt(node ast.GoStmt) {
 	// x := node.call_expr as ast.CallEpxr // TODO
-	match union node.call_expr {
+	match node.call_expr {
 		ast.CallExpr {
 			mut name := node.call_expr.name
 			if node.call_expr.is_method {
@@ -1193,7 +1193,7 @@ fn (mut g JsGen) gen_call_expr(it ast.CallExpr) {
 			g.write(it.name)
 			g.write('(')
 			expr := node.args[0].expr
-			match union expr {
+			match expr {
 				ast.AnonFn {
 					g.gen_fn_decl(expr.decl)
 					g.write(')')
@@ -1538,7 +1538,7 @@ fn (mut g JsGen) gen_struct_init(it ast.StructInit) {
 
 fn (mut g JsGen) gen_typeof_expr(it ast.TypeOf) {
 	sym := g.table.get_type_symbol(it.expr_type)
-	if sym.kind == .union_sum_type {
+	if sym.kind == .sum_type {
 		// TODO: JS sumtypes not implemented yet
 	} else if sym.kind == .array_fixed {
 		fixed_info := sym.info as table.ArrayFixed
diff --git a/vlib/v/gen/sql.v b/vlib/v/gen/sql.v
index 1e2de38bcc..6dea98d958 100644
--- a/vlib/v/gen/sql.v
+++ b/vlib/v/gen/sql.v
@@ -256,7 +256,7 @@ fn (mut g Gen) expr_to_sql(expr ast.Expr) {
 	//
 	// TODO `where id = some_column + 1` needs literal generation of `some_column` as a string,
 	// not a V variable. Need to distinguish column names from V variables.
-	match union expr {
+	match expr {
 		ast.InfixExpr {
 			g.sql_side = .left
 			g.expr_to_sql(expr.left)
diff --git a/vlib/v/gen/x64/gen.v b/vlib/v/gen/x64/gen.v
index ee1473bda7..bfb486a338 100644
--- a/vlib/v/gen/x64/gen.v
+++ b/vlib/v/gen/x64/gen.v
@@ -479,7 +479,7 @@ pub fn (mut g Gen) save_main_fn_addr() {
 }
 
 pub fn (mut g Gen) gen_print_from_expr(expr ast.Expr, newline bool) {
-	match union expr {
+	match expr {
 		ast.StringLiteral {
 			if newline {
 				g.gen_print(expr.val + '\n')
@@ -575,7 +575,7 @@ pub fn (mut g Gen) call_fn(node ast.CallExpr) {
 	// g.mov(.eax, 0)
 	for i in 0 .. node.args.len {
 		expr := node.args[i].expr
-		match union expr {
+		match expr {
 			ast.IntegerLiteral {
 				// `foo(2)` => `mov edi,0x2`
 				g.mov(fn_arg_registers[i], expr.val.int())
@@ -603,7 +603,7 @@ pub fn (mut g Gen) call_fn(node ast.CallExpr) {
 }
 
 fn (mut g Gen) stmt(node ast.Stmt) {
-	match union node {
+	match node {
 		ast.AssignStmt {
 			g.assign_stmt(node)
 		}
@@ -648,7 +648,7 @@ fn C.strtol() int
 
 fn (mut g Gen) expr(node ast.Expr) {
 	// println('cgen expr()')
-	match union node {
+	match node {
 		ast.ArrayInit {}
 		ast.BoolLiteral {}
 		ast.CallExpr {
@@ -719,7 +719,7 @@ fn (mut g Gen) assign_stmt(node ast.AssignStmt) {
 		name := left.str()
 		// if left is ast.Ident {
 		// ident := left as ast.Ident
-		match union right {
+		match right {
 			ast.IntegerLiteral {
 				g.allocate_var(name, 4, right.val.int())
 			}
@@ -755,7 +755,7 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
 	if node.left is ast.InfixExpr {
 		verror('only simple expressions are supported right now (not more than 2 operands)')
 	}
-	match union mut node.left {
+	match mut node.left {
 		ast.Ident { g.mov_var_to_reg(.eax, g.get_var_offset(node.left.name)) }
 		else {}
 	}
@@ -774,7 +774,7 @@ fn (mut g Gen) if_expr(node ast.IfExpr) {
 	branch := node.branches[0]
 	infix_expr := branch.cond as ast.InfixExpr
 	mut jne_addr := 0 // location of `jne *00 00 00 00*`
-	match union mut infix_expr.left {
+	match mut infix_expr.left {
 		ast.Ident {
 			lit := infix_expr.right as ast.IntegerLiteral
 			g.cmp_var(infix_expr.left.name, lit.val.int())
@@ -797,7 +797,7 @@ fn (mut g Gen) for_stmt(node ast.ForStmt) {
 	// g.mov(.eax, 0x77777777)
 	mut jump_addr := 0 // location of `jne *00 00 00 00*`
 	start := g.pos()
-	match union mut infix_expr.left {
+	match mut infix_expr.left {
 		ast.Ident {
 			lit := infix_expr.right as ast.IntegerLiteral
 			g.cmp_var(infix_expr.left.name, lit.val.int())
diff --git a/vlib/v/parser/assign.v b/vlib/v/parser/assign.v
index 9f2d34d052..b1afd45f5e 100644
--- a/vlib/v/parser/assign.v
+++ b/vlib/v/parser/assign.v
@@ -12,7 +12,7 @@ fn (mut p Parser) assign_stmt() ast.Stmt {
 }
 
 fn (mut p Parser) check_undefined_variables(exprs []ast.Expr, val ast.Expr) {
-	match union val {
+	match val {
 		ast.Ident {
 			for expr in exprs {
 				if expr is ast.Ident {
@@ -46,7 +46,7 @@ fn (mut p Parser) check_undefined_variables(exprs []ast.Expr, val ast.Expr) {
 
 fn (mut p Parser) check_cross_variables(exprs []ast.Expr, val ast.Expr) bool {
 	val_ := val
-	match union val_ {
+	match val_ {
 		ast.Ident {
 			for expr in exprs {
 				if expr is ast.Ident {
@@ -113,7 +113,7 @@ fn (mut p Parser) partial_assign_stmt(left []ast.Expr, left_comments []ast.Comme
 	}
 	mut is_static := false
 	for i, lx in left {
-		match union mut lx {
+		match mut lx {
 			ast.Ident {
 				if op == .decl_assign {
 					if p.scope.known_var(lx.name) {
diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v
index 0d1ceaa08f..dd8a34b7c5 100644
--- a/vlib/v/parser/fn.v
+++ b/vlib/v/parser/fn.v
@@ -567,7 +567,7 @@ fn (mut p Parser) fn_args() ([]table.Param, bool, bool) {
 
 fn (mut p Parser) check_fn_mutable_arguments(typ table.Type, pos token.Position) {
 	sym := p.table.get_type_symbol(typ)
-	if sym.kind !in [.array, .struct_, .map, .placeholder, .union_sum_type] && !typ.is_ptr() {
+	if sym.kind !in [.array, .struct_, .map, .placeholder, .sum_type] && !typ.is_ptr() {
 		p.error_with_pos('mutable arguments are only allowed for arrays, maps, and structs\n' +
 			'return values instead: `fn foo(mut n $sym.name) {` => `fn foo(n $sym.name) $sym.name {`',
 			pos)
diff --git a/vlib/v/parser/if_match.v b/vlib/v/parser/if_match.v
index 27de0d046b..447daf54ed 100644
--- a/vlib/v/parser/if_match.v
+++ b/vlib/v/parser/if_match.v
@@ -170,11 +170,6 @@ fn (mut p Parser) match_expr() ast.MatchExpr {
 	match_first_pos := p.tok.position()
 	p.inside_match = true
 	p.check(.key_match)
-	mut is_union_match := false
-	if p.tok.kind == .key_union {
-		p.check(.key_union)
-		is_union_match = true
-	}
 	is_mut := p.tok.kind == .key_mut
 	mut is_sum_type := false
 	if is_mut {
@@ -287,7 +282,6 @@ fn (mut p Parser) match_expr() ast.MatchExpr {
 		is_sum_type: is_sum_type
 		pos: pos
 		is_mut: is_mut
-		is_union_match: is_union_match
 	}
 }
 
@@ -361,12 +355,12 @@ fn (mut p Parser) select_expr() ast.SelectExpr {
 			}
 			p.inside_match = false
 			p.inside_select = false
-			match union mut stmt {
+			match mut stmt {
 				ast.ExprStmt {
 					if !stmt.is_expr {
 						p.error_with_pos('select: invalid expression', stmt.pos)
 					} else {
-						match union mut stmt.expr {
+						match mut stmt.expr {
 							ast.InfixExpr {
 								if stmt.expr.op != .arrow {
 									p.error_with_pos('select key: `<-` operator expected',
@@ -382,7 +376,7 @@ fn (mut p Parser) select_expr() ast.SelectExpr {
 				}
 				ast.AssignStmt {
 					expr := stmt.right[0]
-					match union expr {
+					match expr {
 						ast.PrefixExpr {
 							if expr.op != .arrow {
 								p.error_with_pos('select key: `<-` operator expected',
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v
index 0e5baf7c35..85b4712fe7 100644
--- a/vlib/v/parser/parser.v
+++ b/vlib/v/parser/parser.v
@@ -608,7 +608,7 @@ pub fn (mut p Parser) stmt(is_top_level bool) ast.Stmt {
 					p.next()
 					if p.tok.kind == .key_for {
 						mut stmt := p.stmt(is_top_level)
-						match union mut stmt {
+						match mut stmt {
 							ast.ForStmt {
 								stmt.label = name
 								return stmt
@@ -1933,16 +1933,16 @@ fn (mut p Parser) union_sum_type_decl() ast.TypeDecl {
 		}
 		prepend_mod_name := p.prepend_mod(name)
 		p.table.register_type_symbol(table.TypeSymbol{
-			kind: .union_sum_type
+			kind: .sum_type
 			name: prepend_mod_name
 			source_name: prepend_mod_name
 			mod: p.mod
-			info: table.UnionSumType{
+			info: table.SumType{
 				variants: sum_variants
 			}
 			is_public: is_pub
 		})
-		return ast.UnionSumTypeDecl{
+		return ast.SumTypeDecl{
 			name: name
 			is_pub: is_pub
 			sub_types: sum_variants
@@ -1999,17 +1999,17 @@ fn (mut p Parser) type_decl() ast.TypeDecl {
 		}
 		prepend_mod_name := p.prepend_mod(name)
 		p.table.register_type_symbol(table.TypeSymbol{
-			kind: .union_sum_type
+			kind: .sum_type
 			name: prepend_mod_name
 			source_name: prepend_mod_name
 			mod: p.mod
-			info: table.UnionSumType{
+			info: table.SumType{
 				variants: sum_variants
 			}
 			is_public: is_pub
 		})
 		comments = p.eat_lineend_comments()
-		return ast.UnionSumTypeDecl{
+		return ast.SumTypeDecl{
 			name: name
 			is_pub: is_pub
 			sub_types: sum_variants
@@ -2139,7 +2139,7 @@ fn (mut p Parser) rewind_scanner_to_current_token_in_new_mode() {
 
 pub fn (mut p Parser) mark_var_as_used(varname string) bool {
 	if obj := p.scope.find(varname) {
-		match union mut obj {
+		match mut obj {
 			ast.Var {
 				obj.is_used = true
 				return true
diff --git a/vlib/v/parser/sql.v b/vlib/v/parser/sql.v
index 87d56fe792..63268058a5 100644
--- a/vlib/v/parser/sql.v
+++ b/vlib/v/parser/sql.v
@@ -129,7 +129,7 @@ fn (mut p Parser) sql_stmt() ast.SqlStmt {
 	mut table_name := ''
 	if kind != .delete {
 		expr := p.expr(0)
-		match union expr {
+		match expr {
 			ast.Ident {
 				if kind == .insert {
 					inserted_var_name = expr.name
diff --git a/vlib/v/parser/struct.v b/vlib/v/parser/struct.v
index 7788915a75..8b1acdaef2 100644
--- a/vlib/v/parser/struct.v
+++ b/vlib/v/parser/struct.v
@@ -203,7 +203,7 @@ fn (mut p Parser) struct_decl() ast.StructDecl {
 					// default_expr = p.tok.lit
 					// p.expr(0)
 					default_expr = p.expr(0)
-					match union mut default_expr {
+					match mut default_expr {
 						ast.EnumVal { default_expr.typ = typ }
 						// TODO: implement all types??
 						else {}
diff --git a/vlib/v/table/table.v b/vlib/v/table/table.v
index e89ac2f533..a049c365ad 100644
--- a/vlib/v/table/table.v
+++ b/vlib/v/table/table.v
@@ -722,8 +722,8 @@ pub fn (mut table Table) register_fn_gen_type(fn_name string, typ Type) {
 // so until fixed at least show v (not C) error `x(variant) =  y(SumType*)`
 pub fn (table &Table) sumtype_has_variant(parent Type, variant Type) bool {
 	parent_sym := table.get_type_symbol(parent)
-	if parent_sym.kind == .union_sum_type {
-		parent_info := parent_sym.info as UnionSumType
+	if parent_sym.kind == .sum_type {
+		parent_info := parent_sym.info as SumType
 		for v in parent_info.variants {
 			if v.idx() == variant.idx() {
 				return true
diff --git a/vlib/v/table/types.v b/vlib/v/table/types.v
index 72c7bac8a3..154338477c 100644
--- a/vlib/v/table/types.v
+++ b/vlib/v/table/types.v
@@ -15,8 +15,8 @@ import strings
 
 pub type Type = int
 
-pub __type TypeInfo = Aggregate | Alias | Array | ArrayFixed | Chan | Enum | FnType |
-	GenericStructInst | Interface | Map | MultiReturn | Struct | UnionSumType
+pub type TypeInfo = Aggregate | Alias | Array | ArrayFixed | Chan | Enum | FnType | GenericStructInst |
+	Interface | Map | MultiReturn | Struct | SumType
 
 pub enum Language {
 	v
@@ -404,7 +404,7 @@ pub enum Kind {
 	struct_
 	generic_struct_inst
 	multi_return
-	union_sum_type
+	sum_type
 	alias
 	enum_
 	function
@@ -420,7 +420,7 @@ pub fn (t &TypeSymbol) str() string {
 
 [inline]
 pub fn (t &TypeSymbol) enum_info() Enum {
-	match union mut t.info {
+	match mut t.info {
 		Enum { return t.info }
 		else { panic('TypeSymbol.enum_info(): no enum info for type: $t.name') }
 	}
@@ -428,7 +428,7 @@ pub fn (t &TypeSymbol) enum_info() Enum {
 
 [inline]
 pub fn (t &TypeSymbol) mr_info() MultiReturn {
-	match union mut t.info {
+	match mut t.info {
 		MultiReturn { return t.info }
 		else { panic('TypeSymbol.mr_info(): no multi return info for type: $t.name') }
 	}
@@ -436,7 +436,7 @@ pub fn (t &TypeSymbol) mr_info() MultiReturn {
 
 [inline]
 pub fn (t &TypeSymbol) array_info() Array {
-	match union mut t.info {
+	match mut t.info {
 		Array { return t.info }
 		else { panic('TypeSymbol.array_info(): no array info for type: $t.name') }
 	}
@@ -444,7 +444,7 @@ pub fn (t &TypeSymbol) array_info() Array {
 
 [inline]
 pub fn (t &TypeSymbol) array_fixed_info() ArrayFixed {
-	match union mut t.info {
+	match mut t.info {
 		ArrayFixed { return t.info }
 		else { panic('TypeSymbol.array_fixed(): no array fixed info for type: $t.name') }
 	}
@@ -452,7 +452,7 @@ pub fn (t &TypeSymbol) array_fixed_info() ArrayFixed {
 
 [inline]
 pub fn (t &TypeSymbol) chan_info() Chan {
-	match union mut t.info {
+	match mut t.info {
 		Chan { return t.info }
 		else { panic('TypeSymbol.chan_info(): no chan info for type: $t.name') }
 	}
@@ -460,7 +460,7 @@ pub fn (t &TypeSymbol) chan_info() Chan {
 
 [inline]
 pub fn (t &TypeSymbol) map_info() Map {
-	match union mut t.info {
+	match mut t.info {
 		Map { return t.info }
 		else { panic('TypeSymbol.map_info(): no map info for type: $t.name') }
 	}
@@ -468,7 +468,7 @@ pub fn (t &TypeSymbol) map_info() Map {
 
 [inline]
 pub fn (t &TypeSymbol) struct_info() Struct {
-	match union mut t.info {
+	match mut t.info {
 		Struct { return t.info }
 		else { panic('TypeSymbol.struct_info(): no struct info for type: $t.name') }
 	}
@@ -718,7 +718,7 @@ pub fn (k Kind) str() string {
 		.map { 'map' }
 		.chan { 'chan' }
 		.multi_return { 'multi_return' }
-		.union_sum_type { 'union_sum_type' }
+		.sum_type { 'sum_type' }
 		.alias { 'alias' }
 		.enum_ { 'enum' }
 		.any { 'any' }
@@ -788,7 +788,7 @@ pub:
 // NB: FExpr here is a actually an ast.Expr .
 // It should always be used by casting to ast.Expr, using ast.fe2ex()/ast.ex2fe()
 // That hack is needed to break an import cycle between v.ast and v.table .
-pub __type FExpr = byteptr | voidptr
+pub type FExpr = byteptr | voidptr
 
 pub struct Field {
 pub:
@@ -841,7 +841,7 @@ pub mut:
 	value_type Type
 }
 
-pub struct UnionSumType {
+pub struct SumType {
 pub:
 	variants []Type
 }
diff --git a/vlib/v/tests/union_sum_type_test.v b/vlib/v/tests/union_sum_type_test.v
index 9b6cef92d9..f331ecd1c0 100644
--- a/vlib/v/tests/union_sum_type_test.v
+++ b/vlib/v/tests/union_sum_type_test.v
@@ -1,6 +1,6 @@
-__type Expr = IfExpr | IntegerLiteral
-__type Stmt = FnDecl | StructDecl
-__type Node = Expr | Stmt
+type Expr = IfExpr | IntegerLiteral
+type Stmt = FnDecl | StructDecl
+type Node = Expr | Stmt
 
 struct FnDecl {
 	pos int
@@ -26,7 +26,7 @@ fn handle(e Expr) string {
 	if e is IntegerLiteral {
 		assert typeof(e.val) == 'string'
 	}
-	match union e {
+	match e {
 		IntegerLiteral {
 			assert e.val == '12'
 			// assert e.val == '12' // TODO
@@ -54,7 +54,7 @@ fn test_assignment_and_push() {
 		val: '111'
 	}
 	arr1 << expr
-	match union arr1[0] {
+	match arr1[0] {
 		IntegerLiteral {
 			arr1 << arr1[0]
 			// should ref/dereference on assignent be made automatic?
@@ -66,7 +66,7 @@ fn test_assignment_and_push() {
 }
 
 // Test moving structs between master/sub arrays
-__type Master = Sub1 | Sub2
+type Master = Sub1 | Sub2
 
 struct Sub1 {
 mut:
@@ -95,7 +95,7 @@ fn test_converting_down() {
 	}
 	mut res := []Sub2{cap: out.len}
 	for d in out {
-		match union d {
+		match d {
 			Sub2 { res << d }
 			else {}
 		}
@@ -127,9 +127,9 @@ fn test_nested_sumtype_selector() {
 
 fn test_nested_sumtype_match_selector() {
 	c := NodeWrapper{Node(Expr(IfExpr{pos: 1}))}
-	match union c.node {
+	match c.node {
 		Expr {
-			match union c.node {
+			match c.node {
 				IfExpr {
 					assert c.node.pos == 1
 				}
@@ -161,9 +161,9 @@ fn test_nested_sumtype() {
 
 fn test_nested_sumtype_match() {
 	c := Node(Expr(IfExpr{pos: 1}))
-	match union c {
+	match c {
 		Expr {
-			match union c {
+			match c {
 				IfExpr {
 					assert c.pos == 1
 				}
@@ -178,11 +178,11 @@ fn test_nested_sumtype_match() {
 	}
 }
 
-__type Abc = int | string
+type Abc = int | string
 
 fn test_string_cast_to_sumtype() {
 	a := Abc('test')
-	match union a {
+	match a {
 		int {
 			assert false
 		}
@@ -195,7 +195,7 @@ fn test_string_cast_to_sumtype() {
 fn test_int_cast_to_sumtype() {
 	// literal
 	a := Abc(111)
-	match union a {
+	match a {
 		int {
 			assert true
 		}
@@ -206,7 +206,7 @@ fn test_int_cast_to_sumtype() {
 	// var
 	i := 111
 	b := Abc(i)
-	match union b {
+	match b {
 		int {
 			assert true
 		}
@@ -217,10 +217,10 @@ fn test_int_cast_to_sumtype() {
 }
 
 // TODO: change definition once types other than int and f64 (int, f64, etc) are supported in sumtype
-__type Number = int | f64
+type Number = int | f64
 
 fn is_gt_simple(val string, dst Number) bool {
-	match union dst {
+	match dst {
 		int {
 			return val.int() > dst
 		}
@@ -232,9 +232,9 @@ fn is_gt_simple(val string, dst Number) bool {
 
 fn is_gt_nested(val string, dst Number) bool {
 	dst2 := dst
-	match union dst {
+	match dst {
 		int {
-			match union dst2 {
+			match dst2 {
 				int {
 					return val.int() > dst
 				}
@@ -245,7 +245,7 @@ fn is_gt_nested(val string, dst Number) bool {
 			}
 		}
 		f64 {
-			match union dst2 {
+			match dst2 {
 				f64 {
 					return dst < val.f64()
 				}
@@ -259,7 +259,7 @@ fn is_gt_nested(val string, dst Number) bool {
 }
 
 fn concat(val string, dst Number) string {
-	match union dst {
+	match dst {
 		int {
 			mut res := val + '(int)'
 			res += dst.str()
@@ -274,7 +274,7 @@ fn concat(val string, dst Number) string {
 }
 
 fn get_sum(val string, dst Number) f64 {
-	match union dst {
+	match dst {
 		int {
 			mut res := val.int()
 			res += dst
@@ -288,8 +288,8 @@ fn get_sum(val string, dst Number) f64 {
 	}
 }
 
-__type Bar = string | Test
-__type Xyz = int | string
+type Bar = string | Test
+type Xyz = int | string
 
 struct Test {
 	x string
@@ -337,11 +337,11 @@ fn test_assignment() {
 	}
 }
 
-__type Inner = int | string
+type Inner = int | string
 struct InnerStruct {
 	x Inner
 }
-__type Outer = string | InnerStruct
+type Outer = string | InnerStruct
 
 fn test_nested_if_is() {
 	b := Outer(InnerStruct{Inner(0)})
@@ -352,7 +352,7 @@ fn test_nested_if_is() {
 	}
 }
 
-__type Expr3 = CallExpr | CTempVarExpr
+type Expr3 = CallExpr | CTempVarExpr
 struct Expr3Wrapper {
 mut:
 	expr Expr3
@@ -408,7 +408,7 @@ mut:
 	name string
 }
 
-__type Food = Milk | Eggs
+type Food = Milk | Eggs
 
 struct FoodWrapper {
 mut:
@@ -417,7 +417,7 @@ mut:
 
 fn test_match_aggregate() {
 	f := Food(Milk{'test'})
-	match union f {
+	match f {
 		Milk, Eggs {
 			assert f.name == 'test'
 		}
@@ -426,7 +426,7 @@ fn test_match_aggregate() {
 
 fn test_match_mut() {
 	mut f := Food(Milk{'test'})
-	match union mut f {
+	match mut f {
 		Eggs {
 			f.name = 'eggs'
 			assert f.name == 'eggs'
@@ -440,7 +440,7 @@ fn test_match_mut() {
 
 fn test_match_not_mut() {
 	mut f := Food(Milk{'test'})
-	match union f {
+	match f {
 		Eggs {
 			// only works without smartcast
 			assert f is Eggs
@@ -470,7 +470,7 @@ fn test_if_not_mut() {
 
 fn test_match_mut_selector() {
 	mut f := FoodWrapper{Food(Milk{'test'})}
-	match union mut f.food {
+	match mut f.food {
 		Eggs {
 			f.food.name = 'eggs'
 			assert f.food.name == 'eggs'
diff --git a/vlib/v/token/token.v b/vlib/v/token/token.v
index ded53d0843..3fc57718e2 100644
--- a/vlib/v/token/token.v
+++ b/vlib/v/token/token.v
@@ -121,7 +121,7 @@ pub enum Kind {
 	key_struct
 	key_true
 	key_type
-	key___type // __type
+	key___type // type
 	key_typeof
 	key_orelse
 	key_union
diff --git a/vlib/x/json2/decoder.v b/vlib/x/json2/decoder.v
index a9037490fc..69be6b2f7c 100644
--- a/vlib/x/json2/decoder.v
+++ b/vlib/x/json2/decoder.v
@@ -11,7 +11,7 @@ import v.util
 import v.pref
 
 // `Any` is a sum type that lists the possible types to be decoded and used.
-pub __type Any = string | int | i64 | f32 | f64 | any_int | any_float | bool | Null | []Any | map[string]Any
+pub type Any = string | int | i64 | f32 | f64 | any_int | any_float | bool | Null | []Any | map[string]Any
 // `Null` struct is a simple representation of the `null` value in JSON.
 pub struct Null {}
 
@@ -287,7 +287,7 @@ fn (mut p Parser) decode_string() ?Any {
 					continue
 				}
 				else { return error('invalid backslash escape.') }
-			} 
+			}
 
 			if int(peek) == 85 {
 				return error('unicode endpoints must be in lowercase `u`.')
diff --git a/vlib/x/json2/encoder.v b/vlib/x/json2/encoder.v
index 1c237edb75..6fe39b2f07 100644
--- a/vlib/x/json2/encoder.v
+++ b/vlib/x/json2/encoder.v
@@ -7,9 +7,9 @@ import strings
 
 fn write_value(v Any, i int, len int, mut wr strings.Builder) {
 	str := v.str()
-	if v is string { 
-		wr.write('"$str"') 
-	} else { 
+	if v is string {
+		wr.write('"$str"')
+	} else {
 		wr.write(str)
 	}
 	if i >= len-1 { return }
@@ -51,7 +51,7 @@ pub fn (flds []Any) str() string {
 
 // String representation of the `Any` type.
 pub fn (f Any) str() string {
-	match union f {
+	match f {
 		string { return f }
 		int { return f.str() }
 		i64 { return f.str() }
diff --git a/vlib/x/json2/json2.v b/vlib/x/json2/json2.v
index 7452140c1f..cc95f24695 100644
--- a/vlib/x/json2/json2.v
+++ b/vlib/x/json2/json2.v
@@ -79,7 +79,7 @@ pub fn (f Any) as_map() map[string]Any {
 
 // Use `Any` as an integer.
 pub fn (f Any) int() int {
-	match union f {
+	match f {
 		int  { return f }
 		i64  { return int(f) }
 		f64  { return f.str().int() }
@@ -91,7 +91,7 @@ pub fn (f Any) int() int {
 
 // Use `Any` as a 64-bit integer.
 pub fn (f Any) i64() i64 {
-	match union f {
+	match f {
 		int  { return f }
 		i64  { return int(f) }
 		f64  { return f.str().i64() }
@@ -103,7 +103,7 @@ pub fn (f Any) i64() i64 {
 
 // Use `Any` as a 32-bit float.
 pub fn (f Any) f32() f32 {
-	match union f {
+	match f {
 		int { return f }
 		i64 { return f.str().f32() }
 		f64 { return f.str().f32() }
@@ -114,7 +114,7 @@ pub fn (f Any) f32() f32 {
 
 // Use `Any` as a float.
 pub fn (f Any) f64() f64 {
-	match union f {
+	match f {
 		int { return f }
 		i64 { return f }
 		f64 { return f }
@@ -138,7 +138,7 @@ pub fn (f Any) arr() []Any {
 
 // Use `Any` as a bool
 pub fn (f Any) bool() bool {
-	match union f {
+	match f {
 		bool { return f }
 		string { return f.bool() }
 		else { return false }