cgen: remove obfuscation (strip should be used instead); temporary fix for usecache + toml

Author: medvednikov

vlib/v/builder/rebuilding.v

@@ -190,6 +190,7 @@ fn (mut b Builder) v_build_module(vexe string, imp_path string) {
 	$if trace_v_build_module ? {
 		eprintln('> Builder.v_build_module: ${rebuild_cmd}')
 	}
+	// eprintln('> Builder.v_build_module: ${rebuild_cmd}')
 	os.system(rebuild_cmd)
 }
 

vlib/v/gen/c/cgen.v

@@ -277,7 +277,7 @@ pub:
 	header           string          // produced output for out.h (-parallel-cc)
 	res_builder      strings.Builder // produced output (complete)
 	out_str          string          // produced output from g.out
-	out0_str         string          // helpers output (auto fns, dump fns) for out_0.c (-parallel-cc)	
+	out0_str         string          // helpers output (auto fns, dump fns) for out_0.c (-parallel-cc)
 	extern_str       string          // extern chunk for (-parallel-cc)
 	out_fn_start_pos []int           // fn decl positions
 }
@@ -355,15 +355,6 @@ pub fn gen(files []&ast.File, mut table ast.Table, pref_ &pref.Preferences) GenO
 
 	global_g.type_resolver = type_resolver.TypeResolver.new(table, global_g)
 	global_g.comptime = &global_g.type_resolver.info
-	/*
-	global_g.out_parallel = []strings.Builder{len: nr_cpus}
-	for i in 0 .. nr_cpus {
-		global_g.out_parallel[i] = strings.new_builder(100000)
-		global_g.out_parallel[i].writeln('#include "out.h"\n')
-	}
-	println('LEN=')
-	println(global_g.out_parallel.len)
-	*/
 	// anon fn may include assert and thus this needs
 	// to be included before any test contents are written
 	if pref_.is_test {
@@ -516,18 +507,27 @@ pub fn gen(files []&ast.File, mut table ast.Table, pref_ &pref.Preferences) GenO
 
 	// to make sure type idx's are the same in cached mods
 	if g.pref.build_mode == .build_module {
+		is_toml := g.pref.path.contains('/toml')
 		for idx, sym in g.table.type_symbols {
 			if idx in [0, 31] {
 				continue
 			}
-			g.definitions.writeln('int _v_type_idx_${sym.cname}();')
+			if is_toml && sym.cname.contains('map[string]') {
+				// Temporary hack to make toml work with -usecache TODO remove
+				continue
+			}
+			g.definitions.writeln('int _v_type_idx_${sym.cname}(); // 1build module ${g.pref.path}')
 		}
 	} else if g.pref.use_cache {
+		is_toml := g.pref.path.contains('/toml')
 		for idx, sym in g.table.type_symbols {
 			if idx in [0, 31] {
 				continue
 			}
-			g.definitions.writeln('int _v_type_idx_${sym.cname}() { return ${idx}; };')
+			if is_toml && sym.cname.contains('map[string]') {
+				continue
+			}
+			g.definitions.writeln('int _v_type_idx_${sym.cname}() { return ${idx}; }; //lol ${g.pref.path}')
 		}
 	}
 
@@ -1059,29 +1059,6 @@ pub fn (mut g Gen) init() {
 	if g.pref.is_livemain || g.pref.is_liveshared {
 		g.generate_hotcode_reloading_declarations()
 	}
-	// Obfuscate only functions in the main module for now.
-	// Generate the obf_ast.
-	if g.pref.obfuscate {
-		mut i := 0
-		// fns
-		for key, f in g.table.fns {
-			if f.mod != 'main' && key != 'main' {
-				continue
-			}
-			g.obf_table[key] = '_f${i}'
-			i++
-		}
-		// methods
-		for type_sym in g.table.type_symbols {
-			if type_sym.mod != 'main' {
-				continue
-			}
-			for method in type_sym.methods {
-				g.obf_table[type_sym.name + '.' + method.name] = '_f${i}'
-				i++
-			}
-		}
-	}
 	// we know that this is being called before the multi-threading starts
 	// and this is being called in the main thread, so we can mutate the table
 	mut muttable := unsafe { &ast.Table(g.table) }
@@ -5357,14 +5334,6 @@ fn (mut g Gen) ident(node ast.Ident) {
 				name = g.generic_fn_name(node.concrete_types, name)
 			}
 		}
-
-		if g.pref.obfuscate && g.cur_mod.name == 'main' && name.starts_with('main__') {
-			key := node.name
-			g.write('/* obf identfn: ${key} */')
-			name = g.obf_table[key] or {
-				panic('cgen: obf name "${key}" not found, this should never happen')
-			}
-		}
 	}
 	g.write(g.get_ternary_name(name))
 	if is_auto_heap {

vlib/v/gen/c/fn.v

@@ -256,18 +256,6 @@ fn (mut g Gen) gen_fn_decl(node &ast.FnDecl, skip bool) {
 
 	mut name := g.c_fn_name(node)
 	type_name := g.ret_styp(g.unwrap_generic(node.return_type))
-	if g.pref.obfuscate && g.cur_mod.name == 'main' && name.starts_with('main__') && !node.is_main
-		&& node.name != 'str' {
-		mut key := node.name
-		if node.is_method {
-			sym := g.table.sym(node.receiver.typ)
-			key = sym.name + '.' + node.name
-		}
-		g.writeln('/* obf: ${key} */')
-		name = g.obf_table[key] or {
-			panic('cgen: fn_decl: obf name "${key}" not found, this should never happen')
-		}
-	}
 	// Live functions are protected by a mutex, because otherwise they
 	// can be changed by the live reload thread, *while* they are
 	// running, with unpredictable results (usually just crashing).
@@ -1668,15 +1656,6 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
 	if left_sym.kind == .chan && node.name in ['close', 'try_pop', 'try_push'] {
 		name = 'sync__Channel_${node.name}'
 	}
-	if g.pref.obfuscate && g.cur_mod.name == 'main' && name.starts_with('main__')
-		&& node.name != 'str' {
-		sym := g.table.sym(node.receiver_type)
-		key := sym.name + '.' + node.name
-		g.write('/* obf method call: ${key} */')
-		name = g.obf_table[key] or {
-			panic('cgen: obf name "${key}" not found, this should never happen')
-		}
-	}
 	mut is_range_slice := false
 	if node.receiver_type.is_ptr() && !left_type.is_ptr() {
 		if node.left is ast.IndexExpr {
@@ -2019,14 +1998,6 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 			}
 		}
 	}
-	// Obfuscate only functions in the main module for now
-	if g.pref.obfuscate && g.cur_mod.name == 'main' && name.starts_with('main__') {
-		key := node.name
-		g.write('/* obf call: ${key} */')
-		name = g.obf_table[key] or {
-			panic('cgen: obf name "${key}" not found, this should never happen')
-		}
-	}
 	if !is_selector_call {
 		if func := g.table.find_fn(node_name) {
 			mut concrete_types := node.concrete_types.map(g.unwrap_generic(it))

vlib/v/gen/c/spawn_and_go.v

@@ -71,17 +71,6 @@ fn (mut g Gen) spawn_and_go_expr(node ast.SpawnExpr, mode SpawnGoMode) {
 		}
 	}
 	name = util.no_dots(name)
-	if g.pref.obfuscate && g.cur_mod.name == 'main' && name.starts_with('main__') {
-		mut key := expr.name
-		if expr.is_method {
-			sym := g.table.sym(expr.receiver_type)
-			key = sym.name + '.' + expr.name
-		}
-		g.write('/* obf go: ${key} */')
-		name = g.obf_table[key] or {
-			panic('cgen: obf name "${key}" not found, this should never happen')
-		}
-	}
 	g.empty_line = true
 	g.writeln('// start go')
 	wrapper_struct_name := 'thread_arg_' + name

vlib/v/pref/pref.v

@@ -137,7 +137,7 @@ pub mut:
 	profile_fns        []string // when set, profiling will be off by default, but inside these functions (and what they call) it will be on.
 	translated         bool     // `v translate doom.v` are we running V code translated from C? allow globals, ++ expressions, etc
 	translated_go      bool = true // Are we running V code translated from Go? Allow err shadowing
-	obfuscate          bool // `v -obf program.v`, renames functions to "f_XXX"
+	obfuscate_removed  bool // `v -obf program.v`, renames functions to "f_XXX". REMOVED. Use `strip` instead
 	hide_auto_str      bool // `v -hide-auto-str program.v`, doesn't generate str() with struct data
 	// Note: passing -cg instead of -g will set is_vlines to false and is_debug to true, thus making v generate cleaner C files,
 	// which are sometimes easier to debug / inspect manually than the .tmp.c files by plain -g (when/if v line number generation breaks).
@@ -688,7 +688,8 @@ pub fn parse_args_and_show_errors(known_external_commands []string, args []strin
 				res.is_stats = true
 			}
 			'-obf', '-obfuscate' {
-				res.obfuscate = true
+				println('obfuscation has been removed; use `strip` on the resulting binary instead')
+				res.obfuscate_removed = true
 			}
 			'-hide-auto-str' {
 				res.hide_auto_str = true