Merge pull request #2644 from FnControlOption/intern

Intern {pointer,array,tuple,optional,error union} types when possible

Author: Techatrix

src/analyser/InternPool.zig

@@ -2258,6 +2258,27 @@ pub fn resolvePeerTypes(ip: *InternPool, types: []const Index, target: std.Targe
                     chosen = try ip.errorSetMerge(chosen, candidate);
                     continue;
                 },
+                .error_union_type => |chosen_info| {
+                    if (chosen_info.error_set_type != .none) {
+                        chosen = try ip.get(.{ .error_union_type = .{
+                            .error_set_type = try ip.errorSetMerge(chosen_info.error_set_type, candidate),
+                            .payload_type = chosen_info.payload_type,
+                        } });
+                        continue;
+                    }
+                },
+                else => {},
+            },
+            .error_union_type => |candidate_info| switch (chosen_key) {
+                .error_set_type => {
+                    if (candidate_info.error_set_type != .none) {
+                        chosen = try ip.get(.{ .error_union_type = .{
+                            .error_set_type = try ip.errorSetMerge(chosen, candidate_info.error_set_type),
+                            .payload_type = candidate_info.payload_type,
+                        } });
+                        continue;
+                    }
+                },
                 else => {},
             },
             else => {},
@@ -3534,6 +3555,8 @@ pub fn errorSetMerge(ip: *InternPool, a_ty: Index, b_ty: Index) Allocator.Error!
     for (a_names) |name| set.putAssumeCapacityNoClobber(name, {});
     for (b_names) |name| set.putAssumeCapacity(name, {});
 
+    ip.string_pool.sortStrings(ip.io, set.keys());
+
     return try ip.get(.{
         .error_set_type = .{
             .owner_decl = .none,
@@ -4057,7 +4080,7 @@ fn printInternal(ip: *InternPool, ty: Index, writer: *std.Io.Writer, options: Fo
         .union_type => return panicOrElse(?Index, "TODO", null),
         .tuple_type => |tuple_info| {
             assert(tuple_info.types.len == tuple_info.values.len);
-            try writer.writeAll("tuple{");
+            try writer.writeAll("struct { ");
 
             for (0..tuple_info.types.len) |i| {
                 const field_ty = tuple_info.types.at(@intCast(i), ip);
@@ -4073,7 +4096,7 @@ fn printInternal(ip: *InternPool, ty: Index, writer: *std.Io.Writer, options: Fo
                     try ip.print(field_val, writer, options);
                 }
             }
-            try writer.writeByte('}');
+            try writer.writeAll(" }");
         },
         .vector_type => |vector_info| {
             try writer.print("@Vector({d},{f})", .{
@@ -5248,18 +5271,23 @@ test "resolvePeerTypes error sets" {
         .names = try ip.getStringSlice(&.{bar_name}),
     } });
 
-    const @"error{foo,bar}" = try ip.get(.{ .error_set_type = .{
-        .owner_decl = .none,
-        .names = try ip.getStringSlice(&.{ foo_name, bar_name }),
-    } });
-
     const @"error{bar,foo}" = try ip.get(.{ .error_set_type = .{
         .owner_decl = .none,
         .names = try ip.getStringSlice(&.{ bar_name, foo_name }),
     } });
 
-    try ip.testResolvePeerTypesInOrder(@"error{foo}", @"error{bar}", @"error{foo,bar}");
-    try ip.testResolvePeerTypesInOrder(@"error{bar}", @"error{foo}", @"error{bar,foo}");
+    const @"error{bar}!i32" = try ip.get(.{ .error_union_type = .{
+        .error_set_type = @"error{bar}",
+        .payload_type = .i32_type,
+    } });
+
+    const @"error{bar,foo}!i32" = try ip.get(.{ .error_union_type = .{
+        .error_set_type = @"error{bar,foo}",
+        .payload_type = .i32_type,
+    } });
+
+    try ip.testResolvePeerTypes(@"error{foo}", @"error{bar}", @"error{bar,foo}");
+    try ip.testResolvePeerTypes(@"error{foo}", @"error{bar}!i32", @"error{bar,foo}!i32");
 }
 
 fn testResolvePeerTypes(ip: *InternPool, a: Index, b: Index, expected: Index) !void {

src/analyser/completions.zig

@@ -170,9 +170,9 @@ pub fn dotCompletions(
             try completions.ensureUnusedCapacity(arena, tuple_info.types.len);
             for (tuple_types, 0..) |tuple_ty, i| {
                 completions.appendAssumeCapacity(.{
-                    .label = try std.fmt.allocPrint(arena, "{d}", .{i}),
+                    .label = try std.fmt.allocPrint(arena, "@\"{d}\"", .{i}),
                     .kind = .Field,
-                    .detail = try std.fmt.allocPrint(arena, "{d}: {f}", .{ i, tuple_ty.fmt(ip) }),
+                    .detail = try std.fmt.allocPrint(arena, "{f}", .{tuple_ty.fmt(ip)}),
                 });
             }
         },

src/analyser/string_pool.zig

@@ -167,6 +167,18 @@ pub fn StringPool(comptime config: Config) type {
             return std.mem.sliceTo(string_bytes + start, 0);
         }
 
+        pub fn sortStrings(pool: *Pool, io: std.Io, indexes: []String) void {
+            pool.mutex.lockUncancelable(io);
+            defer pool.mutex.unlock(io);
+            std.mem.sort(String, indexes, pool, stringLessThanUnsafe);
+        }
+
+        fn stringLessThanUnsafe(pool: *Pool, a: String, b: String) bool {
+            const a_slice = pool.stringToSliceUnsafe(a);
+            const b_slice = pool.stringToSliceUnsafe(b);
+            return std.mem.lessThan(u8, a_slice, b_slice);
+        }
+
         mutex: MutexType,
         bytes: std.ArrayList(u8),
         map: std.HashMapUnmanaged(u32, void, std.hash_map.StringIndexContext, std.hash_map.default_max_load_percentage),