several fixes around decl or enum literals (#2552)

- opaque types are now also searched for decl literals
- enum literal types are now resolved if there's a result location type
- inlay hints are now printed for decl literal function calls

Author: dotcarmen

src/analysis.zig

@@ -2770,7 +2770,16 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, options: ResolveOptions) error
             return if (value) |v| Type.fromIP(analyser, ty, v) else Type.fromIP(analyser, ty, null);
         },
 
-        .enum_literal => return Type.fromIP(analyser, .enum_literal_type, null),
+        .enum_literal => {
+            const source_token = tree.tokenStart(tree.nodeMainToken(node));
+            const lineage = try ast.nodesOverlappingIndex(analyser.arena, tree, source_token);
+            defer analyser.arena.free(lineage);
+
+            const tag = offsets.identifierTokenToNameSlice(tree, tree.nodeMainToken(node));
+            const decl = (try analyser.lookupSymbolFieldInit(handle, tag, node, lineage[1..])) orelse return Type.fromIP(analyser, .enum_literal_type, null);
+            return decl.resolveType(analyser);
+        },
+
         .unreachable_literal => return Type.fromIP(analyser, .noreturn_type, null),
         .anyframe_literal => return Type.fromIP(analyser, .anyframe_type, null),
 
@@ -5896,7 +5905,7 @@ pub fn lookupSymbolFieldInit(
     }
 
     switch (container_type.getContainerKind() orelse return null) {
-        .keyword_struct => {},
+        .keyword_struct, .keyword_opaque => {},
         .keyword_enum => if (try (try container_type.typeOf(analyser)).lookupSymbol(analyser, field_name)) |ty| return ty,
         .keyword_union => if (try container_type.lookupSymbol(analyser, field_name)) |ty| return ty,
         else => return null,

src/features/inlay_hints.zig

@@ -399,7 +399,7 @@ fn writeCallNodeHint(builder: *Builder, call: Ast.full.Call) !void {
     const tree = &handle.tree;
 
     switch (tree.nodeTag(call.ast.fn_expr)) {
-        .identifier, .field_access => try writeCallHint(builder, call),
+        .identifier, .field_access, .enum_literal => try writeCallHint(builder, call),
         else => {
             log.debug("cannot deduce fn expression with tag '{}'", .{tree.nodeTag(call.ast.fn_expr)});
         },

tests/analysis/decl_literal.zig

@@ -22,6 +22,13 @@ const TaggedUnionType = union(EnumType) {
     const baz: TaggedUnionType = .{ .foo = 1 };
 };
 
+const OpaqueType = opaque {
+    pub fn init() *OpaqueType {
+        var value: void = {};
+        return @ptrCast(&value);
+    }
+};
+
 const some_struct: StructType = .baz;
 //                              ^^^^ (StructType)()
 
@@ -33,3 +40,6 @@ const some_union: UnionType = .baz;
 
 const some_tagged_union: TaggedUnionType = .baz;
 //                                         ^^^^ (TaggedUnionType)()
+
+const some_opaque: *OpaqueType = .init();
+//                               ^^^^^ (fn () *OpaqueType)()

tests/lsp_features/inlay_hints.zig

@@ -584,6 +584,15 @@ test "tuple fields" {
     , .{ .kind = .Type });
 }
 
+test "declaration literals" {
+    try testInlayHints(
+        \\const X = opaque { fn init(a_thing: u32, b_thing: u32) *X { _ = .{a_thing, b_thing}; const ignore: void = {}; return @ptrCast(&ignore); } };
+        \\test {
+        \\    const x: *X = .init(<a_thing>0, <b_thing>1);
+        \\}
+    , .{ .kind = .Parameter });
+}
+
 const Options = struct {
     kind: types.InlayHint.Kind,
     show_builtin: bool = true,