Struct initialization of optional pointer doesn't get resolved

[MaxCross2500]

const T = struct { a: i32, b: i32 };
var t: ?*const T = &.{ .a = 0, .b = 0 };
t = &.{ .a = 1, .b = 1 };

I don't get completions for a and b, and can't go to their definitions.

I sort-of tried to poke at it myself, and so far managed to get resolution working (can go to definition of a and b) and completions for line 2, but not line 3 and not in function arguments with an arg type of ?*const T.
I simply tried to resolve optional unwrap when resolving address_of operator.

--- a/src/analysis.zig
+++ b/src/analysis.zig
@@ -6728,24 +6728,29 @@ pub fn resolveExpressionTypeFromAncestors(
         .address_of => {
             std.debug.assert(node == tree.nodeData(ancestors[0]).node);
 
             const expr_ty = try analyser.resolveExpressionType(
                 handle,
                 ancestors[0],
                 ancestors[1..],
             ) orelse return null;
 
             if (try analyser.resolveDerefType(expr_ty)) |ty| {
                 return ty;
             }
+            if (try analyser.resolveOptionalUnwrap(expr_ty)) |ty| {
+                if (try analyser.resolveDerefType(ty)) |tty| {
+                    return tty;
+                }
+            }

[MaxCross2500]

Completions for fields in line 3 started working after this. Still haven't figured out completions for function args (even though go to definition works if the line is complete).

--- a/src/features/completions.zig
+++ b/src/features/completions.zig
@@ -1728,22 +1728,23 @@ fn collectBuiltinContainerNodes(
 fn collectVarAccessContainerNodes(
     builder: *Builder,
     handle: *DocumentStore.Handle,
     loc: offsets.Loc,
     dot_context: EnumLiteralContext,
     types_with_handles: *Analyser.Type.ArraySet,
 ) Analyser.Error!void {
     const analyser = builder.analyser;
 
     const symbol_decl = try analyser.lookupSymbolGlobal(handle, handle.tree.source[loc.start..loc.end], loc.end) orelse return;
-    const result = try symbol_decl.resolveType(analyser) orelse return;
-    const type_expr = try analyser.resolveDerefType(result) orelse result;
+    var type_expr = try symbol_decl.resolveType(analyser) orelse return;
+    if (dot_context.likely == .struct_field) type_expr = try analyser.resolveOptionalUnwrap(type_expr) orelse type_expr;
+    type_expr = try analyser.resolveDerefType(type_expr) orelse type_expr;

[MaxCross2500]

I got completions for function args working.
I can open PR if needed, but it's just me poking at unfamiliar codebase just to get it working, so I'm not sure it it breaks anything.
Total diff

diff --git a/src/analysis.zig b/src/analysis.zig
index 45919db6..fb3519e9 100644
--- a/src/analysis.zig
+++ b/src/analysis.zig
@@ -6737,6 +6737,11 @@ pub fn resolveExpressionTypeFromAncestors(
             if (try analyser.resolveDerefType(expr_ty)) |ty| {
                 return ty;
             }
+            if (try analyser.resolveOptionalUnwrap(expr_ty)) |ty| {
+                if (try analyser.resolveDerefType(ty)) |tty| {
+                    return tty;
+                }
+            }
 
             switch (expr_ty.data) {
                 .pointer => |info| switch (info.size) {
diff --git a/src/features/completions.zig b/src/features/completions.zig
index 71d83ce6..c7226b0a 100644
--- a/src/features/completions.zig
+++ b/src/features/completions.zig
@@ -1735,8 +1735,9 @@ fn collectVarAccessContainerNodes(
     const analyser = builder.analyser;
 
     const symbol_decl = try analyser.lookupSymbolGlobal(handle, handle.tree.source[loc.start..loc.end], loc.end) orelse return;
-    const result = try symbol_decl.resolveType(analyser) orelse return;
-    const type_expr = try analyser.resolveDerefType(result) orelse result;
+    var type_expr = try symbol_decl.resolveType(analyser) orelse return;
+    if (dot_context.likely == .struct_field) type_expr = type_expr.resolveDeclLiteralResultType();
+    type_expr = try analyser.resolveDerefType(type_expr) orelse type_expr;
     if (!type_expr.isFunc()) {
         _ = try type_expr.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
         return;
@@ -1752,7 +1753,8 @@ fn collectVarAccessContainerNodes(
     }
     const param_index = dot_context.fn_arg_index;
     if (param_index >= info.parameters.len) return;
-    const param_type = info.parameters[param_index].type;
+    var param_type = info.parameters[param_index].type;
+    if (dot_context.likely == .struct_field) param_type = param_type.resolveDeclLiteralResultType();
     _ = try param_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
 }
 
@@ -1786,7 +1788,8 @@ fn collectFieldAccessTypes(
     const params = info.parameters;
     const param_index = dot_context.fn_arg_index + @intFromBool(has_self_param);
     if (param_index >= params.len) return;
-    const param_type = params[param_index].type;
+    var param_type = params[param_index].type;
+    if (dot_context.likely == .struct_field) param_type = param_type.resolveDeclLiteralResultType();
     _ = try param_type.getAllTypesWithHandlesArraySet(analyser, types_with_handles);
 }