From 5fed32a9aac61d0c8e1a4c495dff7b5960a22714 Mon Sep 17 00:00:00 2001 From: Geoff Romer Date: Mon, 5 Oct 2026 22:26:12 +0000 Subject: [PATCH] Check support for simple `friend` declarations (#7890) As a drive-by fix, this also resolves an issue where out-of-line method definitions didn't have access to private class members. --- toolchain/check/context.h | 8 + toolchain/check/decl_name_stack.cpp | 1 + toolchain/check/handle_class.cpp | 60 +++++- toolchain/check/member_access.cpp | 7 + .../class/access/access_modifiers.carbon | 77 +++++++ .../check/testdata/class/access/friend.carbon | 189 ++++++++++++++++++ toolchain/diagnostics/kind.def | 2 + toolchain/sem_ir/class.h | 4 + 8 files changed, 343 insertions(+), 5 deletions(-) create mode 100644 toolchain/check/testdata/class/access/friend.carbon diff --git a/toolchain/check/context.h b/toolchain/check/context.h index 530377e422ec..d4e1765caa1e 100644 --- a/toolchain/check/context.h +++ b/toolchain/check/context.h @@ -129,6 +129,10 @@ class Context { return field_decls_stack_; } + auto friend_scopes_stack() -> ArrayStack& { + return friend_scopes_stack_; + } + auto require_impls_stack() -> RequireImplsStack& { return require_impls_stack_; } @@ -507,6 +511,10 @@ class Context { // The stack of FieldDecls for in-progress Class definitions. ArrayStack field_decls_stack_; + // The stack of `friend` decls for in-progress Class definitions, identified + // by the constant value of an expression that names them. + ArrayStack friend_scopes_stack_; + // The stack of RequireImpls for in-progress Interface and Constraint // definitions. RequireImplsStack require_impls_stack_; diff --git a/toolchain/check/decl_name_stack.cpp b/toolchain/check/decl_name_stack.cpp index ac1284830424..f6c211264742 100644 --- a/toolchain/check/decl_name_stack.cpp +++ b/toolchain/check/decl_name_stack.cpp @@ -321,6 +321,7 @@ auto DeclNameStack::ApplyNameQualifier(const NameComponent& name) -> void { name_context.parent_scope_id = PushNameQualifierScope( *context_, name_context.loc_id, scope_id, generic_id, context_->name_scopes().Get(scope_id).has_error()); + UpdateAccessContext(); } else { name_context.state = NameContext::State::Error; } diff --git a/toolchain/check/handle_class.cpp b/toolchain/check/handle_class.cpp index 02437612fd4b..7852bfd10ca6 100644 --- a/toolchain/check/handle_class.cpp +++ b/toolchain/check/handle_class.cpp @@ -166,6 +166,7 @@ auto HandleParseNode(Context& context, Parse::ClassDefinitionStartId node_id) context.inst_block_stack().Push(); context.node_stack().Push(node_id, class_id); context.field_decls_stack().PushArray(); + context.friend_scopes_stack().PushArray(); context.vtable_stack().Push(); // TODO: Handle the case where there's control flow in the class body. For @@ -443,13 +444,54 @@ auto HandleParseNode(Context& context, Parse::BaseDeclId node_id) -> bool { return true; } -auto HandleParseNode(Context& context, Parse::FriendIntroducerId node_id) - -> bool { - return context.TODO(node_id, "friend decl not supported in check"); +auto HandleParseNode(Context& /*context*/, + Parse::FriendIntroducerId /*node_id*/) -> bool { + return true; } auto HandleParseNode(Context& context, Parse::FriendDeclId node_id) -> bool { - return context.TODO(node_id, "friend decl not supported in check"); + auto [scope_node_id, scope_inst_id] = + context.node_stack().PopWithNodeId(); + + auto access_scope_inst_id = context.scope_stack().PeekInstId(); + auto access_scope_inst = context.constant_values().GetInst( + context.constant_values().Get(access_scope_inst_id)); + CARBON_KIND_SWITCH(access_scope_inst) { + case SemIR::ClassType::Kind: + case SemIR::GenericClassType::Kind: + break; + default: + CARBON_DIAGNOSTIC(FriendNotAllowedInScope, Error, + "`friend` declaration in non-class scope"); + context.emitter().Emit(node_id, FriendNotAllowedInScope); + return false; + } + + auto scope_const_id = context.constant_values().Get(scope_inst_id); + CARBON_CHECK(scope_const_id.is_constant()); + auto scope_constant = context.constant_values().GetInst(scope_const_id); + CARBON_KIND_SWITCH(scope_constant) { + case SemIR::StructValue::Kind: { + if (context.types().Is(scope_constant.type_id())) { + return context.TODO(node_id, + "befriending a function not yet implemented"); + } + [[fallthrough]]; + } + case SemIR::ClassType::Kind: + case SemIR::GenericClassType::Kind: + case SemIR::FacetType::Kind: + break; + default: { + CARBON_DIAGNOSTIC( + FriendNotNameScope, Error, + "friend declaration names entity that is not a name scope"); + context.emitter().Emit(scope_node_id, FriendNotNameScope); + return false; + } + } + context.friend_scopes_stack().AppendToTop(scope_const_id); + return true; } auto HandleParseNode(Context& context, Parse::ClassDefinitionId node_id) @@ -467,7 +509,15 @@ auto HandleParseNode(Context& context, Parse::ClassDefinitionId node_id) context.field_decls_stack().PopArray(); context.vtable_stack().Pop(); - FinishGenericDefinition(context, context.classes().Get(class_id).generic_id); + auto& class_info = context.classes().Get(class_id); + class_info.friend_scopes.GrowForInsertCount( + context.friend_scopes_stack().PeekArray().size()); + for (auto friend_scope_id : context.friend_scopes_stack().PeekArray()) { + class_info.friend_scopes.Insert(friend_scope_id); + } + context.friend_scopes_stack().PopArray(); + + FinishGenericDefinition(context, class_info.generic_id); // The decl_name_stack and scopes are popped by `ProcessNodeIds`. return true; diff --git a/toolchain/check/member_access.cpp b/toolchain/check/member_access.cpp index 50179673a590..227d442c598f 100644 --- a/toolchain/check/member_access.cpp +++ b/toolchain/check/member_access.cpp @@ -125,6 +125,13 @@ auto GetHighestAllowedAccess(Context& context, SemIR::NameScopeId::AllowHighestAccessLevel) { return SemIR::AccessKind::Private; } + auto& access_context_scope = + context.name_scopes().Get(access_context_scope_id); + auto access_const_id = + context.constant_values().Get(access_context_scope.inst_id()); + if (class_info.friend_scopes.Lookup(access_const_id)) { + return SemIR::AccessKind::Private; + } const auto& scope = context.name_scopes().Get(access_context_scope_id); access_context_scope_id = scope.parent_scope_id(); diff --git a/toolchain/check/testdata/class/access/access_modifiers.carbon b/toolchain/check/testdata/class/access/access_modifiers.carbon index b22e38f32ebc..a44e1bd7b522 100644 --- a/toolchain/check/testdata/class/access/access_modifiers.carbon +++ b/toolchain/check/testdata/class/access/access_modifiers.carbon @@ -110,6 +110,33 @@ class Circle { } } +// --- out_of_line_instance_private_field_access_on_self.carbon +library "[[@TEST_NAME]]"; + +class Circle { + private var radius: i32; + + fn GetRadius(self) -> i32; + + private fn SomeInternalFunction() -> i32 { + return 0; + } + + fn Compute(self) -> i32; +} + +fn Circle.GetRadius(self) -> i32 { +//@dump-sem-ir-begin + return self.radius; +//@dump-sem-ir-end +} + +fn Circle.Compute(self) -> i32 { +//@dump-sem-ir-begin + return self.SomeInternalFunction(); +//@dump-sem-ir-end +} + // --- public_global_access.carbon library "[[@TEST_NAME]]"; @@ -462,6 +489,56 @@ class A { // CHECK:STDOUT: return %Circle.SomeInternalFunction.call // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: --- out_of_line_instance_private_field_access_on_self.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: type: type = facet_type [concrete] +// CHECK:STDOUT: %Circle: type = class_type @Circle [concrete] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] +// CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] +// CHECK:STDOUT: %Circle.elem: type = unbound_element_type %Circle, %i32 [concrete] +// CHECK:STDOUT: %Circle.SomeInternalFunction.type: type = fn_type @Circle.SomeInternalFunction [concrete] +// CHECK:STDOUT: %Circle.SomeInternalFunction: %Circle.SomeInternalFunction.type = struct_value () [concrete] +// CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] +// CHECK:STDOUT: %Int.as.Copy.impl.Op.type.ac8: type = fn_type @Int.as.Copy.impl.Op, @Int.as.Copy.impl(%N) [symbolic] +// CHECK:STDOUT: %Int.as.Copy.impl.Op.5e0: %Int.as.Copy.impl.Op.type.ac8 = struct_value () [symbolic] +// CHECK:STDOUT: %Copy.impl_witness.b51: = impl_witness imports.%Copy.impl_witness_table.8d2, @Int.as.Copy.impl(%int_32) [concrete] +// CHECK:STDOUT: %Int.as.Copy.impl.Op.type.3f6: type = fn_type @Int.as.Copy.impl.Op, @Int.as.Copy.impl(%int_32) [concrete] +// CHECK:STDOUT: %Int.as.Copy.impl.Op.4f6: %Int.as.Copy.impl.Op.type.3f6 = struct_value () [concrete] +// CHECK:STDOUT: %Copy.facet: %Copy.type = facet_value %i32, (%Copy.impl_witness.b51) [concrete] +// CHECK:STDOUT: %Copy.WithSelf.Op.type.381: type = fn_type @Copy.WithSelf.Op, @Copy.WithSelf(%Copy.facet) [concrete] +// CHECK:STDOUT: %.737: type = fn_type_with_self_type %Copy.WithSelf.Op.type.381, %Copy.facet [concrete] +// CHECK:STDOUT: %Int.as.Copy.impl.Op.specific_fn: = specific_function %Int.as.Copy.impl.Op.4f6, @Int.as.Copy.impl.Op(%int_32) [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core.import_ref.cd6: @Int.as.Copy.impl.%Int.as.Copy.impl.Op.type (%Int.as.Copy.impl.Op.type.ac8) = import_ref Core//prelude/parts/int, loc{{\d+_\d+}}, loaded [symbolic = @Int.as.Copy.impl.%Int.as.Copy.impl.Op (constants.%Int.as.Copy.impl.Op.5e0)] +// CHECK:STDOUT: %Copy.impl_witness_table.8d2 = impl_witness_table (%Core.import_ref.cd6), @Int.as.Copy.impl [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Circle.GetRadius(%self.param.loc15: %Circle) -> out %return.param.loc15: %i32 { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %self.ref: %Circle = name_ref self, %self.loc15 +// CHECK:STDOUT: %radius.ref: %Circle.elem = name_ref radius, @Circle.%field_decl [concrete = @Circle.%field_decl] +// CHECK:STDOUT: %.loc17_14.1: ref %i32 = class_element_access %self.ref, element0 +// CHECK:STDOUT: %.loc17_14.2: %i32 = acquire_value %.loc17_14.1 +// CHECK:STDOUT: %impl.elem0: %.737 = impl_witness_access constants.%Copy.impl_witness.b51, element0 [concrete = constants.%Int.as.Copy.impl.Op.4f6] +// CHECK:STDOUT: %bound_method.loc17_14.1: = bound_method %.loc17_14.2, %impl.elem0 +// CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] +// CHECK:STDOUT: %bound_method.loc17_14.2: = bound_method %.loc17_14.2, %specific_fn +// CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc17_14.2(%.loc17_14.2) +// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Circle.Compute(%self.param.loc21: %Circle) -> out %return.param.loc21: %i32 { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %self.ref: %Circle = name_ref self, %self.loc21 +// CHECK:STDOUT: %SomeInternalFunction.ref: %Circle.SomeInternalFunction.type = name_ref SomeInternalFunction, @Circle.%Circle.SomeInternalFunction.decl [concrete = constants.%Circle.SomeInternalFunction] +// CHECK:STDOUT: %Circle.SomeInternalFunction.call: init %i32 = call %SomeInternalFunction.ref() +// CHECK:STDOUT: return %Circle.SomeInternalFunction.call +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: --- public_global_access.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { diff --git a/toolchain/check/testdata/class/access/friend.carbon b/toolchain/check/testdata/class/access/friend.carbon new file mode 100644 index 000000000000..44d767a5ef6b --- /dev/null +++ b/toolchain/check/testdata/class/access/friend.carbon @@ -0,0 +1,189 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// INCLUDE-FILE: toolchain/testing/testdata/min_prelude/int.carbon +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/class/access/friend.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/class/access/friend.carbon + +// --- fail_non_friend.carbon +library "[[@TEST_NAME]]"; + +class C { + private var i: i32; +} + +fn F(c: C) -> i32 { + // CHECK:STDERR: fail_non_friend.carbon:[[@LINE+7]]:10: error: cannot access private member `i` of type `C` [ClassInvalidMemberAccess] + // CHECK:STDERR: return c.i; + // CHECK:STDERR: ^~~ + // CHECK:STDERR: fail_non_friend.carbon:[[@LINE-7]]:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: private var i: i32; + // CHECK:STDERR: ^~~~~~ + // CHECK:STDERR: + return c.i; +} + +// --- fail_todo_friend_function.carbon +library "[[@TEST_NAME]]"; + +class C; + +fn F(c: C) -> i32; + +class C { + private var i: i32; + // CHECK:STDERR: fail_todo_friend_function.carbon:[[@LINE+4]]:3: error: semantics TODO: `befriending a function not yet implemented` [SemanticsTodo] + // CHECK:STDERR: friend F; + // CHECK:STDERR: ^~~~~~~~~ + // CHECK:STDERR: + friend F; +} + +fn F(c: C) -> i32 { + return c.i; +} + +// --- friend_class.carbon +library "[[@TEST_NAME]]"; + +class Friend; + +class C { + private var i: i32; + friend Friend; +} + +class Friend { + fn F(c: C) -> i32 { + return c.i; + } +} + +// --- out_of_line_method.carbon +library "[[@TEST_NAME]]"; + +class Friend; + +class C { + private var i: i32; + friend Friend; +} + +class Friend { + fn F(c: C) -> i32; +} + +fn Friend.F(c: C) -> i32 { + return c.i; +} + +// --- friend_complete_class.carbon +library "[[@TEST_NAME]]"; + +class C; + +class Friend { + fn F(c: C) -> i32; +} + +class C { + private var i: i32; + friend Friend; +} + +fn Friend.F(c: C) -> i32 { + return c.i; +} + +// --- friend_complete_class_fn.carbon +library "[[@TEST_NAME]]"; + +class Friend { + fn F() -> i32; +} + +class C { + private var i: i32; + private fn Make() -> C { return {.i = 0}; } + friend Friend; +} + +fn Friend.F() -> i32 { + return C.Make().i; +} + +// --- friend_parameterized_class.carbon +library "[[@TEST_NAME]]"; + +class Friend(T: type); + +class C { + private var i: i32; + friend Friend; +} + +class Friend(T: type) { + fn F(c: C) -> i32 { + return c.i; + } +} + +// --- fail_friend_var.carbon +library "[[@TEST_NAME]]"; + +var v: i32; + +class C { + private var i: i32; + // CHECK:STDERR: fail_friend_var.carbon:[[@LINE+4]]:10: error: friend declaration names entity that is not a name scope [FriendNotNameScope] + // CHECK:STDERR: friend v; + // CHECK:STDERR: ^ + // CHECK:STDERR: + friend v; +} + +// --- friend_interface.carbon +library "[[@TEST_NAME]]"; + +interface I; + +class C { + private var i: i32 = 0; + friend I; +} + +interface I { + default fn F(c: C) -> i32 { + return c.i; + } +} + +// --- fail_friend_not_in_class.carbon +library "[[@TEST_NAME]]"; + +class C; + +interface I { + // CHECK:STDERR: fail_friend_not_in_class.carbon:[[@LINE+4]]:3: error: `friend` declaration in non-class scope [FriendNotAllowedInScope] + // CHECK:STDERR: friend C; + // CHECK:STDERR: ^~~~~~~~~ + // CHECK:STDERR: + friend C; +} + +// --- fail_friend_not_constant.carbon +library "[[@TEST_NAME]]"; + +class C { + var v: i32; + // CHECK:STDERR: fail_friend_not_constant.carbon:[[@LINE+4]]:10: error: friend declaration names entity that is not a name scope [FriendNotNameScope] + // CHECK:STDERR: friend v; + // CHECK:STDERR: ^ + // CHECK:STDERR: + friend v; +} diff --git a/toolchain/diagnostics/kind.def b/toolchain/diagnostics/kind.def index de80e73f9854..fdacb23597da 100644 --- a/toolchain/diagnostics/kind.def +++ b/toolchain/diagnostics/kind.def @@ -334,6 +334,8 @@ CARBON_DIAGNOSTIC_KIND(ClassForwardDeclaredHere) CARBON_DIAGNOSTIC_KIND(ClassIncompleteWithinDefinition) CARBON_DIAGNOSTIC_KIND(FieldNamedUnderscore) CARBON_DIAGNOSTIC_KIND(FieldWithTuplePattern) +CARBON_DIAGNOSTIC_KIND(FriendNotAllowedInScope) +CARBON_DIAGNOSTIC_KIND(FriendNotNameScope) CARBON_DIAGNOSTIC_KIND(GenericVirtual) CARBON_DIAGNOSTIC_KIND(OverrideWithoutBase) CARBON_DIAGNOSTIC_KIND(OverrideWithoutVirtualInBase) diff --git a/toolchain/sem_ir/class.h b/toolchain/sem_ir/class.h index c73fd4e6304f..4dc2a9b262f9 100644 --- a/toolchain/sem_ir/class.h +++ b/toolchain/sem_ir/class.h @@ -77,6 +77,10 @@ struct ClassFields { // inherited) virtual functions. InstId vtable_decl_id = InstId::None; + // The scopes that are declared as friends of this class. Each scope is + // identified by the constant value of the expression that names it. + Set friend_scopes; + auto PrintClassFields(llvm::raw_ostream& out) const -> void { out << "self_type_id: " << self_type_id << ", inheritance_kind: "; switch (inheritance_kind) {