start keeping track of struct names (#136)

* start keeping track of struct names

* fix fmt

* fix fmt again

Author: JalonSolov

array_map.v

@@ -82,6 +82,7 @@ fn (mut app App) array_init(c CompositeLit) {
 }
 
 fn (mut app App) map_init(node CompositeLit) {
+	app.expr(node.typ)
 	app.genln('{')
 	for elt in node.elts {
 		kv := elt as KeyValueExpr

expr.v

@@ -157,27 +157,26 @@ fn (mut app App) key_value_expr(expr KeyValueExpr) {
 
 fn (mut app App) array_type(node ArrayType) {
 	match node.elt {
-		Ident {
-			app.gen('[]${go2v_type(node.elt.name)}')
+		ArrayType {
+			app.gen('[]')
+			app.array_type(node.elt)
 		}
-		StarExpr {
+		FuncType {
 			app.gen('[]')
-			app.star_expr(node.elt)
-			// app.gen('[]&${node.elt.name}')
+			app.func_type(node.elt)
+		}
+		Ident {
+			app.gen('[]${go2v_type(node.elt.name)}')
 		}
 		SelectorExpr {
 			app.gen('[]')
 			app.force_upper = true
 			app.selector_expr(node.elt)
 			app.force_upper = false
 		}
-		FuncType {
-			app.gen('[]')
-			app.func_type(node.elt)
-		}
-		ArrayType {
+		StarExpr {
 			app.gen('[]')
-			app.array_type(node.elt)
+			app.star_expr(node.elt)
 		}
 		else {
 			app.gen('UNKNOWN ELT ${node.elt.type_name()}')
@@ -186,14 +185,10 @@ fn (mut app App) array_type(node ArrayType) {
 }
 
 fn (mut app App) map_type(node MapType) {
-	app.force_upper = true
 	app.gen('map[')
-	app.force_upper = true
 	app.expr(node.key)
 	app.gen(']')
-	app.force_upper = true
 	app.expr(node.val)
-	app.force_upper = false
 }
 
 fn (mut app App) chan_type(node ChanType) {

main.v

@@ -10,17 +10,18 @@ import v.util.diff
 
 struct App {
 mut:
-	sb             strings.Builder
-	is_fn_call     bool // for lowercase idents
-	tests_ok       bool = true
-	skip_first_arg bool // for `strings.Replace(s...)` => `s.replace(...)`
-	force_upper    bool // for `field Type` in struct decl, `mod.UpperCase` types etc
-	no_star        bool // To skip & in StarExpr in type matches  (interfaces)
-	type_decl_name string
-	is_enum_decl   bool
-	is_mut_recv    bool            // so that `mut f Foo` is generated instead of `mut f &Foo`
-	cur_fn_names   map[string]bool // for fixing shadowing
-	running_test   bool            // disables shadowing for now
+	sb              strings.Builder
+	is_fn_call      bool // for lowercase idents
+	tests_ok        bool = true
+	skip_first_arg  bool // for `strings.Replace(s...)` => `s.replace(...)`
+	force_upper     bool // for `field Type` in struct decl, `mod.UpperCase` types etc
+	no_star         bool // To skip & in StarExpr in type matches  (interfaces)
+	type_decl_name  string
+	is_enum_decl    bool
+	is_mut_recv     bool            // so that `mut f Foo` is generated instead of `mut f &Foo`
+	cur_fn_names    map[string]bool // for fixing shadowing
+	running_test    bool            // disables shadowing for now
+	struct_or_alias []string        // skip camel_to_snake for these, but force capitalize
 }
 
 fn (mut app App) genln(s string) {

stmt.v

@@ -9,40 +9,37 @@ fn (mut app App) stmt_list(list []Stmt) {
 }
 
 fn (mut app App) stmt(stmt Stmt) {
-	// app.genln('TYPE = ${stmt.node_type} ${stmt is ExprStmt}')
-	// println('FOR STMT')
-	// println(stmt)
 	match stmt {
 		AssignStmt {
 			// println('GOT A')
 			app.assign_stmt(stmt, false) // no_mut:false
 		}
-		// have to keep track of variable names which match outer scope, so they can be renamed in inner...
 		BlockStmt {
+			// have to keep track of variable names which match outer scope, so they can be renamed in inner...
 			app.block_stmt(stmt)
 		}
 		BranchStmt {
 			app.branch_stmt(stmt)
 		}
+		DeclStmt {
+			app.decl_stmt(stmt)
+		}
+		DeferStmt {
+			app.defer_stmt(stmt)
+		}
 		ExprStmt {
 			// app.genln('expr stmt')
 			app.expr_stmt(stmt)
 		}
-		SwitchStmt {
-			app.switch_stmt(stmt)
+		ForStmt {
+			app.for_stmt(stmt)
 		}
-		TypeSwitchStmt {
-			app.type_switch_stmt(stmt)
+		GoStmt {
+			app.go_stmt(stmt)
 		}
 		IfStmt {
 			app.if_stmt(stmt)
 		}
-		ForStmt {
-			app.for_stmt(stmt)
-		}
-		DeclStmt {
-			app.decl_stmt(stmt)
-		}
 		IncDecStmt {
 			app.inc_dec_stmt(stmt)
 		}
@@ -52,11 +49,11 @@ fn (mut app App) stmt(stmt Stmt) {
 		ReturnStmt {
 			app.return_stmt(stmt)
 		}
-		DeferStmt {
-			app.defer_stmt(stmt)
+		SwitchStmt {
+			app.switch_stmt(stmt)
 		}
-		GoStmt {
-			app.go_stmt(stmt)
+		TypeSwitchStmt {
+			app.type_switch_stmt(stmt)
 		}
 		else {
 			app.genln('\t// unhandled in stmt: ${stmt}')
@@ -75,8 +72,6 @@ fn (mut app App) go_stmt(stmt GoStmt) {
 
 fn (mut app App) block_stmt(body BlockStmt) {
 	app.genln('{')
-	// println('LIST=')
-	// println(body.list)
 	app.stmt_list(body.list)
 	app.genln('}')
 }
@@ -87,10 +82,8 @@ fn (mut app App) if_stmt(node IfStmt) {
 	}
 
 	app.gen('if ')
-	// app.genln('/*forceu=${app.force_upper}*/')
 	app.expr(node.cond)
 	app.block_stmt(node.body)
-	// else if ... {
 	if node.else_ is IfStmt {
 		app.genln('else')
 		if node.else_.init.tok != '' {
@@ -102,20 +95,14 @@ fn (mut app App) if_stmt(node IfStmt) {
 		if node.else_.init.tok != '' {
 			app.genln('}')
 		}
-	}
-	// else {
-	else if node.else_ is BlockStmt {
+	} else if node.else_ is BlockStmt {
 		app.genln('else')
 		app.block_stmt(node.else_)
 	}
 }
 
 fn (mut app App) for_stmt(f ForStmt) {
 	app.gen('for ')
-	// println(f)
-	// for {}
-	// if f.cond == unsafe { nil } {
-	//}
 
 	init_empty := f.init.node_type == '' // f.init is InvalidStmt // f.init.node_type == ''
 	cond_empty := f.cond.node_type() == ''
@@ -148,15 +135,13 @@ fn (mut app App) range_stmt(node RangeStmt) {
 		app.gen('_ ')
 	} else {
 		key_name := app.unique_name_anti_shadow(app.go2v_ident(node.key.name))
-		// app.gen(app.go2v_ident(node.key.name))
 		app.gen(key_name)
 		app.cur_fn_names[key_name] = true
 		app.gen(', ')
 		if node.value.name == '' {
 			app.gen(' _ ')
 		} else {
 			value_name := app.unique_name_anti_shadow(app.go2v_ident(node.value.name))
-			// app.gen(app.go2v_ident(node.value.name))
 			app.gen(value_name)
 			app.cur_fn_names[value_name] = true
 		}
@@ -173,7 +158,6 @@ fn (mut app App) inc_dec_stmt(i IncDecStmt) {
 }
 
 fn (mut app App) decl_stmt(d DeclStmt) {
-	// app.genln('//decl_stmt')
 	match d.decl {
 		GenDecl {
 			if d.decl.tok == 'var' {
@@ -234,7 +218,6 @@ fn (mut app App) decl_stmt(d DeclStmt) {
 }
 
 fn (mut app App) defer_stmt(node DeferStmt) {
-	// print_backtrace()
 	app.gen('defer ')
 	// `defer fn() { ... } ()
 	// empty function, just generate `defer { ... }` in V

struct.v

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a GPL license that can be found in the LICENSE file.
 
 fn (mut app App) gen_decl(decl GenDecl) {
-	// app.genln('// gen_decl')
-	// mut needs_closer := false
 	app.comments(decl.doc)
 	for spec in decl.specs {
 		match spec {
@@ -16,6 +14,7 @@ fn (mut app App) gen_decl(decl GenDecl) {
 						app.interface_decl(spec.name.name, spec.typ)
 					}
 					StructType {
+						app.struct_or_alias << spec.name.name
 						app.struct_decl(spec.name.name, spec.typ)
 					}
 					else {
@@ -51,7 +50,7 @@ fn (mut app App) type_decl(spec TypeSpec) {
 	// Remember the type name for the upcoming const (enum) handler if it's an enum
 	name := spec.name.name
 	app.type_decl_name = name
-	// TODO figure out how to diffirentiate between enums and type aliases
+	// TODO figure out how to differentiate between enums and type aliases
 	if name == 'EnumTest' {
 		return
 	}
@@ -172,10 +171,6 @@ fn (mut app App) interface_decl(interface_name string, spec InterfaceType) {
 // []int{1,2,3}
 // map[string]int{"foo":1}
 fn (mut app App) composite_lit(c CompositeLit) {
-	// if c.typ.name != '' {
-	// 	app.struct_init(c)
-	// 	return
-	// }
 	match c.typ {
 		ArrayType {
 			app.array_init(c)
@@ -193,7 +188,6 @@ fn (mut app App) composite_lit(c CompositeLit) {
 			app.map_init(c) // loops thru each key_value_expr TODO method needs renaming
 		}
 		else {
-			// app.gen('// UNHANDLED CompositeLit type ${typeof(c.typ).name}')
 			app.genln('// UNHANDLED CompositeLit type  ${c.typ.type_name()} strtyp="${c.typ}"')
 		}
 	}

untested/map_empty/map_empty.go renamed to tests/map_empty/map_empty.go

@@ -1,11 +1,12 @@
 module main
 
 struct Vertex {
-mut:
+pub mut:
 	lat  f64
 	long f64
 }
 
 fn main() {
-	mut l := map[string]Vertex{}
+	mut l := map[string]Vertex{
+	}
 }

untested/map_empty/map_empty.vv renamed to tests/map_empty/map_empty.vv

@@ -51,8 +51,7 @@ fn go2v_type(typ string) string {
 }
 
 fn (mut app App) go2v_ident(ident string) string {
-	// println('ident=${ident} force_upper=${app.force_upper}')
-	if app.force_upper {
+	if app.force_upper || ident in app.struct_or_alias {
 		app.force_upper = false
 		if ident in v_keywords_which_are_not_go_keywords {
 			return ident + '_'
@@ -63,14 +62,6 @@ fn (mut app App) go2v_ident(ident string) string {
 		return ident.capitalize()
 	}
 	return go2v_ident2(ident)
-	/*
-	return if ident[0].is_capital() {
-		// println('is cap')
-		ident
-	} else {
-		go2v_ident2(ident)
-	}
-	*/
 }
 
 const v_keywords_which_are_not_go_keywords = ['match', 'lock', 'fn', 'enum', 'in', 'as']