diff --git a/toolchain/check/BUILD b/toolchain/check/BUILD index 54491bd487423..3fea8437120fb 100644 --- a/toolchain/check/BUILD +++ b/toolchain/check/BUILD @@ -21,6 +21,7 @@ cc_library( "context.cpp", "control_flow.cpp", "convert.cpp", + "cpp/access.cpp", "cpp/call.cpp", "cpp/custom_type_mapping.cpp", "cpp/import.cpp", @@ -72,6 +73,7 @@ cc_library( "context.h", "control_flow.h", "convert.h", + "cpp/access.h", "cpp/call.h", "cpp/custom_type_mapping.h", "cpp/import.h", diff --git a/toolchain/check/cpp/access.cpp b/toolchain/check/cpp/access.cpp new file mode 100644 index 0000000000000..291577dffa499 --- /dev/null +++ b/toolchain/check/cpp/access.cpp @@ -0,0 +1,47 @@ +// 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 "toolchain/check/cpp/access.h" + +namespace Carbon::Check { + +static auto CalculateEffectiveAccess(clang::DeclAccessPair access_pair) + -> clang::AccessSpecifier { + // Note that we use `.getAccess()` here, not `->getAccess()`, which is + // equivalent to `.getDecl()->getAccess()`, because we want to consider the + // lookup access and not the lexical access. + switch (access_pair.getAccess()) { + // Lookup access takes precedence. + case clang::AS_public: + case clang::AS_protected: + case clang::AS_private: + return access_pair.getAccess(); + case clang::AS_none: + // No access specified meaning depends on the declaration. For non class + // members, it means there's no access associated with this function so we + // treat it as public. For class members it means we lost access along the + // inheritance path, and the difference between `none` and `private` only + // matters when the access check is performed within a friend or member of + // the naming class. Because the naming class is a C++ class, and we don't + // yet have a mechanism for a C++ class to befriend a Carbon class, we can + // safely map `none` to `private` for now. + return access_pair->isCXXClassMember() ? clang::AS_private + : clang::AS_public; + } +} + +auto MapCppAccess(clang::DeclAccessPair access_pair) -> SemIR::AccessKind { + switch (CalculateEffectiveAccess(access_pair)) { + case clang::AS_public: + return SemIR::AccessKind::Public; + case clang::AS_protected: + return SemIR::AccessKind::Protected; + case clang::AS_private: + return SemIR::AccessKind::Private; + case clang::AS_none: + CARBON_FATAL("Couldn't convert access"); + } +} + +} // namespace Carbon::Check diff --git a/toolchain/check/cpp/access.h b/toolchain/check/cpp/access.h new file mode 100644 index 0000000000000..557defe74fa61 --- /dev/null +++ b/toolchain/check/cpp/access.h @@ -0,0 +1,18 @@ +// 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 + +#ifndef CARBON_TOOLCHAIN_CHECK_CPP_ACCESS_H_ +#define CARBON_TOOLCHAIN_CHECK_CPP_ACCESS_H_ + +#include "toolchain/sem_ir/name_scope.h" + +namespace Carbon::Check { + +// Calculates the effective access kind from the given (declaration, lookup +// access) pair. +auto MapCppAccess(clang::DeclAccessPair access_pair) -> SemIR::AccessKind; + +} // namespace Carbon::Check + +#endif // CARBON_TOOLCHAIN_CHECK_CPP_ACCESS_H_ diff --git a/toolchain/check/cpp/import.cpp b/toolchain/check/cpp/import.cpp index 5c5b7c5ee99ba..2569817206640 100644 --- a/toolchain/check/cpp/import.cpp +++ b/toolchain/check/cpp/import.cpp @@ -4,6 +4,7 @@ #include "toolchain/check/cpp/import.h" +#include #include #include #include @@ -34,6 +35,7 @@ #include "toolchain/check/context.h" #include "toolchain/check/control_flow.h" #include "toolchain/check/convert.h" +#include "toolchain/check/cpp/access.h" #include "toolchain/check/cpp/custom_type_mapping.h" #include "toolchain/check/cpp/thunk.h" #include "toolchain/check/diagnostic_helpers.h" @@ -2014,33 +2016,18 @@ auto ImportCppFunctionDecl(Context& context, SemIR::LocId loc_id, SemIR::ClangDeclKey::ForFunctionDecl(clang_decl, num_params)); } -// Maps `clang::AccessSpecifier` to `SemIR::AccessKind`. -static auto MapAccess(clang::AccessSpecifier access_specifier) - -> SemIR::AccessKind { - switch (access_specifier) { - case clang::AS_public: - case clang::AS_none: - return SemIR::AccessKind::Public; - case clang::AS_protected: - return SemIR::AccessKind::Protected; - case clang::AS_private: - return SemIR::AccessKind::Private; - } -} - // Imports a Clang declaration into Carbon and adds that name into the // `NameScope`. static auto ImportNameDeclIntoScope(Context& context, SemIR::LocId loc_id, SemIR::NameScopeId scope_id, SemIR::NameId name_id, SemIR::ClangDeclKey key, - clang::AccessSpecifier access) + SemIR::AccessKind access_kind) -> SemIR::ScopeLookupResult { SemIR::InstId inst_id = ImportDeclAndDependencies(context, loc_id, key); if (!inst_id.has_value()) { return SemIR::ScopeLookupResult::MakeNotFound(); } - SemIR::AccessKind access_kind = MapAccess(access); AddNameToScope(context, scope_id, name_id, access_kind, inst_id); return SemIR::ScopeLookupResult::MakeWrappedLookupResult(inst_id, access_kind); @@ -2130,16 +2117,14 @@ auto ImportCppOverloadSet( // after overload resolution. static auto GetOverloadSetAccess(const clang::UnresolvedSet<4>& overload_set) -> SemIR::AccessKind { - clang::AccessSpecifier access = overload_set.begin().getAccess(); - for (auto it = overload_set.begin() + 1; it != overload_set.end(); ++it) { - CARBON_CHECK( - (it.getAccess() == clang::AS_none) == (access == clang::AS_none), - "Unexpected mixture of members and non-members"); - if (it.getAccess() < access) { - access = it->getAccess(); + SemIR::AccessKind access_kind = SemIR::AccessKind::Private; + for (clang::DeclAccessPair overload : overload_set.pairs()) { + access_kind = std::min(access_kind, MapCppAccess(overload)); + if (access_kind == SemIR::AccessKind::Public) { + break; } } - return MapAccess(access); + return access_kind; } // Imports an overload set from Clang to Carbon and adds the name into the @@ -2260,7 +2245,7 @@ auto ImportNameFromCpp(Context& context, SemIR::LocId loc_id, } auto key = SemIR::ClangDeclKey::ForNonFunctionDecl(lookup->getFoundDecl()); return ImportNameDeclIntoScope(context, loc_id, scope_id, name_id, key, - lookup->begin().getAccess()); + MapCppAccess(lookup->begin().getPair())); } auto ImportClassDefinitionForClangDecl(Context& context, SemIR::LocId loc_id, diff --git a/toolchain/check/cpp/overload_resolution.cpp b/toolchain/check/cpp/overload_resolution.cpp index 15237c8f45f35..12f90b8b3b190 100644 --- a/toolchain/check/cpp/overload_resolution.cpp +++ b/toolchain/check/cpp/overload_resolution.cpp @@ -8,6 +8,7 @@ #include "clang/Sema/Overload.h" #include "clang/Sema/Sema.h" #include "toolchain/base/kind_switch.h" +#include "toolchain/check/cpp/access.h" #include "toolchain/check/cpp/import.h" #include "toolchain/check/cpp/location.h" #include "toolchain/check/cpp/operators.h" @@ -88,22 +89,9 @@ static auto CheckOverloadAccess(Context& context, SemIR::LocId loc_id, const SemIR::CppOverloadSet& overload_set, clang::DeclAccessPair overload, SemIR::InstId overload_inst_id) -> void { - SemIR::AccessKind member_access_kind; - switch (overload->getAccess()) { - case clang::AS_none: - case clang::AS_public: { - return; - } - - case clang::AS_protected: { - member_access_kind = SemIR::AccessKind::Protected; - break; - } - - case clang::AS_private: { - member_access_kind = SemIR::AccessKind::Private; - break; - } + SemIR::AccessKind member_access_kind = MapCppAccess(overload); + if (member_access_kind == SemIR::AccessKind::Public) { + return; } auto name_scope_const_id = context.constant_values().Get( diff --git a/toolchain/check/testdata/interop/cpp/class/access.carbon b/toolchain/check/testdata/interop/cpp/class/access.carbon index 24c33adc8017a..271240b94905a 100644 --- a/toolchain/check/testdata/interop/cpp/class/access.carbon +++ b/toolchain/check/testdata/interop/cpp/class/access.carbon @@ -406,16 +406,20 @@ fn F(c: Cpp.C*) { // --- overload_set.h +struct PublicCall {}; +struct ProtectedCall {}; +struct PrivateCall {}; + class C { public: - C(); - static auto foo() -> void; + C(PublicCall x); + static auto Overload(PublicCall x) -> void; protected: - C(int); - static auto foo(int a) -> void; + C(ProtectedCall x); + static auto Overload(ProtectedCall x) -> void; private: - C(int, int); - static auto foo(int a, int b) -> void; + C(PrivateCall x); + static auto Overload(PrivateCall x) -> void; }; // --- import_overload_set_public.carbon @@ -426,8 +430,8 @@ import Cpp library "overload_set.h"; fn F() { //@dump-sem-ir-begin - Cpp.C.C(); - Cpp.C.foo(); + Cpp.C.C(Cpp.PublicCall.PublicCall()); + Cpp.C.Overload(Cpp.PublicCall.PublicCall()); //@dump-sem-ir-end } @@ -439,18 +443,18 @@ import Cpp library "overload_set.h"; fn F() { // CHECK:STDERR: fail_import_overload_set_protected.carbon:[[@LINE+5]]:3: error: cannot access protected member `C` of type `Cpp.C` [ClassInvalidMemberAccess] - // CHECK:STDERR: Cpp.C.C(1 as i32); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ + // CHECK:STDERR: Cpp.C.C(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_import_overload_set_protected.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - Cpp.C.C(1 as i32); + Cpp.C.C(Cpp.ProtectedCall.ProtectedCall()); - // CHECK:STDERR: fail_import_overload_set_protected.carbon:[[@LINE+5]]:3: error: cannot access protected member `foo` of type `Cpp.C` [ClassInvalidMemberAccess] - // CHECK:STDERR: Cpp.C.foo(1 as i32); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_protected.carbon:[[@LINE+5]]:3: error: cannot access protected member `Overload` of type `Cpp.C` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.C.Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_import_overload_set_protected.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - Cpp.C.foo(1 as i32); + Cpp.C.Overload(Cpp.ProtectedCall.ProtectedCall()); } // --- import_overload_set_protected_base.carbon @@ -463,19 +467,27 @@ class D { extend base: Cpp.C; fn MakePublic() -> D { - return {.base = C()}; + //@dump-sem-ir-begin + return {.base = C(Cpp.PublicCall.PublicCall())}; + //@dump-sem-ir-end } fn MakeProtected() -> D { - return {.base = C(1 as i32)}; + //@dump-sem-ir-begin + return {.base = C(Cpp.ProtectedCall.ProtectedCall())}; + //@dump-sem-ir-end } fn CallPublic() { - foo(); + //@dump-sem-ir-begin + Overload(Cpp.PublicCall.PublicCall()); + //@dump-sem-ir-end } fn CallProtected() { - foo(1 as i32); + //@dump-sem-ir-begin + Overload(Cpp.ProtectedCall.ProtectedCall()); + //@dump-sem-ir-end } } @@ -487,18 +499,18 @@ import Cpp library "overload_set.h"; fn F() { // CHECK:STDERR: fail_import_overload_set_private.carbon:[[@LINE+5]]:3: error: cannot access private member `C` of type `Cpp.C` [ClassInvalidMemberAccess] - // CHECK:STDERR: Cpp.C.C(1 as i32, 2 as i32); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: Cpp.C.C(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_import_overload_set_private.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - Cpp.C.C(1 as i32, 2 as i32); + Cpp.C.C(Cpp.PrivateCall.PrivateCall()); - // CHECK:STDERR: fail_import_overload_set_private.carbon:[[@LINE+5]]:3: error: cannot access private member `foo` of type `Cpp.C` [ClassInvalidMemberAccess] - // CHECK:STDERR: Cpp.C.foo(1 as i32, 2 as i32); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private.carbon:[[@LINE+5]]:3: error: cannot access private member `Overload` of type `Cpp.C` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.C.Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_import_overload_set_private.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - Cpp.C.foo(1 as i32, 2 as i32); + Cpp.C.Overload(Cpp.PrivateCall.PrivateCall()); } // --- fail_import_overload_set_private_base.carbon @@ -512,20 +524,218 @@ class D { fn MakePrivate() -> D { // CHECK:STDERR: fail_import_overload_set_private_base.carbon:[[@LINE+5]]:21: error: cannot access private member `C` of type `Cpp.C` [ClassInvalidMemberAccess] - // CHECK:STDERR: return {.base = C(1 as i32, 2 as i32)}; - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: return {.base = C(Cpp.PrivateCall.PrivateCall())}; + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_import_overload_set_private_base.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - return {.base = C(1 as i32, 2 as i32)}; + return {.base = C(Cpp.PrivateCall.PrivateCall())}; } fn CallPrivate() { - // CHECK:STDERR: fail_import_overload_set_private_base.carbon:[[@LINE+5]]:5: error: cannot access private member `foo` of type `Cpp.C` [ClassInvalidMemberAccess] - // CHECK:STDERR: foo(1 as i32, 2 as i32); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private_base.carbon:[[@LINE+5]]:5: error: cannot access private member `Overload` of type `Cpp.C` [ClassInvalidMemberAccess] + // CHECK:STDERR: Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_import_overload_set_private_base.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - foo(1 as i32, 2 as i32); + Overload(Cpp.PrivateCall.PrivateCall()); + } +} + +// --- overload_set_base_class.h + +#include "overload_set.h" + +class Public : public C {}; +class Protected : protected C {}; +class Private : private C {}; + +// --- import_overload_set_public_base_class_call_public.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +fn F() { + //@dump-sem-ir-begin + Cpp.Public.Overload(Cpp.PublicCall.PublicCall()); + //@dump-sem-ir-end +} + +// --- fail_import_overload_set_public_base_class_call_non_public.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +fn F() { + // CHECK:STDERR: fail_import_overload_set_public_base_class_call_non_public.carbon:[[@LINE+5]]:3: error: cannot access protected member `Overload` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Public.Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_public_base_class_call_non_public.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Public.Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: fail_import_overload_set_public_base_class_call_non_public.carbon:[[@LINE+5]]:3: error: cannot access private member `Overload` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Public.Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_public_base_class_call_non_public.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Public.Overload(Cpp.PrivateCall.PrivateCall()); +} + +// --- import_overload_set_public_base_class_derived_call_non_private.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +class Derived { + extend base: Cpp.Public; + + fn F() { + //@dump-sem-ir-begin + Overload(Cpp.PublicCall.PublicCall()); + Overload(Cpp.ProtectedCall.ProtectedCall()); + //@dump-sem-ir-end + } +} + +// --- fail_import_overload_set_public_base_class_derived_call_private.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +class Derived { + extend base: Cpp.Public; + + fn F() { + // CHECK:STDERR: fail_import_overload_set_public_base_class_derived_call_private.carbon:[[@LINE+5]]:5: error: cannot access private member `Overload` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_public_base_class_derived_call_private.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Overload(Cpp.PrivateCall.PrivateCall()); + } +} + +// --- fail_import_overload_set_protected_base_class.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +fn F() { + // CHECK:STDERR: fail_import_overload_set_protected_base_class.carbon:[[@LINE+5]]:3: error: cannot access protected member `Overload` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Protected.Overload(Cpp.PublicCall.PublicCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_protected_base_class.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Protected.Overload(Cpp.PublicCall.PublicCall()); + // CHECK:STDERR: fail_import_overload_set_protected_base_class.carbon:[[@LINE+5]]:3: error: cannot access protected member `Overload` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Protected.Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_protected_base_class.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Protected.Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: fail_import_overload_set_protected_base_class.carbon:[[@LINE+5]]:3: error: cannot access protected member `Overload` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Protected.Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_protected_base_class.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Protected.Overload(Cpp.PrivateCall.PrivateCall()); +} + +// --- import_overload_set_protected_base_class_derived_call_non_private.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +class Derived { + extend base: Cpp.Protected; + + fn F() { + //@dump-sem-ir-begin + Overload(Cpp.PublicCall.PublicCall()); + Overload(Cpp.ProtectedCall.ProtectedCall()); + //@dump-sem-ir-end + } +} + +// --- fail_import_overload_set_protected_base_class_derived_call_private.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +class Derived { + extend base: Cpp.Protected; + + fn F() { + // CHECK:STDERR: fail_import_overload_set_protected_base_class_derived_call_private.carbon:[[@LINE+5]]:5: error: cannot access private member `Overload` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_protected_base_class_derived_call_private.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Overload(Cpp.PrivateCall.PrivateCall()); + } +} + +// --- fail_import_overload_set_private_base_class.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +fn F() { + // CHECK:STDERR: fail_import_overload_set_private_base_class.carbon:[[@LINE+5]]:3: error: cannot access private member `Overload` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.Overload(Cpp.PublicCall.PublicCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private_base_class.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.Overload(Cpp.PublicCall.PublicCall()); + // CHECK:STDERR: fail_import_overload_set_private_base_class.carbon:[[@LINE+5]]:3: error: cannot access private member `Overload` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private_base_class.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: fail_import_overload_set_private_base_class.carbon:[[@LINE+5]]:3: error: cannot access private member `Overload` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private_base_class.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.Overload(Cpp.PrivateCall.PrivateCall()); +} + +// --- fail_import_overload_set_private_base_class_derived.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "overload_set_base_class.h"; + +class Derived { + extend base: Cpp.Private; + + fn F() { + // CHECK:STDERR: fail_import_overload_set_private_base_class_derived.carbon:[[@LINE+5]]:5: error: cannot access private member `Overload` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Overload(Cpp.PublicCall.PublicCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private_base_class_derived.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Overload(Cpp.PublicCall.PublicCall()); + // CHECK:STDERR: fail_import_overload_set_private_base_class_derived.carbon:[[@LINE+5]]:5: error: cannot access private member `Overload` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private_base_class_derived.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Overload(Cpp.ProtectedCall.ProtectedCall()); + // CHECK:STDERR: fail_import_overload_set_private_base_class_derived.carbon:[[@LINE+5]]:5: error: cannot access private member `Overload` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Overload(Cpp.PrivateCall.PrivateCall()); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_import_overload_set_private_base_class_derived.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Overload(Cpp.PrivateCall.PrivateCall()); } } @@ -535,135 +745,725 @@ class D { // --- base_class.h -struct Base { - static auto foo() -> void; +class Base { + public: + static auto PublicStatic() -> void; + auto PublicInstance() -> void; + protected: + static auto ProtectedStatic() -> void; + auto ProtectedInstance() -> void; + private: + static auto PrivateStatic() -> void; + auto PrivateInstance() -> void; }; -class DerivedPublic : public Base {}; -class DerivedProtected : protected Base {}; -class DerivedPrivate : private Base {}; +class Public : public Base {}; +class Protected : protected Base {}; +class Private : private Base {}; + +class PublicProtected : public Protected {}; +class PublicPrivate : public Private {}; -// --- import_base_class_public.carbon +// --- base_class_public_access_allowed.carbon library "[[@TEST_NAME]]"; import Cpp library "base_class.h"; -fn F() { +class Derived { + extend base: Cpp.Public; + + fn CallStatic() { + //@dump-sem-ir-begin + // OK, we can access a public member of our base class. + Cpp.Public.PublicStatic(); + Self.PublicStatic(); + + // OK, we can access a protected member of our base class. + Cpp.Public.ProtectedStatic(); + Self.ProtectedStatic(); + //@dump-sem-ir-end + } + + fn CallInstance(var instance: Cpp.Public) { + //@dump-sem-ir-begin + // OK, we can access a public member of our base class. + instance.PublicInstance(); + // OK, we can access a protected member of our base class. + instance.ProtectedInstance(); + //@dump-sem-ir-end + } +} + +fn Call(var instance: Cpp.Public) { //@dump-sem-ir-begin - Cpp.DerivedPublic.foo(); + Cpp.Public.PublicStatic(); + Derived.PublicStatic(); + + instance.PublicInstance(); + instance.PublicInstance(); //@dump-sem-ir-end } -// --- fail_import_base_class_protected.carbon +// --- fail_base_class_public_access_denied.carbon library "[[@TEST_NAME]]"; import Cpp library "base_class.h"; -fn F() { - // CHECK:STDERR: fail_import_base_class_protected.carbon:[[@LINE+5]]:3: error: cannot access protected member `foo` of type `Cpp.DerivedProtected` [ClassInvalidMemberAccess] - // CHECK:STDERR: Cpp.DerivedProtected.foo(); +class Derived { + extend base: Cpp.Public; + + fn CallStatic() { + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Public.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Public.PrivateStatic(); + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.PrivateStatic(); + } + + fn CallInstance(var instance: Cpp.Public) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateInstance` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); + //@dump-sem-ir-end + } +} + +fn Call(var instance: Cpp.Public) { + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedStatic` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Public.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Public.ProtectedStatic(); + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedStatic` of type `Derived` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.ProtectedStatic(); + + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Public.PrivateStatic(); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_import_base_class_protected.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - Cpp.DerivedProtected.foo(); + Cpp.Public.PrivateStatic(); + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PrivateStatic(); + + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedInstance` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.ProtectedInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.ProtectedInstance(); + // CHECK:STDERR: fail_base_class_public_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateInstance` of type `Cpp.Public` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); } -// --- use_base_class_protected_from_derived.carbon +// --- base_class_protected_access_allowed.carbon library "[[@TEST_NAME]]"; import Cpp library "base_class.h"; class Derived { - extend base: Cpp.DerivedProtected; + extend base: Cpp.Protected; + + fn CallStatic() { + //@dump-sem-ir-begin + // OK, we can access a public member of our base class. + Cpp.Protected.PublicStatic(); + Self.PublicStatic(); - fn F() { // OK, we can access a protected member of our base class. - Cpp.DerivedProtected.foo(); + Cpp.Protected.ProtectedStatic(); + Self.ProtectedStatic(); + //@dump-sem-ir-end + } + + fn CallInstance(var instance: Cpp.Protected) { + //@dump-sem-ir-begin + // OK, we can access a public member of our base class. + instance.PublicInstance(); + // OK, we can access a protected member of our base class. + instance.ProtectedInstance(); + //@dump-sem-ir-end } } -// --- fail_import_base_class_private.carbon +// --- fail_base_class_protected_access_denied.carbon library "[[@TEST_NAME]]"; import Cpp library "base_class.h"; -fn F() { - // CHECK:STDERR: fail_import_base_class_private.carbon:[[@LINE+5]]:3: error: cannot access private member `foo` of type `Cpp.DerivedPrivate` [ClassInvalidMemberAccess] - // CHECK:STDERR: Cpp.DerivedPrivate.foo(); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_import_base_class_private.carbon: note: declared here [ClassMemberDeclaration] +class Derived { + extend base: Cpp.Protected; + + fn CallStatic() { + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Protected.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Protected.PrivateStatic(); + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.PrivateStatic(); + } + + fn CallInstance(var instance: Cpp.Protected) { + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateInstance` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); + } +} + +fn Call(var instance: Cpp.Protected) { + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `PublicStatic` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Protected.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Protected.PublicStatic(); + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `PublicStatic` of type `Derived` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PublicStatic(); + + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedStatic` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Protected.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Protected.ProtectedStatic(); + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedStatic` of type `Derived` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.ProtectedStatic(); + + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Protected.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Protected.PrivateStatic(); + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PrivateStatic(); + + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `PublicInstance` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PublicInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PublicInstance(); + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedInstance` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.ProtectedInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.ProtectedInstance(); + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateInstance` of type `Cpp.Protected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] // CHECK:STDERR: - Cpp.DerivedPrivate.foo(); + instance.PrivateInstance(); } -// CHECK:STDOUT: --- import_non_function_member_public.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %S: type = class_type @S [concrete] -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %S.elem: type = unbound_element_type %S, %i32 [concrete] -// CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .S = %S.decl -// CHECK:STDOUT: import Cpp//... -// CHECK:STDOUT: } -// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} -// CHECK:STDOUT: %static_data.var: ref %i32 = var %static_data.var_patt -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F(%s.param: %S) { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %instance_data.patt: %pattern_type.7ce = binding_pattern instance_data [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %s.ref: %S = name_ref s, %s -// CHECK:STDOUT: %instance_data.ref: %S.elem = name_ref instance_data, @S.%.1 [concrete = @S.%.1] -// CHECK:STDOUT: %.loc8_29.1: ref %i32 = class_element_access %s.ref, element0 -// CHECK:STDOUT: %.loc8_29.2: %i32 = bind_value %.loc8_29.1 -// CHECK:STDOUT: %.loc8_22: type = splice_block %i32.loc8 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc8: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc8: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %instance_data: %i32 = bind_name instance_data, %.loc8_29.2 -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %static_data.patt: %pattern_type.7ce = binding_pattern static_data [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %S.ref.loc9: type = name_ref S, imports.%S.decl [concrete = constants.%S] -// CHECK:STDOUT: -// CHECK:STDOUT: %static_data.ref: ref %i32 = name_ref static_data, imports.%static_data.var -// CHECK:STDOUT: %.loc9_20: type = splice_block %i32.loc9 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc9: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc9: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %.loc9_31: %i32 = bind_value %static_data.ref -// CHECK:STDOUT: %static_data: %i32 = bind_name static_data, %.loc9_31 -// CHECK:STDOUT: -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- import_non_function_member_public_extend.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] -// CHECK:STDOUT: %S: type = class_type @S [concrete] -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %S.elem: type = unbound_element_type %S, %i32 [concrete] -// CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %static_data.var: ref %i32 = var %static_data.var_patt -// CHECK:STDOUT: } -// CHECK:STDOUT: +// --- fail_base_class_private_access_denied.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "base_class.h"; + +class Derived { + extend base: Cpp.Private; + + fn CallStatic() { + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PublicStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.PublicStatic(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PublicStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.PublicStatic(); + + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `ProtectedStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.ProtectedStatic(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `ProtectedStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.ProtectedStatic(); + + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.PrivateStatic(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.PrivateStatic(); + } + + fn CallInstance(var instance: Cpp.Private) { + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PublicInstance` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PublicInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PublicInstance(); + + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `ProtectedInstance` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.ProtectedInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.ProtectedInstance(); + + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateInstance` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); + } +} + +fn Call(var instance: Cpp.Private) { + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PublicStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.PublicStatic(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PublicStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PublicStatic(); + + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `ProtectedStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.ProtectedStatic(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `ProtectedStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.ProtectedStatic(); + + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.Private.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.Private.PrivateStatic(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PrivateStatic(); + + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PublicInstance` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PublicInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PublicInstance(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `ProtectedInstance` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.ProtectedInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.ProtectedInstance(); + // CHECK:STDERR: fail_base_class_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateInstance` of type `Cpp.Private` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); +} + +// --- base_class_public_protected_access_allowed.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "base_class.h"; + +class Derived { + extend base: Cpp.PublicProtected; + + fn CallStatic() { + //@dump-sem-ir-begin + // OK, we can access a public member of our base class. + Cpp.PublicProtected.PublicStatic(); + Self.PublicStatic(); + + // OK, we can access a protected member of our base class. + Cpp.PublicProtected.ProtectedStatic(); + Self.ProtectedStatic(); + //@dump-sem-ir-end + } + + fn CallInstance(var instance: Cpp.PublicProtected) { + //@dump-sem-ir-begin + // OK, we can access a public member of our base class. + instance.PublicInstance(); + // OK, we can access a protected member of our base class. + instance.ProtectedInstance(); + //@dump-sem-ir-end + } +} + +// --- fail_base_class_public_protected_access_denied.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "base_class.h"; + +class Derived { + extend base: Cpp.PublicProtected; + + fn CallStatic() { + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicProtected.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicProtected.PrivateStatic(); + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.PrivateStatic(); + } + + fn CallInstance(var instance: Cpp.PublicProtected) { + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateInstance` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); + } +} + +fn Call(var instance: Cpp.PublicProtected) { + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `PublicStatic` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicProtected.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicProtected.PublicStatic(); + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `PublicStatic` of type `Derived` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PublicStatic(); + + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedStatic` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicProtected.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicProtected.ProtectedStatic(); + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedStatic` of type `Derived` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.ProtectedStatic(); + + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicProtected.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicProtected.PrivateStatic(); + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PrivateStatic(); + + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `PublicInstance` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PublicInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PublicInstance(); + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access protected member `ProtectedInstance` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.ProtectedInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.ProtectedInstance(); + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateInstance` of type `Cpp.PublicProtected` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_protected_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); +} + +// --- fail_base_class_public_private_access_denied.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "base_class.h"; + +class Derived { + extend base: Cpp.PublicPrivate; + + fn CallStatic() { + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PublicStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicPrivate.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicPrivate.PublicStatic(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PublicStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.PublicStatic(); + + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `ProtectedStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicPrivate.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicPrivate.ProtectedStatic(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `ProtectedStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.ProtectedStatic(); + + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicPrivate.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicPrivate.PrivateStatic(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Self.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Self.PrivateStatic(); + } + + fn CallInstance(var instance: Cpp.PublicPrivate) { + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PublicInstance` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PublicInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PublicInstance(); + + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `ProtectedInstance` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.ProtectedInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.ProtectedInstance(); + + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:5: error: cannot access private member `PrivateInstance` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); + } +} + +fn Call(var instance: Cpp.PublicPrivate) { + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PublicStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicPrivate.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicPrivate.PublicStatic(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PublicStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PublicStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PublicStatic(); + + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `ProtectedStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicPrivate.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicPrivate.ProtectedStatic(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `ProtectedStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.ProtectedStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.ProtectedStatic(); + + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Cpp.PublicPrivate.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Cpp.PublicPrivate.PrivateStatic(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateStatic` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: Derived.PrivateStatic(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + Derived.PrivateStatic(); + + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PublicInstance` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PublicInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PublicInstance(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `ProtectedInstance` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.ProtectedInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.ProtectedInstance(); + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon:[[@LINE+5]]:3: error: cannot access private member `PrivateInstance` of type `Cpp.PublicPrivate` [ClassInvalidMemberAccess] + // CHECK:STDERR: instance.PrivateInstance(); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: fail_base_class_public_private_access_denied.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: + instance.PrivateInstance(); +} + +// CHECK:STDOUT: --- import_non_function_member_public.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] +// CHECK:STDOUT: %S.elem: type = unbound_element_type %S, %i32 [concrete] +// CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .S = %S.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} +// CHECK:STDOUT: %static_data.var: ref %i32 = var %static_data.var_patt +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F(%s.param: %S) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %instance_data.patt: %pattern_type.7ce = binding_pattern instance_data [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %S = name_ref s, %s +// CHECK:STDOUT: %instance_data.ref: %S.elem = name_ref instance_data, @S.%.1 [concrete = @S.%.1] +// CHECK:STDOUT: %.loc8_29.1: ref %i32 = class_element_access %s.ref, element0 +// CHECK:STDOUT: %.loc8_29.2: %i32 = bind_value %.loc8_29.1 +// CHECK:STDOUT: %.loc8_22: type = splice_block %i32.loc8 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc8: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc8: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: %instance_data: %i32 = bind_name instance_data, %.loc8_29.2 +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %static_data.patt: %pattern_type.7ce = binding_pattern static_data [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %S.ref.loc9: type = name_ref S, imports.%S.decl [concrete = constants.%S] +// CHECK:STDOUT: +// CHECK:STDOUT: %static_data.ref: ref %i32 = name_ref static_data, imports.%static_data.var +// CHECK:STDOUT: %.loc9_20: type = splice_block %i32.loc9 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc9: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc9: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc9_31: %i32 = bind_value %static_data.ref +// CHECK:STDOUT: %static_data: %i32 = bind_name static_data, %.loc9_31 +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- import_non_function_member_public_extend.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] +// CHECK:STDOUT: %S: type = class_type @S [concrete] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] +// CHECK:STDOUT: %S.elem: type = unbound_element_type %S, %i32 [concrete] +// CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %static_data.var: ref %i32 = var %static_data.var_patt +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: fn @F(%d.param: %Derived) { // CHECK:STDOUT: !entry: // CHECK:STDOUT: name_binding_decl { @@ -920,84 +1720,1017 @@ fn F() { // CHECK:STDOUT: %C: type = class_type @C [concrete] // CHECK:STDOUT: %C.C.cpp_overload_set.type: type = cpp_overload_set_type @C.C.cpp_overload_set [concrete] // CHECK:STDOUT: %C.C.cpp_overload_set.value: %C.C.cpp_overload_set.type = cpp_overload_set_value @C.C.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall: type = class_type @PublicCall [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.type: type = cpp_overload_set_type @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.dfa: type = ptr_type %PublicCall [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk.type: type = fn_type @PublicCall__carbon_thunk [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk: %PublicCall__carbon_thunk.type = struct_value () [concrete] // CHECK:STDOUT: %ptr.d9e: type = ptr_type %C [concrete] // CHECK:STDOUT: %C__carbon_thunk.type: type = fn_type @C__carbon_thunk [concrete] // CHECK:STDOUT: %C__carbon_thunk: %C__carbon_thunk.type = struct_value () [concrete] -// CHECK:STDOUT: %C.foo.cpp_overload_set.type: type = cpp_overload_set_type @C.foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %C.foo.cpp_overload_set.value: %C.foo.cpp_overload_set.type = cpp_overload_set_value @C.foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %C.foo.type: type = fn_type @C.foo [concrete] -// CHECK:STDOUT: %C.foo: %C.foo.type = struct_value () [concrete] +// CHECK:STDOUT: %C.Overload.cpp_overload_set.type: type = cpp_overload_set_type @C.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %C.Overload.cpp_overload_set.value: %C.Overload.cpp_overload_set.type = cpp_overload_set_value @C.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type: type = fn_type @Overload__carbon_thunk [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk: %Overload__carbon_thunk.type = struct_value () [concrete] // CHECK:STDOUT: %type_where: type = facet_type > [concrete] -// CHECK:STDOUT: %facet_value: %type_where = facet_value %C, () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b92: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [concrete] +// CHECK:STDOUT: %facet_value.136: %type_where = facet_value %PublicCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.136) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.3ff: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06 = struct_value () [concrete] +// CHECK:STDOUT: %facet_value.b21: %type_where = facet_value %C, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b92: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.b21) [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.841: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b92 = struct_value () [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { // CHECK:STDOUT: .C = %C.decl +// CHECK:STDOUT: .PublicCall = %PublicCall.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } // CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} // CHECK:STDOUT: %C.C.cpp_overload_set.value: %C.C.cpp_overload_set.type = cpp_overload_set_value @C.C.cpp_overload_set [concrete = constants.%C.C.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall.decl: type = class_decl @PublicCall [concrete = constants.%PublicCall] {} {} +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall__carbon_thunk.decl: %PublicCall__carbon_thunk.type = fn_decl @PublicCall__carbon_thunk [concrete = constants.%PublicCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } // CHECK:STDOUT: %C__carbon_thunk.decl: %C__carbon_thunk.type = fn_decl @C__carbon_thunk [concrete = constants.%C__carbon_thunk] { // CHECK:STDOUT: // CHECK:STDOUT: } { // CHECK:STDOUT: // CHECK:STDOUT: } -// CHECK:STDOUT: %C.foo.cpp_overload_set.value: %C.foo.cpp_overload_set.type = cpp_overload_set_value @C.foo.cpp_overload_set [concrete = constants.%C.foo.cpp_overload_set.value] -// CHECK:STDOUT: %C.foo.decl: %C.foo.type = fn_decl @C.foo [concrete = constants.%C.foo] {} {} +// CHECK:STDOUT: %C.Overload.cpp_overload_set.value: %C.Overload.cpp_overload_set.type = cpp_overload_set_value @C.Overload.cpp_overload_set [concrete = constants.%C.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Overload__carbon_thunk.decl: %Overload__carbon_thunk.type = fn_decl @Overload__carbon_thunk [concrete = constants.%Overload__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %C.ref.loc8_6: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %C.ref.loc8_8: %C.C.cpp_overload_set.type = name_ref C, imports.%C.C.cpp_overload_set.value [concrete = constants.%C.C.cpp_overload_set.value] -// CHECK:STDOUT: %.loc8_11.1: ref %C = temporary_storage -// CHECK:STDOUT: %addr.loc8_11.1: %ptr.d9e = addr_of %.loc8_11.1 -// CHECK:STDOUT: %C__carbon_thunk.call: init %empty_tuple.type = call imports.%C__carbon_thunk.decl(%addr.loc8_11.1) -// CHECK:STDOUT: %.loc8_11.2: init %C = in_place_init %C__carbon_thunk.call, %.loc8_11.1 -// CHECK:STDOUT: %.loc8_11.3: ref %C = temporary %.loc8_11.1, %.loc8_11.2 -// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc8_11: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicCall.ref.loc8_14: type = name_ref PublicCall, imports.%PublicCall.decl [concrete = constants.%PublicCall] +// CHECK:STDOUT: %PublicCall.ref.loc8_25: %PublicCall.PublicCall.cpp_overload_set.type = name_ref PublicCall, imports.%PublicCall.PublicCall.cpp_overload_set.value [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc8_37.1: ref %PublicCall = temporary_storage +// CHECK:STDOUT: %addr.loc8_37.1: %ptr.dfa = addr_of %.loc8_37.1 +// CHECK:STDOUT: %PublicCall__carbon_thunk.call.loc8: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc8_37.1) +// CHECK:STDOUT: %.loc8_37.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call.loc8, %.loc8_37.1 +// CHECK:STDOUT: %.loc8_38.1: ref %C = temporary_storage +// CHECK:STDOUT: %.loc8_37.3: ref %PublicCall = temporary %.loc8_37.1, %.loc8_37.2 +// CHECK:STDOUT: %.loc8_37.4: %PublicCall = bind_value %.loc8_37.3 +// CHECK:STDOUT: %.loc8_37.5: ref %PublicCall = value_as_ref %.loc8_37.4 +// CHECK:STDOUT: %addr.loc8_38.1: %ptr.dfa = addr_of %.loc8_37.5 +// CHECK:STDOUT: %addr.loc8_38.2: %ptr.d9e = addr_of %.loc8_38.1 +// CHECK:STDOUT: %C__carbon_thunk.call: init %empty_tuple.type = call imports.%C__carbon_thunk.decl(%addr.loc8_38.1, %addr.loc8_38.2) +// CHECK:STDOUT: %.loc8_38.2: init %C = in_place_init %C__carbon_thunk.call, %.loc8_38.1 +// CHECK:STDOUT: %.loc8_38.3: ref %C = temporary %.loc8_38.1, %.loc8_38.2 +// CHECK:STDOUT: %Cpp.ref.loc9_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %C.ref.loc9: type = name_ref C, imports.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %foo.ref: %C.foo.cpp_overload_set.type = name_ref foo, imports.%C.foo.cpp_overload_set.value [concrete = constants.%C.foo.cpp_overload_set.value] -// CHECK:STDOUT: %C.foo.call: init %empty_tuple.type = call imports.%C.foo.decl() -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc8_11.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.841 +// CHECK:STDOUT: %Overload.ref: %C.Overload.cpp_overload_set.type = name_ref Overload, imports.%C.Overload.cpp_overload_set.value [concrete = constants.%C.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc9_18: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicCall.ref.loc9_21: type = name_ref PublicCall, imports.%PublicCall.decl [concrete = constants.%PublicCall] +// CHECK:STDOUT: %PublicCall.ref.loc9_32: %PublicCall.PublicCall.cpp_overload_set.type = name_ref PublicCall, imports.%PublicCall.PublicCall.cpp_overload_set.value [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc9_44.1: ref %PublicCall = temporary_storage +// CHECK:STDOUT: %addr.loc9_44.1: %ptr.dfa = addr_of %.loc9_44.1 +// CHECK:STDOUT: %PublicCall__carbon_thunk.call.loc9: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc9_44.1) +// CHECK:STDOUT: %.loc9_44.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call.loc9, %.loc9_44.1 +// CHECK:STDOUT: %.loc9_44.3: ref %PublicCall = temporary %.loc9_44.1, %.loc9_44.2 +// CHECK:STDOUT: %.loc9_44.4: %PublicCall = bind_value %.loc9_44.3 +// CHECK:STDOUT: %.loc9_44.5: ref %PublicCall = value_as_ref %.loc9_44.4 +// CHECK:STDOUT: %addr.loc9_45: %ptr.dfa = addr_of %.loc9_44.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl(%addr.loc9_45) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc9: = bound_method %.loc9_44.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.3ff // CHECK:STDOUT: -// CHECK:STDOUT: %bound_method: = bound_method %.loc8_11.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn -// CHECK:STDOUT: %addr.loc8_11.2: %ptr.d9e = addr_of %.loc8_11.3 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc8_11.2) +// CHECK:STDOUT: %bound_method.loc9: = bound_method %.loc9_44.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1 +// CHECK:STDOUT: %addr.loc9_44.2: %ptr.dfa = addr_of %.loc9_44.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc9: init %empty_tuple.type = call %bound_method.loc9(%addr.loc9_44.2) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc8_38: = bound_method %.loc8_38.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.841 +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc8_38: = bound_method %.loc8_38.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 +// CHECK:STDOUT: %addr.loc8_38.3: %ptr.d9e = addr_of %.loc8_38.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc8_38: init %empty_tuple.type = call %bound_method.loc8_38(%addr.loc8_38.3) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc8_37: = bound_method %.loc8_37.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.3ff +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc8_37: = bound_method %.loc8_37.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.3 +// CHECK:STDOUT: %addr.loc8_37.2: %ptr.dfa = addr_of %.loc8_37.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc8_37: init %empty_tuple.type = call %bound_method.loc8_37(%addr.loc8_37.2) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: --- import_base_class_public.carbon +// CHECK:STDOUT: --- import_overload_set_protected_base.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { +// CHECK:STDOUT: %D: type = class_type @D [concrete] +// CHECK:STDOUT: %C: type = class_type @C [concrete] // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] -// CHECK:STDOUT: %DerivedPublic: type = class_type @DerivedPublic [concrete] -// CHECK:STDOUT: %DerivedPublic.foo.cpp_overload_set.type: type = cpp_overload_set_type @DerivedPublic.foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %DerivedPublic.foo.cpp_overload_set.value: %DerivedPublic.foo.cpp_overload_set.type = cpp_overload_set_value @DerivedPublic.foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %Base.foo.type: type = fn_type @Base.foo [concrete] -// CHECK:STDOUT: %Base.foo: %Base.foo.type = struct_value () [concrete] +// CHECK:STDOUT: %struct_type.base.7c3: type = struct_type {.base: %C} [concrete] +// CHECK:STDOUT: %C.C.cpp_overload_set.type: type = cpp_overload_set_type @C.C.cpp_overload_set [concrete] +// CHECK:STDOUT: %C.C.cpp_overload_set.value: %C.C.cpp_overload_set.type = cpp_overload_set_value @C.C.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall: type = class_type @PublicCall [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.type: type = cpp_overload_set_type @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.dfa: type = ptr_type %PublicCall [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk.type: type = fn_type @PublicCall__carbon_thunk [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk: %PublicCall__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.d9e: type = ptr_type %C [concrete] +// CHECK:STDOUT: %C__carbon_thunk.type.65f120.1: type = fn_type @C__carbon_thunk.1 [concrete] +// CHECK:STDOUT: %C__carbon_thunk.d98342.1: %C__carbon_thunk.type.65f120.1 = struct_value () [concrete] +// CHECK:STDOUT: %type_where: type = facet_type > [concrete] +// CHECK:STDOUT: %facet_value.136: %type_where = facet_value %PublicCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.136) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.3ff: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06 = struct_value () [concrete] +// CHECK:STDOUT: %ProtectedCall: type = class_type @ProtectedCall [concrete] +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.type: type = cpp_overload_set_type @ProtectedCall.ProtectedCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.value: %ProtectedCall.ProtectedCall.cpp_overload_set.type = cpp_overload_set_value @ProtectedCall.ProtectedCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.8e6: type = ptr_type %ProtectedCall [concrete] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.type: type = fn_type @ProtectedCall__carbon_thunk [concrete] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk: %ProtectedCall__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %C__carbon_thunk.type.65f120.2: type = fn_type @C__carbon_thunk.2 [concrete] +// CHECK:STDOUT: %C__carbon_thunk.d98342.2: %C__carbon_thunk.type.65f120.2 = struct_value () [concrete] +// CHECK:STDOUT: %facet_value.c53: %type_where = facet_value %ProtectedCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b70: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.c53) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.a5b: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b70 = struct_value () [concrete] +// CHECK:STDOUT: %C.Overload.cpp_overload_set.type: type = cpp_overload_set_type @C.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %C.Overload.cpp_overload_set.value: %C.Overload.cpp_overload_set.type = cpp_overload_set_value @C.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type.9a101f.1: type = fn_type @Overload__carbon_thunk.1 [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.794c5b.1: %Overload__carbon_thunk.type.9a101f.1 = struct_value () [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type.9a101f.2: type = fn_type @Overload__carbon_thunk.2 [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.794c5b.2: %Overload__carbon_thunk.type.9a101f.2 = struct_value () [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { -// CHECK:STDOUT: .DerivedPublic = %DerivedPublic.decl +// CHECK:STDOUT: .C = %C.decl +// CHECK:STDOUT: .PublicCall = %PublicCall.decl +// CHECK:STDOUT: .ProtectedCall = %ProtectedCall.decl // CHECK:STDOUT: import Cpp//... // CHECK:STDOUT: } -// CHECK:STDOUT: %DerivedPublic.decl: type = class_decl @DerivedPublic [concrete = constants.%DerivedPublic] {} {} -// CHECK:STDOUT: %DerivedPublic.foo.cpp_overload_set.value: %DerivedPublic.foo.cpp_overload_set.type = cpp_overload_set_value @DerivedPublic.foo.cpp_overload_set [concrete = constants.%DerivedPublic.foo.cpp_overload_set.value] -// CHECK:STDOUT: %Base.foo.decl: %Base.foo.type = fn_decl @Base.foo [concrete = constants.%Base.foo] {} {} +// CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} +// CHECK:STDOUT: %C.C.cpp_overload_set.value: %C.C.cpp_overload_set.type = cpp_overload_set_value @C.C.cpp_overload_set [concrete = constants.%C.C.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall.decl: type = class_decl @PublicCall [concrete = constants.%PublicCall] {} {} +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall__carbon_thunk.decl: %PublicCall__carbon_thunk.type = fn_decl @PublicCall__carbon_thunk [concrete = constants.%PublicCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %C__carbon_thunk.decl.8acdfe.1: %C__carbon_thunk.type.65f120.1 = fn_decl @C__carbon_thunk.1 [concrete = constants.%C__carbon_thunk.d98342.1] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %ProtectedCall.decl: type = class_decl @ProtectedCall [concrete = constants.%ProtectedCall] {} {} +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.value: %ProtectedCall.ProtectedCall.cpp_overload_set.type = cpp_overload_set_value @ProtectedCall.ProtectedCall.cpp_overload_set [concrete = constants.%ProtectedCall.ProtectedCall.cpp_overload_set.value] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.decl: %ProtectedCall__carbon_thunk.type = fn_decl @ProtectedCall__carbon_thunk [concrete = constants.%ProtectedCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %C__carbon_thunk.decl.8acdfe.2: %C__carbon_thunk.type.65f120.2 = fn_decl @C__carbon_thunk.2 [concrete = constants.%C__carbon_thunk.d98342.2] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %C.Overload.cpp_overload_set.value: %C.Overload.cpp_overload_set.type = cpp_overload_set_value @C.Overload.cpp_overload_set [concrete = constants.%C.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Overload__carbon_thunk.decl.85994f.1: %Overload__carbon_thunk.type.9a101f.1 = fn_decl @Overload__carbon_thunk.1 [concrete = constants.%Overload__carbon_thunk.794c5b.1] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Overload__carbon_thunk.decl.85994f.2: %Overload__carbon_thunk.type.9a101f.2 = fn_decl @Overload__carbon_thunk.2 [concrete = constants.%Overload__carbon_thunk.794c5b.2] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: class @D { +// CHECK:STDOUT: +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%D +// CHECK:STDOUT: .Cpp = +// CHECK:STDOUT: .base = %.loc7 +// CHECK:STDOUT: .D = +// CHECK:STDOUT: .MakePublic = %D.MakePublic.decl +// CHECK:STDOUT: .MakeProtected = %D.MakeProtected.decl +// CHECK:STDOUT: .CallPublic = %D.CallPublic.decl +// CHECK:STDOUT: .CallProtected = %D.CallProtected.decl +// CHECK:STDOUT: .C = +// CHECK:STDOUT: .Overload = +// CHECK:STDOUT: extend %C.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @D.MakePublic() -> %return.param: %D { // CHECK:STDOUT: !entry: +// CHECK:STDOUT: %C.ref: %C.C.cpp_overload_set.type = name_ref C, imports.%C.C.cpp_overload_set.value [concrete = constants.%C.C.cpp_overload_set.value] // CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %DerivedPublic.ref: type = name_ref DerivedPublic, imports.%DerivedPublic.decl [concrete = constants.%DerivedPublic] -// CHECK:STDOUT: %foo.ref: %DerivedPublic.foo.cpp_overload_set.type = name_ref foo, imports.%DerivedPublic.foo.cpp_overload_set.value [concrete = constants.%DerivedPublic.foo.cpp_overload_set.value] -// CHECK:STDOUT: %Base.foo.call: init %empty_tuple.type = call imports.%Base.foo.decl() +// CHECK:STDOUT: %PublicCall.ref.loc11_26: type = name_ref PublicCall, imports.%PublicCall.decl [concrete = constants.%PublicCall] +// CHECK:STDOUT: %PublicCall.ref.loc11_37: %PublicCall.PublicCall.cpp_overload_set.type = name_ref PublicCall, imports.%PublicCall.PublicCall.cpp_overload_set.value [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc11_49.1: ref %PublicCall = temporary_storage +// CHECK:STDOUT: %addr.loc11_49.1: %ptr.dfa = addr_of %.loc11_49.1 +// CHECK:STDOUT: %PublicCall__carbon_thunk.call: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc11_49.1) +// CHECK:STDOUT: %.loc11_49.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call, %.loc11_49.1 +// CHECK:STDOUT: %.loc11_51.1: ref %C = class_element_access %return, element0 +// CHECK:STDOUT: %.loc11_49.3: ref %PublicCall = temporary %.loc11_49.1, %.loc11_49.2 +// CHECK:STDOUT: %.loc11_49.4: %PublicCall = bind_value %.loc11_49.3 +// CHECK:STDOUT: %.loc11_49.5: ref %PublicCall = value_as_ref %.loc11_49.4 +// CHECK:STDOUT: %addr.loc11_50.1: %ptr.dfa = addr_of %.loc11_49.5 +// CHECK:STDOUT: %addr.loc11_50.2: %ptr.d9e = addr_of %.loc11_51.1 +// CHECK:STDOUT: %C__carbon_thunk.call: init %empty_tuple.type = call imports.%C__carbon_thunk.decl.8acdfe.1(%addr.loc11_50.1, %addr.loc11_50.2) +// CHECK:STDOUT: %.loc11_50: init %C = in_place_init %C__carbon_thunk.call, %.loc11_51.1 +// CHECK:STDOUT: %.loc11_51.2: %struct_type.base.7c3 = struct_literal (%.loc11_50) +// CHECK:STDOUT: %.loc11_51.3: init %D = class_init (%.loc11_50), %return +// CHECK:STDOUT: %.loc11_52: init %D = converted %.loc11_51.2, %.loc11_51.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc11_49.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.3ff +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc11_49.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc11_49.2: %ptr.dfa = addr_of %.loc11_49.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc11_49.2) +// CHECK:STDOUT: return %.loc11_52 to %return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @D.MakeProtected() -> %return.param: %D { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %C.ref: %C.C.cpp_overload_set.type = name_ref C, imports.%C.C.cpp_overload_set.value [concrete = constants.%C.C.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ProtectedCall.ref.loc17_26: type = name_ref ProtectedCall, imports.%ProtectedCall.decl [concrete = constants.%ProtectedCall] +// CHECK:STDOUT: %ProtectedCall.ref.loc17_40: %ProtectedCall.ProtectedCall.cpp_overload_set.type = name_ref ProtectedCall, imports.%ProtectedCall.ProtectedCall.cpp_overload_set.value [concrete = constants.%ProtectedCall.ProtectedCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc17_55.1: ref %ProtectedCall = temporary_storage +// CHECK:STDOUT: %addr.loc17_55.1: %ptr.8e6 = addr_of %.loc17_55.1 +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.call: init %empty_tuple.type = call imports.%ProtectedCall__carbon_thunk.decl(%addr.loc17_55.1) +// CHECK:STDOUT: %.loc17_55.2: init %ProtectedCall = in_place_init %ProtectedCall__carbon_thunk.call, %.loc17_55.1 +// CHECK:STDOUT: %.loc17_57.1: ref %C = class_element_access %return, element0 +// CHECK:STDOUT: %.loc17_55.3: ref %ProtectedCall = temporary %.loc17_55.1, %.loc17_55.2 +// CHECK:STDOUT: %.loc17_55.4: %ProtectedCall = bind_value %.loc17_55.3 +// CHECK:STDOUT: %.loc17_55.5: ref %ProtectedCall = value_as_ref %.loc17_55.4 +// CHECK:STDOUT: %addr.loc17_56.1: %ptr.8e6 = addr_of %.loc17_55.5 +// CHECK:STDOUT: %addr.loc17_56.2: %ptr.d9e = addr_of %.loc17_57.1 +// CHECK:STDOUT: %C__carbon_thunk.call: init %empty_tuple.type = call imports.%C__carbon_thunk.decl.8acdfe.2(%addr.loc17_56.1, %addr.loc17_56.2) +// CHECK:STDOUT: %.loc17_56: init %C = in_place_init %C__carbon_thunk.call, %.loc17_57.1 +// CHECK:STDOUT: %.loc17_57.2: %struct_type.base.7c3 = struct_literal (%.loc17_56) +// CHECK:STDOUT: %.loc17_57.3: init %D = class_init (%.loc17_56), %return +// CHECK:STDOUT: %.loc17_58: init %D = converted %.loc17_57.2, %.loc17_57.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc17_55.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a5b +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc17_55.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc17_55.2: %ptr.8e6 = addr_of %.loc17_55.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc17_55.2) +// CHECK:STDOUT: return %.loc17_58 to %return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @D.CallPublic() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Overload.ref: %C.Overload.cpp_overload_set.type = name_ref Overload, imports.%C.Overload.cpp_overload_set.value [concrete = constants.%C.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicCall.ref.loc23_17: type = name_ref PublicCall, imports.%PublicCall.decl [concrete = constants.%PublicCall] +// CHECK:STDOUT: %PublicCall.ref.loc23_28: %PublicCall.PublicCall.cpp_overload_set.type = name_ref PublicCall, imports.%PublicCall.PublicCall.cpp_overload_set.value [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc23_40.1: ref %PublicCall = temporary_storage +// CHECK:STDOUT: %addr.loc23_40.1: %ptr.dfa = addr_of %.loc23_40.1 +// CHECK:STDOUT: %PublicCall__carbon_thunk.call: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc23_40.1) +// CHECK:STDOUT: %.loc23_40.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call, %.loc23_40.1 +// CHECK:STDOUT: %.loc23_40.3: ref %PublicCall = temporary %.loc23_40.1, %.loc23_40.2 +// CHECK:STDOUT: %.loc23_40.4: %PublicCall = bind_value %.loc23_40.3 +// CHECK:STDOUT: %.loc23_40.5: ref %PublicCall = value_as_ref %.loc23_40.4 +// CHECK:STDOUT: %addr.loc23_41: %ptr.dfa = addr_of %.loc23_40.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl.85994f.1(%addr.loc23_41) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc23_40.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.3ff +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc23_40.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc23_40.2: %ptr.dfa = addr_of %.loc23_40.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc23_40.2) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @D.CallProtected() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Overload.ref: %C.Overload.cpp_overload_set.type = name_ref Overload, imports.%C.Overload.cpp_overload_set.value [concrete = constants.%C.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ProtectedCall.ref.loc29_17: type = name_ref ProtectedCall, imports.%ProtectedCall.decl [concrete = constants.%ProtectedCall] +// CHECK:STDOUT: %ProtectedCall.ref.loc29_31: %ProtectedCall.ProtectedCall.cpp_overload_set.type = name_ref ProtectedCall, imports.%ProtectedCall.ProtectedCall.cpp_overload_set.value [concrete = constants.%ProtectedCall.ProtectedCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc29_46.1: ref %ProtectedCall = temporary_storage +// CHECK:STDOUT: %addr.loc29_46.1: %ptr.8e6 = addr_of %.loc29_46.1 +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.call: init %empty_tuple.type = call imports.%ProtectedCall__carbon_thunk.decl(%addr.loc29_46.1) +// CHECK:STDOUT: %.loc29_46.2: init %ProtectedCall = in_place_init %ProtectedCall__carbon_thunk.call, %.loc29_46.1 +// CHECK:STDOUT: %.loc29_46.3: ref %ProtectedCall = temporary %.loc29_46.1, %.loc29_46.2 +// CHECK:STDOUT: %.loc29_46.4: %ProtectedCall = bind_value %.loc29_46.3 +// CHECK:STDOUT: %.loc29_46.5: ref %ProtectedCall = value_as_ref %.loc29_46.4 +// CHECK:STDOUT: %addr.loc29_47: %ptr.8e6 = addr_of %.loc29_46.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl.85994f.2(%addr.loc29_47) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc29_46.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a5b +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc29_46.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc29_46.2: %ptr.8e6 = addr_of %.loc29_46.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc29_46.2) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- import_overload_set_public_base_class_call_public.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Public: type = class_type @Public [concrete] +// CHECK:STDOUT: %Public.Overload.cpp_overload_set.type: type = cpp_overload_set_type @Public.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %Public.Overload.cpp_overload_set.value: %Public.Overload.cpp_overload_set.type = cpp_overload_set_value @Public.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall: type = class_type @PublicCall [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.type: type = cpp_overload_set_type @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.dfa: type = ptr_type %PublicCall [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk.type: type = fn_type @PublicCall__carbon_thunk [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk: %PublicCall__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type: type = fn_type @Overload__carbon_thunk [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk: %Overload__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %type_where: type = facet_type > [concrete] +// CHECK:STDOUT: %facet_value: %type_where = facet_value %PublicCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.3ff: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Public = %Public.decl +// CHECK:STDOUT: .PublicCall = %PublicCall.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Public.decl: type = class_decl @Public [concrete = constants.%Public] {} {} +// CHECK:STDOUT: %Public.Overload.cpp_overload_set.value: %Public.Overload.cpp_overload_set.type = cpp_overload_set_value @Public.Overload.cpp_overload_set [concrete = constants.%Public.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall.decl: type = class_decl @PublicCall [concrete = constants.%PublicCall] {} {} +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall__carbon_thunk.decl: %PublicCall__carbon_thunk.type = fn_decl @PublicCall__carbon_thunk [concrete = constants.%PublicCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Overload__carbon_thunk.decl: %Overload__carbon_thunk.type = fn_decl @Overload__carbon_thunk [concrete = constants.%Overload__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Cpp.ref.loc8_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Public.ref: type = name_ref Public, imports.%Public.decl [concrete = constants.%Public] +// CHECK:STDOUT: %Overload.ref: %Public.Overload.cpp_overload_set.type = name_ref Overload, imports.%Public.Overload.cpp_overload_set.value [concrete = constants.%Public.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc8_23: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicCall.ref.loc8_26: type = name_ref PublicCall, imports.%PublicCall.decl [concrete = constants.%PublicCall] +// CHECK:STDOUT: %PublicCall.ref.loc8_37: %PublicCall.PublicCall.cpp_overload_set.type = name_ref PublicCall, imports.%PublicCall.PublicCall.cpp_overload_set.value [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc8_49.1: ref %PublicCall = temporary_storage +// CHECK:STDOUT: %addr.loc8_49.1: %ptr.dfa = addr_of %.loc8_49.1 +// CHECK:STDOUT: %PublicCall__carbon_thunk.call: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc8_49.1) +// CHECK:STDOUT: %.loc8_49.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call, %.loc8_49.1 +// CHECK:STDOUT: %.loc8_49.3: ref %PublicCall = temporary %.loc8_49.1, %.loc8_49.2 +// CHECK:STDOUT: %.loc8_49.4: %PublicCall = bind_value %.loc8_49.3 +// CHECK:STDOUT: %.loc8_49.5: ref %PublicCall = value_as_ref %.loc8_49.4 +// CHECK:STDOUT: %addr.loc8_50: %ptr.dfa = addr_of %.loc8_49.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl(%addr.loc8_50) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc8_49.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.3ff +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method: = bound_method %.loc8_49.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %addr.loc8_49.2: %ptr.dfa = addr_of %.loc8_49.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc8_49.2) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- import_overload_set_public_base_class_derived_call_non_private.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] +// CHECK:STDOUT: %Public: type = class_type @Public [concrete] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Public.Overload.cpp_overload_set.type: type = cpp_overload_set_type @Public.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %Public.Overload.cpp_overload_set.value: %Public.Overload.cpp_overload_set.type = cpp_overload_set_value @Public.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall: type = class_type @PublicCall [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.type: type = cpp_overload_set_type @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.dfa: type = ptr_type %PublicCall [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk.type: type = fn_type @PublicCall__carbon_thunk [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk: %PublicCall__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type.9a101f.1: type = fn_type @Overload__carbon_thunk.1 [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.794c5b.1: %Overload__carbon_thunk.type.9a101f.1 = struct_value () [concrete] +// CHECK:STDOUT: %ProtectedCall: type = class_type @ProtectedCall [concrete] +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.type: type = cpp_overload_set_type @ProtectedCall.ProtectedCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.value: %ProtectedCall.ProtectedCall.cpp_overload_set.type = cpp_overload_set_value @ProtectedCall.ProtectedCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.8e6: type = ptr_type %ProtectedCall [concrete] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.type: type = fn_type @ProtectedCall__carbon_thunk [concrete] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk: %ProtectedCall__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type.9a101f.2: type = fn_type @Overload__carbon_thunk.2 [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.794c5b.2: %Overload__carbon_thunk.type.9a101f.2 = struct_value () [concrete] +// CHECK:STDOUT: %type_where: type = facet_type > [concrete] +// CHECK:STDOUT: %facet_value.c53: %type_where = facet_value %ProtectedCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b70: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.c53) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.a5b: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b70 = struct_value () [concrete] +// CHECK:STDOUT: %facet_value.136: %type_where = facet_value %PublicCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.136) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.3ff: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Public = %Public.decl +// CHECK:STDOUT: .PublicCall = %PublicCall.decl +// CHECK:STDOUT: .ProtectedCall = %ProtectedCall.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Public.decl: type = class_decl @Public [concrete = constants.%Public] {} {} +// CHECK:STDOUT: %Public.Overload.cpp_overload_set.value: %Public.Overload.cpp_overload_set.type = cpp_overload_set_value @Public.Overload.cpp_overload_set [concrete = constants.%Public.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall.decl: type = class_decl @PublicCall [concrete = constants.%PublicCall] {} {} +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall__carbon_thunk.decl: %PublicCall__carbon_thunk.type = fn_decl @PublicCall__carbon_thunk [concrete = constants.%PublicCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Overload__carbon_thunk.decl.85994f.1: %Overload__carbon_thunk.type.9a101f.1 = fn_decl @Overload__carbon_thunk.1 [concrete = constants.%Overload__carbon_thunk.794c5b.1] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %ProtectedCall.decl: type = class_decl @ProtectedCall [concrete = constants.%ProtectedCall] {} {} +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.value: %ProtectedCall.ProtectedCall.cpp_overload_set.type = cpp_overload_set_value @ProtectedCall.ProtectedCall.cpp_overload_set [concrete = constants.%ProtectedCall.ProtectedCall.cpp_overload_set.value] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.decl: %ProtectedCall__carbon_thunk.type = fn_decl @ProtectedCall__carbon_thunk [concrete = constants.%ProtectedCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Overload__carbon_thunk.decl.85994f.2: %Overload__carbon_thunk.type.9a101f.2 = fn_decl @Overload__carbon_thunk.2 [concrete = constants.%Overload__carbon_thunk.794c5b.2] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @Derived { +// CHECK:STDOUT: +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%Derived +// CHECK:STDOUT: .Cpp = +// CHECK:STDOUT: .base = %.loc7 +// CHECK:STDOUT: .F = %Derived.F.decl +// CHECK:STDOUT: .Overload = +// CHECK:STDOUT: extend %Public.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Overload.ref.loc11: %Public.Overload.cpp_overload_set.type = name_ref Overload, imports.%Public.Overload.cpp_overload_set.value [concrete = constants.%Public.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc11: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicCall.ref.loc11_17: type = name_ref PublicCall, imports.%PublicCall.decl [concrete = constants.%PublicCall] +// CHECK:STDOUT: %PublicCall.ref.loc11_28: %PublicCall.PublicCall.cpp_overload_set.type = name_ref PublicCall, imports.%PublicCall.PublicCall.cpp_overload_set.value [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc11_40.1: ref %PublicCall = temporary_storage +// CHECK:STDOUT: %addr.loc11_40.1: %ptr.dfa = addr_of %.loc11_40.1 +// CHECK:STDOUT: %PublicCall__carbon_thunk.call: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc11_40.1) +// CHECK:STDOUT: %.loc11_40.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call, %.loc11_40.1 +// CHECK:STDOUT: %.loc11_40.3: ref %PublicCall = temporary %.loc11_40.1, %.loc11_40.2 +// CHECK:STDOUT: %.loc11_40.4: %PublicCall = bind_value %.loc11_40.3 +// CHECK:STDOUT: %.loc11_40.5: ref %PublicCall = value_as_ref %.loc11_40.4 +// CHECK:STDOUT: %addr.loc11_41: %ptr.dfa = addr_of %.loc11_40.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call.loc11: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl.85994f.1(%addr.loc11_41) +// CHECK:STDOUT: %Overload.ref.loc12: %Public.Overload.cpp_overload_set.type = name_ref Overload, imports.%Public.Overload.cpp_overload_set.value [concrete = constants.%Public.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ProtectedCall.ref.loc12_17: type = name_ref ProtectedCall, imports.%ProtectedCall.decl [concrete = constants.%ProtectedCall] +// CHECK:STDOUT: %ProtectedCall.ref.loc12_31: %ProtectedCall.ProtectedCall.cpp_overload_set.type = name_ref ProtectedCall, imports.%ProtectedCall.ProtectedCall.cpp_overload_set.value [concrete = constants.%ProtectedCall.ProtectedCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc12_46.1: ref %ProtectedCall = temporary_storage +// CHECK:STDOUT: %addr.loc12_46.1: %ptr.8e6 = addr_of %.loc12_46.1 +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.call: init %empty_tuple.type = call imports.%ProtectedCall__carbon_thunk.decl(%addr.loc12_46.1) +// CHECK:STDOUT: %.loc12_46.2: init %ProtectedCall = in_place_init %ProtectedCall__carbon_thunk.call, %.loc12_46.1 +// CHECK:STDOUT: %.loc12_46.3: ref %ProtectedCall = temporary %.loc12_46.1, %.loc12_46.2 +// CHECK:STDOUT: %.loc12_46.4: %ProtectedCall = bind_value %.loc12_46.3 +// CHECK:STDOUT: %.loc12_46.5: ref %ProtectedCall = value_as_ref %.loc12_46.4 +// CHECK:STDOUT: %addr.loc12_47: %ptr.8e6 = addr_of %.loc12_46.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call.loc12: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl.85994f.2(%addr.loc12_47) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc12: = bound_method %.loc12_46.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a5b +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc12: = bound_method %.loc12_46.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1 +// CHECK:STDOUT: %addr.loc12_46.2: %ptr.8e6 = addr_of %.loc12_46.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc12: init %empty_tuple.type = call %bound_method.loc12(%addr.loc12_46.2) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc11: = bound_method %.loc11_40.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.3ff +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc11: = bound_method %.loc11_40.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 +// CHECK:STDOUT: %addr.loc11_40.2: %ptr.dfa = addr_of %.loc11_40.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc11: init %empty_tuple.type = call %bound_method.loc11(%addr.loc11_40.2) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- import_overload_set_protected_base_class_derived_call_non_private.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] +// CHECK:STDOUT: %Protected: type = class_type @Protected [concrete] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Protected.Overload.cpp_overload_set.type: type = cpp_overload_set_type @Protected.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %Protected.Overload.cpp_overload_set.value: %Protected.Overload.cpp_overload_set.type = cpp_overload_set_value @Protected.Overload.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall: type = class_type @PublicCall [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.type: type = cpp_overload_set_type @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.dfa: type = ptr_type %PublicCall [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk.type: type = fn_type @PublicCall__carbon_thunk [concrete] +// CHECK:STDOUT: %PublicCall__carbon_thunk: %PublicCall__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type.9a101f.1: type = fn_type @Overload__carbon_thunk.1 [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.794c5b.1: %Overload__carbon_thunk.type.9a101f.1 = struct_value () [concrete] +// CHECK:STDOUT: %ProtectedCall: type = class_type @ProtectedCall [concrete] +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.type: type = cpp_overload_set_type @ProtectedCall.ProtectedCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.value: %ProtectedCall.ProtectedCall.cpp_overload_set.type = cpp_overload_set_value @ProtectedCall.ProtectedCall.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.8e6: type = ptr_type %ProtectedCall [concrete] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.type: type = fn_type @ProtectedCall__carbon_thunk [concrete] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk: %ProtectedCall__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.type.9a101f.2: type = fn_type @Overload__carbon_thunk.2 [concrete] +// CHECK:STDOUT: %Overload__carbon_thunk.794c5b.2: %Overload__carbon_thunk.type.9a101f.2 = struct_value () [concrete] +// CHECK:STDOUT: %type_where: type = facet_type > [concrete] +// CHECK:STDOUT: %facet_value.c53: %type_where = facet_value %ProtectedCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b70: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.c53) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.a5b: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.b70 = struct_value () [concrete] +// CHECK:STDOUT: %facet_value.136: %type_where = facet_value %PublicCall, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.136) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.3ff: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.f06 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Protected = %Protected.decl +// CHECK:STDOUT: .PublicCall = %PublicCall.decl +// CHECK:STDOUT: .ProtectedCall = %ProtectedCall.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Protected.decl: type = class_decl @Protected [concrete = constants.%Protected] {} {} +// CHECK:STDOUT: %Protected.Overload.cpp_overload_set.value: %Protected.Overload.cpp_overload_set.type = cpp_overload_set_value @Protected.Overload.cpp_overload_set [concrete = constants.%Protected.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall.decl: type = class_decl @PublicCall [concrete = constants.%PublicCall] {} {} +// CHECK:STDOUT: %PublicCall.PublicCall.cpp_overload_set.value: %PublicCall.PublicCall.cpp_overload_set.type = cpp_overload_set_value @PublicCall.PublicCall.cpp_overload_set [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %PublicCall__carbon_thunk.decl: %PublicCall__carbon_thunk.type = fn_decl @PublicCall__carbon_thunk [concrete = constants.%PublicCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Overload__carbon_thunk.decl.85994f.1: %Overload__carbon_thunk.type.9a101f.1 = fn_decl @Overload__carbon_thunk.1 [concrete = constants.%Overload__carbon_thunk.794c5b.1] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %ProtectedCall.decl: type = class_decl @ProtectedCall [concrete = constants.%ProtectedCall] {} {} +// CHECK:STDOUT: %ProtectedCall.ProtectedCall.cpp_overload_set.value: %ProtectedCall.ProtectedCall.cpp_overload_set.type = cpp_overload_set_value @ProtectedCall.ProtectedCall.cpp_overload_set [concrete = constants.%ProtectedCall.ProtectedCall.cpp_overload_set.value] +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.decl: %ProtectedCall__carbon_thunk.type = fn_decl @ProtectedCall__carbon_thunk [concrete = constants.%ProtectedCall__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Overload__carbon_thunk.decl.85994f.2: %Overload__carbon_thunk.type.9a101f.2 = fn_decl @Overload__carbon_thunk.2 [concrete = constants.%Overload__carbon_thunk.794c5b.2] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @Derived { +// CHECK:STDOUT: +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%Derived +// CHECK:STDOUT: .Cpp = +// CHECK:STDOUT: .base = %.loc7 +// CHECK:STDOUT: .F = %Derived.F.decl +// CHECK:STDOUT: .Overload = +// CHECK:STDOUT: extend %Protected.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.F() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Overload.ref.loc11: %Protected.Overload.cpp_overload_set.type = name_ref Overload, imports.%Protected.Overload.cpp_overload_set.value [concrete = constants.%Protected.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc11: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicCall.ref.loc11_17: type = name_ref PublicCall, imports.%PublicCall.decl [concrete = constants.%PublicCall] +// CHECK:STDOUT: %PublicCall.ref.loc11_28: %PublicCall.PublicCall.cpp_overload_set.type = name_ref PublicCall, imports.%PublicCall.PublicCall.cpp_overload_set.value [concrete = constants.%PublicCall.PublicCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc11_40.1: ref %PublicCall = temporary_storage +// CHECK:STDOUT: %addr.loc11_40.1: %ptr.dfa = addr_of %.loc11_40.1 +// CHECK:STDOUT: %PublicCall__carbon_thunk.call: init %empty_tuple.type = call imports.%PublicCall__carbon_thunk.decl(%addr.loc11_40.1) +// CHECK:STDOUT: %.loc11_40.2: init %PublicCall = in_place_init %PublicCall__carbon_thunk.call, %.loc11_40.1 +// CHECK:STDOUT: %.loc11_40.3: ref %PublicCall = temporary %.loc11_40.1, %.loc11_40.2 +// CHECK:STDOUT: %.loc11_40.4: %PublicCall = bind_value %.loc11_40.3 +// CHECK:STDOUT: %.loc11_40.5: ref %PublicCall = value_as_ref %.loc11_40.4 +// CHECK:STDOUT: %addr.loc11_41: %ptr.dfa = addr_of %.loc11_40.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call.loc11: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl.85994f.1(%addr.loc11_41) +// CHECK:STDOUT: %Overload.ref.loc12: %Protected.Overload.cpp_overload_set.type = name_ref Overload, imports.%Protected.Overload.cpp_overload_set.value [concrete = constants.%Protected.Overload.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ProtectedCall.ref.loc12_17: type = name_ref ProtectedCall, imports.%ProtectedCall.decl [concrete = constants.%ProtectedCall] +// CHECK:STDOUT: %ProtectedCall.ref.loc12_31: %ProtectedCall.ProtectedCall.cpp_overload_set.type = name_ref ProtectedCall, imports.%ProtectedCall.ProtectedCall.cpp_overload_set.value [concrete = constants.%ProtectedCall.ProtectedCall.cpp_overload_set.value] +// CHECK:STDOUT: %.loc12_46.1: ref %ProtectedCall = temporary_storage +// CHECK:STDOUT: %addr.loc12_46.1: %ptr.8e6 = addr_of %.loc12_46.1 +// CHECK:STDOUT: %ProtectedCall__carbon_thunk.call: init %empty_tuple.type = call imports.%ProtectedCall__carbon_thunk.decl(%addr.loc12_46.1) +// CHECK:STDOUT: %.loc12_46.2: init %ProtectedCall = in_place_init %ProtectedCall__carbon_thunk.call, %.loc12_46.1 +// CHECK:STDOUT: %.loc12_46.3: ref %ProtectedCall = temporary %.loc12_46.1, %.loc12_46.2 +// CHECK:STDOUT: %.loc12_46.4: %ProtectedCall = bind_value %.loc12_46.3 +// CHECK:STDOUT: %.loc12_46.5: ref %ProtectedCall = value_as_ref %.loc12_46.4 +// CHECK:STDOUT: %addr.loc12_47: %ptr.8e6 = addr_of %.loc12_46.5 +// CHECK:STDOUT: %Overload__carbon_thunk.call.loc12: init %empty_tuple.type = call imports.%Overload__carbon_thunk.decl.85994f.2(%addr.loc12_47) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc12: = bound_method %.loc12_46.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a5b +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc12: = bound_method %.loc12_46.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1 +// CHECK:STDOUT: %addr.loc12_46.2: %ptr.8e6 = addr_of %.loc12_46.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc12: init %empty_tuple.type = call %bound_method.loc12(%addr.loc12_46.2) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc11: = bound_method %.loc11_40.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.3ff +// CHECK:STDOUT: +// CHECK:STDOUT: %bound_method.loc11: = bound_method %.loc11_40.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 +// CHECK:STDOUT: %addr.loc11_40.2: %ptr.dfa = addr_of %.loc11_40.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc11: init %empty_tuple.type = call %bound_method.loc11(%addr.loc11_40.2) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- base_class_public_access_allowed.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] +// CHECK:STDOUT: %Public: type = class_type @Public [concrete] +// CHECK:STDOUT: %Base: type = class_type @Base [concrete] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Public.PublicStatic.cpp_overload_set.type: type = cpp_overload_set_type @Public.PublicStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Public.PublicStatic.cpp_overload_set.value: %Public.PublicStatic.cpp_overload_set.type = cpp_overload_set_value @Public.PublicStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.PublicStatic.type: type = fn_type @Base.PublicStatic [concrete] +// CHECK:STDOUT: %Base.PublicStatic: %Base.PublicStatic.type = struct_value () [concrete] +// CHECK:STDOUT: %Public.ProtectedStatic.cpp_overload_set.type: type = cpp_overload_set_type @Public.ProtectedStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Public.ProtectedStatic.cpp_overload_set.value: %Public.ProtectedStatic.cpp_overload_set.type = cpp_overload_set_value @Public.ProtectedStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.ProtectedStatic.type: type = fn_type @Base.ProtectedStatic [concrete] +// CHECK:STDOUT: %Base.ProtectedStatic: %Base.ProtectedStatic.type = struct_value () [concrete] +// CHECK:STDOUT: %Public.PublicInstance.cpp_overload_set.type: type = cpp_overload_set_type @Public.PublicInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %Public.PublicInstance.cpp_overload_set.value: %Public.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Public.PublicInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.fb2: type = ptr_type %Base [concrete] +// CHECK:STDOUT: %Base.PublicInstance.type: type = fn_type @Base.PublicInstance [concrete] +// CHECK:STDOUT: %Base.PublicInstance: %Base.PublicInstance.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.1e8: type = ptr_type %Public [concrete] +// CHECK:STDOUT: %Public.ProtectedInstance.cpp_overload_set.type: type = cpp_overload_set_type @Public.ProtectedInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %Public.ProtectedInstance.cpp_overload_set.value: %Public.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Public.ProtectedInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.ProtectedInstance.type: type = fn_type @Base.ProtectedInstance [concrete] +// CHECK:STDOUT: %Base.ProtectedInstance: %Base.ProtectedInstance.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Public = %Public.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Public.decl: type = class_decl @Public [concrete = constants.%Public] {} {} +// CHECK:STDOUT: %Public.PublicStatic.cpp_overload_set.value: %Public.PublicStatic.cpp_overload_set.type = cpp_overload_set_value @Public.PublicStatic.cpp_overload_set [concrete = constants.%Public.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.decl: %Base.PublicStatic.type = fn_decl @Base.PublicStatic [concrete = constants.%Base.PublicStatic] {} {} +// CHECK:STDOUT: %Public.ProtectedStatic.cpp_overload_set.value: %Public.ProtectedStatic.cpp_overload_set.type = cpp_overload_set_value @Public.ProtectedStatic.cpp_overload_set [concrete = constants.%Public.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.decl: %Base.ProtectedStatic.type = fn_decl @Base.ProtectedStatic [concrete = constants.%Base.ProtectedStatic] {} {} +// CHECK:STDOUT: %Public.PublicInstance.cpp_overload_set.value: %Public.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Public.PublicInstance.cpp_overload_set [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicInstance.decl: %Base.PublicInstance.type = fn_decl @Base.PublicInstance [concrete = constants.%Base.PublicInstance] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Public.ProtectedInstance.cpp_overload_set.value: %Public.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Public.ProtectedInstance.cpp_overload_set [concrete = constants.%Public.ProtectedInstance.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedInstance.decl: %Base.ProtectedInstance.type = fn_decl @Base.ProtectedInstance [concrete = constants.%Base.ProtectedInstance] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @Derived { +// CHECK:STDOUT: +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%Derived +// CHECK:STDOUT: .Cpp = +// CHECK:STDOUT: .base = %.loc7 +// CHECK:STDOUT: .CallStatic = %Derived.CallStatic.decl +// CHECK:STDOUT: .CallInstance = %Derived.CallInstance.decl +// CHECK:STDOUT: .PublicStatic = +// CHECK:STDOUT: .ProtectedStatic = +// CHECK:STDOUT: extend %Public.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.CallStatic() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Public.ref.loc12: type = name_ref Public, imports.%Public.decl [concrete = constants.%Public] +// CHECK:STDOUT: %PublicStatic.ref.loc12: %Public.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%Public.PublicStatic.cpp_overload_set.value [concrete = constants.%Public.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc12: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %Self.ref.loc13: type = name_ref Self, constants.%Derived [concrete = constants.%Derived] +// CHECK:STDOUT: %PublicStatic.ref.loc13: %Public.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%Public.PublicStatic.cpp_overload_set.value [concrete = constants.%Public.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc13: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %Cpp.ref.loc16: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Public.ref.loc16: type = name_ref Public, imports.%Public.decl [concrete = constants.%Public] +// CHECK:STDOUT: %ProtectedStatic.ref.loc16: %Public.ProtectedStatic.cpp_overload_set.type = name_ref ProtectedStatic, imports.%Public.ProtectedStatic.cpp_overload_set.value [concrete = constants.%Public.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.call.loc16: init %empty_tuple.type = call imports.%Base.ProtectedStatic.decl() +// CHECK:STDOUT: %Self.ref.loc17: type = name_ref Self, constants.%Derived [concrete = constants.%Derived] +// CHECK:STDOUT: %ProtectedStatic.ref.loc17: %Public.ProtectedStatic.cpp_overload_set.type = name_ref ProtectedStatic, imports.%Public.ProtectedStatic.cpp_overload_set.value [concrete = constants.%Public.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.call.loc17: init %empty_tuple.type = call imports.%Base.ProtectedStatic.decl() +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.CallInstance(%instance.param: %Public) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %instance.ref.loc24: ref %Public = name_ref instance, %instance +// CHECK:STDOUT: %PublicInstance.ref: %Public.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Public.PublicInstance.cpp_overload_set.value [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc24: = bound_method %instance.ref.loc24, %PublicInstance.ref +// CHECK:STDOUT: %addr.loc24_5.1: %ptr.1e8 = addr_of %instance.ref.loc24 +// CHECK:STDOUT: %.loc24_5.1: ref %Public = deref %addr.loc24_5.1 +// CHECK:STDOUT: %.loc24_5.2: ref %Base = class_element_access %.loc24_5.1, element0 +// CHECK:STDOUT: %addr.loc24_5.2: %ptr.fb2 = addr_of %.loc24_5.2 +// CHECK:STDOUT: %.loc24_5.3: %ptr.fb2 = converted %addr.loc24_5.1, %addr.loc24_5.2 +// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.3) +// CHECK:STDOUT: %instance.ref.loc26: ref %Public = name_ref instance, %instance +// CHECK:STDOUT: %ProtectedInstance.ref: %Public.ProtectedInstance.cpp_overload_set.type = name_ref ProtectedInstance, imports.%Public.ProtectedInstance.cpp_overload_set.value [concrete = constants.%Public.ProtectedInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc26: = bound_method %instance.ref.loc26, %ProtectedInstance.ref +// CHECK:STDOUT: %addr.loc26_5.1: %ptr.1e8 = addr_of %instance.ref.loc26 +// CHECK:STDOUT: %.loc26_5.1: ref %Public = deref %addr.loc26_5.1 +// CHECK:STDOUT: %.loc26_5.2: ref %Base = class_element_access %.loc26_5.1, element0 +// CHECK:STDOUT: %addr.loc26_5.2: %ptr.fb2 = addr_of %.loc26_5.2 +// CHECK:STDOUT: %.loc26_5.3: %ptr.fb2 = converted %addr.loc26_5.1, %addr.loc26_5.2 +// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Call(%instance.param: %Public) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Cpp.ref.loc33: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Public.ref.loc33: type = name_ref Public, imports.%Public.decl [concrete = constants.%Public] +// CHECK:STDOUT: %PublicStatic.ref.loc33: %Public.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%Public.PublicStatic.cpp_overload_set.value [concrete = constants.%Public.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc33: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %Derived.ref: type = name_ref Derived, file.%Derived.decl [concrete = constants.%Derived] +// CHECK:STDOUT: %PublicStatic.ref.loc34: %Public.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%Public.PublicStatic.cpp_overload_set.value [concrete = constants.%Public.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc34: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %instance.ref.loc36: ref %Public = name_ref instance, %instance +// CHECK:STDOUT: %PublicInstance.ref.loc36: %Public.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Public.PublicInstance.cpp_overload_set.value [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc36: = bound_method %instance.ref.loc36, %PublicInstance.ref.loc36 +// CHECK:STDOUT: %addr.loc36_3.1: %ptr.1e8 = addr_of %instance.ref.loc36 +// CHECK:STDOUT: %.loc36_3.1: ref %Public = deref %addr.loc36_3.1 +// CHECK:STDOUT: %.loc36_3.2: ref %Base = class_element_access %.loc36_3.1, element0 +// CHECK:STDOUT: %addr.loc36_3.2: %ptr.fb2 = addr_of %.loc36_3.2 +// CHECK:STDOUT: %.loc36_3.3: %ptr.fb2 = converted %addr.loc36_3.1, %addr.loc36_3.2 +// CHECK:STDOUT: %Base.PublicInstance.call.loc36: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc36_3.3) +// CHECK:STDOUT: %instance.ref.loc37: ref %Public = name_ref instance, %instance +// CHECK:STDOUT: %PublicInstance.ref.loc37: %Public.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Public.PublicInstance.cpp_overload_set.value [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc37: = bound_method %instance.ref.loc37, %PublicInstance.ref.loc37 +// CHECK:STDOUT: %addr.loc37_3.1: %ptr.1e8 = addr_of %instance.ref.loc37 +// CHECK:STDOUT: %.loc37_3.1: ref %Public = deref %addr.loc37_3.1 +// CHECK:STDOUT: %.loc37_3.2: ref %Base = class_element_access %.loc37_3.1, element0 +// CHECK:STDOUT: %addr.loc37_3.2: %ptr.fb2 = addr_of %.loc37_3.2 +// CHECK:STDOUT: %.loc37_3.3: %ptr.fb2 = converted %addr.loc37_3.1, %addr.loc37_3.2 +// CHECK:STDOUT: %Base.PublicInstance.call.loc37: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc37_3.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_base_class_public_access_denied.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] +// CHECK:STDOUT: %Public: type = class_type @Public [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @Derived { +// CHECK:STDOUT: +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%Derived +// CHECK:STDOUT: .Cpp = +// CHECK:STDOUT: .base = %.loc7 +// CHECK:STDOUT: .CallStatic = %Derived.CallStatic.decl +// CHECK:STDOUT: .CallInstance = %Derived.CallInstance.decl +// CHECK:STDOUT: .PrivateStatic = +// CHECK:STDOUT: .ProtectedStatic = +// CHECK:STDOUT: extend %Public.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.CallInstance(%instance.param: %Public) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %instance.ref: ref %Public = name_ref instance, %instance +// CHECK:STDOUT: %PrivateInstance.ref: = name_ref PrivateInstance, [concrete = ] +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- base_class_protected_access_allowed.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] +// CHECK:STDOUT: %Protected: type = class_type @Protected [concrete] +// CHECK:STDOUT: %Base: type = class_type @Base [concrete] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Protected.PublicStatic.cpp_overload_set.type: type = cpp_overload_set_type @Protected.PublicStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Protected.PublicStatic.cpp_overload_set.value: %Protected.PublicStatic.cpp_overload_set.type = cpp_overload_set_value @Protected.PublicStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.PublicStatic.type: type = fn_type @Base.PublicStatic [concrete] +// CHECK:STDOUT: %Base.PublicStatic: %Base.PublicStatic.type = struct_value () [concrete] +// CHECK:STDOUT: %Protected.ProtectedStatic.cpp_overload_set.type: type = cpp_overload_set_type @Protected.ProtectedStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Protected.ProtectedStatic.cpp_overload_set.value: %Protected.ProtectedStatic.cpp_overload_set.type = cpp_overload_set_value @Protected.ProtectedStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.ProtectedStatic.type: type = fn_type @Base.ProtectedStatic [concrete] +// CHECK:STDOUT: %Base.ProtectedStatic: %Base.ProtectedStatic.type = struct_value () [concrete] +// CHECK:STDOUT: %Protected.PublicInstance.cpp_overload_set.type: type = cpp_overload_set_type @Protected.PublicInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %Protected.PublicInstance.cpp_overload_set.value: %Protected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.PublicInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.fb2: type = ptr_type %Base [concrete] +// CHECK:STDOUT: %Base.PublicInstance.type: type = fn_type @Base.PublicInstance [concrete] +// CHECK:STDOUT: %Base.PublicInstance: %Base.PublicInstance.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.f97: type = ptr_type %Protected [concrete] +// CHECK:STDOUT: %Protected.ProtectedInstance.cpp_overload_set.type: type = cpp_overload_set_type @Protected.ProtectedInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %Protected.ProtectedInstance.cpp_overload_set.value: %Protected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.ProtectedInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.ProtectedInstance.type: type = fn_type @Base.ProtectedInstance [concrete] +// CHECK:STDOUT: %Base.ProtectedInstance: %Base.ProtectedInstance.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Protected = %Protected.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Protected.decl: type = class_decl @Protected [concrete = constants.%Protected] {} {} +// CHECK:STDOUT: %Protected.PublicStatic.cpp_overload_set.value: %Protected.PublicStatic.cpp_overload_set.type = cpp_overload_set_value @Protected.PublicStatic.cpp_overload_set [concrete = constants.%Protected.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.decl: %Base.PublicStatic.type = fn_decl @Base.PublicStatic [concrete = constants.%Base.PublicStatic] {} {} +// CHECK:STDOUT: %Protected.ProtectedStatic.cpp_overload_set.value: %Protected.ProtectedStatic.cpp_overload_set.type = cpp_overload_set_value @Protected.ProtectedStatic.cpp_overload_set [concrete = constants.%Protected.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.decl: %Base.ProtectedStatic.type = fn_decl @Base.ProtectedStatic [concrete = constants.%Base.ProtectedStatic] {} {} +// CHECK:STDOUT: %Protected.PublicInstance.cpp_overload_set.value: %Protected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.PublicInstance.cpp_overload_set [concrete = constants.%Protected.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicInstance.decl: %Base.PublicInstance.type = fn_decl @Base.PublicInstance [concrete = constants.%Base.PublicInstance] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Protected.ProtectedInstance.cpp_overload_set.value: %Protected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.ProtectedInstance.cpp_overload_set [concrete = constants.%Protected.ProtectedInstance.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedInstance.decl: %Base.ProtectedInstance.type = fn_decl @Base.ProtectedInstance [concrete = constants.%Base.ProtectedInstance] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @Derived { +// CHECK:STDOUT: +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%Derived +// CHECK:STDOUT: .Cpp = +// CHECK:STDOUT: .base = %.loc7 +// CHECK:STDOUT: .CallStatic = %Derived.CallStatic.decl +// CHECK:STDOUT: .CallInstance = %Derived.CallInstance.decl +// CHECK:STDOUT: .PublicStatic = +// CHECK:STDOUT: .ProtectedStatic = +// CHECK:STDOUT: extend %Protected.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.CallStatic() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Protected.ref.loc12: type = name_ref Protected, imports.%Protected.decl [concrete = constants.%Protected] +// CHECK:STDOUT: %PublicStatic.ref.loc12: %Protected.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%Protected.PublicStatic.cpp_overload_set.value [concrete = constants.%Protected.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc12: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %Self.ref.loc13: type = name_ref Self, constants.%Derived [concrete = constants.%Derived] +// CHECK:STDOUT: %PublicStatic.ref.loc13: %Protected.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%Protected.PublicStatic.cpp_overload_set.value [concrete = constants.%Protected.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc13: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %Cpp.ref.loc16: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Protected.ref.loc16: type = name_ref Protected, imports.%Protected.decl [concrete = constants.%Protected] +// CHECK:STDOUT: %ProtectedStatic.ref.loc16: %Protected.ProtectedStatic.cpp_overload_set.type = name_ref ProtectedStatic, imports.%Protected.ProtectedStatic.cpp_overload_set.value [concrete = constants.%Protected.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.call.loc16: init %empty_tuple.type = call imports.%Base.ProtectedStatic.decl() +// CHECK:STDOUT: %Self.ref.loc17: type = name_ref Self, constants.%Derived [concrete = constants.%Derived] +// CHECK:STDOUT: %ProtectedStatic.ref.loc17: %Protected.ProtectedStatic.cpp_overload_set.type = name_ref ProtectedStatic, imports.%Protected.ProtectedStatic.cpp_overload_set.value [concrete = constants.%Protected.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.call.loc17: init %empty_tuple.type = call imports.%Base.ProtectedStatic.decl() +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.CallInstance(%instance.param: %Protected) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %instance.ref.loc24: ref %Protected = name_ref instance, %instance +// CHECK:STDOUT: %PublicInstance.ref: %Protected.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Protected.PublicInstance.cpp_overload_set.value [concrete = constants.%Protected.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc24: = bound_method %instance.ref.loc24, %PublicInstance.ref +// CHECK:STDOUT: %addr.loc24_5.1: %ptr.f97 = addr_of %instance.ref.loc24 +// CHECK:STDOUT: %.loc24_5.1: ref %Protected = deref %addr.loc24_5.1 +// CHECK:STDOUT: %.loc24_5.2: ref %Base = class_element_access %.loc24_5.1, element0 +// CHECK:STDOUT: %addr.loc24_5.2: %ptr.fb2 = addr_of %.loc24_5.2 +// CHECK:STDOUT: %.loc24_5.3: %ptr.fb2 = converted %addr.loc24_5.1, %addr.loc24_5.2 +// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.3) +// CHECK:STDOUT: %instance.ref.loc26: ref %Protected = name_ref instance, %instance +// CHECK:STDOUT: %ProtectedInstance.ref: %Protected.ProtectedInstance.cpp_overload_set.type = name_ref ProtectedInstance, imports.%Protected.ProtectedInstance.cpp_overload_set.value [concrete = constants.%Protected.ProtectedInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc26: = bound_method %instance.ref.loc26, %ProtectedInstance.ref +// CHECK:STDOUT: %addr.loc26_5.1: %ptr.f97 = addr_of %instance.ref.loc26 +// CHECK:STDOUT: %.loc26_5.1: ref %Protected = deref %addr.loc26_5.1 +// CHECK:STDOUT: %.loc26_5.2: ref %Base = class_element_access %.loc26_5.1, element0 +// CHECK:STDOUT: %addr.loc26_5.2: %ptr.fb2 = addr_of %.loc26_5.2 +// CHECK:STDOUT: %.loc26_5.3: %ptr.fb2 = converted %addr.loc26_5.1, %addr.loc26_5.2 +// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.3) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- base_class_public_protected_access_allowed.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Derived: type = class_type @Derived [concrete] +// CHECK:STDOUT: %PublicProtected: type = class_type @PublicProtected [concrete] +// CHECK:STDOUT: %Protected: type = class_type @Protected [concrete] +// CHECK:STDOUT: %Base: type = class_type @Base [concrete] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %PublicProtected.PublicStatic.cpp_overload_set.type: type = cpp_overload_set_type @PublicProtected.PublicStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicProtected.PublicStatic.cpp_overload_set.value: %PublicProtected.PublicStatic.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.PublicStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.PublicStatic.type: type = fn_type @Base.PublicStatic [concrete] +// CHECK:STDOUT: %Base.PublicStatic: %Base.PublicStatic.type = struct_value () [concrete] +// CHECK:STDOUT: %PublicProtected.ProtectedStatic.cpp_overload_set.type: type = cpp_overload_set_type @PublicProtected.ProtectedStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicProtected.ProtectedStatic.cpp_overload_set.value: %PublicProtected.ProtectedStatic.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.ProtectedStatic.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.ProtectedStatic.type: type = fn_type @Base.ProtectedStatic [concrete] +// CHECK:STDOUT: %Base.ProtectedStatic: %Base.ProtectedStatic.type = struct_value () [concrete] +// CHECK:STDOUT: %PublicProtected.PublicInstance.cpp_overload_set.type: type = cpp_overload_set_type @PublicProtected.PublicInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicProtected.PublicInstance.cpp_overload_set.value: %PublicProtected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.PublicInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.fb2: type = ptr_type %Base [concrete] +// CHECK:STDOUT: %Base.PublicInstance.type: type = fn_type @Base.PublicInstance [concrete] +// CHECK:STDOUT: %Base.PublicInstance: %Base.PublicInstance.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.dc4: type = ptr_type %PublicProtected [concrete] +// CHECK:STDOUT: %PublicProtected.ProtectedInstance.cpp_overload_set.type: type = cpp_overload_set_type @PublicProtected.ProtectedInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %PublicProtected.ProtectedInstance.cpp_overload_set.value: %PublicProtected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.ProtectedInstance.cpp_overload_set [concrete] +// CHECK:STDOUT: %Base.ProtectedInstance.type: type = fn_type @Base.ProtectedInstance [concrete] +// CHECK:STDOUT: %Base.ProtectedInstance: %Base.ProtectedInstance.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .PublicProtected = %PublicProtected.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %PublicProtected.decl: type = class_decl @PublicProtected [concrete = constants.%PublicProtected] {} {} +// CHECK:STDOUT: %PublicProtected.PublicStatic.cpp_overload_set.value: %PublicProtected.PublicStatic.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.PublicStatic.cpp_overload_set [concrete = constants.%PublicProtected.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.decl: %Base.PublicStatic.type = fn_decl @Base.PublicStatic [concrete = constants.%Base.PublicStatic] {} {} +// CHECK:STDOUT: %PublicProtected.ProtectedStatic.cpp_overload_set.value: %PublicProtected.ProtectedStatic.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.ProtectedStatic.cpp_overload_set [concrete = constants.%PublicProtected.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.decl: %Base.ProtectedStatic.type = fn_decl @Base.ProtectedStatic [concrete = constants.%Base.ProtectedStatic] {} {} +// CHECK:STDOUT: %PublicProtected.PublicInstance.cpp_overload_set.value: %PublicProtected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.PublicInstance.cpp_overload_set [concrete = constants.%PublicProtected.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicInstance.decl: %Base.PublicInstance.type = fn_decl @Base.PublicInstance [concrete = constants.%Base.PublicInstance] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %PublicProtected.ProtectedInstance.cpp_overload_set.value: %PublicProtected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.ProtectedInstance.cpp_overload_set [concrete = constants.%PublicProtected.ProtectedInstance.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedInstance.decl: %Base.ProtectedInstance.type = fn_decl @Base.ProtectedInstance [concrete = constants.%Base.ProtectedInstance] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @Derived { +// CHECK:STDOUT: +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%Derived +// CHECK:STDOUT: .Cpp = +// CHECK:STDOUT: .base = %.loc7 +// CHECK:STDOUT: .CallStatic = %Derived.CallStatic.decl +// CHECK:STDOUT: .CallInstance = %Derived.CallInstance.decl +// CHECK:STDOUT: .PublicStatic = +// CHECK:STDOUT: .ProtectedStatic = +// CHECK:STDOUT: extend %PublicProtected.ref +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.CallStatic() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicProtected.ref.loc12: type = name_ref PublicProtected, imports.%PublicProtected.decl [concrete = constants.%PublicProtected] +// CHECK:STDOUT: %PublicStatic.ref.loc12: %PublicProtected.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%PublicProtected.PublicStatic.cpp_overload_set.value [concrete = constants.%PublicProtected.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc12: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %Self.ref.loc13: type = name_ref Self, constants.%Derived [concrete = constants.%Derived] +// CHECK:STDOUT: %PublicStatic.ref.loc13: %PublicProtected.PublicStatic.cpp_overload_set.type = name_ref PublicStatic, imports.%PublicProtected.PublicStatic.cpp_overload_set.value [concrete = constants.%PublicProtected.PublicStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.PublicStatic.call.loc13: init %empty_tuple.type = call imports.%Base.PublicStatic.decl() +// CHECK:STDOUT: %Cpp.ref.loc16: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PublicProtected.ref.loc16: type = name_ref PublicProtected, imports.%PublicProtected.decl [concrete = constants.%PublicProtected] +// CHECK:STDOUT: %ProtectedStatic.ref.loc16: %PublicProtected.ProtectedStatic.cpp_overload_set.type = name_ref ProtectedStatic, imports.%PublicProtected.ProtectedStatic.cpp_overload_set.value [concrete = constants.%PublicProtected.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.call.loc16: init %empty_tuple.type = call imports.%Base.ProtectedStatic.decl() +// CHECK:STDOUT: %Self.ref.loc17: type = name_ref Self, constants.%Derived [concrete = constants.%Derived] +// CHECK:STDOUT: %ProtectedStatic.ref.loc17: %PublicProtected.ProtectedStatic.cpp_overload_set.type = name_ref ProtectedStatic, imports.%PublicProtected.ProtectedStatic.cpp_overload_set.value [concrete = constants.%PublicProtected.ProtectedStatic.cpp_overload_set.value] +// CHECK:STDOUT: %Base.ProtectedStatic.call.loc17: init %empty_tuple.type = call imports.%Base.ProtectedStatic.decl() +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @Derived.CallInstance(%instance.param: %PublicProtected) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %instance.ref.loc24: ref %PublicProtected = name_ref instance, %instance +// CHECK:STDOUT: %PublicInstance.ref: %PublicProtected.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%PublicProtected.PublicInstance.cpp_overload_set.value [concrete = constants.%PublicProtected.PublicInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc24: = bound_method %instance.ref.loc24, %PublicInstance.ref +// CHECK:STDOUT: %addr.loc24_5.1: %ptr.dc4 = addr_of %instance.ref.loc24 +// CHECK:STDOUT: %.loc24_5.1: ref %PublicProtected = deref %addr.loc24_5.1 +// CHECK:STDOUT: %.loc24_5.2: ref %Protected = class_element_access %.loc24_5.1, element0 +// CHECK:STDOUT: %.loc24_5.3: ref %Base = class_element_access %.loc24_5.2, element0 +// CHECK:STDOUT: %addr.loc24_5.2: %ptr.fb2 = addr_of %.loc24_5.3 +// CHECK:STDOUT: %.loc24_5.4: %ptr.fb2 = converted %addr.loc24_5.1, %addr.loc24_5.2 +// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.4) +// CHECK:STDOUT: %instance.ref.loc26: ref %PublicProtected = name_ref instance, %instance +// CHECK:STDOUT: %ProtectedInstance.ref: %PublicProtected.ProtectedInstance.cpp_overload_set.type = name_ref ProtectedInstance, imports.%PublicProtected.ProtectedInstance.cpp_overload_set.value [concrete = constants.%PublicProtected.ProtectedInstance.cpp_overload_set.value] +// CHECK:STDOUT: %bound_method.loc26: = bound_method %instance.ref.loc26, %ProtectedInstance.ref +// CHECK:STDOUT: %addr.loc26_5.1: %ptr.dc4 = addr_of %instance.ref.loc26 +// CHECK:STDOUT: %.loc26_5.1: ref %PublicProtected = deref %addr.loc26_5.1 +// CHECK:STDOUT: %.loc26_5.2: ref %Protected = class_element_access %.loc26_5.1, element0 +// CHECK:STDOUT: %.loc26_5.3: ref %Base = class_element_access %.loc26_5.2, element0 +// CHECK:STDOUT: %addr.loc26_5.2: %ptr.fb2 = addr_of %.loc26_5.3 +// CHECK:STDOUT: %.loc26_5.4: %ptr.fb2 = converted %addr.loc26_5.1, %addr.loc26_5.2 +// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.4) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: