compiler: accept pointer operand to @export

This commit does not yet migrate uses of this builtin.

Resolves: #14911

Author: mlugg

lib/std/zig/AstGen.zig

@@ -2855,7 +2855,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .ensure_result_non_error,
             .ensure_err_union_payload_void,
             .@"export",
-            .export_value,
             .set_eval_branch_quota,
             .atomic_store,
             .store_node,
@@ -9136,87 +9135,11 @@ fn builtinCall(
         // zig fmt: on
 
         .@"export" => {
-            const node_tags = tree.nodes.items(.tag);
-            const node_datas = tree.nodes.items(.data);
-            // This function causes a Decl to be exported. The first parameter is not an expression,
-            // but an identifier of the Decl to be exported.
-            var namespace: Zir.Inst.Ref = .none;
-            var decl_name: Zir.NullTerminatedString = .empty;
-            switch (node_tags[params[0]]) {
-                .identifier => {
-                    const ident_token = main_tokens[params[0]];
-                    if (isPrimitive(tree.tokenSlice(ident_token))) {
-                        return astgen.failTok(ident_token, "unable to export primitive value", .{});
-                    }
-                    decl_name = try astgen.identAsString(ident_token);
-
-                    var s = scope;
-                    var found_already: ?Ast.Node.Index = null; // we have found a decl with the same name already
-                    while (true) switch (s.tag) {
-                        .local_val => {
-                            const local_val = s.cast(Scope.LocalVal).?;
-                            if (local_val.name == decl_name) {
-                                local_val.used = ident_token;
-                                _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
-                                    .operand = local_val.inst,
-                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
-                                });
-                                return rvalue(gz, ri, .void_value, node);
-                            }
-                            s = local_val.parent;
-                        },
-                        .local_ptr => {
-                            const local_ptr = s.cast(Scope.LocalPtr).?;
-                            if (local_ptr.name == decl_name) {
-                                if (!local_ptr.maybe_comptime)
-                                    return astgen.failNode(params[0], "unable to export runtime-known value", .{});
-                                local_ptr.used = ident_token;
-                                const loaded = try gz.addUnNode(.load, local_ptr.ptr, node);
-                                _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
-                                    .operand = loaded,
-                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
-                                });
-                                return rvalue(gz, ri, .void_value, node);
-                            }
-                            s = local_ptr.parent;
-                        },
-                        .gen_zir => s = s.cast(GenZir).?.parent,
-                        .defer_normal, .defer_error => s = s.cast(Scope.Defer).?.parent,
-                        .namespace => {
-                            const ns = s.cast(Scope.Namespace).?;
-                            if (ns.decls.get(decl_name)) |i| {
-                                if (found_already) |f| {
-                                    return astgen.failNodeNotes(node, "ambiguous reference", .{}, &.{
-                                        try astgen.errNoteNode(f, "declared here", .{}),
-                                        try astgen.errNoteNode(i, "also declared here", .{}),
-                                    });
-                                }
-                                // We found a match but must continue looking for ambiguous references to decls.
-                                found_already = i;
-                            }
-                            s = ns.parent;
-                        },
-                        .top => break,
-                    };
-                    if (found_already == null) {
-                        const ident_name = try astgen.identifierTokenString(ident_token);
-                        return astgen.failNode(params[0], "use of undeclared identifier '{s}'", .{ident_name});
-                    }
-                },
-                .field_access => {
-                    const namespace_node = node_datas[params[0]].lhs;
-                    namespace = try typeExpr(gz, scope, namespace_node);
-                    const dot_token = main_tokens[params[0]];
-                    const field_ident = dot_token + 1;
-                    decl_name = try astgen.identAsString(field_ident);
-                },
-                else => return astgen.failNode(params[0], "symbol to export must identify a declaration", .{}),
-            }
-            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]);
-            _ = try gz.addPlNode(.@"export", node, Zir.Inst.Export{
-                .namespace = namespace,
-                .decl_name = decl_name,
-                .options = options,
+            const ptr_inst = try comptimeExpr(gz, scope, .{ .rl = .none }, params[0]);
+            const options_inst = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]);
+            _ = try gz.addPlNode(.@"export", node, Zir.Inst.Bin{
+                .lhs = ptr_inst,
+                .rhs = options_inst,
             });
             return rvalue(gz, ri, .void_value, node);
         },

lib/std/zig/Zir.zig

@@ -436,14 +436,10 @@ pub const Inst = struct {
         error_union_type,
         /// `error.Foo` syntax. Uses the `str_tok` field of the Data union.
         error_value,
-        /// Implements the `@export` builtin function, based on either an identifier to a Decl,
-        /// or field access of a Decl. The thing being exported is the Decl.
-        /// Uses the `pl_node` union field. Payload is `Export`.
+        /// Implements the `@export` builtin function,
+        /// Uses the `pl_node` union field. Payload is `Bin`.
+        /// `lhs` is pointer to export, `rhs` is options.
         @"export",
-        /// Implements the `@export` builtin function, based on a comptime-known value.
-        /// The thing being exported is the comptime-known value which is the operand.
-        /// Uses the `pl_node` union field. Payload is `ExportValue`.
-        export_value,
         /// Given a pointer to a struct or object that contains virtual fields, returns a pointer
         /// to the named field. The field name is stored in string_bytes. Used by a.b syntax.
         /// Uses `pl_node` field. The AST node is the a.b syntax. Payload is Field.
@@ -1103,7 +1099,6 @@ pub const Inst = struct {
                 .ensure_result_non_error,
                 .ensure_err_union_payload_void,
                 .@"export",
-                .export_value,
                 .field_ptr,
                 .field_val,
                 .field_ptr_named,
@@ -1325,7 +1320,6 @@ pub const Inst = struct {
                 .validate_deref,
                 .validate_destructure,
                 .@"export",
-                .export_value,
                 .set_runtime_safety,
                 .memcpy,
                 .memset,
@@ -1653,7 +1647,6 @@ pub const Inst = struct {
                 .error_union_type = .pl_node,
                 .error_value = .str_tok,
                 .@"export" = .pl_node,
-                .export_value = .pl_node,
                 .field_ptr = .pl_node,
                 .field_val = .pl_node,
                 .field_ptr_named = .pl_node,
@@ -3416,21 +3409,6 @@ pub const Inst = struct {
         };
     };
 
-    pub const Export = struct {
-        /// If present, this is referring to a Decl via field access, e.g. `a.b`.
-        /// If omitted, this is referring to a Decl via identifier, e.g. `a`.
-        namespace: Ref,
-        /// Null-terminated string index.
-        decl_name: NullTerminatedString,
-        options: Ref,
-    };
-
-    pub const ExportValue = struct {
-        /// The comptime value to export.
-        operand: Ref,
-        options: Ref,
-    };
-
     /// Trailing: `CompileErrors.Item` for each `items_len`.
     pub const CompileErrors = struct {
         items_len: u32,

src/Module.zig

@@ -3781,7 +3781,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
         const export_src: LazySrcLoc = .{ .token_offset = @intFromBool(decl.is_pub) };
         if (is_inline) return sema.fail(&block_scope, export_src, "export of inline function", .{});
         // The scope needs to have the decl in it.
-        try sema.analyzeExport(&block_scope, export_src, .{ .name = decl.name }, decl_index);
+        try sema.analyzeExport(&block_scope, export_src, .{ .name = decl.name }, .{ .decl_index = decl_index });
     }
 
     return result;

src/Sema.zig

@@ -1409,11 +1409,6 @@ fn analyzeBodyInner(
                 i += 1;
                 continue;
             },
-            .export_value => {
-                try sema.zirExportValue(block, inst);
-                i += 1;
-                continue;
-            },
             .set_runtime_safety => {
                 try sema.zirSetRuntimeSafety(block, inst);
                 i += 1;
@@ -6358,85 +6353,89 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const tracy = trace(@src());
     defer tracy.end();
 
-    const mod = sema.mod;
+    const zcu = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
-    const extra = sema.code.extraData(Zir.Inst.Export, inst_data.payload_index).data;
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src = inst_data.src();
     const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
     const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
-    const decl_name = try mod.intern_pool.getOrPutString(mod.gpa, sema.code.nullTerminatedString(extra.decl_name));
-    const decl_index = if (extra.namespace != .none) index_blk: {
-        const container_ty = try sema.resolveType(block, operand_src, extra.namespace);
-        const container_namespace = container_ty.getNamespaceIndex(mod);
-
-        const maybe_index = try sema.lookupInNamespace(block, operand_src, container_namespace, decl_name, false);
-        break :index_blk maybe_index orelse
-            return sema.failWithBadMemberAccess(block, container_ty, operand_src, decl_name);
-    } else try sema.lookupIdentifier(block, operand_src, decl_name);
-    const options = sema.resolveExportOptions(block, .unneeded, extra.options) catch |err| switch (err) {
-        error.NeededSourceLocation => {
-            _ = try sema.resolveExportOptions(block, options_src, extra.options);
-            unreachable;
-        },
-        else => |e| return e,
-    };
-    {
-        try mod.ensureDeclAnalyzed(decl_index);
-        const exported_decl = mod.declPtr(decl_index);
-        if (exported_decl.val.getFunction(mod)) |function| {
-            return sema.analyzeExport(block, src, options, function.owner_decl);
-        }
+
+    const operand = try sema.resolveInst(extra.lhs);
+    const ptr_val = try sema.resolveConstDefinedValue(block, operand_src, operand, .{
+        .needed_comptime_reason = "export pointer must be comptime-known",
+    });
+    const ptr_ty = ptr_val.typeOf(zcu);
+
+    switch (ptr_ty.zigTypeTag(zcu)) {
+        .Pointer => if (ptr_ty.isSlice(zcu)) return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(block, operand_src, "expected pointer, found '{}'", .{ptr_ty.fmt(zcu)});
+            errdefer msg.destroy(sema.gpa);
+            try sema.errNote(block, operand_src, msg, "use 'ptr' field to convert slice to many pointer", .{});
+            break :msg msg;
+        }),
+        else => return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(block, operand_src, "expected pointer, found '{}'", .{ptr_ty.fmt(zcu)});
+            errdefer msg.destroy(sema.gpa);
+            try sema.errNote(block, operand_src, msg, "take the address of a value to export it", .{});
+            break :msg msg;
+        }),
     }
-    try sema.analyzeExport(block, src, options, decl_index);
-}
 
-fn zirExportValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const options = try sema.resolveExportOptions(block, options_src, extra.rhs);
 
-    const mod = sema.mod;
-    const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
-    const extra = sema.code.extraData(Zir.Inst.ExportValue, inst_data.payload_index).data;
-    const src = inst_data.src();
-    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
-    const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
-    const operand = try sema.resolveInstConst(block, operand_src, extra.operand, .{
-        .needed_comptime_reason = "export target must be comptime-known",
-    });
-    const options = try sema.resolveExportOptions(block, options_src, extra.options);
-    if (options.linkage == .internal)
-        return;
-    if (operand.getFunction(mod)) |function| {
-        const decl_index = function.owner_decl;
-        return sema.analyzeExport(block, src, options, decl_index);
+    if (ptr_val.canMutateComptimeVarState(zcu)) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(block, operand_src, "export pointer contains reference to comptime var", .{});
+            errdefer msg.destroy(sema.gpa);
+            try sema.errNote(block, operand_src, msg, "comptime var pointers are not available at runtime", .{});
+            break :msg msg;
+        });
     }
 
-    try addExport(mod, .{
-        .opts = options,
-        .src = src,
-        .owner_decl = sema.owner_decl_index,
-        .src_decl = block.src_decl,
-        .exported = .{ .value = operand.toIntern() },
-        .status = .in_progress,
-    });
+    // TODO: support exporting part of Decl, so always use Decl if `ptr_val.pointerDecl(zcu) != .none`
+    const exported: Module.Exported = switch (zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr) {
+        .decl => |decl_index| .{ .decl_index = decl_index },
+        else => e: {
+            const val = try sema.pointerDeref(block, operand_src, ptr_val, ptr_val.typeOf(zcu)) orelse
+                return sema.failWithOwnedErrorMsg(block, msg: {
+                const msg = try sema.errMsg(block, operand_src, "export target is not comptime-known", .{});
+                errdefer msg.destroy(sema.gpa);
+                try sema.errNote(block, operand_src, msg, "export must refer to global declaration or comptime-known value", .{});
+                break :msg msg;
+            });
+            break :e .{ .value = val.toIntern() };
+        },
+    };
+    try sema.analyzeExport(block, src, options, exported);
 }
 
 pub fn analyzeExport(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
     options: Module.Export.Options,
-    exported_decl_index: InternPool.DeclIndex,
+    exported: Module.Exported,
 ) !void {
     const gpa = sema.gpa;
     const mod = sema.mod;
 
     if (options.linkage == .internal)
         return;
 
-    try mod.ensureDeclAnalyzed(exported_decl_index);
-    const exported_decl = mod.declPtr(exported_decl_index);
-    const export_ty = exported_decl.typeOf(mod);
+    const export_val = switch (exported) {
+        .decl_index => |decl_index| ty: {
+            try mod.ensureDeclAnalyzed(decl_index);
+            const exported_decl = mod.declPtr(decl_index);
+            break :ty exported_decl.val;
+        },
+        .value => |ip_index| Value.fromInterned(ip_index),
+    };
+    if (export_val.getFunction(mod)) |func| {
+        if (exported != .decl_index or exported.decl_index != func.owner_decl) {
+            return sema.analyzeExport(block, src, options, .{ .decl_index = func.owner_decl });
+        }
+    }
+    const export_ty = export_val.typeOf(mod);
 
     if (!try sema.validateExternType(export_ty, .other)) {
         const msg = msg: {
@@ -6452,19 +6451,29 @@ pub fn analyzeExport(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
-    // TODO: some backends might support re-exporting extern decls
-    if (exported_decl.isExtern(mod)) {
-        return sema.fail(block, src, "export target cannot be extern", .{});
+    switch (exported) {
+        .decl_index => |decl_index| {
+            const exported_decl = mod.declPtr(decl_index);
+            // TODO: some backends might support re-exporting extern decls
+            if (exported_decl.isExtern(mod)) {
+                return sema.fail(block, src, "export target cannot be extern", .{});
+            }
+        },
+        .value => {},
     }
 
-    try sema.maybeQueueFuncBodyAnalysis(exported_decl_index);
+    if (mod.intern_pool.isFuncBody(export_val.toIntern()) and
+        try sema.fnHasRuntimeBits(export_ty))
+    {
+        try mod.ensureFuncBodyAnalysisQueued(export_val.toIntern());
+    }
 
     try addExport(mod, .{
         .opts = options,
         .src = src,
         .owner_decl = sema.owner_decl_index,
         .src_decl = block.src_decl,
-        .exported = .{ .decl_index = exported_decl_index },
+        .exported = exported,
         .status = .in_progress,
     });
 }