v/cmd/tools/vreduce.v

import os
import flag
import math
import log

const version = '0.0.2'
const default_command = '${os.quoted_path(@VEXE)} -no-skip-unused' // Command used to compile the program, using -no-skip-unused to ease the reducing
const default_error_msg = 'C compilation error' // the pattern to reproduce
// Temporary files
const tmp_folder = os.join_path(os.vtmp_dir(), 'vreduce')
const tmp_reduced_code_file_name = '__v_reduced_code.v'
const path = '${tmp_folder}/${tmp_reduced_code_file_name}'

fn main() {
	log.use_stdout()
	mut fp := flag.new_flag_parser(os.args)
	fp.skip_executable()
	fp.application('v reduce path/to/file_to_reduce.v')
	fp.description('This tool will reduce the code file and try to make the smallest one it can that reproduces the error when the command is executed')
	fp.version(version)

	error_msg := fp.string('error_msg', `e`, default_error_msg, 'the error message you want to reproduce, default: \'${default_error_msg}\'')
	command := fp.string('command', `c`, default_command, 'the command used to try to reproduce the error, default: \'${default_command}\'')
	do_fmt := fp.bool('fmt', `w`, false, 'enable v fmt for the output (rpdc.v)')
	file_paths := fp.finalize() or {
		eprintln(err)
		println(fp.usage())
		return
	}

	if file_paths.len != 2 {
		println(fp.usage())
		exit(0)
	}

	file_path := file_paths[1]
	if file_path == '' || !os.exists(file_path) {
		log.error('You need to specify a valid file to reduce.')
		if file_path != '' {
			log.error('Path `${file_path}` is not a valid .v file.')
		}
		println(fp.usage())
		exit(1)
	}

	log.info("Starting to reduce the file: '${file_path}'\n    with command: `${command}`,\n    trying to reproduce: `${error_msg}`")

	if do_fmt {
		log.info('Will do `v fmt -w rpdc.v` after the reduction.')
	} else {
		log.info('Will NOT do `v fmt -w rpdc.v` (use the `--fmt` or `-w` flag to enable it)')
	}

	content := os.read_file(file_path)!
	warn_on_false(string_reproduces(content, error_msg, command), 'string_reproduces',
		@LOCATION)
	show_code_stats(content, label: 'Original code size')

	// start tests
	tmp_code := create_code(parse(content))
	warn_on_false(string_reproduces(tmp_code, error_msg, command), 'string_reproduces',
		@LOCATION)
	show_code_stats(tmp_code, label: 'Code size without comments')

	// reduce the code
	reduce_scope(content, error_msg, command, do_fmt)
}

// Return true if the command ran on the file produces the pattern
fn string_reproduces(file string, pattern string, command string) bool {
	if !os.exists(tmp_folder) {
		os.mkdir(tmp_folder) or { panic(err) }
	}
	os.write_file(path, file) or { panic(err) }
	res := os.execute(command + ' ' + path)
	if res.output.contains(pattern) {
		// println('reproduces')
		return true
	} else {
		// println('does not reproduce')
		// println(res.output)
		return false
	}
}

type Elem = string | Scope

@[heap]
struct Scope {
mut:
	fn_scope    bool   // contains a function (string: signature{}, children: function body)
	ignored     bool   // is the scope ignored when creating the file
	tmp_ignored bool   // used when testing if it can be ignored in the file
	children    []Elem // code blocks (strings & children scope
}

// Parse a V file and create a scope tree to represent it
fn parse(file string) Scope { // The parser is surely incomplete for the V syntax, but should work for most of the cases, if not, please open an issue or submit a PR
	mut stack := []&Scope{} // add the last parent to the stack
	stack << &Scope{}
	mut top := stack[0] // stores stack[stack.len-1] (the element on the top of the stack)
	mut scope_level := 0 // Counts the scope depth of the current position in the file
	mut i := 0 // index of the current char in the file
	mut current_string := ''
	for i < file.len {
		top = stack[stack.len - 1] // the element on the top of the stack
		if file[i] == `/` && file[i + 1] == `/` {
			for file[i] != `\n` { // comment -> skip until newline
				i++
			}
		} else if file[i] == `\n` && file[i - 1] == `\n` {
			i++ // remove excess newlines
		} else if file[i] == `\t` {
			i++ // remove tabs for easier processing
		} else if file[i] == `f` && file[i + 1] == `n` && file[i + 2] == ` ` && file[i - 1] or {
			`\n`
		} == `\n` {
			top.children << current_string
			// no increase in scope because not handled with {}
			current_string = ''
			top.children << &Scope{
				fn_scope: true
			}
			stack << &(top.children[top.children.len - 1] as Scope)
			current_string += file[i].ascii_str() // f
			i++
			current_string += file[i].ascii_str() // n
			i++
		} else if file[i] == `/` && file[i + 1] == `*` {
			i++
			i++
			i++
			for !(file[i - 1] == `*` && file[i] == `/`) { // multiline comment -> skip next multiline end sequence
				i++
			}
			i++
		} else if file[i] == `\`` && file[i - 1] != `\\` {
			current_string += file[i].ascii_str()
			i++
			for file[i] != `\`` || (file[i - 1] == `\\` && file[i - 2] != `\\`) { // string -> skip until next `
				current_string += file[i].ascii_str()
				i++
			}
			current_string += file[i].ascii_str() // `
			i++
		} else if file[i] == `'` {
			current_string += file[i].ascii_str() // '
			i++
			for file[i] != `'` || (file[i - 1] == `\\` && file[i - 2] != `\\`) { // string -> skip until next '
				current_string += file[i].ascii_str()
				i++
			}
			current_string += file[i].ascii_str() // '
			i++
		} else if file[i] == `"` {
			current_string += file[i].ascii_str() // "
			i++
			for file[i] != `"` || (file[i - 1] == `\\` && file[i - 2] != `\\`) { // string -> skip until next "
				current_string += file[i].ascii_str()
				i++
			}
			current_string += file[i].ascii_str() // "
			i++
		} else if file[i] == `{` {
			current_string += file[i].ascii_str()
			i++
			top.children << current_string
			scope_level += 1
			current_string = ''
			top.children << &Scope{}
			stack << &(top.children[top.children.len - 1] as Scope)
		} else if file[i] == `}` {
			scope_level -= 1
			assert scope_level >= 0, 'The scopes are not well detected ${stack[0]}'
			if current_string != '' {
				top.children << current_string
			}
			if stack.last().children == [] {
				stack[stack.len - 2].children.delete(stack[stack.len - 2].children.len - 1) // delete the empty scope (the last children because top of the stack)
			}
			stack.pop()
			top = stack[stack.len - 1]
			current_string = ''
			current_string += file[i].ascii_str() // }
			i++
			if scope_level == 0 && stack.len == 2 { // the function and the body scope
				top.children << current_string
				stack.pop()
				top = stack[stack.len - 1]
				current_string = ''
			}
		} else {
			current_string += file[i].ascii_str()
			i++
		}
		// nothing here: to avoid complexity, no need to predict what happened before in the ifs, everything will be handled properly by the ifs
	}
	top = stack[stack.len - 1]
	top.children << current_string // last part of the file
	warn_on_false(scope_level == 0, 'scope_level == 0 /* the scopes are not well detected*/',
		@LOCATION)
	warn_on_false(stack.len == 1, 'stack.len == 1 /* the stack should only have the body scope */',
		@LOCATION)
	return *stack[0]
}

// Create the file from a scope tree
fn create_code(sc Scope) string {
	mut output_code := ''
	mut stack := []Elem{}
	stack << sc
	for stack.len > 0 {
		item := stack.pop()
		if item is Scope {
			if !item.ignored && !item.tmp_ignored {
				stack << item.children.reverse() // to traverse the tree in the good order
			} else {
			}
		} else if item is string { // string
			output_code += item
		} else {
			panic('Should never happen')
		}
	}
	return output_code
}

// Reduces the code contained in the scope tree and writes the reduced code to `rpdc.v`
fn reduce_scope(content string, error_msg string, command string, do_fmt bool) {
	mut sc := parse('') // will get filled in the start of the loop
	log.info('Cleaning the scopes')
	mut text_code := content
	mut outer_modified_smth := true
	for outer_modified_smth {
		sc = parse(text_code)
		outer_modified_smth = false
		mut modified_smth := true // was a modification successful in reducing the code in the last iteration
		for modified_smth { // as long as there are successful modifications
			modified_smth = false
			log.info('NEXT ITERATION, loop 1')
			mut stack := []&Elem{}
			for i in 0 .. sc.children.len {
				stack << &sc.children[i]
			}
			for stack.len > 0 { // traverse the tree and disable (ignore) scopes that are not needed for reproduction
				mut item := stack.pop()
				if mut item is Scope {
					if !item.ignored {
						item.tmp_ignored = true // try to ignore it
						code := create_code(sc)
						item.tmp_ignored = false // dont need it anymore
						if string_reproduces(code, error_msg, command) {
							item.ignored = true
							modified_smth = true
							outer_modified_smth = true
							show_code_stats(code)
						} else { // if can remove it, no need to go though it's children
							for i in 0 .. item.children.len {
								stack << &item.children[i]
							}
						}
					}
				}
			}
		}

		text_code = create_code(sc)

		log.info('Processing remaining lines')
		split_code := text_code.split_into_lines() // dont forget to add back the \n
		// Create the binary tree of the lines
		depth := int(math.log2(split_code.len)) + 1
		mut c := 0
		mut line_stack := []&Scope{}
		line_stack << &Scope{}
		for c < split_code.len {
			l1 := line_stack.len
			if l1 <= depth { // or equal because of the first node
				if line_stack[l1 - 1].children.len < 2 {
					line_stack[l1 - 1].children << &Scope{}
					l2 := line_stack[l1 - 1].children.len
					line_stack << &(line_stack[l1 - 1].children[l2 - 1] as Scope)
				} else {
					line_stack.pop()
				}
			} else {
				if line_stack[l1 - 1].children.len != 0 { // if there is already a string
					line_stack.pop()
				} else {
					line_stack[l1 - 1].children << split_code[c] + '\n' // the \n were removed by the split
					c++
					line_stack.pop() // already a string
				}
			}
		}

		// Traverse the tree and prune the useless lines / line groups for the reproduction
		mut line_tree := *line_stack[0]
		warn_on_false(string_reproduces(create_code(line_tree), error_msg, command), 'string_reproduces',
			@LOCATION) // should be the same
		log.info('Pruning the lines/line groups')
		modified_smth = true
		for modified_smth {
			modified_smth = false
			log.info('NEXT ITERATION, loop 2')
			mut stack := []&Elem{}
			for i in 0 .. line_tree.children.len {
				stack << &line_tree.children[i]
			}
			for stack.len > 0 { // traverse the binary tree (of the lines)
				mut item := stack.pop()
				if mut item is Scope {
					if !item.ignored {
						item.tmp_ignored = true
						code := create_code(line_tree)
						item.tmp_ignored = false // dont need it anymore
						if string_reproduces(code, error_msg, command) {
							item.ignored = true
							modified_smth = true
							outer_modified_smth = true
							show_code_stats(code)
						} else { // if can remove it, can remove it's children
							for i in 0 .. item.children.len {
								stack << &item.children[i]
							}
						}
					}
				}
			}
		}
		text_code = create_code(line_tree)
	}

	warn_on_false(string_reproduces(text_code, error_msg, command), 'string_reproduces',
		@LOCATION)
	os.write_file('rpdc.v', text_code) or { panic(err) }
	if do_fmt {
		os.execute('v fmt -w rpdc.v')
		final_content := os.read_file('rpdc.v') or { panic(err) }
		show_code_stats(final_content, label: 'Code size after formatting')
	}
	println('The reduced code is now in rpdc.v')
}

@[params]
struct ShowParams {
	label string = 'Code size'
}

fn show_code_stats(code string, params ShowParams) {
	lines := code.split_into_lines()
	log.info('${params.label}: ${code.len} chars, ${lines.len} lines.')
}

fn warn_on_false(res bool, what string, loc string) {
	if !res {
		log.warn('${what} is false, at ${loc}')
	}
}