Fix orelse type resolution

src/analysis.zig

@@ -1470,7 +1470,13 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, node_handle: NodeWithHandle) e
                 .deref => try analyser.resolveDerefType(base_type),
                 .unwrap_optional => try analyser.resolveOptionalUnwrap(base_type),
                 .array_access => try analyser.resolveBracketAccessType(base_type, .Single),
-                .@"orelse" => try analyser.resolveOptionalUnwrap(base_type),
+                .@"orelse" => {
+                    const type_right = try analyser.resolveTypeOfNodeInternal(.{ .node = datas[node].rhs, .handle = handle }) orelse return null;
+                    return switch (type_right.data) {
+                        .optional => type_right,
+                        else => try analyser.resolveOptionalUnwrap(base_type),
+                    };
+                },
                 .@"catch" => try analyser.resolveUnwrapErrorUnionType(base_type, .payload),
                 .@"try" => try analyser.resolveUnwrapErrorUnionType(base_type, .payload),
                 .address_of => try analyser.resolveAddressOf(base_type),
@@ -1853,13 +1859,29 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, node_handle: NodeWithHandle) e
                 label_token: ?Ast.TokenIndex,
                 then_expr: Ast.Node.Index,
                 else_expr: Ast.Node.Index,
-            } = if (ast.fullWhile(tree, node)) |while_node|
-                .{
+            } = if (ast.fullWhile(tree, node)) |while_node| no_hang: {
+
+                // while (true) {} is a noreturn type
+                if (try analyser.resolveTypeOfNodeInternal(.{ .node = while_node.ast.cond_expr, .handle = handle })) |cond_type| {
+                    switch (cond_type.data) {
+                        .ip_index => |payload| {
+                            switch (payload.index) {
+                                .bool_true => {
+                                    return try Type.typeValFromIP(analyser, .noreturn_type);
+                                },
+                                else => {},
+                            }
+                        },
+                        else => {},
+                    }
+                }
+
+                break :no_hang .{
                     .label_token = while_node.label_token,
                     .then_expr = while_node.ast.then_expr,
                     .else_expr = while_node.ast.else_expr,
-                }
-            else if (ast.fullFor(tree, node)) |for_node|
+                };
+            } else if (ast.fullFor(tree, node)) |for_node|
                 .{
                     .label_token = for_node.label_token,
                     .then_expr = for_node.ast.then_expr,
@@ -2122,10 +2144,13 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, node_handle: NodeWithHandle) e
         .switch_case,
         .switch_case_inline,
         .switch_range,
+        => {},
         .@"continue",
         .@"break",
         .@"return",
-        => {},
+        => {
+            return try Type.typeValFromIP(analyser, .noreturn_type);
+        },
 
         .@"await",
         .@"suspend",

tests/lsp_features/hover.zig

@@ -554,6 +554,84 @@ test "optional" {
         \\
         \\Go to [S](file:///test.zig#L1)
     );
+
+    try testHover(
+        \\const foo: ?i32 = 5;
+        \\const b<cursor>ar = foo orelse 0;
+    ,
+        \\```zig
+        \\const bar = foo orelse 0
+        \\```
+        \\```zig
+        \\(i32)
+        \\```
+    );
+
+    try testHover(
+        \\const foo: ?i32 = 5;
+        \\const b<cursor>ar = foo orelse foo;
+    ,
+        \\```zig
+        \\const bar = foo orelse foo
+        \\```
+        \\```zig
+        \\(?i32)
+        \\```
+    );
+
+    try testHover(
+        \\const foo: ?i32 = 5;
+        \\const b<cursor>ar = foo orelse unreachable;
+    ,
+        \\```zig
+        \\const bar = foo orelse unreachable
+        \\```
+        \\```zig
+        \\(i32)
+        \\```
+    );
+
+    try testHover(
+        \\fn foo(a: ?i32) void {
+        \\    const b<cursor>ar = a orelse return;
+        \\}
+    ,
+        \\```zig
+        \\const bar = a orelse return
+        \\```
+        \\```zig
+        \\(i32)
+        \\```
+    );
+
+    try testHover(
+        \\fn foo() void {
+        \\    const array: [1]?i32 = [1]?i32{ 4 };
+        \\    for (array) |elem| {
+        \\        const b<cursor>ar = elem orelse continue;
+        \\    }
+        \\}
+    ,
+        \\```zig
+        \\const bar = elem orelse continue
+        \\```
+        \\```zig
+        \\(i32)
+        \\```
+    );
+
+    try testHover(
+        \\fn foo(foo: ?i32) void {
+        \\    const b<cursor>ar = foo orelse while (true) {};
+        \\}
+    ,
+        \\```zig
+        \\const bar = foo orelse while (true) {}
+        \\```
+        \\```zig
+        \\(i32)
+        \\```
+    );
 }
 
 test "error union" {