From e09faaa16c35721d37d61625ce14239ac29ba6eb Mon Sep 17 00:00:00 2001 From: Nathaniel Saxe Date: Tue, 3 Feb 2026 17:03:16 -0500 Subject: refactor into file; handle indentation --- src/server/action_populate_switch_cases.odin | 206 +++++++++++++++++++++++++++ 1 file changed, 206 insertions(+) create mode 100644 src/server/action_populate_switch_cases.odin (limited to 'src/server/action_populate_switch_cases.odin') diff --git a/src/server/action_populate_switch_cases.odin b/src/server/action_populate_switch_cases.odin new file mode 100644 index 0000000..f2255c5 --- /dev/null +++ b/src/server/action_populate_switch_cases.odin @@ -0,0 +1,206 @@ +#+private file + +package server + +import "core:fmt" +import "core:odin/ast" +import "core:slice" +import "core:strings" + +import "src:common" + + +// Get the indentation (leading whitespace) of the line containing the given offset +get_line_start_offset :: proc(src: string, offset: int) -> int { + line_start := offset + for line_start > 0 && src[line_start - 1] != '\n' { + line_start -= 1 + } + return line_start +} +get_block_original_text :: proc(block: []^ast.Stmt, document_text: string) -> string { + if len(block) == 0 { + return "" + } + start := get_line_start_offset(document_text, block[0].pos.offset) + end := block[max(0, len(block) - 1)].end.offset + return string(document_text[start:end]) +} + +SwitchCaseInfo :: struct { + name: string, + case_indentation: string, + body_indentation: string, + body: string, +} +get_switch_cases_info :: proc( + document: ^Document, + ast_context: ^AstContext, + position_context: ^DocumentPositionContext, +) -> ( + existing_cases: []SwitchCaseInfo, + all_case_names: []string, + is_enum: bool, + ok: bool, +) { + if (position_context.switch_stmt == nil && position_context.switch_type_stmt == nil) || + (position_context.switch_stmt != nil && position_context.switch_stmt.cond == nil) { + return nil, nil, false, false + } + switch_block: ^ast.Block_Stmt + found_switch_block: bool + if position_context.switch_stmt != nil { + switch_block, found_switch_block = position_context.switch_stmt.body.derived.(^ast.Block_Stmt) + is_enum = true + } + if !found_switch_block && position_context.switch_type_stmt != nil { + switch_block, found_switch_block = position_context.switch_type_stmt.body.derived.(^ast.Block_Stmt) + } + if !found_switch_block { + return nil, nil, false, false + } + existing_cases_in_order := make([dynamic]SwitchCaseInfo, context.temp_allocator) + for stmt in switch_block.stmts { + if case_clause, ok := stmt.derived.(^ast.Case_Clause); ok { + case_indent := get_line_indentation(string(document.text), case_clause.pos.offset) + case_name := "" + for name in case_clause.list { + if is_enum { + if implicit, ok := name.derived.(^ast.Implicit_Selector_Expr); ok { + case_name = implicit.field.name + break + } + } else { + reset_ast_context(ast_context) + if ty, ok := resolve_type_expression(ast_context, name); ok { + //TODO: this is wrong for anonymous enums and structs, where the name field is "enum" or "struct" respectively but we want to use the full signature + //we also can't use the signature all the time because type aliases need to use specifically the alias name here and not the signature + case_name = ty.name != "" ? ty.name : get_signature(ast_context, ty) + break + } + } + } + if case_name != "" { + case_info := SwitchCaseInfo { + name = case_name, + case_indentation = get_line_indentation(string(document.text), case_clause.pos.offset), + body = get_block_original_text(case_clause.body, string(document.text)), + } + append(&existing_cases_in_order, case_info) + } + } + } + if is_enum { + enum_value, was_super_enum, unwrap_ok := unwrap_enum(ast_context, position_context.switch_stmt.cond) + if !unwrap_ok { + return nil, nil, true, false + } + return existing_cases_in_order[:], enum_value.names, !was_super_enum, true + } else { + st := position_context.switch_type_stmt + if st == nil { + return nil, nil, false, false + } + reset_ast_context(ast_context) + union_value, unwrap_ok := unwrap_union(ast_context, st.tag.derived.(^ast.Assign_Stmt).rhs[0]) + if !unwrap_ok { + return nil, nil, false, false + } + case_names := make([]string, len(union_value.types), context.temp_allocator) + for t, i in union_value.types { + reset_ast_context(ast_context) + if ty, ok := resolve_type_expression(ast_context, t); ok { + //TODO: this is wrong for anonymous enums and structs, where the name field is "enum" or "struct" respectively but we want to use the full signature + //we also can't use the signature all the time because type aliases need to use specifically the alias name here and not the signature + case_names[i] = ty.name != "" ? ty.name : get_signature(ast_context, ty) + } else { + case_names[i] = "invalid type expression" + } + } + return existing_cases_in_order[:], case_names, false, true + } +} + +create_populate_switch_cases_edit :: proc( + position_context: ^DocumentPositionContext, + existing_cases: []SwitchCaseInfo, + all_case_names: []string, + is_enum: bool, +) -> ( + TextEdit, + bool, +) { + //we need to be either in a switch stmt or a switch type stmt + if position_context.switch_stmt == nil && position_context.switch_type_stmt == nil { + return {}, false + } + //entirety of the switch block + range: common.Range + if is_enum { + range = common.get_token_range(position_context.switch_stmt.body.stmt_base, position_context.file.src) + } else { + range = common.get_token_range(position_context.switch_type_stmt.body.stmt_base, position_context.file.src) + } + replacement_builder := strings.builder_make() + dot := is_enum ? "." : "" + b := &replacement_builder + fmt.sbprintln(b, "{") + existing_cases_map := map[string]struct{}{} + indent_for_new_cases := "" + for case_info in existing_cases { + if indent_for_new_cases == "" {indent_for_new_cases = case_info.case_indentation} + existing_cases_map[case_info.name] = {} + fmt.sbprintln(b, case_info.case_indentation, "case ", dot, case_info.name, ":", sep = "") + case_body := case_info.body + if case_body != "" { + fmt.sbprintln(b, case_info.body) + } + } + for name in all_case_names { + if name in existing_cases_map {continue} //covered by prev loop + fmt.sbprintln(b, indent_for_new_cases, "case ", dot, name, ":", sep = "") + } + fmt.sbprint(b, indent_for_new_cases, "}") + return TextEdit{range = range, newText = strings.to_string(replacement_builder)}, true +} +@(private = "package") +add_populate_switch_cases_action :: proc( + document: ^Document, + ast_context: ^AstContext, + position_context: ^DocumentPositionContext, + uri: string, + actions: ^[dynamic]CodeAction, +) { + existing_cases, all_case_names, is_enum, ok := get_switch_cases_info(document, ast_context, position_context) + if !ok {return} + all_cases_covered := true + { + existing_cases_map := map[string]struct{}{} + for case_info in existing_cases { + existing_cases_map[case_info.name] = {} + } + for name in all_case_names { + if name not_in existing_cases_map { + all_cases_covered = false + } + } + } + if all_cases_covered {return} //action not needed + edit, edit_ok := create_populate_switch_cases_edit(position_context, existing_cases, all_case_names, is_enum) + if !edit_ok {return} + textEdits := make([dynamic]TextEdit, context.temp_allocator) + append(&textEdits, edit) + + workspaceEdit: WorkspaceEdit + workspaceEdit.changes = make(map[string][]TextEdit, 0, context.temp_allocator) + workspaceEdit.changes[uri] = textEdits[:] + append( + actions, + CodeAction { + kind = "refactor.rewrite", + isPreferred = true, + title = "populate remaining switch cases", + edit = workspaceEdit, + }, + ) +} -- cgit v1.2.3 From 5c582738aa27ad8a6dd290be0a56ab6c619fd121 Mon Sep 17 00:00:00 2001 From: Nathaniel Saxe Date: Tue, 3 Feb 2026 17:05:05 -0500 Subject: sep='' --- src/server/action_populate_switch_cases.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/server/action_populate_switch_cases.odin') diff --git a/src/server/action_populate_switch_cases.odin b/src/server/action_populate_switch_cases.odin index f2255c5..8489979 100644 --- a/src/server/action_populate_switch_cases.odin +++ b/src/server/action_populate_switch_cases.odin @@ -160,7 +160,7 @@ create_populate_switch_cases_edit :: proc( if name in existing_cases_map {continue} //covered by prev loop fmt.sbprintln(b, indent_for_new_cases, "case ", dot, name, ":", sep = "") } - fmt.sbprint(b, indent_for_new_cases, "}") + fmt.sbprint(b, indent_for_new_cases, "}", sep = "") return TextEdit{range = range, newText = strings.to_string(replacement_builder)}, true } @(private = "package") -- cgit v1.2.3 From 857cfd03a5d3b66402105fafe0ec262b4cae5186 Mon Sep 17 00:00:00 2001 From: Nathaniel Saxe Date: Tue, 3 Feb 2026 17:23:07 -0500 Subject: capture indentation of the overall switch block --- src/server/action_populate_switch_cases.odin | 59 ++++++++++++++++------------ 1 file changed, 33 insertions(+), 26 deletions(-) (limited to 'src/server/action_populate_switch_cases.odin') diff --git a/src/server/action_populate_switch_cases.odin b/src/server/action_populate_switch_cases.odin index 8489979..ca5c258 100644 --- a/src/server/action_populate_switch_cases.odin +++ b/src/server/action_populate_switch_cases.odin @@ -4,7 +4,6 @@ package server import "core:fmt" import "core:odin/ast" -import "core:slice" import "core:strings" import "src:common" @@ -29,7 +28,6 @@ get_block_original_text :: proc(block: []^ast.Stmt, document_text: string) -> st SwitchCaseInfo :: struct { name: string, - case_indentation: string, body_indentation: string, body: string, } @@ -40,12 +38,13 @@ get_switch_cases_info :: proc( ) -> ( existing_cases: []SwitchCaseInfo, all_case_names: []string, + switch_indentation: string, is_enum: bool, ok: bool, ) { if (position_context.switch_stmt == nil && position_context.switch_type_stmt == nil) || (position_context.switch_stmt != nil && position_context.switch_stmt.cond == nil) { - return nil, nil, false, false + return nil, nil, "", false, false } switch_block: ^ast.Block_Stmt found_switch_block: bool @@ -57,12 +56,12 @@ get_switch_cases_info :: proc( switch_block, found_switch_block = position_context.switch_type_stmt.body.derived.(^ast.Block_Stmt) } if !found_switch_block { - return nil, nil, false, false + return nil, nil, "", false, false } + switch_indentation = get_line_indentation(string(document.text), switch_block.pos.offset) existing_cases_in_order := make([dynamic]SwitchCaseInfo, context.temp_allocator) for stmt in switch_block.stmts { if case_clause, ok := stmt.derived.(^ast.Case_Clause); ok { - case_indent := get_line_indentation(string(document.text), case_clause.pos.offset) case_name := "" for name in case_clause.list { if is_enum { @@ -82,9 +81,8 @@ get_switch_cases_info :: proc( } if case_name != "" { case_info := SwitchCaseInfo { - name = case_name, - case_indentation = get_line_indentation(string(document.text), case_clause.pos.offset), - body = get_block_original_text(case_clause.body, string(document.text)), + name = case_name, + body = get_block_original_text(case_clause.body, string(document.text)), } append(&existing_cases_in_order, case_info) } @@ -93,18 +91,18 @@ get_switch_cases_info :: proc( if is_enum { enum_value, was_super_enum, unwrap_ok := unwrap_enum(ast_context, position_context.switch_stmt.cond) if !unwrap_ok { - return nil, nil, true, false + return nil, nil, "", true, false } - return existing_cases_in_order[:], enum_value.names, !was_super_enum, true + return existing_cases_in_order[:], enum_value.names, switch_indentation, !was_super_enum, true } else { st := position_context.switch_type_stmt if st == nil { - return nil, nil, false, false + return nil, nil, "", false, false } reset_ast_context(ast_context) union_value, unwrap_ok := unwrap_union(ast_context, st.tag.derived.(^ast.Assign_Stmt).rhs[0]) if !unwrap_ok { - return nil, nil, false, false + return nil, nil, "", false, false } case_names := make([]string, len(union_value.types), context.temp_allocator) for t, i in union_value.types { @@ -117,13 +115,14 @@ get_switch_cases_info :: proc( case_names[i] = "invalid type expression" } } - return existing_cases_in_order[:], case_names, false, true + return existing_cases_in_order[:], case_names, switch_indentation, false, true } } create_populate_switch_cases_edit :: proc( position_context: ^DocumentPositionContext, existing_cases: []SwitchCaseInfo, + switch_indentation: string, all_case_names: []string, is_enum: bool, ) -> ( @@ -145,22 +144,20 @@ create_populate_switch_cases_edit :: proc( dot := is_enum ? "." : "" b := &replacement_builder fmt.sbprintln(b, "{") - existing_cases_map := map[string]struct{}{} - indent_for_new_cases := "" + existing_case_names := map[string]struct{}{} for case_info in existing_cases { - if indent_for_new_cases == "" {indent_for_new_cases = case_info.case_indentation} - existing_cases_map[case_info.name] = {} - fmt.sbprintln(b, case_info.case_indentation, "case ", dot, case_info.name, ":", sep = "") + existing_case_names[case_info.name] = {} + fmt.sbprintln(b, switch_indentation, "case ", dot, case_info.name, ":", sep = "") case_body := case_info.body if case_body != "" { fmt.sbprintln(b, case_info.body) } } for name in all_case_names { - if name in existing_cases_map {continue} //covered by prev loop - fmt.sbprintln(b, indent_for_new_cases, "case ", dot, name, ":", sep = "") + if name in existing_case_names {continue} //covered by prev loop + fmt.sbprintln(b, switch_indentation, "case ", dot, name, ":", sep = "") } - fmt.sbprint(b, indent_for_new_cases, "}", sep = "") + fmt.sbprint(b, switch_indentation, "}", sep = "") return TextEdit{range = range, newText = strings.to_string(replacement_builder)}, true } @(private = "package") @@ -171,22 +168,32 @@ add_populate_switch_cases_action :: proc( uri: string, actions: ^[dynamic]CodeAction, ) { - existing_cases, all_case_names, is_enum, ok := get_switch_cases_info(document, ast_context, position_context) + existing_cases, all_case_names, switch_indentation, is_enum, ok := get_switch_cases_info( + document, + ast_context, + position_context, + ) if !ok {return} all_cases_covered := true { - existing_cases_map := map[string]struct{}{} + existing_case_names := map[string]struct{}{} for case_info in existing_cases { - existing_cases_map[case_info.name] = {} + existing_case_names[case_info.name] = {} } for name in all_case_names { - if name not_in existing_cases_map { + if name not_in existing_case_names { all_cases_covered = false } } } if all_cases_covered {return} //action not needed - edit, edit_ok := create_populate_switch_cases_edit(position_context, existing_cases, all_case_names, is_enum) + edit, edit_ok := create_populate_switch_cases_edit( + position_context, + existing_cases, + switch_indentation, + all_case_names, + is_enum, + ) if !edit_ok {return} textEdits := make([dynamic]TextEdit, context.temp_allocator) append(&textEdits, edit) -- cgit v1.2.3 From 342a0e1a401627d76dbc20d22bf9d0788b3760c2 Mon Sep 17 00:00:00 2001 From: Nathaniel Saxe Date: Wed, 4 Feb 2026 15:35:08 -0500 Subject: qualify union case names with pointer / package when necessary --- src/server/action_populate_switch_cases.odin | 23 +++++++++++------- src/server/completion.odin | 35 +++++++++++++++++----------- 2 files changed, 37 insertions(+), 21 deletions(-) (limited to 'src/server/action_populate_switch_cases.odin') diff --git a/src/server/action_populate_switch_cases.odin b/src/server/action_populate_switch_cases.odin index ca5c258..a733aa5 100644 --- a/src/server/action_populate_switch_cases.odin +++ b/src/server/action_populate_switch_cases.odin @@ -9,7 +9,7 @@ import "core:strings" import "src:common" -// Get the indentation (leading whitespace) of the line containing the given offset +// Get the offset of the start of the line containing the given offset get_line_start_offset :: proc(src: string, offset: int) -> int { line_start := offset for line_start > 0 && src[line_start - 1] != '\n' { @@ -63,18 +63,21 @@ get_switch_cases_info :: proc( for stmt in switch_block.stmts { if case_clause, ok := stmt.derived.(^ast.Case_Clause); ok { case_name := "" - for name in case_clause.list { + for clause in case_clause.list { if is_enum { - if implicit, ok := name.derived.(^ast.Implicit_Selector_Expr); ok { - case_name = implicit.field.name + if name, ok := get_used_switch_name(clause); ok { + case_name = name break } } else { reset_ast_context(ast_context) - if ty, ok := resolve_type_expression(ast_context, name); ok { + if symbol, ok := resolve_type_expression(ast_context, clause); ok { + case_name = get_qualified_union_case_name(&symbol, ast_context, position_context) //TODO: this is wrong for anonymous enums and structs, where the name field is "enum" or "struct" respectively but we want to use the full signature //we also can't use the signature all the time because type aliases need to use specifically the alias name here and not the signature - case_name = ty.name != "" ? ty.name : get_signature(ast_context, ty) + if case_name == "" { + case_name = get_signature(ast_context, symbol) + } break } } @@ -107,10 +110,14 @@ get_switch_cases_info :: proc( case_names := make([]string, len(union_value.types), context.temp_allocator) for t, i in union_value.types { reset_ast_context(ast_context) - if ty, ok := resolve_type_expression(ast_context, t); ok { + if symbol, ok := resolve_type_expression(ast_context, t); ok { + case_name := get_qualified_union_case_name(&symbol, ast_context, position_context) //TODO: this is wrong for anonymous enums and structs, where the name field is "enum" or "struct" respectively but we want to use the full signature //we also can't use the signature all the time because type aliases need to use specifically the alias name here and not the signature - case_names[i] = ty.name != "" ? ty.name : get_signature(ast_context, ty) + if case_name == "" { + case_name = get_signature(ast_context, symbol) + } + case_names[i] = case_name } else { case_names[i] = "invalid type expression" } diff --git a/src/server/completion.odin b/src/server/completion.odin index 8be6079..a7b1720 100644 --- a/src/server/completion.odin +++ b/src/server/completion.odin @@ -1943,12 +1943,32 @@ get_used_switch_name :: proc(node: ^ast.Expr) -> (string, bool) { return n.name, true case ^ast.Selector_Expr: return n.field.name, true + case ^ast.Implicit_Selector_Expr: + return n.field.name, true case ^ast.Pointer_Type: return get_used_switch_name(n.elem) } return "", false } +//handles pointers / packages +get_qualified_union_case_name :: proc( + symbol: ^Symbol, + ast_context: ^AstContext, + position_context: ^DocumentPositionContext, +) -> string { + if symbol.pkg == ast_context.document_package { + return fmt.aprintf("%v%v", repeat("^", symbol.pointers, context.temp_allocator), symbol.name) + } else { + return fmt.aprintf( + "%v%v.%v", + repeat("^", symbol.pointers, context.temp_allocator), + get_symbol_pkg_name(ast_context, symbol), + symbol.name, + ) + } +} + get_type_switch_completion :: proc( ast_context: ^AstContext, position_context: ^DocumentPositionContext, @@ -1987,19 +2007,8 @@ get_type_switch_completion :: proc( item := CompletionItem { kind = .EnumMember, } - - if symbol.pkg == ast_context.document_package { - item.label = fmt.aprintf("%v%v", repeat("^", symbol.pointers, context.temp_allocator), name) - item.detail = item.label - } else { - item.label = fmt.aprintf( - "%v%v.%v", - repeat("^", symbol.pointers, context.temp_allocator), - get_symbol_pkg_name(ast_context, &symbol), - name, - ) - item.detail = item.label - } + item.label = get_qualified_union_case_name(&symbol, ast_context, position_context) + item.detail = item.label if position_context.implicit_selector_expr != nil { if remove_edit, ok := create_implicit_selector_remove_edit(position_context); ok { item.additionalTextEdits = remove_edit -- cgit v1.2.3 From 7d5b8ede0f4248773d71fbfffcf9cde40c9cc774 Mon Sep 17 00:00:00 2001 From: Nathaniel Saxe Date: Sat, 7 Feb 2026 15:14:36 -0500 Subject: refactor switch case info into struct; handle multiple comma-separated variants in case block --- src/server/action_populate_switch_cases.odin | 129 +++++++++++++++------------ 1 file changed, 74 insertions(+), 55 deletions(-) (limited to 'src/server/action_populate_switch_cases.odin') diff --git a/src/server/action_populate_switch_cases.odin b/src/server/action_populate_switch_cases.odin index a733aa5..f038e7c 100644 --- a/src/server/action_populate_switch_cases.odin +++ b/src/server/action_populate_switch_cases.odin @@ -27,27 +27,32 @@ get_block_original_text :: proc(block: []^ast.Stmt, document_text: string) -> st } SwitchCaseInfo :: struct { - name: string, + names: []string, body_indentation: string, body: string, } +SwitchBlockInfo :: struct { + existing_cases: []SwitchCaseInfo, + all_covered_case_names: []string, + all_case_names: []string, + switch_indentation: string, + is_enum: bool, +} get_switch_cases_info :: proc( document: ^Document, ast_context: ^AstContext, position_context: ^DocumentPositionContext, ) -> ( - existing_cases: []SwitchCaseInfo, - all_case_names: []string, - switch_indentation: string, - is_enum: bool, + info: SwitchBlockInfo, ok: bool, ) { if (position_context.switch_stmt == nil && position_context.switch_type_stmt == nil) || (position_context.switch_stmt != nil && position_context.switch_stmt.cond == nil) { - return nil, nil, "", false, false + return {}, false } switch_block: ^ast.Block_Stmt found_switch_block: bool + is_enum: bool if position_context.switch_stmt != nil { switch_block, found_switch_block = position_context.switch_stmt.body.derived.(^ast.Block_Stmt) is_enum = true @@ -56,36 +61,40 @@ get_switch_cases_info :: proc( switch_block, found_switch_block = position_context.switch_type_stmt.body.derived.(^ast.Block_Stmt) } if !found_switch_block { - return nil, nil, "", false, false + return {}, false } - switch_indentation = get_line_indentation(string(document.text), switch_block.pos.offset) + switch_indentation := get_line_indentation(string(document.text), switch_block.pos.offset) existing_cases_in_order := make([dynamic]SwitchCaseInfo, context.temp_allocator) + all_covered_names := make([dynamic]string, context.temp_allocator) for stmt in switch_block.stmts { if case_clause, ok := stmt.derived.(^ast.Case_Clause); ok { - case_name := "" + case_names := make([dynamic]string, context.temp_allocator) for clause in case_clause.list { if is_enum { - if name, ok := get_used_switch_name(clause); ok { - case_name = name - break + if name, ok := get_used_switch_name(clause); ok && name != "" { + append(&case_names, name) + append(&all_covered_names, name) } } else { reset_ast_context(ast_context) if symbol, ok := resolve_type_expression(ast_context, clause); ok { - case_name = get_qualified_union_case_name(&symbol, ast_context, position_context) + name := get_qualified_union_case_name(&symbol, ast_context, position_context) //TODO: this is wrong for anonymous enums and structs, where the name field is "enum" or "struct" respectively but we want to use the full signature //we also can't use the signature all the time because type aliases need to use specifically the alias name here and not the signature - if case_name == "" { - case_name = get_signature(ast_context, symbol) + if name == "" { + name = get_signature(ast_context, symbol) + } + if name != "" { + append(&case_names, name) + append(&all_covered_names, name) } - break } } } - if case_name != "" { + if len(case_names) > 0 { case_info := SwitchCaseInfo { - name = case_name, - body = get_block_original_text(case_clause.body, string(document.text)), + names = case_names[:], + body = get_block_original_text(case_clause.body, string(document.text)), } append(&existing_cases_in_order, case_info) } @@ -94,20 +103,27 @@ get_switch_cases_info :: proc( if is_enum { enum_value, was_super_enum, unwrap_ok := unwrap_enum(ast_context, position_context.switch_stmt.cond) if !unwrap_ok { - return nil, nil, "", true, false + return {}, false } - return existing_cases_in_order[:], enum_value.names, switch_indentation, !was_super_enum, true + return SwitchBlockInfo { + existing_cases = existing_cases_in_order[:], + all_covered_case_names = all_covered_names[:], + all_case_names = enum_value.names, + switch_indentation = switch_indentation, + is_enum = !was_super_enum, + }, + true } else { st := position_context.switch_type_stmt if st == nil { - return nil, nil, "", false, false + return {}, false } reset_ast_context(ast_context) union_value, unwrap_ok := unwrap_union(ast_context, st.tag.derived.(^ast.Assign_Stmt).rhs[0]) if !unwrap_ok { - return nil, nil, "", false, false + return {}, false } - case_names := make([]string, len(union_value.types), context.temp_allocator) + all_case_names := make([]string, len(union_value.types), context.temp_allocator) for t, i in union_value.types { reset_ast_context(ast_context) if symbol, ok := resolve_type_expression(ast_context, t); ok { @@ -117,21 +133,25 @@ get_switch_cases_info :: proc( if case_name == "" { case_name = get_signature(ast_context, symbol) } - case_names[i] = case_name + all_case_names[i] = case_name } else { - case_names[i] = "invalid type expression" + all_case_names[i] = "invalid type expression" } } - return existing_cases_in_order[:], case_names, switch_indentation, false, true + return SwitchBlockInfo { + existing_cases = existing_cases_in_order[:], + all_covered_case_names = all_covered_names[:], + all_case_names = all_case_names, + switch_indentation = switch_indentation, + is_enum = false, + }, + true } } create_populate_switch_cases_edit :: proc( position_context: ^DocumentPositionContext, - existing_cases: []SwitchCaseInfo, - switch_indentation: string, - all_case_names: []string, - is_enum: bool, + info: SwitchBlockInfo, ) -> ( TextEdit, bool, @@ -142,29 +162,38 @@ create_populate_switch_cases_edit :: proc( } //entirety of the switch block range: common.Range - if is_enum { + if info.is_enum { range = common.get_token_range(position_context.switch_stmt.body.stmt_base, position_context.file.src) } else { range = common.get_token_range(position_context.switch_type_stmt.body.stmt_base, position_context.file.src) } replacement_builder := strings.builder_make() - dot := is_enum ? "." : "" + dot := info.is_enum ? "." : "" b := &replacement_builder fmt.sbprintln(b, "{") - existing_case_names := map[string]struct{}{} - for case_info in existing_cases { - existing_case_names[case_info.name] = {} - fmt.sbprintln(b, switch_indentation, "case ", dot, case_info.name, ":", sep = "") + for case_info in info.existing_cases { + fmt.sbprint(b, info.switch_indentation, "case ", sep = "") + for name, i in case_info.names { + fmt.sbprint(b, dot, name, sep = "") + if i != len(case_info.names) - 1 { + fmt.sbprint(b, ", ", sep = "") + } + } + fmt.sbprintln(b, ":", sep = "") case_body := case_info.body if case_body != "" { fmt.sbprintln(b, case_info.body) } } - for name in all_case_names { + existing_case_names := map[string]struct{}{} + for name in info.all_covered_case_names { + existing_case_names[name] = {} + } + for name in info.all_case_names { if name in existing_case_names {continue} //covered by prev loop - fmt.sbprintln(b, switch_indentation, "case ", dot, name, ":", sep = "") + fmt.sbprintln(b, info.switch_indentation, "case ", dot, name, ":", sep = "") } - fmt.sbprint(b, switch_indentation, "}", sep = "") + fmt.sbprint(b, info.switch_indentation, "}", sep = "") return TextEdit{range = range, newText = strings.to_string(replacement_builder)}, true } @(private = "package") @@ -175,32 +204,22 @@ add_populate_switch_cases_action :: proc( uri: string, actions: ^[dynamic]CodeAction, ) { - existing_cases, all_case_names, switch_indentation, is_enum, ok := get_switch_cases_info( - document, - ast_context, - position_context, - ) + info, ok := get_switch_cases_info(document, ast_context, position_context) if !ok {return} all_cases_covered := true { existing_case_names := map[string]struct{}{} - for case_info in existing_cases { - existing_case_names[case_info.name] = {} + for name in info.all_covered_case_names { + existing_case_names[name] = {} } - for name in all_case_names { + for name in info.all_case_names { if name not_in existing_case_names { all_cases_covered = false } } } if all_cases_covered {return} //action not needed - edit, edit_ok := create_populate_switch_cases_edit( - position_context, - existing_cases, - switch_indentation, - all_case_names, - is_enum, - ) + edit, edit_ok := create_populate_switch_cases_edit(position_context, info) if !edit_ok {return} textEdits := make([dynamic]TextEdit, context.temp_allocator) append(&textEdits, edit) -- cgit v1.2.3