v3: extend baseline part2 #9

@@ -151,6 +151,7 @@ pub:

151151 children_count i16

152152 kind NodeKind

153153 op Op

154+ is_mut bool

154155}

155156

156157// FlatAst represents flat ast data used by flat.

@@ -237,6 +238,7 @@ pub fn (n Node) with_shifted_children(shift i32) Node {

237238 children_count: n.children_count

238239 kind: n.kind

239240 op: n.op

241+ is_mut: n.is_mut

240242 }

241243}

242244

@@ -32,6 +32,7 @@ mut:

3232 global_init_order []string // qualified global names, in declaration order

3333 iface_impls map[string][]string // interface name -> implementing concrete type names

3434 iface_type_ids map[string]int // "${iface}::${concrete}" -> 1-based type id

35+ ierror_method_emit_names map[string]bool // names/lowered names of concrete IError msg/code methods

3536 module_init_fns []string // C names of module-level `init()` fns, in source order

3637 module_init_fn_modules map[string]string // C init fn name -> V module name

3738 module_imports map[string][]string // module -> imported modules

@@ -134,6 +135,7 @@ pub fn FlatGen.new() FlatGen {

134135 global_init_order: []string{}

135136 iface_impls: map[string][]string{}

136137 iface_type_ids: map[string]int{}

138+ ierror_method_emit_names: map[string]bool{}

137139 module_init_fns: []string{}

138140 module_init_fn_modules: map[string]string{}

139141 module_imports: map[string][]string{}

@@ -221,6 +223,7 @@ pub fn (mut g FlatGen) gen_with_used_options(a &flat.FlatAst, used_fns map[strin

221223 g.global_init_order = []string{}

222224 g.iface_impls = map[string][]string{}

223225 g.iface_type_ids = map[string]int{}

226+ g.ierror_method_emit_names = map[string]bool{}

224227 g.module_init_fns = []string{}

225228 g.module_init_fn_modules = map[string]string{}

226229 g.module_imports = map[string][]string{}

@@ -2066,6 +2069,11 @@ fn (mut g FlatGen) gen_expr_with_expected_type(id flat.NodeId, expected types.Ty

20662069 g.expected_enum = old_expected_enum

20672070 return

20682071 }

2072+ if g.gen_sum_constructor_call_with_expected_type(id, node, expected) {

2073+ g.expected_expr_type = old_expected

2074+ g.expected_enum = old_expected_enum

2075+ return

2076+ }

20692077 if g.gen_sum_value_expr(id, expected) {

20702078 g.expected_expr_type = old_expected

20712079 g.expected_enum = old_expected_enum

@@ -2076,6 +2084,45 @@ fn (mut g FlatGen) gen_expr_with_expected_type(id flat.NodeId, expected types.Ty

20762084 g.expected_enum = old_expected_enum

20772085}

20782086

2087+fn (mut g FlatGen) gen_sum_constructor_call_with_expected_type(id flat.NodeId, node flat.Node, expected types.Type) bool {

2088+ _ = id

2089+ sum_type0 := if expected is types.Alias { expected.base_type } else { expected }

2090+ if sum_type0 !is types.SumType || node.kind != .call || node.children_count < 2 {

2091+ return false

2092+ }

2093+ sum_type := sum_type0 as types.SumType

2094+ callee := g.a.child_node(&node, 0)

2095+ if !g.call_callee_names_sum_base(callee, sum_type.name) {

2096+ return false

2097+ }

2098+ g.gen_sum_cast_expr(sum_type, g.a.child(&node, 1))

2099+ return true

2100+}

2101+

2102+fn (g &FlatGen) call_callee_names_sum_base(callee flat.Node, sum_name string) bool {

2103+ _ = g

2104+ base := generic_sum_base_name(sum_name)

2105+ short_base := base.all_after_last('.')

2106+ if callee.kind == .ident {

2107+ return callee.value == base || callee.value == short_base

2108+ }

2109+ if callee.kind == .selector {

2110+ return callee.value == short_base || callee.value == base

2111+ }

2112+ if callee.kind == .index && callee.children_count > 0 {

2113+ return g.call_callee_names_sum_base(g.a.child_node(&callee, 0), sum_name)

2114+ }

2115+ return false

2116+}

2117+

2118+fn generic_sum_base_name(name string) string {

2119+ bracket := name.index_u8(`[`)

2120+ if bracket > 0 {

2121+ return name[..bracket]

2122+ }

2123+ return name

2124+}

2125+

20792126// gen_sum_value_expr emits sum value expr output for c.

20802127fn (mut g FlatGen) gen_sum_value_expr(id flat.NodeId, expected types.Type) bool {

20812128 sum_type0 := if expected is types.Alias { expected.base_type } else { expected }

@@ -2432,7 +2479,7 @@ fn (g &FlatGen) const_ref_name(name string) string {

24322479 }

24332480 if name in g.const_vals {

24342481 mod := g.const_modules[name] or { '' }

2435- if mod.len == 0 || mod == g.tc.cur_module

2482+ if mod.len == 0 || mod == g.tc.cur_module || mod == 'builtin'

24362483 || (g.tc.cur_module in ['', 'main', 'builtin'] && mod in ['', 'main', 'builtin']) {

24372484 return g.const_primary_name(name)

24382485 }

@@ -2659,7 +2706,7 @@ fn (g &FlatGen) const_ident_c_name(name string) string {

26592706 return c_name(name)

26602707 }

26612708 mod := if name in g.const_modules { g.const_modules[name] } else { '' }

2662- if mod.len > 0 && mod != 'main' && mod != 'builtin' {

2709+ if mod.len > 0 && mod != 'main' {

26632710 return c_name('${mod}.${name}')

26642711 }

26652712 if (mod == '' || mod == 'main') && name in g.const_modules {

@@ -3557,7 +3604,8 @@ fn (mut g FlatGen) gen_expr(id flat.NodeId) {

35573604 .is_expr {

35583605 expr_id := g.a.child(&node, 0)

35593606 expr_type := g.tc.resolve_type(expr_id)

3560- clean := types.unwrap_pointer(expr_type)

3607+ clean0 := types.unwrap_pointer(expr_type)

3608+ clean := if clean0 is types.Alias { clean0.base_type } else { clean0 }

35613609 if clean is types.SumType {

35623610 idx := g.sum_type_index(clean.name, node.value)

35633611 g.write('(')

@@ -3569,6 +3617,40 @@ fn (mut g FlatGen) gen_expr(id flat.NodeId) {

35693617 g.write('.typ == ${idx}')

35703618 }

35713619 g.write(')')

3620+ } else if clean is types.Interface {

3621+ idx := if g.is_ierror_type_name(clean.name) {

3622+ g.ierror_type_id_for_pattern(node.value)

3623+ } else {

3624+ g.iface_type_id_for_pattern(clean.name, node.value)

3625+ }

3626+ if idx == 0 {

3627+ g.write('0')

3628+ return

3629+ }

3630+ g.write('(')

3631+ if expr_type.is_pointer() {

3632+ g.gen_expr(expr_id)

3633+ g.write('->_typ == ${idx}')

3634+ } else {

3635+ g.gen_expr(expr_id)

3636+ g.write('._typ == ${idx}')

3637+ }

3638+ g.write(')')

3639+ } else if g.is_ierror_type_name(types.Type(clean).name()) {

3640+ idx := g.ierror_type_id_for_pattern(node.value)

3641+ if idx == 0 {

3642+ g.write('0')

3643+ return

3644+ }

3645+ g.write('(')

3646+ if expr_type.is_pointer() {

3647+ g.gen_expr(expr_id)

3648+ g.write('->_typ == ${idx}')

3649+ } else {

3650+ g.gen_expr(expr_id)

3651+ g.write('._typ == ${idx}')

3652+ }

3653+ g.write(')')

35723654 } else {

35733655 g.write('1')

35743656 }

@@ -183,6 +183,9 @@ fn (mut g FlatGen) should_emit_fn_node_in_module(node flat.Node, node_index int,

183183 if node.value.starts_with('__anon_fn_') || qfn.contains('__anon_fn_') {

184184 return true

185185 }

186+ if g.should_emit_ierror_method(node.value, qfn) {

187+ return true

188+ }

186189 if g.has_used_fn_filter() && !g.used_fn_contains_in_module(node.value, module_name) {

187190 return false

188191 }

@@ -185,24 +185,26 @@ fn (mut g FlatGen) collect_fn_gen_items() []FlatFnGenItem {

185185 mut cur_file := ''

186186 for i in 0 .. g.a.nodes.len {

187187 node := g.a.nodes[i]

188- kind_id := node_kind_id(node)

189- if kind_id == 77 {

190- cur_file = node.value

191- g.tc.cur_file = cur_file

192- cur_module = ''

193- g.tc.cur_module = cur_module

194- continue

195- }

196- if kind_id == 73 {

197- cur_module = node.value

198- g.tc.cur_file = cur_file

199- g.tc.cur_module = cur_module

200- continue

188+ match node.kind {

189+ .file {

190+ cur_file = node.value

191+ g.tc.cur_file = cur_file

192+ cur_module = ''

193+ g.tc.cur_module = cur_module

194+ continue

195+ }

196+ .module_decl {

197+ cur_module = node.value

198+ g.tc.cur_file = cur_file

199+ g.tc.cur_module = cur_module

200+ continue

201+ }

202+ .fn_decl {}

203+ else {

204+ continue

205+ }

201206 }

202207

203- if kind_id != 61 {

204- continue

205- }

206208 if !g.should_emit_fn_node_in_module(node, i, cur_module) {

207209 continue

208210 }

@@ -241,6 +243,9 @@ fn (mut g FlatGen) prepare_parallel_items(items []FlatFnGenItem) {

241243 g.tc.cur_module = item.module

242244 g.prepare_parallel_node(item.node_id)

243245 }

246+ if _ := g.ierror_interface_name() {

247+ g.intern_string('')

248+ }

244249 g.register_interface_strings()

245250}

246251

@@ -374,6 +379,7 @@ fn (g &FlatGen) new_parallel_worker(worker_id int) &FlatGen {

374379 global_init_order: g.global_init_order

375380 iface_impls: g.iface_impls

376381 iface_type_ids: g.iface_type_ids

382+ ierror_method_emit_names: g.ierror_method_emit_names

377383 module_init_fns: g.module_init_fns

378384 module_init_fn_modules: g.module_init_fn_modules

379385 module_imports: g.module_imports

@@ -431,58 +437,60 @@ fn (g &FlatGen) clone_parallel_type_checker() &types.TypeChecker {

431437 fs.names = g.tc.file_scope.names.clone()

432438 fs.types = g.tc.file_scope.types.clone()

433439 return &types.TypeChecker{

434- a: unsafe { g.tc.a }

435- fn_ret_types: g.tc.fn_ret_types

436- fn_param_types: g.tc.fn_param_types

437- fn_ret_type_texts: g.tc.fn_ret_type_texts

438- fn_param_type_texts: g.tc.fn_param_type_texts

439- fn_type_files: g.tc.fn_type_files

440- fn_type_modules: g.tc.fn_type_modules

441- fn_variadic: g.tc.fn_variadic

442- fn_implicit_veb_ctx: g.tc.fn_implicit_veb_ctx

443- c_variadic_fns: g.tc.c_variadic_fns

444- structs: g.tc.structs

445- struct_generic_params: g.tc.struct_generic_params

446- struct_field_c_abi_fns: g.tc.struct_field_c_abi_fns

447- unions: g.tc.unions

448- type_aliases: g.tc.type_aliases

449- type_alias_c_abi_fns: g.tc.type_alias_c_abi_fns

450- sum_types: g.tc.sum_types

451- enum_names: g.tc.enum_names

452- enum_fields: g.tc.enum_fields

453- flag_enums: g.tc.flag_enums

454- interface_names: g.tc.interface_names

455- interface_fields: g.tc.interface_fields

456- interface_embeds: g.tc.interface_embeds

457- interface_abstract_methods: g.tc.interface_abstract_methods

458- c_globals: g.tc.c_globals

459- const_types: g.tc.const_types

460- const_exprs: g.tc.const_exprs

461- const_modules: g.tc.const_modules

462- const_suffixes: g.tc.const_suffixes

463- imports: g.tc.imports

464- file_imports: g.tc.file_imports

465- file_selective_imports: g.tc.file_selective_imports

466- file_modules: g.tc.file_modules

467- file_scope: fs

468- cur_scope: fs

469- scope_pool: []&types.Scope{}

470- has_builtins: g.tc.has_builtins

471- cur_module: g.tc.cur_module

472- cur_file: g.tc.cur_file

473- errors: g.tc.errors.clone()

474- resolved_call_names: g.tc.resolved_call_names

475- resolved_call_set: g.tc.resolved_call_set

476- resolved_fn_value_names: g.tc.resolved_fn_value_names

477- resolved_fn_value_set: g.tc.resolved_fn_value_set

478- expr_type_values: g.tc.expr_type_values

479- expr_type_set: g.tc.expr_type_set

480- checking_nodes: g.tc.checking_nodes

481- diagnose_unknown_calls: g.tc.diagnose_unknown_calls

482- reject_unlowered_map_mutation: g.tc.reject_unlowered_map_mutation

483- diagnostic_files: g.tc.diagnostic_files

484- cur_fn_ret_type: g.tc.cur_fn_ret_type

485- smartcasts: g.tc.smartcasts

440+ a: unsafe { g.tc.a }

441+ fn_ret_types: g.tc.fn_ret_types

442+ fn_param_types: g.tc.fn_param_types

443+ fn_ret_type_texts: g.tc.fn_ret_type_texts

444+ fn_param_type_texts: g.tc.fn_param_type_texts

445+ fn_type_files: g.tc.fn_type_files

446+ fn_type_modules: g.tc.fn_type_modules

447+ fn_variadic: g.tc.fn_variadic

448+ fn_implicit_veb_ctx: g.tc.fn_implicit_veb_ctx

449+ c_variadic_fns: g.tc.c_variadic_fns

450+ structs: g.tc.structs

451+ struct_modules: g.tc.struct_modules

452+ struct_files: g.tc.struct_files

453+ struct_error_embeds_shadow_builtin: g.tc.struct_error_embeds_shadow_builtin

454+ struct_generic_params: g.tc.struct_generic_params

455+ struct_field_c_abi_fns: g.tc.struct_field_c_abi_fns

456+ unions: g.tc.unions

457+ type_aliases: g.tc.type_aliases

458+ type_alias_c_abi_fns: g.tc.type_alias_c_abi_fns

459+ sum_types: g.tc.sum_types

460+ enum_names: g.tc.enum_names

461+ enum_fields: g.tc.enum_fields

462+ flag_enums: g.tc.flag_enums

463+ interface_names: g.tc.interface_names

464+ interface_fields: g.tc.interface_fields

465+ interface_embeds: g.tc.interface_embeds

466+ interface_abstract_methods: g.tc.interface_abstract_methods

467+ c_globals: g.tc.c_globals

468+ const_types: g.tc.const_types

469+ const_exprs: g.tc.const_exprs

470+ const_modules: g.tc.const_modules

471+ const_suffixes: g.tc.const_suffixes

472+ imports: g.tc.imports

473+ file_imports: g.tc.file_imports

474+ file_selective_imports: g.tc.file_selective_imports

475+ file_modules: g.tc.file_modules

476+ file_scope: fs

477+ cur_scope: fs

478+ scope_pool: []&types.Scope{}

479+ has_builtins: g.tc.has_builtins

480+ cur_module: g.tc.cur_module

481+ cur_file: g.tc.cur_file

482+ errors: g.tc.errors.clone()

483+ resolved_call_names: g.tc.resolved_call_names

484+ resolved_call_set: g.tc.resolved_call_set

485+ resolved_fn_value_names: g.tc.resolved_fn_value_names

486+ expr_type_values: g.tc.expr_type_values

487+ expr_type_set: g.tc.expr_type_set

488+ checking_nodes: g.tc.checking_nodes

489+ diagnose_unknown_calls: g.tc.diagnose_unknown_calls

490+ reject_unlowered_map_mutation: g.tc.reject_unlowered_map_mutation

491+ diagnostic_files: g.tc.diagnostic_files

492+ cur_fn_ret_type: g.tc.cur_fn_ret_type

493+ smartcasts: g.tc.smartcasts

486494 // Read-only map cgen uses to recover substituted signatures for generic-receiver

487495 // method values (`Box[int].method` as a callback); without it a parallel worker

488496 // sees an empty map and gen_method_value_closure falls through.

@@ -195,6 +195,7 @@ fn (mut g FlatGen) register_interface_strings() {

195195// type id. The id is stored in the boxed interface value's `_typ` field and is

196196// what the generated method-dispatch switch matches on.

197197fn (mut g FlatGen) collect_interface_impls() {

198+ g.ierror_method_emit_names = map[string]bool{}

198199 mut iface_names := []string{}

199200 for name, _ in g.interfaces {

200201 iface_names << name

@@ -206,12 +207,13 @@ fn (mut g FlatGen) collect_interface_impls() {

206207 }

207208 struct_names.sort()

208209 for iface in iface_names {

209- if c_name(iface) == 'IError' {

210- continue

211- }

212210 mut impls := []string{}

213211 for concrete in struct_names {

214- if g.tc.named_type_implements_interface(concrete, iface) {

212+ if g.is_ierror_type_name(iface) {

213+ if g.type_can_box_as_ierror(concrete) {

214+ impls << concrete

215+ }

216+ } else if g.tc.named_type_implements_interface(concrete, iface) {

215217 impls << concrete

216218 }

217219 }

@@ -219,6 +221,29 @@ fn (mut g FlatGen) collect_interface_impls() {

219221 for idx, concrete in impls {

220222 g.iface_type_ids['${iface}::${concrete}'] = idx + 1

221223 }

224+ if g.is_ierror_type_name(iface) {

225+ g.collect_ierror_method_emit_names(impls)

226+ }

227+ }

228+}

229+

230+fn (mut g FlatGen) collect_ierror_method_emit_names(impls []string) {

231+ for concrete in impls {

232+ for method in ['msg', 'code'] {

233+ call := g.ierror_method_call(concrete, method) or { continue }

234+ g.add_ierror_method_emit_name(call.method_name)

235+ }

236+ }

237+}

238+

239+fn (mut g FlatGen) add_ierror_method_emit_name(name string) {

240+ if name.len == 0 {

241+ return

242+ }

243+ g.ierror_method_emit_names[name] = true

244+ lowered := c_name(name)

245+ if lowered != name {

246+ g.ierror_method_emit_names[lowered] = true

222247 }

223248}

224249

@@ -228,12 +253,273 @@ fn (g &FlatGen) iface_type_id(iface string, concrete string) int {

228253 return g.iface_type_ids['${iface}::${concrete}'] or { 0 }

229254}

230255

256+fn (g &FlatGen) iface_type_id_for_pattern(iface string, pattern string) int {

257+ id := g.iface_type_id(iface, pattern)

258+ if id != 0 {

259+ return id

260+ }

261+ qpattern := g.tc.qualify_name(pattern)

262+ if qpattern != pattern {

263+ qid := g.iface_type_id(iface, qpattern)

264+ if qid != 0 {

265+ return qid

266+ }

267+ }

268+ if pattern.contains('.') {

269+ return 0

270+ }

271+ mut found := 0

272+ for concrete in g.iface_impls[iface] or { []string{} } {

273+ if concrete.all_after_last('.') != pattern {

274+ continue

275+ }

276+ cid := g.iface_type_id(iface, concrete)

277+ if cid == 0 {

278+ continue

279+ }

280+ if found != 0 {

281+ return 0

282+ }

283+ found = cid

284+ }

285+ return found

286+}

287+

288+fn (g &FlatGen) ierror_interface_name() ?string {

289+ for name, _ in g.interfaces {

290+ if g.is_ierror_type_name(name) {

291+ return name

292+ }

293+ }

294+ return none

295+}

296+

297+fn (g &FlatGen) is_ierror_type_name(name string) bool {

298+ _ = g

299+ return name == 'IError' || name == 'builtin.IError' || c_name(name) == 'IError'

300+}

301+

302+fn (g &FlatGen) ierror_direct_method_name(concrete string, method string) ?string {

303+ direct := '${concrete}.${method}'

304+ if g.ierror_method_signature_matches(direct, concrete, method) {

305+ return direct

306+ }

307+ qconcrete := g.tc.qualify_name(concrete)

308+ if qconcrete != concrete {

309+ qdirect := '${qconcrete}.${method}'

310+ if g.ierror_method_signature_matches(qdirect, qconcrete, method) {

311+ return qdirect

312+ }

313+ }

314+ return none

315+}

316+

317+fn (g &FlatGen) ierror_method_signature_matches(name string, concrete string, method string) bool {

318+ params := g.tc.fn_param_types[name] or { return false }

319+ if params.len != 1 {

320+ return false

321+ }

322+ ret := g.tc.fn_ret_types[name] or { return false }

323+ if !g.ierror_method_return_matches(method, ret) {

324+ return false

325+ }

326+ receiver := g.ierror_clean_type(params[0])

327+ expected := g.ierror_clean_type(g.tc.parse_type(concrete))

328+ return g.type_names_match(receiver, expected)

329+}

330+

331+fn (g &FlatGen) ierror_method_return_matches(method string, ret types.Type) bool {

332+ clean := if ret is types.Alias { ret.base_type } else { ret }

333+ return match method {

334+ 'msg' { clean is types.String }

335+ 'code' { clean.name() == 'int' }

336+ else { false }

337+ }

338+}

339+

340+fn (g &FlatGen) ierror_clean_type(typ types.Type) types.Type {

341+ clean0 := types.unwrap_pointer(typ)

342+ return if clean0 is types.Alias { clean0.base_type } else { clean0 }

343+}

344+

345+struct IErrorMethodCall {

346+ method_name string

347+ path []types.StructField

348+}

349+

350+fn (g &FlatGen) ierror_method_call(concrete string, method string) ?IErrorMethodCall {

351+ if direct := g.ierror_direct_method_name(concrete, method) {

352+ return IErrorMethodCall{

353+ method_name: direct

354+ }

355+ }

356+ mut seen := map[string]bool{}

357+ return g.ierror_promoted_method_call(concrete, method, mut seen)

358+}

359+

360+fn (g &FlatGen) ierror_promoted_method_call(concrete string, method string, mut seen map[string]bool) ?IErrorMethodCall {

361+ if concrete in seen {

362+ return none

363+ }

364+ seen[concrete] = true

365+ for field in g.struct_embedded_fields(concrete) {

366+ embedded_name := g.embedded_field_type_name(field)

367+ if embedded_name.len == 0 {

368+ continue

369+ }

370+ if direct := g.ierror_direct_method_name(embedded_name, method) {

371+ return IErrorMethodCall{

372+ method_name: direct

373+ path: [field]

374+ }

375+ }

376+ if nested := g.ierror_promoted_method_call(embedded_name, method, mut seen) {

377+ mut path := [field]

378+ path << nested.path

379+ return IErrorMethodCall{

380+ method_name: nested.method_name

381+ path: path

382+ }

383+ }

384+ }

385+ return none

386+}

387+

388+fn (g &FlatGen) ierror_method_receiver_expr(concrete string, path []types.StructField, recv_is_ptr bool) string {

389+ concrete_ct := g.tc.c_type(g.tc.parse_type(concrete))

390+ object := '(${concrete_ct}*)i->_object'

391+ if path.len == 0 {

392+ return if recv_is_ptr { object } else { '*${object}' }

393+ }

394+ mut access := object

395+ mut access_is_ptr := true

396+ for field in path {

397+ op := if access_is_ptr { '->' } else { '.' }

398+ access = '(${access})${op}${c_field_name(field.name)}'

399+ access_is_ptr = field.typ is types.Pointer

400+ }

401+ if access_is_ptr == recv_is_ptr {

402+ return access

403+ }

404+ return if recv_is_ptr { '&(${access})' } else { '*(${access})' }

405+}

406+

407+fn (g &FlatGen) type_can_box_as_ierror(concrete string) bool {

408+ return g.tc.named_type_compatible_with_ierror(concrete)

409+}

410+

411+fn (g &FlatGen) ierror_concrete_name(t types.Type) ?string {

412+ clean0 := types.unwrap_pointer(t)

413+ clean := if clean0 is types.Alias { clean0.base_type } else { clean0 }

414+ if clean !is types.Struct {

415+ return none

416+ }

417+ iface := g.ierror_interface_name() or { return none }

418+ name := (clean as types.Struct).name

419+ if g.iface_type_id(iface, name) != 0 {

420+ return name

421+ }

422+ qname := g.tc.qualify_name(name)

423+ if qname != name && g.iface_type_id(iface, qname) != 0 {

424+ return qname

425+ }

426+ return none

427+}

428+

429+fn (g &FlatGen) ierror_type_id_for_pattern(pattern string) int {

430+ iface := g.ierror_interface_name() or { return 0 }

431+ return g.iface_type_id_for_pattern(iface, pattern)

432+}

433+

434+fn (g &FlatGen) should_emit_ierror_method(name string, qname string) bool {

435+ if name in g.ierror_method_emit_names || qname in g.ierror_method_emit_names {

436+ return true

437+ }

438+ return c_name(qname) in g.ierror_method_emit_names

439+}

440+

441+fn (mut g FlatGen) gen_ierror_from_expr(id flat.NodeId) bool {

442+ s := g.ierror_from_expr_string(id) or { return false }

443+ g.write(s)

444+ return true

445+}

446+

447+fn (mut g FlatGen) ierror_from_expr_string(id flat.NodeId) ?string {

448+ node := g.a.nodes[int(id)]

449+ mut actual := g.usable_expr_type(id)

450+ if node.kind == .ident {

451+ if param_type := g.current_param_type(node.value) {

452+ actual = param_type

453+ } else if param_type := g.cur_param_types[node.value] {

454+ actual = param_type

455+ }

456+ }

457+ return g.ierror_from_expr_string_with_type(id, actual)

458+}

459+

460+fn (mut g FlatGen) ierror_from_expr_string_with_type(id flat.NodeId, actual types.Type) ?string {

461+ node := g.a.nodes[int(id)]

462+ concrete := g.ierror_concrete_name(actual) or { return none }

463+ iface := g.ierror_interface_name() or { return none }

464+ type_id := g.iface_type_id(iface, concrete)

465+ if type_id == 0 {

466+ return none

467+ }

468+ expr := g.expr_to_string(id)

469+ concrete_ct := g.tc.c_type(g.tc.parse_type(concrete))

470+ object := if actual is types.Pointer {

471+ if g.ierror_pointer_payload_needs_heap_copy(node) {

472+ 'memdup(${expr}, sizeof(${concrete_ct}))'

473+ } else {

474+ expr

475+ }

476+ } else {

477+ 'memdup((${concrete_ct}[]){${expr}}, sizeof(${concrete_ct}))'

478+ }

479+ empty_sid := g.intern_string('')

480+ return '(IError){._typ = ${type_id}, ._object = ${object}, .message = _str_${empty_sid}, .code = 0}'

481+}

482+

483+fn (g &FlatGen) ierror_pointer_payload_needs_heap_copy(node flat.Node) bool {

484+ if node.kind != .prefix || node.op != .amp || node.children_count == 0 {

485+ return false

486+ }

487+ mut child_id := g.a.child(&node, 0)

488+ for {

489+ child := g.a.nodes[int(child_id)]

490+ if child.kind !in [.selector, .index] || child.children_count == 0 {

491+ break

492+ }

493+ child_id = g.a.child(&child, 0)

494+ }

495+ root := g.a.nodes[int(child_id)]

496+ if root.kind != .ident {

497+ return false

498+ }

499+ if param_type := g.current_param_type(root.value) {

500+ return param_type !is types.Pointer

501+ }

502+ if param_type := g.cur_param_types[root.value] {

503+ return param_type !is types.Pointer

504+ }

505+ if local_type := g.tc.cur_scope.lookup(root.value) {

506+ return local_type !is types.Pointer

507+ }

508+ return false

509+}

510+

231511fn (mut g FlatGen) gen_interface_value_expr(id flat.NodeId, expected types.Type) bool {

232512 iface_type := if expected is types.Alias { expected.base_type } else { expected }

233513 if iface_type !is types.Interface {

234514 return false

235515 }

236516 iface := iface_type as types.Interface

517+ if g.is_ierror_type_name(iface.name) {

518+ if s := g.ierror_from_expr_string(id) {

519+ g.write(s)

520+ return true

521+ }

522+ }

237523 node := g.a.nodes[int(id)]

238524 mut actual := g.usable_expr_type(id)

239525 if node.kind == .ident {

@@ -300,7 +586,7 @@ fn (g &FlatGen) is_interface_type_name(name string) bool {

300586// has_ierror_interface reports whether has ierror interface applies in c.

301587fn (g &FlatGen) has_ierror_interface() bool {

302588 for name, _ in g.interfaces {

303- if c_name(name) == 'IError' {

589+ if g.is_ierror_type_name(name) {

304590 return true

305591 }

306592 }

@@ -389,6 +675,17 @@ fn (mut g FlatGen) gen_interface_dispatch(iface_name string, cn string, method s

389675 if cn == 'IError' {

390676 ret_ct := if method == 'code' { 'int' } else { 'string' }

391677 g.writeln('${ret_ct} ${cn}__${method}(${cn}* i) {')

678+ for concrete in impls {

679+ id := g.iface_type_id(iface_name, concrete)

680+ call := g.ierror_method_call(concrete, method) or { continue }

681+ if id == 0 {

682+ continue

683+ }

684+ params := g.tc.fn_param_types[call.method_name] or { []types.Type{} }

685+ recv_is_ptr := params.len > 0 && params[0] is types.Pointer

686+ recv := g.ierror_method_receiver_expr(concrete, call.path, recv_is_ptr)

687+ g.writeln('\tif (i->_typ == ${id}) return ${c_name(call.method_name)}(${recv});')

688+ }

392689 match method {

393690 'msg' {

394691 g.writeln('\treturn i->message;')

@@ -250,6 +250,12 @@ fn (mut g FlatGen) gen_node(id flat.NodeId) {

250250 return

251251 }

252252 if base is types.Void {

253+ if g.cur_fn_ret is types.ResultType {

254+ if err := g.result_error_from_expr_string(ret_id) {

255+ g.writeln('return (${ct}){.ok = false, .err = ${err}};')

256+ return

257+ }

258+ }

253259 g.writeln('return (${ct}){.ok = false};')

254260 } else if base is types.ArrayFixed {

255261 // The optional's `.value` is a fixed-array member, which can't be set

@@ -287,11 +293,18 @@ fn (mut g FlatGen) gen_node(id flat.NodeId) {

287293 && !g.type_names_match(expr_value_type, base)

288294 && !g.expr_is_nil_pointer_payload(ret_id, base)

289295 && !g.type_can_wrap_as_sum(expr_value_type, base)

296+ && !g.type_can_wrap_as_ierror_payload(expr_value_type, base)

290297 && !g.types_numeric_compatible(expr_value_type, base)

291298 && !g.call_constructs_type(ret_id, base)

292299 && !g.clone_call_matches_base(ret_node, base)

293300 && expr_value_type !is types.Primitive

294301 && expr_value_type !is types.Unknown {

302+ if g.cur_fn_ret is types.ResultType {

303+ if err := g.result_error_from_expr_string(ret_id) {

304+ g.writeln('return (${ct}){.ok = false, .err = ${err}};')

305+ return

306+ }

307+ }

295308 g.writeln('return (${ct}){.ok = false};')

296309 } else {

297310 g.write('return (${ct}){.ok = true, .value = ')

@@ -350,7 +363,10 @@ fn (mut g FlatGen) gen_node(id flat.NodeId) {

350363 g.gen_expr(ret_id)

351364 }

352365 } else {

353- g.gen_expr(ret_id)

366+ if !g.gen_sum_constructor_call_with_expected_type(ret_id, ret_node,

367+ g.cur_fn_ret) {

368+ g.gen_expr(ret_id)

369+ }

354370 }

355371 g.writeln(';')

356372 }

@@ -550,6 +566,11 @@ fn (mut g FlatGen) return_expr_string(node flat.Node, ret_id flat.NodeId, ret_no

550566 return '(${ct}){.ok = false}'

551567 }

552568 if base is types.Void {

569+ if g.cur_fn_ret is types.ResultType {

570+ if err := g.result_error_from_expr_string(ret_id) {

571+ return '(${ct}){.ok = false, .err = ${err}}'

572+ }

573+ }

553574 return '(${ct}){.ok = false}'

554575 }

555576 if base is types.ArrayFixed {

@@ -586,9 +607,15 @@ fn (mut g FlatGen) return_expr_string(node flat.Node, ret_id flat.NodeId, ret_no

586607 && !g.type_names_match(expr_value_type, base)

587608 && !g.expr_is_nil_pointer_payload(ret_id, base)

588609 && !g.type_can_wrap_as_sum(expr_value_type, base)

610+ && !g.type_can_wrap_as_ierror_payload(expr_value_type, base)

589611 && !g.types_numeric_compatible(expr_value_type, base)

590612 && !g.call_constructs_type(ret_id, base) && !g.clone_call_matches_base(ret_node, base)

591613 && expr_value_type !is types.Primitive && expr_value_type !is types.Unknown {

614+ if g.cur_fn_ret is types.ResultType {

615+ if err := g.result_error_from_expr_string(ret_id) {

616+ return '(${ct}){.ok = false, .err = ${err}}'

617+ }

618+ }

592619 return '(${ct}){.ok = false}'

593620 }

594621 return '(${ct}){.ok = true, .value = ${g.expr_to_string_with_expected_type(ret_id, base)}}'

@@ -612,9 +639,42 @@ fn (mut g FlatGen) return_expr_string(node flat.Node, ret_id flat.NodeId, ret_no

612639 // preserves `_typ`/`_object` instead of zeroing the interface.

613640 return g.interface_value_to_string(ret_id, g.cur_fn_ret)

614641 }

642+ if expr := g.sum_constructor_return_expr_string(ret_id, ret_node, g.cur_fn_ret) {

643+ return expr

644+ }

615645 return g.expr_to_string(ret_id)

616646}

617647

648+fn (mut g FlatGen) sum_constructor_return_expr_string(ret_id flat.NodeId, ret_node flat.Node, expected types.Type) ?string {

649+ sum_type0 := if expected is types.Alias { expected.base_type } else { expected }

650+ if sum_type0 !is types.SumType || ret_node.kind != .call || ret_node.children_count < 2 {

651+ return none

652+ }

653+ sum_type := sum_type0 as types.SumType

654+ callee := g.a.child_node(&ret_node, 0)

655+ if !g.call_callee_names_sum_base(callee, sum_type.name) {

656+ return none

657+ }

658+ return g.expr_to_string_with_expected_type(ret_id, expected)

659+}

660+

661+fn (mut g FlatGen) result_error_from_expr_string(id flat.NodeId) ?string {

662+ if err := g.ierror_from_expr_string(id) {

663+ return err

664+ }

665+ expr_type := g.usable_expr_type(id)

666+ mut expr_value_type := expr_type

667+ if expr_type is types.OptionType {

668+ expr_value_type = expr_type.base_type

669+ } else if expr_type is types.ResultType {

670+ expr_value_type = expr_type.base_type

671+ }

672+ if g.is_ierror_type_name(expr_value_type.name()) {

673+ return g.expr_to_string(id)

674+ }

675+ return none

676+}

677+

618678fn (g &FlatGen) local_fn_call_return_type(call_id flat.NodeId, call_node flat.Node) types.Type {

619679 if call_node.kind != .call || call_node.children_count == 0 {

620680 return types.Type(types.void_)

@@ -1080,6 +1140,23 @@ fn (g &FlatGen) type_can_wrap_as_sum(actual types.Type, expected types.Type) boo

10801140 return variant in variants

10811141}

10821142

1143+fn (g &FlatGen) type_can_wrap_as_ierror_payload(actual types.Type, expected types.Type) bool {

1144+ expected0 := if expected is types.Alias { expected.base_type } else { expected }

1145+ if expected0 !is types.Interface || !g.is_ierror_type_name(expected0.name()) {

1146+ return false

1147+ }

1148+ actual0 := types.unwrap_pointer(actual)

1149+ actual_base := if actual0 is types.Alias { actual0.base_type } else { actual0 }

1150+ if actual_base is types.Interface {

1151+ return false

1152+ }

1153+ concrete := actual_base.name()

1154+ if concrete.len == 0 {

1155+ return false

1156+ }

1157+ return g.type_can_box_as_ierror(concrete)

1158+}

1159+

10831160// types_numeric_compatible supports types numeric compatible handling for FlatGen.

10841161fn (g &FlatGen) types_numeric_compatible(a types.Type, b types.Type) bool {

10851162 _ = g

@@ -45,11 +45,15 @@ fn (mut g FlatGen) gen_string_interp(node flat.Node) {

4545 g.write('.message')

4646 } else if typ is types.Primitive {

4747 prim_name := types.Type(typ).name()

48- g.write('${c_name('${prim_name}.str')}(')

48+ prim_method := prim_name + '.str'

49+ g.write(c_name(prim_method))

50+ g.write('(')

4951 g.gen_expr(child_id)

5052 g.write(')')

5153 } else if typ is types.ISize || typ is types.USize {

52- g.write('${c_name('${typ.name()}.str')}(')

54+ size_method := typ.name() + '.str'

55+ g.write(c_name(size_method))

56+ g.write('(')

5357 g.gen_expr(child_id)

5458 g.write(')')

5559 } else if typ is types.Struct {

@@ -148,7 +148,7 @@ fn mark_used_with_test_files(a &flat.FlatAst, tc &types.TypeChecker, test_files

148148 'string.==', 'string.<', 'string.free', 'string.all_before', 'string.all_before_last',

149149 'string.all_after', 'string.all_after_last', 'string.substr', 'string__substr', 'u8.vstring',

150150 '[]rune.string', 'map.set', 'map.exists', 'map.get', 'map.get_check', 'map.get_and_set',

151- 'map.delete', 'map.clone', 'map.clear', 'memdup', 'strings.Builder.write_ptr',

151+ 'map.delete', 'map.clone', 'map.clear', 'map.keys', 'memdup', 'strings.Builder.write_ptr',

152152 'strings.Builder.write_runes', 'strings.Builder.free', 'strconv.format_int',

153153 'strconv.format_uint', 'bool.str', 'ptr_str', 'strconv__f32_to_str_l',

154154 'strconv__f64_to_str_l', 'sync.new_channel_st', 'sync.Channel.push', 'sync.Channel.pop',

@@ -268,6 +268,10 @@ fn mark_used_with_test_files(a &flat.FlatAst, tc &types.TypeChecker, test_files

268268 if !valid_symbol_name(callee) {

269269 continue

270270 }

271+ if callee == 'string__plus' {

272+ enqueue(callee, mut used, mut queue)

273+ continue

274+ }

271275 mut found_direct := false

272276 if callee_info := fn_decls[callee] {

273277 found_direct = true

@@ -351,7 +355,11 @@ fn ensure_iface_impls(recv string, cur_module string, tc &types.TypeChecker, mut

351355 }

352356 mut impls := []string{}

353357 for struct_name, _ in tc.structs {

354- if tc.named_type_implements_interface(struct_name, iface_name) {

358+ if markused_is_ierror_interface_name(iface_name) {

359+ if tc.named_type_compatible_with_ierror(struct_name) {

360+ impls << struct_name

361+ }

362+ } else if tc.named_type_implements_interface(struct_name, iface_name) {

355363 impls << struct_name

356364 }

357365 }

@@ -378,6 +386,10 @@ fn interface_name_for_receiver(recv string, cur_module string, tc &types.TypeChe

378386 return none

379387}

380388

389+fn markused_is_ierror_interface_name(name string) bool {

390+ return name == 'IError' || name == 'builtin.IError'

391+}

392+

381393// add_suffix_candidate updates add suffix candidate state for markused.

382394fn add_suffix_candidate(mut suffix_map map[string][]string, short string, name string) {

383395 if !valid_symbol_name(short) || !valid_symbol_name(name) {

@@ -969,6 +981,29 @@ fn markused_call_lowers_to_join_path_single(a &flat.FlatAst, fn_node flat.Node,

969981 return base.value == 'os' || imports[base.value] == 'os'

970982}

971983

984+fn markused_type_name_lowers_to_map_str(type_name string, tc &types.TypeChecker) bool {

985+ if markused_clean_map_type(type_name).starts_with('map[') {

986+ return true

987+ }

988+ return markused_type_lowers_to_map_str(tc.parse_type(type_name))

989+}

990+

991+fn markused_type_lowers_to_map_str(typ0 types.Type) bool {

992+ mut typ := typ0

993+ for _ in 0 .. 8 {

994+ if typ is types.Alias {

995+ typ = typ.base_type

996+ continue

997+ }

998+ if typ is types.Pointer {

999+ typ = typ.base_type

1000+ continue

1001+ }

1002+ break

1003+ }

1004+ return typ is types.Map || markused_clean_map_type(typ.name()).starts_with('map[')

1005+}

1006+

9721007// enqueue_stringified_custom_str_method supports enqueue_stringified_custom_str_method handling.

9731008fn enqueue_stringified_custom_str_method(expr_id flat.NodeId, cur_module string, tc &types.TypeChecker, mut used map[string]bool, mut queue []string) {

9741009 mut typ := tc.expr_type(expr_id) or { tc.resolve_type(expr_id) }

@@ -1018,14 +1053,21 @@ fn enqueue_enum_str_method(type_name string, cur_module string, tc &types.TypeCh

10181053// enqueue_structlike_str_method supports enqueue structlike str method handling for markused.

10191054fn enqueue_structlike_str_method(type_name string, cur_module string, tc &types.TypeChecker, mut used map[string]bool, mut queue []string) {

10201055 for candidate in stringification_type_candidates(type_name, cur_module) {

1021- lowered := '${markused_c_name(candidate)}__str'

1022- if lowered in tc.fn_ret_types {

1023- enqueue(lowered, mut used, mut queue)

1024- }

1025- method := '${candidate}.str'

1026- if method in tc.fn_ret_types {

1027- enqueue(method, mut used, mut queue)

1028- }

1056+ enqueue_structlike_str_candidate(candidate, tc, mut used, mut queue)

1057+ }

1058+ for candidate in generic_stringification_type_candidates(type_name, cur_module, tc) {

1059+ enqueue_structlike_str_candidate(candidate, tc, mut used, mut queue)

1060+ }

1061+}

1062+

1063+fn enqueue_structlike_str_candidate(candidate string, tc &types.TypeChecker, mut used map[string]bool, mut queue []string) {

1064+ lowered := '${markused_c_name(candidate)}__str'

1065+ if lowered in tc.fn_ret_types {

1066+ enqueue(lowered, mut used, mut queue)

1067+ }

1068+ method := '${candidate}.str'

1069+ if method in tc.fn_ret_types {

1070+ enqueue(method, mut used, mut queue)

10291071 }

10301072}

10311073

@@ -1043,6 +1085,97 @@ fn stringification_type_candidates(type_name string, cur_module string) []string

10431085 return candidates

10441086}

10451087

1088+fn generic_stringification_type_candidates(type_name string, cur_module string, tc &types.TypeChecker) []string {

1089+ base, args, ok := markused_generic_app_parts(type_name)

1090+ if !ok || args.len == 0 {

1091+ return []string{}

1092+ }

1093+ mut candidates := []string{}

1094+ for base_candidate in stringification_type_candidates(base, cur_module) {

1095+ params := generic_stringification_params(base_candidate, tc) or { continue }

1096+ if params.len != args.len {

1097+ continue

1098+ }

1099+ candidates << '${base_candidate}[${params.join(', ')}]'

1100+ }

1101+ return candidates

1102+}

1103+

1104+fn generic_stringification_params(base_candidate string, tc &types.TypeChecker) ?[]string {

1105+ if params := tc.struct_generic_params[base_candidate] {

1106+ return params

1107+ }

1108+ if params := tc.sum_generic_params[base_candidate] {

1109+ return params

1110+ }

1111+ return none

1112+}

1113+

1114+fn markused_generic_app_parts(typ string) (string, []string, bool) {

1115+ clean := typ.trim_space()

1116+ if clean.starts_with('fn(') || clean.starts_with('fn (') {

1117+ return '', []string{}, false

1118+ }

1119+ bracket := clean.index_u8(`[`)

1120+ if bracket <= 0 {

1121+ return '', []string{}, false

1122+ }

1123+ bracket_end := markused_generic_matching_bracket(clean, bracket)

1124+ if bracket_end <= bracket || bracket_end >= clean.len {

1125+ return '', []string{}, false

1126+ }

1127+ return clean[..bracket], markused_split_generic_args(clean[bracket + 1..bracket_end]), true

1128+}

1129+

1130+fn markused_generic_matching_bracket(s string, start int) int {

1131+ mut depth := 0

1132+ for i in start .. s.len {

1133+ if s[i] == `[` {

1134+ depth++

1135+ } else if s[i] == `]` {

1136+ depth--

1137+ if depth == 0 {

1138+ return i

1139+ }

1140+ }

1141+ }

1142+ return s.len

1143+}

1144+

1145+fn markused_split_generic_args(s string) []string {

1146+ mut args := []string{}

1147+ mut start := 0

1148+ mut bracket_depth := 0

1149+ mut paren_depth := 0

1150+ for i in 0 .. s.len {

1151+ match s[i] {

1152+ `[` {

1153+ bracket_depth++

1154+ }

1155+ `]` {

1156+ bracket_depth--

1157+ }

1158+ `(` {

1159+ paren_depth++

1160+ }

1161+ `)` {

1162+ paren_depth--

1163+ }

1164+ `,` {

1165+ if bracket_depth == 0 && paren_depth == 0 {

1166+ args << s[start..i].trim_space()

1167+ start = i + 1

1168+ }

1169+ }

1170+ else {}

1171+ }

1172+ }

1173+ if start <= s.len {

1174+ args << s[start..].trim_space()

1175+ }

1176+ return args

1177+}

1178+

10461179// enqueue_function_value_selectors supports enqueue function value selectors handling for markused.

10471180fn enqueue_function_value_selectors(a &flat.FlatAst, collector CallCollector, fn_decls map[string]FnDeclInfo, mut used map[string]bool, mut queue []string) {

10481181 ignored_top_level_nodes := markused_ignored_top_level_nodes(a)

@@ -1360,6 +1493,7 @@ fn (c &CallCollector) collect_calls(node &flat.Node, cur_module string, imports

13601493 if resolved := c.tc.resolved_call_name(child_id) {

13611494 resolved_call = resolved

13621495 }

1496+ c.collect_lowered_join_path_single(child, resolved_call, mut calls)

13631497 if child.children_count > 0 {

13641498 callee_id := c.a.child(child, 0)

13651499 if int(callee_id) >= 0 {

@@ -1368,6 +1502,13 @@ fn (c &CallCollector) collect_calls(node &flat.Node, cur_module string, imports

13681502 if resolved_call.len > 0 {

13691503 calls << resolved_call

13701504 }

1505+ if callee.value in ['print', 'println', 'eprint', 'eprintln']

1506+ && child.children_count >= 2 {

1507+ arg_id := c.a.child(child, 1)

1508+ if c.expr_lowers_to_map_str(arg_id, local_values, local_types) {

1509+ calls << 'string__plus'

1510+ }

1511+ }

13711512 if callee.value !in local_values {

13721513 calls << callee.value

13731514 qcallee := qualify_fn(cur_module, callee.value)

@@ -1383,6 +1524,10 @@ fn (c &CallCollector) collect_calls(node &flat.Node, cur_module string, imports

13831524 base := c.a.nodes[int(base_id)]

13841525 has_exact_selector_call = c.collect_checker_selected_call(resolved_call, mut

13851526 calls)

1527+ if callee.value == 'str'

1528+ && c.expr_lowers_to_map_str(base_id, local_values, local_types) {

1529+ calls << 'string__plus'

1530+ }

13861531 if !has_exact_selector_call {

13871532 has_exact_selector_call = c.collect_typed_receiver_method(base_id,

13881533 callee.value, cur_module, imports, local_values,

@@ -1572,7 +1717,8 @@ fn (c &CallCollector) local_value_type_names(node &flat.Node, cur_module string,

15721717 type_name := if child.children_count == 2 && child.typ.len > 0 {

15731718 child.typ

15741719 } else {

1575- c.top_level_decl_rhs_type_name(rhs_id, cur_module, imports)

1720+ c.top_level_decl_rhs_type_name(rhs_id, cur_module, imports,

1721+ map[string]bool{}, result)

15761722 }

15771723 if type_name.len > 0 {

15781724 result[lhs.value] = type_name

@@ -1711,13 +1857,14 @@ fn markused_mark_visible_local_ident(a &flat.FlatAst, id flat.NodeId, local_valu

17111857 }

17121858}

17131859

1714-fn (c &CallCollector) top_level_decl_rhs_type_name(rhs_id flat.NodeId, cur_module string, imports map[string]string) string {

1860+fn (c &CallCollector) top_level_decl_rhs_type_name(rhs_id flat.NodeId, cur_module string, imports map[string]string, local_values map[string]bool, local_types map[string]string) string {

17151861 rhs := c.a.node(rhs_id)

17161862 if rhs.kind == .struct_init && rhs.value.len > 0 {

17171863 return c.struct_lookup_name(markused_resolve_imported_type_name(rhs.value, imports),

17181864 cur_module)

17191865 }

1720- type_name := resolve_type_name(c.node_type(rhs_id))

1866+ type_name := c.top_level_expr_type_name(rhs_id, cur_module, imports, local_values, local_types,

1867+ false)

17211868 if type_name.len > 0 {

17221869 struct_type := c.struct_lookup_name(type_name, cur_module)

17231870 if struct_type.len > 0 {

@@ -1807,7 +1954,8 @@ fn (c &CallCollector) collect_top_level_assign_calls(node &flat.Node, cur_module

18071954 lhs := c.a.node(lhs_id)

18081955 if lhs.kind == .ident && lhs.value.len > 0 {

18091956 local_values[lhs.value] = true

1810- type_name := c.top_level_decl_rhs_type_name(rhs_id, cur_module, imports)

1957+ type_name := c.top_level_decl_rhs_type_name(rhs_id, cur_module, imports,

1958+ pre_values, pre_types)

18111959 if type_name.len > 0 {

18121960 local_types[lhs.value] = type_name

18131961 }

@@ -1844,7 +1992,8 @@ fn (c &CallCollector) collect_top_level_global_decl_calls(node &flat.Node, cur_m

18441992 local_values[field.value] = true

18451993 if field.children_count > 0 {

18461994 expr_id := c.a.child(field, 0)

1847- type_name := c.top_level_decl_rhs_type_name(expr_id, cur_module, imports)

1995+ type_name := c.top_level_decl_rhs_type_name(expr_id, cur_module, imports, pre_values,

1996+ pre_types)

18481997 if type_name.len > 0 {

18491998 local_types[field.value] = type_name

18501999 }

@@ -1962,11 +2111,40 @@ fn (c &CallCollector) selector_base_is_local(node &flat.Node, local_values map[s

19622111 return base.kind == .ident && base.value in local_values

19632112}

19642113

2114+fn (c &CallCollector) expr_lowers_to_map_str(id flat.NodeId, local_values map[string]bool, local_types map[string]string) bool {

2115+ if int(id) < 0 {

2116+ return false

2117+ }

2118+ if markused_type_lowers_to_map_str(c.node_type(id)) {

2119+ return true

2120+ }

2121+ expr := c.a.node(id)

2122+ if expr.kind == .ident && expr.value.len > 0 && expr.value in local_values {

2123+ if type_name := local_types[expr.value] {

2124+ return markused_type_name_lowers_to_map_str(type_name, c.tc)

2125+ }

2126+ }

2127+ return false

2128+}

2129+

2130+fn (c &CallCollector) top_level_expr_lowers_to_map_str(id flat.NodeId, cur_module string, imports map[string]string, local_values map[string]bool, local_types map[string]string) bool {

2131+ if int(id) < 0 {

2132+ return false

2133+ }

2134+ if markused_type_lowers_to_map_str(c.node_type(id)) {

2135+ return true

2136+ }

2137+ type_name := c.top_level_expr_type_name(id, cur_module, imports, local_values, local_types,

2138+ false)

2139+ return type_name.len > 0 && markused_type_name_lowers_to_map_str(type_name, c.tc)

2140+}

2141+

19652142fn (c &CallCollector) collect_top_level_call(call_id flat.NodeId, call &flat.Node, cur_module string, imports map[string]string, local_values map[string]bool, local_types map[string]string, mut calls []string) {

19662143 mut resolved_call := ''

19672144 if resolved := c.tc.resolved_call_name(call_id) {

19682145 resolved_call = resolved

19692146 }

2147+ c.collect_lowered_join_path_single(call, resolved_call, mut calls)

19702148 if call.children_count == 0 {

19712149 if resolved_call.len > 0 {

19722150 calls << resolved_call

@@ -1982,6 +2160,14 @@ fn (c &CallCollector) collect_top_level_call(call_id flat.NodeId, call &flat.Nod

19822160 if resolved_call.len > 0 {

19832161 calls << resolved_call

19842162 }

2163+ if callee.value in ['print', 'println', 'eprint', 'eprintln'] && call.children_count >= 2 {

2164+ arg_id := c.a.child(call, 1)

2165+ if c.top_level_expr_lowers_to_map_str(arg_id, cur_module, imports, local_values,

2166+ local_types)

2167+ {

2168+ calls << 'string__plus'

2169+ }

2170+ }

19852171 if callee.value !in local_values {

19862172 calls << callee.value

19872173 qcallee := qualify_fn(cur_module, callee.value)

@@ -2016,6 +2202,10 @@ fn (c &CallCollector) collect_top_level_selector_call(callee &flat.Node, method

20162202 if int(base_id) >= 0 {

20172203 base := c.a.node(base_id)

20182204 has_exact_selector_call = c.collect_checker_selected_call(resolved_call, mut calls)

2205+ if method == 'str'

2206+ && c.top_level_expr_lowers_to_map_str(base_id, cur_module, imports, local_values, local_types) {

2207+ calls << 'string__plus'

2208+ }

20192209 if !has_exact_selector_call {

20202210 has_exact_selector_call = c.collect_top_level_typed_receiver_method(base_id,

20212211 method, cur_module, imports, local_values, local_types, mut calls)

@@ -2101,6 +2291,44 @@ fn (c &CallCollector) collect_top_level_selector_fallback(base &flat.Node, metho

21012291 }

21022292}

21032293

2294+fn (c &CallCollector) collect_lowered_join_path_single(call &flat.Node, resolved_call string, mut calls []string) {

2295+ mut call_names := []string{}

2296+ if resolved_call.len > 0 {

2297+ call_names << resolved_call

2298+ }

2299+ if call.children_count > 0 {

2300+ callee_id := c.a.child(call, 0)

2301+ if int(callee_id) >= 0 {

2302+ callee := c.a.node(callee_id)

2303+ if callee.kind == .ident && callee.value.len > 0 {

2304+ call_names << callee.value

2305+ } else if callee.kind == .selector && callee.value.len > 0 && callee.children_count > 0 {

2306+ base_id := c.a.child(callee, 0)

2307+ if int(base_id) >= 0 {

2308+ base := c.a.node(base_id)

2309+ if base.kind == .ident && base.value.len > 0 {

2310+ call_names << '${base.value}.${callee.value}'

2311+ }

2312+ }

2313+ }

2314+ }

2315+ }

2316+ if !call_names.any(it == 'join_path' || it == 'os.join_path') {

2317+ return

2318+ }

2319+ if call.children_count <= 2 {

2320+ return

2321+ }

2322+ for i in 1 .. call.children_count {

2323+ arg := c.a.child_node(call, i)

2324+ if arg.kind == .prefix && arg.value == '...' {

2325+ return

2326+ }

2327+ }

2328+ calls << 'join_path_single'

2329+ calls << 'os.join_path_single'

2330+}

2331+

21042332fn (c &CallCollector) collect_top_level_typed_receiver_method(base_id flat.NodeId, method string, cur_module string, imports map[string]string, local_values map[string]bool, local_types map[string]string, mut calls []string) bool {

21052333 type_name := c.top_level_receiver_type_name(base_id, cur_module, imports, local_values,

21062334 local_types)

@@ -2133,6 +2361,13 @@ fn (c &CallCollector) top_level_receiver_type_name(base_id flat.NodeId, cur_modu

21332361 return ''

21342362 }

21352363 }

2364+ if base.kind == .or_expr {

2365+ or_type_name := c.top_level_or_expr_base_type_name(base_id, cur_module, imports,

2366+ local_values, local_types)

2367+ if or_type_name.len > 0 {

2368+ return or_type_name

2369+ }

2370+ }

21362371 if base.kind == .ident && base.value.len > 0 {

21372372 return c.value_type_name(base.value, cur_module, imports)

21382373 }

@@ -2145,6 +2380,88 @@ fn (c &CallCollector) top_level_receiver_type_name(base_id flat.NodeId, cur_modu

21452380 return ''

21462381}

21472382

2383+fn (c &CallCollector) top_level_expr_type_name(id flat.NodeId, cur_module string, imports map[string]string, local_values map[string]bool, local_types map[string]string, unwrap_optional_result bool) string {

2384+ typ := c.node_type(id)

2385+ if type_name := markused_type_name(typ, unwrap_optional_result) {

2386+ return type_name

2387+ }

2388+ node := c.a.node(id)

2389+ match node.kind {

2390+ .call {

2391+ return c.top_level_call_return_type_name(id, cur_module, imports, local_values,

2392+ local_types, unwrap_optional_result)

2393+ }

2394+ .or_expr {

2395+ return c.top_level_or_expr_base_type_name(id, cur_module, imports, local_values,

2396+ local_types)

2397+ }

2398+ .ident {

2399+ return local_types[node.value] or { '' }

2400+ }

2401+ else {}

2402+ }

2403+

2404+ return ''

2405+}

2406+

2407+fn (c &CallCollector) top_level_call_return_type_name(call_id flat.NodeId, cur_module string, imports map[string]string, local_values map[string]bool, local_types map[string]string, unwrap_optional_result bool) string {

2408+ call := c.a.node(call_id)

2409+ if call.kind != .call || call.children_count == 0 {

2410+ return ''

2411+ }

2412+ callee_id := c.a.child(call, 0)

2413+ if int(callee_id) < 0 {

2414+ return ''

2415+ }

2416+ callee := c.a.node(callee_id)

2417+ if callee.kind == .selector && callee.value.len > 0 && callee.children_count > 0 {

2418+ base_id := c.a.child(callee, 0)

2419+ base := c.a.node(base_id)

2420+ type_name := c.top_level_receiver_type_name(base_id, cur_module, imports, local_values,

2421+ local_types)

2422+ if type_name.len > 0 {

2423+ if method_name := c.typed_receiver_method_name(type_name, callee.value, cur_module) {

2424+ return c.fn_return_type_name(method_name, unwrap_optional_result)

2425+ }

2426+ }

2427+ if base.kind == .ident && base.value in imports {

2428+ return c.fn_return_type_name('${imports[base.value]}.${callee.value}',

2429+ unwrap_optional_result)

2430+ }

2431+ }

2432+ if callee.kind == .ident && callee.value.len > 0 {

2433+ name := qualify_fn(cur_module, callee.value)

2434+ type_name := c.fn_return_type_name(name, unwrap_optional_result)

2435+ if type_name.len > 0 {

2436+ return type_name

2437+ }

2438+ return c.fn_return_type_name(callee.value, unwrap_optional_result)

2439+ }

2440+ return ''

2441+}

2442+

2443+fn (c &CallCollector) top_level_or_expr_base_type_name(id flat.NodeId, cur_module string, imports map[string]string, local_values map[string]bool, local_types map[string]string) string {

2444+ node := c.a.node(id)

2445+ if node.kind != .or_expr || node.children_count == 0 {

2446+ return ''

2447+ }

2448+ return c.top_level_expr_type_name(c.a.child(node, 0), cur_module, imports, local_values,

2449+ local_types, true)

2450+}

2451+

2452+fn (c &CallCollector) fn_return_type_name(name string, unwrap_optional_result bool) string {

2453+ if typ := c.tc.fn_ret_types[name] {

2454+ return markused_type_name_or_empty(typ, unwrap_optional_result)

2455+ }

2456+ lowered := markused_c_name(name)

2457+ if lowered != name {

2458+ if typ := c.tc.fn_ret_types[lowered] {

2459+ return markused_type_name_or_empty(typ, unwrap_optional_result)

2460+ }

2461+ }

2462+ return ''

2463+}

2464+

21482465// collect_struct_operator_call updates collect struct operator call state for markused.

21492466fn (c &CallCollector) collect_struct_operator_call(lhs_id flat.NodeId, op flat.Op, cur_module string, mut calls []string) {

21502467 lhs_type := c.node_type(lhs_id)

@@ -3037,6 +3354,32 @@ fn markused_nested_type_name(t types.Type) string {

30373354 return t.name()

30383355}

30393356

3357+fn markused_type_name(t types.Type, unwrap_optional_result bool) ?string {

3358+ if unwrap_optional_result {

3359+ if t is types.OptionType {

3360+ name := resolve_type_name(t.base_type)

3361+ if name.len > 0 {

3362+ return name

3363+ }

3364+ }

3365+ if t is types.ResultType {

3366+ name := resolve_type_name(t.base_type)

3367+ if name.len > 0 {

3368+ return name

3369+ }

3370+ }

3371+ }

3372+ name := resolve_type_name(t)

3373+ if name.len == 0 {

3374+ return none

3375+ }

3376+ return name

3377+}

3378+

3379+fn markused_type_name_or_empty(t types.Type, unwrap_optional_result bool) string {

3380+ return markused_type_name(t, unwrap_optional_result) or { '' }

3381+}

3382+

30403383// markused_c_name converts markused c name data for markused.

30413384fn markused_c_name(name string) string {

30423385 if name.starts_with('C.') {

@@ -625,6 +625,7 @@ fn (mut p Parser) fn_decl() flat.NodeId {

625625 mut name := ''

626626 mut receiver_name := ''

627627 mut receiver_type := ''

628+ mut receiver_is_mut := false

628629 mut is_method := false

629630

630631 // method receiver: fn (mut r Type) name()

@@ -634,6 +635,7 @@ fn (mut p Parser) fn_decl() flat.NodeId {

634635 mut is_mut := false

635636 if p.tok == .key_mut || p.tok == .key_shared {

636637 is_mut = p.tok == .key_mut

638+ receiver_is_mut = is_mut

637639 p.next()

638640 }

639641 receiver_name = p.expect_name()

@@ -648,7 +650,8 @@ fn (mut p Parser) fn_decl() flat.NodeId {

648650 if p.tok.is_overloadable() {

649651 op_name := overload_token_name(p.tok)

650652 p.next()

651- return p.fn_operator_overload(receiver_name, receiver_type, op_name)

653+ return p.fn_operator_overload(receiver_name, receiver_type, receiver_is_mut,