First version of selector rename.

3 files changed, 99 insertions, 85 deletions

diff --git a/src/server/analysis.odin b/src/server/analysis.odin
index 4fef18c..4c32c46 100644
--- a/src/server/analysis.odin
+++ b/src/server/analysis.odin
@@ -76,7 +76,7 @@ DocumentLocal :: struct {
 	parameter:       bool,
 }
 
-DeferredDepth :: 100
+DeferredDepth :: 35
 
 AstContext :: struct {
 	locals:           map[int]map[string][dynamic]DocumentLocal, //locals all the way to the document position
@@ -4803,6 +4803,8 @@ get_document_position_node :: proc(
 			position_context.function = cast(^Proc_Lit)node
 			append(&position_context.functions, position_context.function)
 			get_document_position(n.body, position_context)
+		} else if position_in_node(n.type, position_context.position) {
+			position_context.function = cast(^Proc_Lit)node
 		}
 	case ^Comp_Lit:
 		//only set this for the parent comp literal, since we will need to walk through it to infer types.
diff --git a/src/server/file_resolve.odin b/src/server/file_resolve.odin
index 1aa5163..3d6d7c0 100644
--- a/src/server/file_resolve.odin
+++ b/src/server/file_resolve.odin
@@ -19,10 +19,9 @@ import "src:common"
 
 ResolveReferenceFlag :: enum {
 	None,
-	Variable,
-	Constant,
-	StructElement,
-	EnumElement,
+	Identifier,
+	Base,
+	Field,
 }
 
 resolve_entire_file :: proc(
@@ -156,7 +155,7 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^Selector_Call_Expr:
 		data.position_context.selector = n.expr
 		data.position_context.field = n.call
-		data.position_context.selector_expr = cast(^Selector_Expr)node
+		data.position_context.selector_expr = node
 
 		if _, ok := n.call.derived.(^ast.Call_Expr); ok {
 			data.position_context.call = n.call
@@ -167,15 +166,23 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^Selector_Expr:
 		data.position_context.selector = n.expr
 		data.position_context.field = n.field
-		data.position_context.selector_expr = cast(^Selector_Expr)node
+		data.position_context.selector_expr = node
 
 		if data.flag != .None {
 			if symbol, ok := resolve_location_selector(data.ast_context, n);
 			   ok {
-				data.symbols[cast(uintptr)node] = SymbolAndNode {
-					node   = n,
-					symbol = symbol,
+				if data.flag == .Field {
+					data.symbols[cast(uintptr)node] = SymbolAndNode {
+						node   = n.field,
+						symbol = symbol,
+					}
+				} else {
+					data.symbols[cast(uintptr)node] = SymbolAndNode {
+						node   = n,
+						symbol = symbol,
+					}
 				}
+
 			}
 		} else {
 			if symbol, ok := resolve_type_expression(
@@ -201,8 +208,6 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 			data.position_context,
 		)
 
-		//log.error(data.ast_context.locals)
-
 		resolve_node(n.type, data)
 
 		data.position_context.function = cast(^Proc_Lit)node
@@ -234,7 +239,7 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 		resolve_node(n.body, data)
 	case ^Switch_Stmt:
 		local_scope(data, n)
-		data.position_context.switch_stmt = cast(^Switch_Stmt)node
+		data.position_context.switch_stmt = n
 		resolve_node(n.label, data)
 		resolve_node(n.init, data)
 		resolve_node(n.cond, data)
@@ -271,10 +276,10 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^Comp_Lit:
 		//only set this for the parent comp literal, since we will need to walk through it to infer types.
 		if data.position_context.parent_comp_lit == nil {
-			data.position_context.parent_comp_lit = cast(^Comp_Lit)node
+			data.position_context.parent_comp_lit = n
 		}
 
-		data.position_context.comp_lit = cast(^Comp_Lit)node
+		data.position_context.comp_lit = n
 
 		resolve_node(n.type, data)
 		resolve_nodes(n.elems, data)
@@ -286,13 +291,13 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 		if data.position_context.parent_binary == nil {
 			data.position_context.parent_binary = cast(^Binary_Expr)node
 		}
-		data.position_context.binary = cast(^Binary_Expr)node
+		data.position_context.binary = n
 		resolve_node(n.left, data)
 		resolve_node(n.right, data)
 	case ^Paren_Expr:
 		resolve_node(n.expr, data)
 	case ^Call_Expr:
-		data.position_context.call = cast(^Expr)node
+		data.position_context.call = n
 		resolve_node(n.expr, data)
 		resolve_nodes(n.args, data)
 	case ^Index_Expr:
@@ -305,7 +310,7 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 		resolve_node(n.low, data)
 		resolve_node(n.high, data)
 	case ^Field_Value:
-		data.position_context.field_value = cast(^Field_Value)node
+		data.position_context.field_value = n
 		resolve_node(n.field, data)
 		resolve_node(n.value, data)
 	case ^Ternary_If_Expr:
@@ -331,15 +336,11 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^Tag_Stmt:
 		r := cast(^Tag_Stmt)node
 		resolve_node(r.stmt, data)
-	case ^Assign_Stmt:
-		data.position_context.assign = cast(^Assign_Stmt)node
-		resolve_nodes(n.lhs, data)
-		resolve_nodes(n.rhs, data)
 	case ^Block_Stmt:
 		resolve_node(n.label, data)
 		resolve_nodes(n.stmts, data)
 	case ^Return_Stmt:
-		data.position_context.returns = cast(^Return_Stmt)node
+		data.position_context.returns = n
 		resolve_nodes(n.results, data)
 	case ^Defer_Stmt:
 		resolve_node(n.stmt, data)
@@ -347,7 +348,7 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 		resolve_nodes(n.list, data)
 		resolve_nodes(n.body, data)
 	case ^Type_Switch_Stmt:
-		data.position_context.switch_type_stmt = cast(^Type_Switch_Stmt)node
+		data.position_context.switch_type_stmt = n
 		resolve_node(n.label, data)
 		resolve_node(n.tag, data)
 		resolve_node(n.expr, data)
@@ -357,8 +358,16 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^Using_Stmt:
 		resolve_nodes(n.list, data)
 	case ^Bad_Decl:
+	case ^Assign_Stmt:
+		data.position_context.assign = n
+		data.position_context.comp_lit = nil
+		data.position_context.parent_comp_lit = nil
+		resolve_nodes(n.lhs, data)
+		resolve_nodes(n.rhs, data)
 	case ^Value_Decl:
-		data.position_context.value_decl = cast(^Value_Decl)node
+		data.position_context.value_decl = n
+		data.position_context.comp_lit = nil
+		data.position_context.parent_comp_lit = nil
 		resolve_nodes(n.names, data)
 		resolve_node(n.type, data)
 		resolve_nodes(n.values, data)
@@ -374,7 +383,22 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^Attribute:
 		resolve_nodes(n.elems, data)
 	case ^Field:
-		resolve_nodes(n.names, data)
+		if data.flag != .None {
+			for name in n.names {
+				data.symbols[cast(uintptr)node] = SymbolAndNode {
+					node = name,
+					symbol = Symbol {
+						range = common.get_token_range(
+							name,
+							string(data.document.text),
+						),
+					},
+				}
+			}
+		} else {
+			resolve_nodes(n.names, data)
+		}
+
 		resolve_node(n.type, data)
 		resolve_node(n.default_value, data)
 	case ^Field_List:
@@ -401,21 +425,21 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^Multi_Pointer_Type:
 		resolve_node(n.elem, data)
 	case ^Struct_Type:
-		data.position_context.struct_type = cast(^Struct_Type)node
+		data.position_context.struct_type = n
 		resolve_node(n.poly_params, data)
 		resolve_node(n.align, data)
 		resolve_node(n.fields, data)
 	case ^Union_Type:
-		data.position_context.union_type = cast(^Union_Type)node
+		data.position_context.union_type = n
 		resolve_node(n.poly_params, data)
 		resolve_node(n.align, data)
 		resolve_nodes(n.variants, data)
 	case ^Enum_Type:
-		data.position_context.enum_type = cast(^Enum_Type)node
+		data.position_context.enum_type = n
 		resolve_node(n.base_type, data)
 		resolve_nodes(n.fields, data)
 	case ^Bit_Set_Type:
-		data.position_context.bitset_type = cast(^Bit_Set_Type)node
+		data.position_context.bitset_type = n
 		resolve_node(n.elem, data)
 		resolve_node(n.underlying, data)
 	case ^Map_Type:
@@ -431,7 +455,7 @@ resolve_node :: proc(node: ^ast.Node, data: ^FileResolveData) {
 	case ^ast.Or_Return_Expr:
 		resolve_node(n.expr, data)
 	case ^ast.Bit_Field_Type:
-		data.position_context.bit_field_type = cast(^Bit_Field_Type)node
+		data.position_context.bit_field_type = n
 		resolve_node(n.backing_type, data)
 		resolve_nodes(n.fields, data)
 	case ^ast.Bit_Field_Field:
diff --git a/src/server/references.odin b/src/server/references.odin
index f1939c1..2ab571e 100644
--- a/src/server/references.odin
+++ b/src/server/references.odin
@@ -45,22 +45,6 @@ walk_directories :: proc(
 	return 0, false
 }
 
-position_in_struct_names :: proc(
-	position_context: ^DocumentPositionContext,
-	type: ^ast.Struct_Type,
-) -> bool {
-	for field in type.fields.list {
-		for name in field.names {
-			if position_in_node(name, position_context.position) {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-
 resolve_references :: proc(
 	document: ^Document,
 	ast_context: ^AstContext,
@@ -87,12 +71,26 @@ resolve_references :: proc(
 
 	reset_ast_context(ast_context)
 
-	if position_context.struct_type != nil &&
-	   position_in_struct_names(
-		   position_context,
-		   position_context.struct_type,
-	   ) {
-		return {}, true
+	if position_context.struct_type != nil {
+		found := false
+		done: for field in position_context.struct_type.fields.list {
+			for name in field.names {
+				if position_in_node(name, position_context.position) {
+					symbol = Symbol {
+						range = common.get_token_range(
+							name,
+							string(document.text),
+						),
+					}
+					found = true
+					resolve_flag = .Field
+					break done
+				}
+			}
+		}
+		if !found {
+			return {}, false
+		}
 	} else if position_context.enum_type != nil {
 		return {}, true
 	} else if position_context.bitset_type != nil {
@@ -100,53 +98,43 @@ resolve_references :: proc(
 	} else if position_context.union_type != nil {
 		return {}, true
 	} else if position_context.selector_expr != nil {
-		if resolved, ok := resolve_type_expression(
-			ast_context,
-			position_context.selector,
-		); ok {
-			if _, is_package := resolved.value.(SymbolPackageValue);
-			   !is_package {
-				return {}, true
-			}
-			resolve_flag = .Constant
-		}
+		resolve_flag = .Field
 
-		symbol, ok = resolve_location_selector(
-			ast_context,
-			position_context.selector_expr,
-		)
+		base: ^ast.Ident
+		base, ok = position_context.selector.derived.(^ast.Ident)
 
-		if !ok {
+		if !ok || position_context.identifier == nil {
 			return {}, true
 		}
 
-		if ident, ok := position_context.identifier.derived.(^ast.Ident); ok {
-			reference = ident.name
-		} else {
-			return {}, true
-		}
-	} else if position_context.implicit {
-		return {}, true
-	} else if position_context.identifier != nil {
 		ident := position_context.identifier.derived.(^ast.Ident)
 
-		if resolved, ok := resolve_type_identifier(ast_context, ident^); ok {
-			if resolved.type == .Variable {
-				resolve_flag = .Variable
-			} else {
-				resolve_flag = .Constant
+		if position_in_node(base, position_context.position) {
+			symbol, ok = resolve_location_identifier(ast_context, ident^)
+
+			if !ok {
+				return {}, true
 			}
+
+			resolve_flag = .Base
 		} else {
-			log.errorf(
-				"Failed to resolve identifier for indexing: %v",
-				ident.name,
+			symbol, ok = resolve_location_selector(
+				ast_context,
+				position_context.selector_expr,
 			)
-			return {}, true
+
+			resolve_flag = .Field
 		}
+	} else if position_context.implicit {
+		return {}, true
+	} else if position_context.identifier != nil {
+		ident := position_context.identifier.derived.(^ast.Ident)
 
 		reference = ident.name
 		symbol, ok = resolve_location_identifier(ast_context, ident^)
 
+		resolve_flag = .Identifier
+
 		if !ok {
 			return {}, true
 		}