v/vlib/v/fmt/fmt.v

1472 lines
32 KiB
V
Raw Normal View History

2020-02-03 05:00:36 +01:00
// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
2019-12-22 02:34:37 +01:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module fmt
2020-04-14 19:32:23 +02:00
import v.ast
import v.table
import v.token
2020-04-14 19:32:23 +02:00
import strings
2020-02-17 22:50:04 +01:00
const (
2020-05-28 05:50:57 +02:00
tabs = ['', '\t', '\t\t', '\t\t\t', '\t\t\t\t', '\t\t\t\t\t', '\t\t\t\t\t\t', '\t\t\t\t\t\t\t',
'\t\t\t\t\t\t\t\t'
]
// when to break a line dependant on penalty
max_len = [0, 35, 85, 93, 100]
2020-02-17 22:50:04 +01:00
)
pub struct Fmt {
pub:
2020-05-24 04:43:00 +02:00
table &table.Table
pub mut:
out_imports strings.Builder
out strings.Builder
out_save strings.Builder
2020-05-24 04:43:00 +02:00
indent int
empty_line bool
line_len int
buffering bool // expressions will be analyzed later by adjust_complete_line() before finally written
expr_bufs []string // and stored here in the meantime (expr_bufs.len-1 = penalties.len = precedences.len)
penalties []int // how hard should it be to break line after each expression
precedences []int // operator/parenthese precedences for operator at end of each expression
par_level int // how many parentheses are put around the current expression
2020-05-24 04:43:00 +02:00
single_line_if bool
cur_mod string
file ast.File
did_imports bool
is_assign bool
is_inside_interp bool
2020-05-24 04:43:00 +02:00
auto_imports []string // automatically inserted imports that the user forgot to specify
import_pos int // position of the imports in the resulting string for later autoimports insertion
used_imports []string // to remove unused imports
is_debug bool
mod2alias map[string]string // for `import time as t`, will contain: 'time'=>'t'
use_short_fn_args bool
2020-06-18 20:07:48 +02:00
it_name string // the name to replace `it` with
2020-02-17 22:50:04 +01:00
}
2020-05-04 16:22:41 +02:00
pub fn fmt(file ast.File, table &table.Table, is_debug bool) string {
mut f := Fmt{
2020-02-17 22:50:04 +01:00
out: strings.new_builder(1000)
out_imports: strings.new_builder(200)
2020-02-17 22:50:04 +01:00
table: table
2020-02-18 22:35:14 +01:00
indent: 0
2020-04-05 02:08:10 +02:00
file: file
2020-05-04 16:22:41 +02:00
is_debug: is_debug
2020-02-17 22:50:04 +01:00
}
f.process_file_imports(file)
2020-04-05 21:53:00 +02:00
f.cur_mod = 'main'
for stmt in file.stmts {
if stmt is ast.Import {
// Just remember the position of the imports for now
f.import_pos = f.out.len
// f.imports(f.file.imports)
}
2020-02-19 16:12:39 +01:00
f.stmt(stmt)
}
2020-04-05 18:15:12 +02:00
// for comment in file.comments { println('$comment.line_nr $comment.text') }
f.imports(f.file.imports) // now that we have all autoimports, handle them
res := f.out.str().trim_space() + '\n'
2020-04-20 09:04:17 +02:00
return res[..f.import_pos] + f.out_imports.str() + res[f.import_pos..] // + '\n'
2020-02-17 22:50:04 +01:00
}
pub fn (mut f Fmt) process_file_imports(file &ast.File) {
for imp in file.imports {
f.mod2alias[imp.mod.all_after_last('.')] = imp.alias
}
}
2020-04-05 02:08:10 +02:00
/*
2020-06-04 10:35:40 +02:00
fn (mut f Fmt) find_comment(line_nr int) {
2020-04-05 02:08:10 +02:00
for comment in f.file.comments {
if comment.line_nr == line_nr {
f.writeln('// FFF $comment.line_nr $comment.text')
return
}
}
}
*/
pub fn (mut f Fmt) write(s string) {
if !f.buffering {
if f.indent > 0 && f.empty_line {
if f.indent < tabs.len {
f.out.write(tabs[f.indent])
} else {
// too many indents, do it the slow way:
for _ in 0 .. f.indent {
f.out.write('\t')
}
}
f.line_len += f.indent * 4
}
f.out.write(s)
f.line_len += s.len
f.empty_line = false
} else {
f.out.write(s)
2020-02-17 22:50:04 +01:00
}
}
pub fn (mut f Fmt) writeln(s string) {
empty_fifo := f.buffering
if empty_fifo {
f.write(s)
f.expr_bufs << f.out.str()
f.out = f.out_save
f.adjust_complete_line()
f.buffering = false
for i, p in f.penalties {
f.write(f.expr_bufs[i])
f.wrap_long_line(p, true)
}
2020-06-24 14:35:00 +02:00
f.write(f.expr_bufs[f.expr_bufs.len - 1])
f.expr_bufs = []string{}
f.penalties = []int{}
f.precedences = []int{}
}
2020-02-18 03:28:39 +01:00
if f.indent > 0 && f.empty_line {
// println(f.indent.str() + s)
2020-02-17 22:50:04 +01:00
f.out.write(tabs[f.indent])
}
2020-06-24 14:35:00 +02:00
f.out.writeln(if empty_fifo {
''
} else {
s
})
2020-02-17 22:50:04 +01:00
f.empty_line = true
2020-02-21 15:32:48 +01:00
f.line_len = 0
2020-02-17 22:50:04 +01:00
}
// adjustments that can only be done after full line is processed. For now
// only prevents line breaks if everything fits in max_len[last] by increasing
// penalties to maximum
fn (mut f Fmt) adjust_complete_line() {
for i, buf in f.expr_bufs {
// search for low penalties
if i == 0 || f.penalties[i-1] <= 1 {
precedence := if i == 0 { -1 } else { f.precedences[i-1] }
mut len_sub_expr := if i == 0 { buf.len + f.line_len } else { buf.len }
mut sub_expr_end_idx := f.penalties.len
// search for next position with low penalty and same precedence to form subexpression
for j in i..f.penalties.len {
if f.penalties[j] <= 1 && f.precedences[j] == precedence && len_sub_expr >= max_len[1] {
sub_expr_end_idx = j
break
} else if f.precedences[j] < precedence {
// we cannot form a sensible subexpression
len_sub_expr = C.INT32_MAX
break
} else {
len_sub_expr += f.expr_bufs[j+1].len
}
}
// if subexpression would fit in single line adjust penalties to actually do so
if len_sub_expr <= max_len[max_len.len-1] {
for j in i..sub_expr_end_idx {
f.penalties[j] = max_len.len-1
}
if i > 0 {
f.penalties[i-1] = 0
}
if sub_expr_end_idx < f.penalties.len {
f.penalties[sub_expr_end_idx] = 0
}
}
}
// emergency fallback: decrease penalty in front of long unbreakable parts
if i > 0 && buf.len > max_len[3] - max_len[1] && f.penalties[i-1] > 0 {
f.penalties[i-1] = if buf.len >= max_len[2] { 0 } else { 1 }
}
}
}
pub fn (mut f Fmt) mod(mod ast.Module) {
2020-02-21 19:56:37 +01:00
f.cur_mod = mod.name
if mod.is_skipped {
return
}
f.writeln('module $mod.name\n')
2020-02-18 22:35:14 +01:00
}
pub fn (mut f Fmt) imports(imports []ast.Import) {
2020-04-14 18:24:19 +02:00
if f.did_imports || imports.len == 0 {
2020-04-05 21:53:00 +02:00
return
}
// f.import_pos = f.out.len
2020-04-14 18:24:19 +02:00
f.did_imports = true
/*
2020-02-18 22:35:14 +01:00
if imports.len == 1 {
imp_stmt_str := f.imp_stmt_str(imports[0])
f.out_imports.writeln('import ${imp_stmt_str}\n')
} else if imports.len > 1 {
2020-04-25 17:49:16 +02:00
*/
2020-04-14 19:32:23 +02:00
// f.out_imports.writeln('import (')
2020-04-14 18:24:19 +02:00
for imp in imports {
if imp.mod !in f.used_imports {
2020-04-14 18:24:19 +02:00
// TODO bring back once only unused imports are removed
// continue
}
2020-04-14 19:32:23 +02:00
// f.out_imports.write('\t')
// f.out_imports.writeln(f.imp_stmt_str(imp))
f.out_imports.write('import ')
2020-04-14 18:24:19 +02:00
f.out_imports.writeln(f.imp_stmt_str(imp))
2020-02-18 22:35:14 +01:00
}
2020-04-14 19:32:23 +02:00
f.out_imports.writeln('')
// f.out_imports.writeln(')\n')
2020-04-14 18:24:19 +02:00
// }
2020-02-18 22:35:14 +01:00
}
pub fn (f Fmt) imp_stmt_str(imp ast.Import) string {
2020-02-21 20:12:55 +01:00
is_diff := imp.alias != imp.mod && !imp.mod.ends_with('.' + imp.alias)
2020-06-18 20:07:48 +02:00
imp_alias_suffix := if is_diff { ' as $imp.alias' } else { '' }
return '$imp.mod$imp_alias_suffix'
2020-02-18 22:35:14 +01:00
}
pub fn (mut f Fmt) stmts(stmts []ast.Stmt) {
2020-02-17 22:50:04 +01:00
f.indent++
for stmt in stmts {
f.stmt(stmt)
}
f.indent--
}
pub fn (mut f Fmt) stmt(node ast.Stmt) {
2020-05-04 16:22:41 +02:00
if f.is_debug {
eprintln('stmt: ${node.position():-42} | node: ${typeof(node):-20}')
}
2020-02-17 22:50:04 +01:00
match node {
ast.AssignStmt {
2020-06-18 20:07:48 +02:00
for i, left in node.left {
if left is ast.Ident {
ident := left as ast.Ident
var_info := ident.var_info()
if var_info.is_mut {
f.write('mut ')
}
f.expr(left)
2020-06-18 20:07:48 +02:00
if i < node.left.len - 1 {
f.write(', ')
}
2020-06-18 20:07:48 +02:00
} else {
f.expr(left)
2020-02-17 22:50:04 +01:00
}
}
2020-04-05 23:00:17 +02:00
f.is_assign = true
2020-06-18 20:07:48 +02:00
f.write(' $node.op.str() ')
for i, val in node.right {
f.expr(val)
2020-06-18 20:07:48 +02:00
if i < node.right.len - 1 {
f.write(', ')
}
2020-02-17 22:50:04 +01:00
}
if !f.single_line_if {
f.writeln('')
}
2020-04-05 23:00:17 +02:00
f.is_assign = false
2020-02-17 22:50:04 +01:00
}
2020-04-07 18:51:39 +02:00
ast.AssertStmt {
f.write('assert ')
2020-06-18 20:07:48 +02:00
f.expr(node.expr)
2020-04-07 18:51:39 +02:00
f.writeln('')
}
2020-02-24 17:18:14 +01:00
ast.Attr {
2020-06-18 20:07:48 +02:00
f.writeln('[$node.name]')
2020-02-24 17:18:14 +01:00
}
2020-04-05 23:00:17 +02:00
ast.Block {
f.writeln('{')
2020-06-18 20:07:48 +02:00
f.stmts(node.stmts)
2020-04-05 23:00:17 +02:00
f.writeln('}')
}
2020-02-18 03:28:39 +01:00
ast.BranchStmt {
2020-06-18 20:07:48 +02:00
match node.tok.kind {
2020-04-17 20:51:16 +02:00
.key_break { f.writeln('break') }
.key_continue { f.writeln('continue') }
2020-02-18 03:28:39 +01:00
else {}
2020-04-05 18:03:36 +02:00
}
}
ast.Comment {
f.comment(it)
2020-02-18 03:28:39 +01:00
}
2020-04-07 18:51:39 +02:00
ast.CompIf {
inversion := if it.is_not { '!' } else { '' }
is_opt := if it.is_opt { ' ?' } else { '' }
2020-06-18 20:07:48 +02:00
f.writeln('\$if $inversion$it.val$is_opt {')
2020-04-07 18:51:39 +02:00
f.stmts(it.stmts)
if it.has_else {
f.writeln('} \$else {')
f.stmts(it.else_stmts)
}
f.writeln('}')
}
2020-02-17 22:50:04 +01:00
ast.ConstDecl {
2020-05-12 00:09:59 +02:00
f.const_decl(it)
2020-02-17 22:50:04 +01:00
}
2020-02-26 20:44:42 +01:00
ast.DeferStmt {
f.writeln('defer {')
f.stmts(it.stmts)
f.writeln('}')
}
2020-02-28 17:21:20 +01:00
ast.EnumDecl {
if it.is_pub {
f.write('pub ')
}
2020-04-09 15:33:46 +02:00
name := it.name.after('.')
f.writeln('enum $name {')
2020-04-09 19:23:49 +02:00
for field in it.fields {
f.write('\t$field.name')
2020-04-10 14:44:01 +02:00
if field.has_expr {
2020-04-09 19:23:49 +02:00
f.write(' = ')
2020-04-10 14:44:01 +02:00
f.expr(field.expr)
2020-04-09 19:23:49 +02:00
}
f.writeln('')
2020-02-28 17:21:20 +01:00
}
f.writeln('}\n')
}
2020-02-17 22:50:04 +01:00
ast.ExprStmt {
f.expr(it.expr)
2020-02-21 16:48:37 +01:00
if !f.single_line_if {
f.writeln('')
}
2020-02-17 22:50:04 +01:00
}
ast.FnDecl {
2020-04-25 17:49:16 +02:00
f.fn_decl(it)
2020-02-17 22:50:04 +01:00
}
ast.ForCStmt {
f.write('for ')
if it.has_init {
f.single_line_if = true // to keep all for ;; exprs on the same line
f.stmt(it.init)
f.single_line_if = false
}
f.write('; ')
f.expr(it.cond)
f.write('; ')
f.stmt(it.inc)
f.writeln(' {')
f.stmts(it.stmts)
f.writeln('}')
}
2020-02-22 14:39:25 +01:00
ast.ForInStmt {
2020-03-20 20:19:43 +01:00
f.write('for ')
if it.key_var != '' {
f.write(it.key_var)
}
if it.val_var != '' {
2020-03-20 20:19:43 +01:00
if it.key_var != '' {
f.write(', ')
}
f.write(it.val_var)
}
f.write(' in ')
2020-02-22 16:59:50 +01:00
f.expr(it.cond)
if it.is_range {
f.write(' .. ')
f.expr(it.high)
}
2020-02-22 16:59:50 +01:00
f.writeln(' {')
2020-02-22 14:39:25 +01:00
f.stmts(it.stmts)
f.writeln('}')
}
2020-02-18 03:28:39 +01:00
ast.ForStmt {
f.write('for ')
f.expr(it.cond)
if it.is_inf {
f.writeln('{')
} else {
f.writeln(' {')
}
2020-02-18 03:28:39 +01:00
f.stmts(it.stmts)
f.writeln('}')
}
2020-04-07 18:51:39 +02:00
ast.GlobalDecl {
f.write('__global $it.name ')
2020-04-09 15:33:46 +02:00
f.write(f.type_to_str(it.typ))
2020-04-07 18:51:39 +02:00
if it.has_expr {
f.write(' = ')
f.expr(it.expr)
}
f.writeln('')
2020-04-07 18:51:39 +02:00
}
2020-04-25 17:49:16 +02:00
ast.GoStmt {
f.write('go ')
f.expr(it.call_expr)
f.writeln('')
}
2020-03-02 17:41:32 +01:00
ast.GotoLabel {
f.writeln('$it.name:')
}
ast.GotoStmt {
f.writeln('goto $it.name')
}
2020-04-08 21:21:58 +02:00
ast.HashStmt {
f.writeln('#$it.val')
}
2020-04-05 18:03:36 +02:00
ast.Import {
// Imports are handled after the file is formatted, to automatically add necessary modules
// f.imports(f.file.imports)
2020-04-05 18:03:36 +02:00
}
2020-04-22 20:20:49 +02:00
ast.InterfaceDecl {
f.writeln('interface $it.name {')
for method in it.methods {
f.write('\t')
f.writeln(method.str(f.table).after('fn '))
}
f.writeln('}\n')
}
2020-04-05 18:03:36 +02:00
ast.Module {
f.mod(it)
}
2020-02-17 22:50:04 +01:00
ast.Return {
f.write('return')
if it.exprs.len > 1 {
2020-04-05 18:03:36 +02:00
// multiple returns
2020-02-18 03:28:39 +01:00
f.write(' ')
2020-02-17 22:50:04 +01:00
for i, expr in it.exprs {
f.expr(expr)
if i < it.exprs.len - 1 {
f.write(', ')
}
}
2020-04-05 18:03:36 +02:00
} else if it.exprs.len == 1 {
// normal return
2020-02-17 22:50:04 +01:00
f.write(' ')
f.expr(it.exprs[0])
}
f.writeln('')
}
2020-06-24 14:35:00 +02:00
ast.SqlStmt {}
2020-02-17 22:50:04 +01:00
ast.StructDecl {
f.struct_decl(it)
}
ast.TypeDecl {
2020-04-05 02:08:10 +02:00
// already handled in f.imports
f.type_decl(it)
}
2020-04-07 18:51:39 +02:00
ast.UnsafeStmt {
f.writeln('unsafe {')
f.stmts(it.stmts)
f.writeln('}')
}
2020-02-17 22:50:04 +01:00
}
}
pub fn (mut f Fmt) type_decl(node ast.TypeDecl) {
match node {
ast.AliasTypeDecl {
2020-06-18 20:07:48 +02:00
if node.is_pub {
f.write('pub ')
}
2020-06-18 20:07:48 +02:00
ptype := f.type_to_str(node.parent_type)
f.write('type $node.name $ptype')
}
2020-04-25 20:58:00 +02:00
ast.FnTypeDecl {
2020-06-18 20:07:48 +02:00
if node.is_pub {
2020-04-25 20:58:00 +02:00
f.write('pub ')
}
2020-06-18 20:07:48 +02:00
typ_sym := f.table.get_type_symbol(node.typ)
2020-04-25 20:58:00 +02:00
fn_typ_info := typ_sym.info as table.FnType
fn_info := fn_typ_info.func
2020-06-18 20:07:48 +02:00
fn_name := node.name.replace(f.cur_mod + '.', '')
2020-04-25 20:58:00 +02:00
f.write('type $fn_name = fn (')
for i, arg in fn_info.args {
f.write(arg.name)
mut s := f.table.type_to_str(arg.typ).replace(f.cur_mod + '.', '')
2020-04-25 20:58:00 +02:00
if arg.is_mut {
f.write('mut ')
if s.starts_with('&') {
s = s[1..]
}
}
is_last_arg := i == fn_info.args.len - 1
2020-06-24 14:35:00 +02:00
should_add_type := is_last_arg || fn_info.args[i + 1].typ != arg.typ ||
(fn_info.is_variadic && i == fn_info.args.len - 2)
2020-04-25 20:58:00 +02:00
if should_add_type {
if fn_info.is_variadic && is_last_arg {
f.write(' ...' + s)
} else {
f.write(' ' + s)
}
}
if !is_last_arg {
f.write(', ')
}
}
f.write(')')
if fn_info.return_type.idx() != table.void_type_idx {
2020-05-28 05:50:57 +02:00
ret_str := f.table.type_to_str(fn_info.return_type).replace(f.cur_mod + '.',
'')
2020-04-25 20:58:00 +02:00
f.write(' ' + ret_str)
}
}
ast.SumTypeDecl {
2020-06-18 20:07:48 +02:00
if node.is_pub {
f.write('pub ')
}
2020-06-18 20:07:48 +02:00
f.write('type $node.name = ')
mut sum_type_names := []string{}
2020-06-18 20:07:48 +02:00
for t in node.sub_types {
2020-04-09 15:33:46 +02:00
sum_type_names << f.type_to_str(t)
}
2020-04-25 20:58:00 +02:00
sum_type_names.sort()
2020-05-18 18:08:28 +02:00
for i, name in sum_type_names {
f.write(name)
if i < sum_type_names.len - 1 {
f.write(' | ')
}
f.wrap_long_line(2, true)
2020-05-18 18:08:28 +02:00
}
// f.write(sum_type_names.join(' | '))
}
}
f.writeln('\n')
}
pub fn (mut f Fmt) struct_decl(node ast.StructDecl) {
2020-02-29 17:51:35 +01:00
if node.is_pub {
f.write('pub ')
}
f.write('struct ')
f.write_language_prefix(node.language)
2020-04-05 02:08:10 +02:00
name := node.name.after('.')
f.writeln('$name {')
mut max := 0
2020-02-17 22:50:04 +01:00
for field in node.fields {
end_pos := field.pos.pos + field.pos.len
mut comments_len := 0 // Length of comments between field name and type
for comment in field.comments {
2020-06-24 14:35:00 +02:00
if comment.pos.pos >= end_pos {
break
}
if comment.pos.pos > field.pos.pos {
2020-06-24 14:35:00 +02:00
comments_len += '/* $comment.text */ '.len
}
}
if comments_len + field.name.len > max {
max = comments_len + field.name.len
2020-02-17 22:50:04 +01:00
}
}
2020-02-22 14:13:19 +01:00
for i, field in node.fields {
if i == node.mut_pos {
f.writeln('mut:')
2020-04-05 18:03:36 +02:00
} else if i == node.pub_pos {
2020-02-22 14:13:19 +01:00
f.writeln('pub:')
2020-04-05 18:03:36 +02:00
} else if i == node.pub_mut_pos {
2020-02-22 14:13:19 +01:00
f.writeln('pub mut:')
}
end_pos := field.pos.pos + field.pos.len
comments := field.comments
if comments.len == 0 {
f.write('\t$field.name ')
f.write(strings.repeat(` `, max - field.name.len))
f.write(f.type_to_str(field.typ))
if field.attrs.len > 0 {
f.write(' [' + field.attrs.join(';') + ']')
}
if field.has_default_expr {
f.write(' = ')
f.struct_field_expr(field.default_expr)
}
f.write('\n')
continue
}
// Handle comments before field
mut j := 0
for j < comments.len && comments[j].pos.pos < field.pos.pos {
f.indent++
f.empty_line = true
f.comment(comments[j])
f.indent--
j++
2020-04-05 02:08:10 +02:00
}
2020-02-17 22:50:04 +01:00
f.write('\t$field.name ')
// Handle comments between field name and type
mut comments_len := 0
for j < comments.len && comments[j].pos.pos < end_pos {
comment := '/* ${comments[j].text} */ ' // TODO: handle in a function
comments_len += comment.len
f.write(comment)
j++
}
f.write(strings.repeat(` `, max - field.name.len - comments_len))
f.write(f.type_to_str(field.typ))
if field.attrs.len > 0 {
f.write(' [' + field.attrs.join(';') + ']')
}
if field.has_default_expr {
f.write(' = ')
2020-06-06 12:43:35 +02:00
f.struct_field_expr(field.default_expr)
2020-04-10 00:30:43 +02:00
}
// Handle comments after field type (same line)
2020-06-24 14:35:00 +02:00
for j < comments.len && field.pos.line_nr == comments[j].pos.line_nr {
f.write(' // ${comments[j].text}') // TODO: handle in a function
j++
}
f.write('\n')
}
2020-06-24 12:54:39 +02:00
// Handle comments after last field
for comment in node.end_comments {
f.indent++
f.empty_line = true
f.comment(comment)
f.indent--
2020-02-17 22:50:04 +01:00
}
f.writeln('}\n')
}
pub fn (mut f Fmt) struct_field_expr(fexpr ast.Expr) {
mut is_pe_amp_ce := false
mut ce := ast.CastExpr{}
if fexpr is ast.PrefixExpr {
pe := fexpr as ast.PrefixExpr
if pe.right is ast.CastExpr && pe.op == .amp {
ce = pe.right as ast.CastExpr
is_pe_amp_ce = true
f.expr(ce)
}
}
if !is_pe_amp_ce {
f.expr(fexpr)
}
}
pub fn (f &Fmt) type_to_str(t table.Type) string {
mut res := f.table.type_to_str(t)
2020-06-13 00:01:44 +02:00
for res.ends_with('_ptr') {
// type_ptr => &type
2020-04-25 17:49:16 +02:00
res = res[0..res.len - 4]
2020-04-16 07:28:41 +02:00
start_pos := 2 * res.count('[]')
2020-04-25 17:49:16 +02:00
res = res[0..start_pos] + '&' + res[start_pos..res.len]
2020-04-16 07:28:41 +02:00
}
if res.starts_with('[]fixed_') {
prefix := '[]fixed_'
res = res[prefix.len..]
last_underscore_idx := res.last_index('_') or {
return '[]' + res.replace(f.cur_mod + '.', '')
}
limit := res[last_underscore_idx + 1..]
res = '[' + limit + ']' + res[..last_underscore_idx]
}
2020-02-21 19:56:37 +01:00
return res.replace(f.cur_mod + '.', '')
}
pub fn (mut f Fmt) expr(node ast.Expr) {
2020-05-04 16:22:41 +02:00
if f.is_debug {
2020-06-18 20:07:48 +02:00
eprintln('expr: ${node.position():-42} | node: ${typeof(node):-20} | $node.str()')
2020-05-04 16:22:41 +02:00
}
2020-02-17 22:50:04 +01:00
match node {
2020-04-25 17:49:16 +02:00
ast.AnonFn {
2020-06-18 20:07:48 +02:00
f.fn_decl(node.decl)
2020-06-24 12:54:39 +02:00
if node.is_called {
f.write('()')
}
2020-04-25 17:49:16 +02:00
}
2020-02-17 22:50:04 +01:00
ast.ArrayInit {
2020-06-18 20:07:48 +02:00
f.array_init(node)
2020-02-17 22:50:04 +01:00
}
2020-03-06 22:12:15 +01:00
ast.AsCast {
2020-06-18 20:07:48 +02:00
type_str := f.type_to_str(node.typ)
f.expr(node.expr)
2020-03-06 22:12:15 +01:00
f.write(' as $type_str')
}
2020-02-22 14:39:25 +01:00
ast.Assoc {
f.writeln('{')
// f.indent++
2020-06-18 20:07:48 +02:00
f.writeln('\t$node.var_name |')
2020-02-22 14:39:25 +01:00
// TODO StructInit copy pasta
2020-06-18 20:07:48 +02:00
for i, field in node.fields {
2020-04-09 15:59:19 +02:00
f.write('\t$field: ')
2020-06-18 20:07:48 +02:00
f.expr(node.exprs[i])
2020-02-22 14:39:25 +01:00
f.writeln('')
}
// f.indent--
f.write('}')
}
2020-02-17 22:50:04 +01:00
ast.BoolLiteral {
2020-06-18 20:07:48 +02:00
f.write(node.val.str())
2020-02-17 22:50:04 +01:00
}
ast.CastExpr {
2020-06-18 20:07:48 +02:00
f.write(f.type_to_str(node.typ) + '(')
f.expr(node.expr)
f.write(')')
}
2020-02-17 22:50:04 +01:00
ast.CallExpr {
2020-06-18 20:07:48 +02:00
f.call_expr(node)
2020-02-17 22:50:04 +01:00
}
2020-02-27 21:51:40 +01:00
ast.CharLiteral {
2020-06-18 20:07:48 +02:00
f.write('`$node.val`')
2020-02-27 21:51:40 +01:00
}
ast.ComptimeCall {
2020-06-18 20:07:48 +02:00
if node.is_vweb {
f.write('$' + 'vweb.html()')
}
}
2020-04-25 17:49:16 +02:00
ast.ConcatExpr {
2020-06-18 20:07:48 +02:00
for i, val in node.vals {
2020-04-25 17:49:16 +02:00
if i != 0 {
f.write(' + ')
}
f.expr(val)
}
}
2020-02-18 03:28:39 +01:00
ast.EnumVal {
2020-06-18 20:07:48 +02:00
name := f.short_module(node.enum_name)
f.write(name + '.' + node.val)
2020-02-18 03:28:39 +01:00
}
2020-02-17 22:50:04 +01:00
ast.FloatLiteral {
2020-06-18 20:07:48 +02:00
f.write(node.val)
2020-02-17 22:50:04 +01:00
}
ast.IfExpr {
2020-06-18 20:07:48 +02:00
f.if_expr(node)
2020-02-17 22:50:04 +01:00
}
ast.Ident {
2020-06-18 20:07:48 +02:00
f.write_language_prefix(node.language)
if true {
} else {
}
if node.name == 'it' && f.it_name != '' {
f.write(f.it_name)
} else if node.kind == .blank_ident {
2020-02-27 21:51:40 +01:00
f.write('_')
2020-04-05 18:03:36 +02:00
} else {
2020-06-18 20:07:48 +02:00
name := f.short_module(node.name)
// f.write('<$it.name => $name>')
f.write(name)
2020-04-13 16:36:32 +02:00
if name.contains('.') {
f.mark_module_as_used(name)
}
2020-02-27 21:51:40 +01:00
}
2020-02-17 22:50:04 +01:00
}
2020-04-25 17:49:16 +02:00
ast.IfGuardExpr {
2020-06-18 20:07:48 +02:00
f.write(node.var_name + ' := ')
f.expr(node.expr)
2020-04-25 17:49:16 +02:00
}
2020-02-17 22:50:04 +01:00
ast.InfixExpr {
if f.is_inside_interp {
f.expr(node.left)
2020-06-18 20:07:48 +02:00
f.write('$node.op.str()')
f.expr(node.right)
} else {
buffering_save := f.buffering
if !f.buffering {
f.out_save = f.out
f.out = strings.new_builder(60)
f.buffering = true
}
f.expr(node.left)
2020-06-18 20:07:48 +02:00
f.write(' $node.op.str() ')
f.expr_bufs << f.out.str()
mut penalty := 3
if node.left is ast.InfixExpr || node.left is ast.ParExpr {
penalty--
}
if node.right is ast.InfixExpr || node.right is ast.ParExpr {
penalty--
}
f.penalties << penalty
// combine parentheses level with operator precedence to form effective precedence
f.precedences << int(token.precedences[node.op]) | (f.par_level << 16)
f.out = strings.new_builder(60)
f.buffering = true
f.expr(node.right)
if !buffering_save && f.buffering { // now decide if and where to break
f.expr_bufs << f.out.str()
f.out = f.out_save
f.buffering = false
f.adjust_complete_line()
for i, p in f.penalties {
f.write(f.expr_bufs[i])
f.wrap_long_line(p, true)
}
2020-06-24 14:35:00 +02:00
f.write(f.expr_bufs[f.expr_bufs.len - 1])
f.expr_bufs = []string{}
f.penalties = []int{}
f.precedences = []int{}
}
}
2020-02-17 22:50:04 +01:00
}
ast.IndexExpr {
2020-06-18 20:07:48 +02:00
f.expr(node.left)
2020-02-29 17:45:08 +01:00
f.write('[')
2020-06-18 20:07:48 +02:00
f.expr(node.index)
2020-02-29 17:45:08 +01:00
f.write(']')
2020-02-17 22:50:04 +01:00
}
ast.IntegerLiteral {
2020-06-18 20:07:48 +02:00
f.write(node.val)
2020-02-17 22:50:04 +01:00
}
2020-02-22 14:13:19 +01:00
ast.MapInit {
2020-06-18 20:07:48 +02:00
if node.keys.len == 0 {
mut ktyp := node.key_type
mut vtyp := node.value_type
2020-05-27 15:26:45 +02:00
if vtyp == 0 {
2020-06-18 20:07:48 +02:00
typ_sym := f.table.get_type_symbol(node.typ)
minfo := typ_sym.info as table.Map
2020-05-27 15:26:45 +02:00
ktyp = minfo.key_type
vtyp = minfo.value_type
}
f.write('map[')
2020-05-27 15:26:45 +02:00
f.write(f.type_to_str(ktyp))
f.write(']')
2020-05-27 15:26:45 +02:00
f.write(f.type_to_str(vtyp))
f.write('{}')
return
}
2020-02-22 14:13:19 +01:00
f.writeln('{')
f.indent++
2020-06-18 20:07:48 +02:00
for i, key in node.keys {
2020-02-22 14:13:19 +01:00
f.expr(key)
// f.write(strings.repeat(` `, max - field.name.len))
f.write(': ')
2020-06-18 20:07:48 +02:00
f.expr(node.vals[i])
2020-02-22 14:13:19 +01:00
f.writeln('')
}
f.indent--
f.write('}')
}
2020-02-29 20:43:15 +01:00
ast.MatchExpr {
2020-06-18 20:07:48 +02:00
f.match_expr(node)
2020-02-29 20:43:15 +01:00
}
2020-02-21 17:52:20 +01:00
ast.None {
f.write('none')
}
2020-04-25 17:49:16 +02:00
ast.OrExpr {
// shouldn't happen, an or expression
// is always linked to a call expr
panic('fmt: OrExpr should to linked to CallExpr')
}
ast.ParExpr {
2020-02-28 14:41:19 +01:00
f.write('(')
f.par_level++
2020-06-18 20:07:48 +02:00
f.expr(node.expr)
f.par_level--
2020-02-28 14:41:19 +01:00
f.write(')')
}
2020-02-17 22:50:04 +01:00
ast.PostfixExpr {
2020-06-18 20:07:48 +02:00
f.expr(node.expr)
f.write(node.op.str())
2020-02-17 22:50:04 +01:00
}
ast.PrefixExpr {
2020-06-18 20:07:48 +02:00
f.write(node.op.str())
f.expr(node.right)
2020-02-17 22:50:04 +01:00
}
2020-02-29 17:45:08 +01:00
ast.RangeExpr {
2020-06-18 20:07:48 +02:00
f.expr(node.low)
2020-02-29 17:45:08 +01:00
f.write('..')
2020-06-18 20:07:48 +02:00
f.expr(node.high)
2020-02-29 17:45:08 +01:00
}
2020-02-17 22:50:04 +01:00
ast.SelectorExpr {
2020-06-18 20:07:48 +02:00
f.expr(node.expr)
2020-02-17 22:50:04 +01:00
f.write('.')
2020-06-18 20:07:48 +02:00
f.write(node.field_name)
2020-02-17 22:50:04 +01:00
}
2020-04-07 18:51:39 +02:00
ast.SizeOf {
2020-04-10 00:30:43 +02:00
f.write('sizeof(')
2020-06-18 20:07:48 +02:00
if node.type_name != '' {
f.write(node.type_name)
2020-04-07 18:51:39 +02:00
} else {
2020-06-18 20:07:48 +02:00
f.write(f.type_to_str(node.typ))
2020-04-07 18:51:39 +02:00
}
2020-04-10 00:30:43 +02:00
f.write(')')
2020-04-07 18:51:39 +02:00
}
2020-06-16 12:23:52 +02:00
ast.SqlExpr {}
2020-02-17 22:50:04 +01:00
ast.StringLiteral {
2020-06-18 20:07:48 +02:00
if node.is_raw {
2020-05-27 03:10:47 +02:00
f.write('r')
}
2020-06-18 20:07:48 +02:00
if node.val.contains("'") && !node.val.contains('"') {
f.write('"$node.val"')
2020-04-05 19:35:10 +02:00
} else {
2020-06-18 20:07:48 +02:00
f.write("'$node.val'")
2020-04-05 19:35:10 +02:00
}
2020-02-17 22:50:04 +01:00
}
ast.StringInterLiteral {
// TODO: this code is very similar to ast.Expr.str()
mut contains_single_quote := false
2020-06-18 20:07:48 +02:00
for val in node.vals {
if val.contains("'") {
contains_single_quote = true
}
if val.contains('"') {
contains_single_quote = false
break
}
}
if contains_single_quote {
f.write('"')
} else {
f.write("'")
}
f.is_inside_interp = true
2020-06-18 20:07:48 +02:00
for i, val in node.vals {
f.write(val)
2020-06-18 20:07:48 +02:00
if i >= node.exprs.len {
break
}
f.write('$')
2020-06-18 20:07:48 +02:00
fspec_str, needs_braces := node.get_fspec_braces(i)
if needs_braces {
f.write('{')
2020-06-18 20:07:48 +02:00
f.expr(node.exprs[i])
f.write(fspec_str)
f.write('}')
2020-04-05 18:03:36 +02:00
} else {
2020-06-18 20:07:48 +02:00
f.expr(node.exprs[i])
}
}
f.is_inside_interp = false
if contains_single_quote {
f.write('"')
} else {
f.write("'")
}
}
2020-02-17 22:50:04 +01:00
ast.StructInit {
2020-06-18 20:07:48 +02:00
f.struct_init(node)
2020-02-17 22:50:04 +01:00
}
2020-04-05 02:08:10 +02:00
ast.Type {
2020-06-18 20:07:48 +02:00
f.write(f.type_to_str(node.typ))
2020-04-05 02:08:10 +02:00
}
2020-04-03 11:59:53 +02:00
ast.TypeOf {
f.write('typeof(')
2020-06-18 20:07:48 +02:00
f.expr(node.expr)
2020-04-03 11:59:53 +02:00
f.write(')')
}
ast.Likely {
2020-06-18 20:07:48 +02:00
if node.is_likely {
f.write('_likely_')
} else {
f.write('_unlikely_')
}
f.write('(')
2020-06-18 20:07:48 +02:00
f.expr(node.expr)
f.write(')')
}
2020-02-17 22:50:04 +01:00
}
}
2019-12-22 02:34:37 +01:00
pub fn (mut f Fmt) wrap_long_line(penalty int, add_indent bool) bool {
if f.line_len <= max_len[penalty] {
2020-04-25 17:49:16 +02:00
return false
}
if f.out.buf[f.out.buf.len - 1] == ` ` {
f.out.go_back(1)
2020-02-21 16:14:15 +01:00
}
2020-06-24 14:35:00 +02:00
f.write('\n' + tabs[f.indent + if add_indent {
1
} else {
0
}])
2020-04-25 17:49:16 +02:00
f.line_len = 0
return true
2020-02-21 16:14:15 +01:00
}
2020-03-02 17:09:45 +01:00
pub fn (mut f Fmt) call_args(args []ast.CallArg) {
2020-03-02 17:09:45 +01:00
for i, arg in args {
if arg.is_mut {
2020-03-02 17:09:45 +01:00
f.write('mut ')
}
if i > 0 {
f.wrap_long_line(2, true)
2020-03-02 17:09:45 +01:00
}
f.expr(arg.expr)
2020-03-02 17:09:45 +01:00
if i < args.len - 1 {
if f.is_inside_interp {
f.write(',')
} else {
f.write(', ')
}
2020-03-02 17:09:45 +01:00
}
}
}
pub fn (mut f Fmt) or_expr(or_block ast.OrExpr) {
2020-05-23 08:51:15 +02:00
match or_block.kind {
.absent {}
.block {
f.writeln(' or {')
f.stmts(or_block.stmts)
f.write('}')
}
.propagate {
f.write('?')
}
2020-03-02 17:09:45 +01:00
}
}
2020-04-05 02:08:10 +02:00
pub fn (mut f Fmt) comment(node ast.Comment) {
2020-04-05 02:08:10 +02:00
if !node.text.contains('\n') {
2020-04-05 16:38:29 +02:00
is_separate_line := node.text.starts_with('|')
mut s := if is_separate_line { node.text[1..] } else { node.text }
if s == '' {
s = '//'
2020-04-05 16:38:29 +02:00
} else {
s = '// ' + s
}
if !is_separate_line {
f.remove_new_line() // delete the generated \n
f.write(' ')
2020-04-05 16:38:29 +02:00
}
f.writeln(s)
2020-04-05 02:08:10 +02:00
return
}
lines := node.text.split_into_lines()
f.writeln('/*')
for line in lines {
f.writeln(line)
2020-04-05 19:35:10 +02:00
f.empty_line = false
2020-04-05 02:08:10 +02:00
}
2020-04-25 17:49:16 +02:00
f.empty_line = true
2020-04-05 02:08:10 +02:00
f.writeln('*/')
}
pub fn (mut f Fmt) fn_decl(node ast.FnDecl) {
2020-04-25 17:49:16 +02:00
// println('$it.name find_comment($it.pos.line_nr)')
// f.find_comment(it.pos.line_nr)
s := node.str(f.table)
f.write(s.replace(f.cur_mod + '.', '')) // `Expr` instead of `ast.Expr` in mod ast
if node.language == .v {
2020-04-25 17:49:16 +02:00
f.writeln(' {')
f.stmts(node.stmts)
f.write('}')
if !node.is_anon {
f.writeln('\n')
}
} else {
f.writeln('\n')
}
// Mark all function's used type so that they are not removed from imports
for arg in node.args {
f.mark_types_module_as_used(arg.typ)
}
f.mark_types_module_as_used(node.return_type)
}
// foo.bar.fn() => bar.fn()
pub fn (mut f Fmt) short_module(name string) string {
if !name.contains('.') {
return name
}
vals := name.split('.')
if vals.len < 2 {
return name
}
mname := vals[vals.len - 2]
symname := vals[vals.len - 1]
aname := f.mod2alias[mname]
if aname == '' {
return symname
}
2020-06-18 20:07:48 +02:00
return '${aname}.$symname'
2020-04-05 18:03:36 +02:00
}
pub fn (mut f Fmt) if_expr(it ast.IfExpr) {
2020-06-24 14:35:00 +02:00
single_line := it.branches.len == 2 && it.has_else &&
it.branches[0].stmts.len == 1 &&
it.branches[1].stmts.len == 1 &&
(it.is_expr || f.is_assign)
2020-04-05 18:03:36 +02:00
f.single_line_if = single_line
for i, branch in it.branches {
if branch.comment.text != '' {
f.comment(branch.comment)
}
2020-04-05 18:03:36 +02:00
if i == 0 {
f.write('if ')
f.expr(branch.cond)
f.write(' {')
} else if i < it.branches.len - 1 || !it.has_else {
f.write('} else if ')
f.expr(branch.cond)
f.write(' {')
} else if i == it.branches.len - 1 && it.has_else {
f.write('} else {')
}
2020-04-05 19:35:10 +02:00
if single_line {
f.write(' ')
} else {
f.writeln('')
}
2020-04-05 18:03:36 +02:00
f.stmts(branch.stmts)
if single_line {
f.write(' ')
}
}
f.write('}')
f.single_line_if = false
}
pub fn (mut f Fmt) call_expr(node ast.CallExpr) {
2020-05-24 04:43:00 +02:00
/*
if node.args.len == 1 && node.expected_arg_types.len == 1 && node.args[0].expr is ast.StructInit &&
node.args[0].typ == node.expected_arg_types[0] {
// struct_init := node.args[0].expr as ast.StructInit
// if struct_init.typ == node.args[0].typ {
f.use_short_fn_args = true
// }
}
*/
if node.is_method {
2020-06-06 16:05:16 +02:00
/*
// x.foo!() experiment
mut is_mut := false
if node.left is ast.Ident {
scope := f.file.scope.innermost(node.pos.pos)
x := node.left as ast.Ident
var := scope.find_var(x.name) or {
panic(err)
}
println(var.typ)
if var.typ != 0 {
sym := f.table.get_type_symbol(var.typ)
if method := f.table.type_find_method(sym, node.name) {
is_mut = method.args[0].is_mut
}
}
}
*/
2020-04-25 17:49:16 +02:00
if node.left is ast.Ident {
it := node.left as ast.Ident
// `time.now()` without `time imported` is processed as a method call with `time` being
// a `node.left` expression. Import `time` automatically.
// TODO fetch all available modules
if it.name in ['time', 'os', 'strings', 'math', 'json', 'base64'] {
if it.name !in f.auto_imports {
2020-04-25 17:49:16 +02:00
f.auto_imports << it.name
f.file.imports << ast.Import{
mod: it.name
alias: it.name
}
}
2020-04-25 17:49:16 +02:00
// for imp in f.file.imports {
// println(imp.mod)
// }
}
}
f.expr(node.left)
f.write('.' + node.name + '(')
f.call_args(node.args)
f.write(')')
2020-06-06 16:52:41 +02:00
// if is_mut {
// f.write('!')
// }
f.or_expr(node.or_block)
} else {
f.write_language_prefix(node.language)
name := f.short_module(node.name)
2020-04-13 15:05:51 +02:00
f.mark_module_as_used(name)
2020-06-18 20:07:48 +02:00
f.write('$name')
2020-05-21 18:36:25 +02:00
if node.generic_type != 0 && node.generic_type != table.void_type {
f.write('<')
f.write(f.type_to_str(node.generic_type))
f.write('>')
}
f.write('(')
f.call_args(node.args)
f.write(')')
f.or_expr(node.or_block)
}
2020-05-24 04:43:00 +02:00
f.use_short_fn_args = false
}
2020-04-13 15:05:51 +02:00
pub fn (mut f Fmt) match_expr(it ast.MatchExpr) {
2020-04-17 20:51:16 +02:00
f.write('match ')
if it.is_mut {
f.write('mut ')
2020-04-17 20:51:16 +02:00
}
f.expr(it.cond)
2020-06-18 20:07:48 +02:00
if it.cond is ast.Ident {
ident := it.cond as ast.Ident
f.it_name = ident.name
2020-06-19 11:46:08 +02:00
} else if it.cond is ast.SelectorExpr {
// `x.y as z`
// if ident.name != it.var_name && it.var_name != '' {
if it.var_name != '' {
f.write(' as $it.var_name')
}
2020-06-18 20:07:48 +02:00
}
2020-04-17 20:51:16 +02:00
f.writeln(' {')
f.indent++
mut single_line := true
for branch in it.branches {
2020-04-17 20:51:16 +02:00
if branch.stmts.len > 1 {
single_line = false
break
}
if branch.stmts.len == 0 {
continue
}
stmt := branch.stmts[0]
if stmt is ast.ExprStmt {
// If expressions inside match branches can't be one a single line
expr_stmt := stmt as ast.ExprStmt
if !expr_is_single_line(expr_stmt.expr) {
single_line = false
break
}
2020-04-25 17:49:16 +02:00
} else if stmt is ast.Comment {
single_line = false
break
}
2020-04-17 20:51:16 +02:00
}
for branch in it.branches {
2020-04-17 20:51:16 +02:00
if branch.comment.text != '' {
f.comment(branch.comment)
}
if !branch.is_else {
// normal branch
for j, expr in branch.exprs {
f.expr(expr)
if j < branch.exprs.len - 1 {
f.write(', ')
}
}
} else {
// else branch
f.write('else')
}
if branch.stmts.len == 0 {
f.writeln(' {}')
} else {
if single_line {
f.write(' { ')
} else {
f.writeln(' {')
}
f.stmts(branch.stmts)
if single_line {
f.remove_new_line()
f.writeln(' }')
} else {
f.writeln('}')
}
}
}
f.indent--
f.write('}')
2020-06-18 20:07:48 +02:00
f.it_name = ''
2020-04-17 20:51:16 +02:00
}
pub fn (mut f Fmt) remove_new_line() {
mut i := 0
2020-06-18 20:07:48 +02:00
for i = f.out.len - 1; i >= 0; i--
{
if !f.out.buf[i].is_space() { // != `\n` {
2020-04-17 20:51:16 +02:00
break
}
}
f.out.go_back(f.out.len - i - 1)
f.empty_line = false
// f.writeln('sdf')
}
pub fn (mut f Fmt) mark_types_module_as_used(typ table.Type) {
2020-04-13 15:05:51 +02:00
sym := f.table.get_type_symbol(typ)
f.mark_module_as_used(sym.name)
}
// `name` is a function (`foo.bar()`) or type (`foo.Bar{}`)
pub fn (mut f Fmt) mark_module_as_used(name string) {
2020-04-13 15:05:51 +02:00
if !name.contains('.') {
return
}
pos := name.last_index('.') or {
0
}
mod := name[..pos]
if mod in f.used_imports {
return
}
f.used_imports << mod
// println('marking module $mod as used')
}
fn (mut f Fmt) write_language_prefix(lang table.Language) {
match lang {
2020-06-06 12:43:35 +02:00
.c { f.write('C.') }
.js { f.write('JS.') }
else {}
}
}
fn expr_is_single_line(expr ast.Expr) bool {
match expr {
ast.IfExpr { return false }
else {}
}
return true
}
pub fn (mut f Fmt) array_init(it ast.ArrayInit) {
if it.exprs.len == 0 && it.typ != 0 && it.typ != table.void_type {
// `x := []string`
typ_sym := f.table.get_type_symbol(it.typ)
if typ_sym.kind == .array && typ_sym.name.starts_with('array_map') {
ainfo := typ_sym.info as table.Array
map_typ_sym := f.table.get_type_symbol(ainfo.elem_type)
minfo := map_typ_sym.info as table.Map
mk := f.table.get_type_symbol(minfo.key_type).name
mv := f.table.get_type_symbol(minfo.value_type).name
for _ in 0 .. ainfo.nr_dims {
f.write('[]')
}
2020-06-18 20:07:48 +02:00
f.write('map[$mk]$mv')
f.write('{')
if it.has_len {
f.write('len: ')
f.expr(it.len_expr)
}
if it.has_cap {
f.write('cap: ')
f.expr(it.cap_expr)
}
if it.has_default {
2020-05-13 22:00:24 +02:00
f.write('init: ')
f.expr(it.default_expr)
}
f.write('}')
return
}
f.write(f.type_to_str(it.typ))
2020-04-29 12:20:22 +02:00
f.write('{')
// TODO copypasta
if it.has_len {
f.write('len: ')
f.expr(it.len_expr)
if it.has_cap || it.has_default {
f.write(', ')
}
}
2020-04-29 12:20:22 +02:00
if it.has_cap {
f.write('cap: ')
f.expr(it.cap_expr)
if it.has_default {
f.write(', ')
}
}
if it.has_default {
2020-05-13 22:00:24 +02:00
f.write('init: ')
f.expr(it.default_expr)
2020-04-29 12:20:22 +02:00
}
f.write('}')
return
}
// `[1,2,3]`
// type_sym := f.table.get_type_symbol(it.typ)
f.write('[')
mut inc_indent := false
mut last_line_nr := it.pos.line_nr // to have the same newlines between array elements
for i, expr in it.exprs {
mut penalty := 3
line_nr := expr.position().line_nr
if last_line_nr < line_nr {
penalty--
}
2020-06-24 14:35:00 +02:00
if i == 0 || it.exprs[i - 1] is ast.ArrayInit ||
it.exprs[i - 1] is ast.StructInit ||
it.exprs[i - 1] is ast.MapInit ||
it.exprs[i - 1] is ast.CallExpr {
penalty--
}
2020-06-24 14:35:00 +02:00
if expr is ast.ArrayInit ||
expr is ast.StructInit || expr is ast.MapInit ||
expr is ast.CallExpr {
penalty--
}
is_new_line := f.wrap_long_line(penalty, !inc_indent)
if is_new_line && !inc_indent {
f.indent++
inc_indent = true
}
if !is_new_line && i > 0 {
f.write(' ')
}
f.expr(expr)
if i == it.exprs.len - 1 {
if is_new_line {
f.writeln('')
}
} else {
f.write(',')
}
last_line_nr = line_nr
}
if inc_indent {
f.indent--
}
f.write(']')
2020-05-18 16:52:09 +02:00
// `[100]byte`
if it.is_fixed {
f.write(f.type_to_str(it.elem_type))
}
}
pub fn (mut f Fmt) struct_init(it ast.StructInit) {
type_sym := f.table.get_type_symbol(it.typ)
// f.write('<old name: $type_sym.name>')
mut name := f.short_module(type_sym.name).replace(f.cur_mod + '.', '') // TODO f.type_to_str?
if name == 'void' {
name = ''
}
if it.fields.len == 0 {
// `Foo{}` on one line if there are no fields
f.write('$name{}')
} else if it.is_short {
// `Foo{1,2,3}` (short syntax )
// if name != '' {
f.write('$name{')
// }
for i, field in it.fields {
f.struct_field_expr(field.expr)
if i < it.fields.len - 1 {
f.write(', ')
}
}
f.write('}')
} else {
2020-05-24 04:43:00 +02:00
if f.use_short_fn_args {
f.writeln('')
} else {
f.writeln('$name{')
}
f.indent++
for field in it.fields {
f.write('$field.name: ')
f.struct_field_expr(field.expr)
f.writeln('')
}
f.indent--
2020-05-24 04:43:00 +02:00
if !f.use_short_fn_args {
f.write('}')
}
}
}
2020-05-12 00:09:59 +02:00
pub fn (mut f Fmt) const_decl(it ast.ConstDecl) {
2020-05-12 00:09:59 +02:00
if it.is_pub {
f.write('pub ')
}
f.writeln('const (')
mut max := 0
for field in it.fields {
if field.name.len > max {
max = field.name.len
}
}
f.indent++
for field in it.fields {
comments := field.comments
mut j := 0
for j < comments.len && comments[j].pos.pos < field.pos.pos {
f.comment(comments[j])
j++
2020-05-12 00:09:59 +02:00
}
name := field.name.after('.')
f.write('$name ')
f.write(strings.repeat(` `, max - field.name.len))
f.write('= ')
f.expr(field.expr)
f.writeln('')
}
f.indent--
f.writeln(')\n')
}