diff --git a/toolchain/check/cpp/import.cpp b/toolchain/check/cpp/import.cpp index 3a76890d4a8b..1ff276830326 100644 --- a/toolchain/check/cpp/import.cpp +++ b/toolchain/check/cpp/import.cpp @@ -1391,7 +1391,8 @@ static auto GetFunctionName(Context& context, clang::FunctionDecl* clang_decl) return SemIR::NameId::CppDestructor; } - case clang::DeclarationName::CXXOperatorName: { + case clang::DeclarationName::CXXOperatorName: + case clang::DeclarationName::CXXConversionFunctionName: { return SemIR::NameId::CppOperator; } @@ -1406,6 +1407,7 @@ static auto GetFunctionName(Context& context, clang::FunctionDecl* clang_decl) // * Have not been imported before. // * Be of supported type (ignoring parameters). static auto ImportFunction(Context& context, SemIR::LocId loc_id, + SemIR::ImportIRInstId import_ir_inst_id, clang::FunctionDecl* clang_decl, int num_params) -> std::optional { context.scope_stack().PushForDeclName(); @@ -1426,7 +1428,8 @@ static auto ImportFunction(Context& context, SemIR::LocId loc_id, auto function_decl = SemIR::FunctionDecl{ SemIR::TypeId::None, SemIR::FunctionId::None, decl_block_id}; auto decl_id = AddPlaceholderImportedInstInNoBlock( - context, SemIR::LocIdAndInst::NoLoc(function_decl)); + context, + MakeImportedLocIdAndInst(context, import_ir_inst_id, function_decl)); auto virtual_modifier = SemIR::Function::VirtualModifier::None; int32_t virtual_index = -1; @@ -1506,10 +1509,13 @@ static auto ImportFunctionDecl(Context& context, SemIR::LocId loc_id, return SemIR::ErrorInst::InstId; } + auto import_ir_inst_id = + AddImportIRInst(context.sem_ir(), clang_decl->getLocation()); + CARBON_CHECK(clang_decl->getFunctionType()->isFunctionProtoType(), "Not Prototype function (non-C++ code)"); - - auto function_id = ImportFunction(context, loc_id, clang_decl, num_params); + auto function_id = ImportFunction(context, loc_id, import_ir_inst_id, + clang_decl, num_params); if (!function_id) { MarkFailedDecl(context, key); return SemIR::ErrorInst::InstId; @@ -1526,9 +1532,9 @@ static auto ImportFunctionDecl(Context& context, SemIR::LocId loc_id, if (clang::FunctionDecl* thunk_clang_decl = BuildCppThunk(context, function_info)) { - if (auto thunk_function_id = - ImportFunction(context, loc_id, thunk_clang_decl, - thunk_clang_decl->getNumParams())) { + if (auto thunk_function_id = ImportFunction( + context, loc_id, import_ir_inst_id, thunk_clang_decl, + thunk_clang_decl->getNumParams())) { SemIR::InstId thunk_function_decl_id = context.functions().Get(*thunk_function_id).first_owning_decl_id; function_info.SetHasCppThunk(thunk_function_decl_id); diff --git a/toolchain/check/cpp/operators.cpp b/toolchain/check/cpp/operators.cpp index 6ee07fa8e3c1..5fb84868fea5 100644 --- a/toolchain/check/cpp/operators.cpp +++ b/toolchain/check/cpp/operators.cpp @@ -4,6 +4,7 @@ #include "toolchain/check/cpp/operators.h" +#include "clang/Sema/Initialization.h" #include "clang/Sema/Overload.h" #include "clang/Sema/Sema.h" #include "toolchain/check/core_identifier.h" @@ -192,6 +193,114 @@ static auto GetClangOperatorKind(Context& context, SemIR::LocId loc_id, } } +static auto LookupCppConversion(Context& context, SemIR::LocId loc_id, + SemIR::InstId source_id, + SemIR::TypeId dest_type_id, bool allow_explicit) + -> SemIR::InstId { + auto dest_type = MapToCppType(context, dest_type_id); + if (dest_type.isNull()) { + return SemIR::InstId::None; + } + + auto* arg_expr = InventClangArg(context, source_id); + // If we can't map the argument, we can't perform the conversion. + if (!arg_expr) { + return SemIR::InstId::None; + } + + auto loc = GetCppLocation(context, loc_id); + + // Form a Clang initialization sequence. + auto& sema = context.clang_sema(); + clang::InitializedEntity entity = + clang::InitializedEntity::InitializeTemporary(dest_type); + clang::InitializationKind kind = + allow_explicit ? clang::InitializationKind::CreateDirect( + loc, /*LParenLoc=*/clang::SourceLocation(), + /*RParenLoc=*/clang::SourceLocation()) + : clang::InitializationKind::CreateCopy( + loc, /*EqualLoc=*/clang::SourceLocation()); + clang::MultiExprArg args(arg_expr); + // `(a, b) as T` uses `T{a, b}`, not `T({a, b})`. The latter would introduce + // a redundant extra copy. + // TODO: We need to communicate this back to the caller so they know to call + // the constructor with an exploded argument list somehow. + if (allow_explicit && isa(arg_expr)) { + kind = clang::InitializationKind::CreateDirectList(loc); + } + clang::InitializationSequence init(sema, entity, kind, args); + + if (init.Failed()) { + // TODO: Are there initialization failures that we should translate into + // errors rather than a missing conversion? + return SemIR::InstId::None; + } + + // Scan the steps looking for user-defined conversions. For now we just find + // and return the first such conversion function. We skip over standard + // conversions; we'll perform those using the Carbon rules as part of calling + // the C++ conversion function. + for (const auto& step : init.steps()) { + switch (step.Kind) { + case clang::InitializationSequence::SK_UserConversion: + case clang::InitializationSequence::SK_ConstructorInitialization: { + if (auto* ctor = + dyn_cast(step.Function.Function); + ctor && ctor->isCopyOrMoveConstructor()) { + // Skip copy / move constructor calls. They shouldn't be performed + // this way because they're not considered conversions in Carbon, and + // will frequently lead to infinite recursion because we'll end up + // back here when attempting to convert the argument. + continue; + } + + if (sema.DiagnoseUseOfOverloadedDecl(step.Function.Function, loc)) { + return SemIR::ErrorInst::InstId; + } + + sema.MarkFunctionReferenced(loc, step.Function.Function); + + auto result_id = ImportCppFunctionDecl( + context, loc_id, step.Function.Function, + // If this is a constructor, the source is passed as an argument; + // otherwise, this is a conversion function and the source is passed + // as `self`. + isa(step.Function.Function) ? 1 : 0); + if (auto fn_decl = context.insts().TryGetAsWithId( + result_id)) { + CheckCppOverloadAccess(context, loc_id, step.Function.FoundDecl, + fn_decl->inst_id); + } else { + CARBON_CHECK(result_id == SemIR::ErrorInst::InstId); + } + + // TODO: There may be other conversions later in the sequence that we + // need to model; we've only applied the first one here. + return result_id; + } + + case clang::InitializationSequence::SK_ConversionSequence: + case clang::InitializationSequence::SK_ConversionSequenceNoNarrowing: { + // Implicit conversions are handled by the normal Carbon conversion + // logic, so we ignore them here. + continue; + } + + default: { + // TODO: Handle other kinds of initialization steps. For now we assume + // they will be handled by our function call logic and we can skip them. + RawStringOstream os; + os << "Unsupported initialization sequence:\n"; + init.dump(os); + context.TODO(loc_id, os.TakeStr()); + return SemIR::ErrorInst::InstId; + } + } + } + + return SemIR::InstId::None; +} + auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, llvm::ArrayRef arg_ids) -> SemIR::InstId { // Register an annotation scope to flush any Clang diagnostics when we return. @@ -200,6 +309,26 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, Diagnostics::AnnotationScope annotate_diagnostics(&context.emitter(), [](auto& /*builder*/) {}); + // Handle `ImplicitAs` and `As`. + if (op.interface_name == CoreIdentifier::ImplicitAs || + op.interface_name == CoreIdentifier::As) { + if (op.interface_args_ref.size() != 1 || arg_ids.size() != 1) { + return SemIR::InstId::None; + } + // The argument is the destination type for both interfaces. + auto dest_const_id = + context.constant_values().Get(op.interface_args_ref[0]); + auto dest_type_id = + context.types().TryGetTypeIdForTypeConstantId(dest_const_id); + if (!dest_type_id.has_value()) { + return SemIR::InstId::None; + } + + return LookupCppConversion( + context, loc_id, arg_ids[0], dest_type_id, + /*allow_explicit=*/op.interface_name == CoreIdentifier::As); + } + auto op_kind = GetClangOperatorKind(context, loc_id, op.interface_name, op.op_name); if (!op_kind) { @@ -304,7 +433,9 @@ auto LookupCppOperator(Context& context, SemIR::LocId loc_id, Operator op, auto IsCppOperatorMethodDecl(clang::Decl* decl) -> bool { auto* clang_method_decl = dyn_cast(decl); - return clang_method_decl && clang_method_decl->isOverloadedOperator(); + return clang_method_decl && + (clang_method_decl->isOverloadedOperator() || + isa(clang_method_decl)); } static auto GetAsCppFunctionDecl(Context& context, SemIR::InstId inst_id) diff --git a/toolchain/check/operator.cpp b/toolchain/check/operator.cpp index af0a4c271f2a..d2f4a72f1860 100644 --- a/toolchain/check/operator.cpp +++ b/toolchain/check/operator.cpp @@ -40,10 +40,10 @@ static auto GetOperatorOpFunction(Context& context, SemIR::LocId loc_id, op_name_id); } -// Returns whether the instruction is a C++ class. +// Returns whether the instruction is a C++ class type. Assumes the argument is +// in canonical form and does not look through the constant value. static auto IsCppClassType(Context& context, SemIR::InstId inst_id) -> bool { - auto class_type = context.insts().TryGetAs( - context.types().GetInstId(context.insts().Get(inst_id).type_id())); + auto class_type = context.insts().TryGetAs(inst_id); if (!class_type) { // Not a class. return false; @@ -55,6 +55,12 @@ static auto IsCppClassType(Context& context, SemIR::InstId inst_id) -> bool { context.name_scopes().Get(class_scope_id).is_cpp_scope(); } +// Returns whether the instruction is a value of C++ class type. +static auto HasCppClassType(Context& context, SemIR::InstId inst_id) -> bool { + return IsCppClassType(context, context.types().GetInstId( + context.insts().Get(inst_id).type_id())); +} + auto BuildUnaryOperator(Context& context, SemIR::LocId loc_id, Operator op, SemIR::InstId operand_id, MakeDiagnosticBuilderFn missing_impl_diagnoser) @@ -70,7 +76,10 @@ auto BuildUnaryOperator(Context& context, SemIR::LocId loc_id, Operator op, // the C++ operator. // TODO: Change impl lookup instead. See // https://github.com/carbon-language/carbon-lang/blob/db0a00d713015436844c55e7ac190a0f95556499/toolchain/check/operator.cpp#L76 - if (IsCppClassType(context, operand_id)) { + if (HasCppClassType(context, operand_id) || + llvm::any_of(op.interface_args_ref, [&](SemIR::InstId arg_id) { + return IsCppClassType(context, arg_id); + })) { op_fn_id = LookupCppOperator(context, loc_id, op, {operand_id}); // If C++ operator lookup found a non-method operator, call it with one call @@ -117,7 +126,10 @@ auto BuildBinaryOperator(Context& context, SemIR::LocId loc_id, Operator op, // https://github.com/carbon-language/carbon-lang/pull/5996/files/5d01fa69511b76f87efbc0387f5e40abcf4c911a#r2308666348 // and // https://github.com/carbon-language/carbon-lang/pull/5996/files/5d01fa69511b76f87efbc0387f5e40abcf4c911a#r2308664536 - if (IsCppClassType(context, lhs_id) || IsCppClassType(context, rhs_id)) { + if (HasCppClassType(context, lhs_id) || HasCppClassType(context, rhs_id) || + llvm::any_of(op.interface_args_ref, [&](SemIR::InstId arg_id) { + return IsCppClassType(context, arg_id); + })) { op_fn_id = LookupCppOperator(context, loc_id, op, {lhs_id, rhs_id}); // If C++ operator lookup found a non-method operator, call it with two call diff --git a/toolchain/check/testdata/basics/raw_sem_ir/cpp_interop.carbon b/toolchain/check/testdata/basics/raw_sem_ir/cpp_interop.carbon index 757261470431..c7c0b689a734 100644 --- a/toolchain/check/testdata/basics/raw_sem_ir/cpp_interop.carbon +++ b/toolchain/check/testdata/basics/raw_sem_ir/cpp_interop.carbon @@ -50,6 +50,8 @@ fn G(x: Cpp.X) { // CHECK:STDOUT: import_ir_inst0: {ir_id: import_ir(Cpp), clang_source_loc_id: clang_source_loc60000000} // CHECK:STDOUT: import_ir_inst1: {ir_id: import_ir(Cpp), clang_source_loc_id: clang_source_loc60000001} // CHECK:STDOUT: import_ir_inst2: {ir_id: import_ir(Cpp), clang_source_loc_id: clang_source_loc60000002} +// CHECK:STDOUT: import_ir_inst3: {ir_id: import_ir(Cpp), clang_source_loc_id: clang_source_loc60000003} +// CHECK:STDOUT: import_ir_inst4: {ir_id: import_ir(Cpp), clang_source_loc_id: clang_source_loc60000004} // CHECK:STDOUT: clang_decls: // CHECK:STDOUT: clang_decl_id60000000: {key: "", inst_id: inst60000011} // CHECK:STDOUT: clang_decl_id60000001: {key: "struct X {}", inst_id: inst60000014} diff --git a/toolchain/check/testdata/interop/cpp/class/access.carbon b/toolchain/check/testdata/interop/cpp/class/access.carbon index e602ab094e66..d6bfc0980df8 100644 --- a/toolchain/check/testdata/interop/cpp/class/access.carbon +++ b/toolchain/check/testdata/interop/cpp/class/access.carbon @@ -467,17 +467,23 @@ library "[[@TEST_NAME]]"; 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: fail_import_overload_set_protected.carbon:[[@LINE+8]]:3: error: cannot access protected member `C` of type `Cpp.C` [ClassInvalidMemberAccess] // CHECK:STDERR: Cpp.C.C(Cpp.ProtectedCall.ProtectedCall()); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_import_overload_set_protected.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: fail_import_overload_set_protected.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:11:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: C(ProtectedCall x); + // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.C.C(Cpp.ProtectedCall.ProtectedCall()); - // CHECK:STDERR: fail_import_overload_set_protected.carbon:[[@LINE+5]]:3: error: cannot access protected member `Overload` of type `Cpp.C` [ClassInvalidMemberAccess] + // CHECK:STDERR: fail_import_overload_set_protected.carbon:[[@LINE+8]]: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: fail_import_overload_set_protected.carbon:[[@LINE-16]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:12:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: static auto Overload(ProtectedCall x) -> void; + // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.C.Overload(Cpp.ProtectedCall.ProtectedCall()); } @@ -523,17 +529,23 @@ library "[[@TEST_NAME]]"; 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: fail_import_overload_set_private.carbon:[[@LINE+8]]:3: error: cannot access private member `C` of type `Cpp.C` [ClassInvalidMemberAccess] // CHECK:STDERR: Cpp.C.C(Cpp.PrivateCall.PrivateCall()); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_import_overload_set_private.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: fail_import_overload_set_private.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:14:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: C(PrivateCall x); + // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.C.C(Cpp.PrivateCall.PrivateCall()); - // CHECK:STDERR: fail_import_overload_set_private.carbon:[[@LINE+5]]:3: error: cannot access private member `Overload` of type `Cpp.C` [ClassInvalidMemberAccess] + // CHECK:STDERR: fail_import_overload_set_private.carbon:[[@LINE+8]]: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: fail_import_overload_set_private.carbon:[[@LINE-16]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:15:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: static auto Overload(PrivateCall x) -> void; + // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.C.Overload(Cpp.PrivateCall.PrivateCall()); } @@ -548,19 +560,25 @@ class D { extend base: Cpp.C; 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: fail_import_overload_set_private_base.carbon:[[@LINE+8]]:21: error: cannot access private member `C` of type `Cpp.C` [ClassInvalidMemberAccess] // 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: fail_import_overload_set_private_base.carbon:[[@LINE-9]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:14:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: C(PrivateCall x); + // CHECK:STDERR: ^ // CHECK:STDERR: 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 `Overload` of type `Cpp.C` [ClassInvalidMemberAccess] + // CHECK:STDERR: fail_import_overload_set_private_base.carbon:[[@LINE+8]]: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: fail_import_overload_set_private_base.carbon:[[@LINE-21]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:15:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: static auto Overload(PrivateCall x) -> void; + // CHECK:STDERR: ^ // CHECK:STDERR: Overload(Cpp.PrivateCall.PrivateCall()); } @@ -593,16 +611,24 @@ 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: fail_import_overload_set_public_base_class_call_non_public.carbon:[[@LINE+9]]: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: fail_import_overload_set_public_base_class_call_non_public.carbon:[[@LINE-6]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set_base_class.h:2:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:12:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: static auto Overload(ProtectedCall x) -> void; + // CHECK:STDERR: ^ // 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: fail_import_overload_set_public_base_class_call_non_public.carbon:[[@LINE+9]]: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: fail_import_overload_set_public_base_class_call_non_public.carbon:[[@LINE-16]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set_base_class.h:2:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:15:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: static auto Overload(PrivateCall x) -> void; + // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.Public.Overload(Cpp.PrivateCall.PrivateCall()); } @@ -634,10 +660,14 @@ 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: fail_import_overload_set_public_base_class_derived_call_private.carbon:[[@LINE+9]]: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: fail_import_overload_set_public_base_class_derived_call_private.carbon:[[@LINE-9]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set_base_class.h:2:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:15:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: static auto Overload(PrivateCall x) -> void; + // CHECK:STDERR: ^ // CHECK:STDERR: Overload(Cpp.PrivateCall.PrivateCall()); } @@ -703,10 +733,14 @@ 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: fail_import_overload_set_protected_base_class_derived_call_private.carbon:[[@LINE+9]]: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: fail_import_overload_set_protected_base_class_derived_call_private.carbon:[[@LINE-9]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set_base_class.h:2:10: in file included here [InCppInclude] + // CHECK:STDERR: ./overload_set.h:15:15: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: static auto Overload(PrivateCall x) -> void; + // CHECK:STDERR: ^ // CHECK:STDERR: Overload(Cpp.PrivateCall.PrivateCall()); } diff --git a/toolchain/check/testdata/interop/cpp/class/constructor.carbon b/toolchain/check/testdata/interop/cpp/class/constructor.carbon index 4d2d02739349..9cb35a3089d5 100644 --- a/toolchain/check/testdata/interop/cpp/class/constructor.carbon +++ b/toolchain/check/testdata/interop/cpp/class/constructor.carbon @@ -191,7 +191,7 @@ class C { C(int x); }; -// --- fail_todo_import_implicit_single_argument.carbon +// --- import_implicit_single_argument.carbon library "[[@TEST_NAME]]"; @@ -200,13 +200,6 @@ import Cpp library "implicit_single_argument.h"; fn F() { //@dump-sem-ir-begin let c1: Cpp.C = Cpp.C.C(8); - // CHECK:STDERR: fail_todo_import_implicit_single_argument.carbon:[[@LINE+7]]:19: error: cannot implicitly convert expression of type `i32` to `Cpp.C` [ConversionFailure] - // CHECK:STDERR: let c2: Cpp.C = 8 as i32; - // CHECK:STDERR: ^~~~~~~~ - // CHECK:STDERR: fail_todo_import_implicit_single_argument.carbon:[[@LINE+4]]:19: note: type `i32` does not implement interface `Core.ImplicitAs(Cpp.C)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: let c2: Cpp.C = 8 as i32; - // CHECK:STDERR: ^~~~~~~~ - // CHECK:STDERR: let c2: Cpp.C = 8 as i32; //@dump-sem-ir-end } @@ -222,7 +215,7 @@ class C { C(int x, int y = 8); }; -// --- fail_todo_import_implicit_multi_arguments.carbon +// --- import_implicit_multi_arguments.carbon library "[[@TEST_NAME]]"; @@ -232,13 +225,6 @@ fn F() { //@dump-sem-ir-begin let c1: Cpp.C = Cpp.C.C(8, 9); let c2: Cpp.C = Cpp.C.C(8); - // CHECK:STDERR: fail_todo_import_implicit_multi_arguments.carbon:[[@LINE+7]]:19: error: cannot implicitly convert expression of type `i32` to `Cpp.C` [ConversionFailure] - // CHECK:STDERR: let c3: Cpp.C = 8 as i32; - // CHECK:STDERR: ^~~~~~~~ - // CHECK:STDERR: fail_todo_import_implicit_multi_arguments.carbon:[[@LINE+4]]:19: note: type `i32` does not implement interface `Core.ImplicitAs(Cpp.C)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: let c3: Cpp.C = 8 as i32; - // CHECK:STDERR: ^~~~~~~~ - // CHECK:STDERR: let c3: Cpp.C = 8 as i32; //@dump-sem-ir-end } @@ -830,7 +816,7 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp.loc9(%self.param: bool) = "no_op"; // CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_import_implicit_single_argument.carbon +// CHECK:STDOUT: --- import_implicit_single_argument.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] @@ -909,9 +895,9 @@ fn F() { // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc8_27.2(%int_8.loc8) [concrete = constants.%int_8.98c] // CHECK:STDOUT: %.loc8_27.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_8.98c] // CHECK:STDOUT: %.loc8_27.2: %i32 = converted %int_8.loc8, %.loc8_27.1 [concrete = constants.%int_8.98c] -// CHECK:STDOUT: %addr: %ptr.d9e = addr_of %.loc8_28.1 -// CHECK:STDOUT: %C__carbon_thunk.call: init %empty_tuple.type = call imports.%C__carbon_thunk.decl(%.loc8_27.2, %addr) -// CHECK:STDOUT: %.loc8_28.2: init %C to %.loc8_28.1 = in_place_init %C__carbon_thunk.call +// CHECK:STDOUT: %addr.loc8: %ptr.d9e = addr_of %.loc8_28.1 +// CHECK:STDOUT: %C__carbon_thunk.call.loc8: init %empty_tuple.type = call imports.%C__carbon_thunk.decl(%.loc8_27.2, %addr.loc8) +// CHECK:STDOUT: %.loc8_28.2: init %C to %.loc8_28.1 = in_place_init %C__carbon_thunk.call.loc8 // CHECK:STDOUT: %.loc8_14: type = splice_block %C.ref.loc8_14 [concrete = constants.%C] { // CHECK:STDOUT: %Cpp.ref.loc8_11: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %C.ref.loc8_14: type = name_ref C, imports.%C.decl [concrete = constants.%C] @@ -922,30 +908,38 @@ fn F() { // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %c2.patt: %pattern_type.217 = value_binding_pattern c2 [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %int_8.loc16: Core.IntLiteral = int_value 8 [concrete = constants.%int_8.b85] +// CHECK:STDOUT: %int_8.loc9: Core.IntLiteral = int_value 8 [concrete = constants.%int_8.b85] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %impl.elem0.loc16: %.97a = impl_witness_access constants.%As.impl_witness.ab6, element0 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.29b] -// CHECK:STDOUT: %bound_method.loc16_21.1: = bound_method %int_8.loc16, %impl.elem0.loc16 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.bound] -// CHECK:STDOUT: %specific_fn.loc16: = specific_function %impl.elem0.loc16, @Core.IntLiteral.as.As.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc16_21.2: = bound_method %int_8.loc16, %specific_fn.loc16 [concrete = constants.%bound_method.530] -// CHECK:STDOUT: %Core.IntLiteral.as.As.impl.Convert.call: init %i32 = call %bound_method.loc16_21.2(%int_8.loc16) [concrete = constants.%int_8.98c] -// CHECK:STDOUT: %.loc16_21.1: %i32 = value_of_initializer %Core.IntLiteral.as.As.impl.Convert.call [concrete = constants.%int_8.98c] -// CHECK:STDOUT: %.loc16_21.2: %i32 = converted %int_8.loc16, %.loc16_21.1 [concrete = constants.%int_8.98c] -// CHECK:STDOUT: %.loc16_14: type = splice_block %C.ref.loc16 [concrete = constants.%C] { -// CHECK:STDOUT: %Cpp.ref.loc16: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %C.ref.loc16: type = name_ref C, imports.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %impl.elem0.loc9: %.97a = impl_witness_access constants.%As.impl_witness.ab6, element0 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.29b] +// CHECK:STDOUT: %bound_method.loc9_21.1: = bound_method %int_8.loc9, %impl.elem0.loc9 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.bound] +// CHECK:STDOUT: %specific_fn.loc9: = specific_function %impl.elem0.loc9, @Core.IntLiteral.as.As.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc9_21.2: = bound_method %int_8.loc9, %specific_fn.loc9 [concrete = constants.%bound_method.530] +// CHECK:STDOUT: %Core.IntLiteral.as.As.impl.Convert.call: init %i32 = call %bound_method.loc9_21.2(%int_8.loc9) [concrete = constants.%int_8.98c] +// CHECK:STDOUT: %.loc9_21.1: %i32 = value_of_initializer %Core.IntLiteral.as.As.impl.Convert.call [concrete = constants.%int_8.98c] +// CHECK:STDOUT: %.loc9_21.2: %i32 = converted %int_8.loc9, %.loc9_21.1 [concrete = constants.%int_8.98c] +// CHECK:STDOUT: %.loc9_14: type = splice_block %C.ref.loc9 [concrete = constants.%C] { +// CHECK:STDOUT: %Cpp.ref.loc9: = 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: } -// CHECK:STDOUT: %.loc16_21.3: %C = converted %.loc16_21.2, [concrete = ] -// CHECK:STDOUT: %c2: %C = value_binding c2, [concrete = ] -// CHECK:STDOUT: %C.cpp_destructor.bound: = bound_method %.loc8_28.3, constants.%C.cpp_destructor -// CHECK:STDOUT: %C.cpp_destructor.call: init %empty_tuple.type = call %C.cpp_destructor.bound(%.loc8_28.3) +// CHECK:STDOUT: %.loc9_21.3: ref %C = temporary_storage +// CHECK:STDOUT: %addr.loc9: %ptr.d9e = addr_of %.loc9_21.3 +// CHECK:STDOUT: %C__carbon_thunk.call.loc9: init %empty_tuple.type = call imports.%C__carbon_thunk.decl(%.loc9_21.2, %addr.loc9) +// CHECK:STDOUT: %.loc9_21.4: init %C to %.loc9_21.3 = in_place_init %C__carbon_thunk.call.loc9 +// CHECK:STDOUT: %.loc9_21.5: init %C = converted %.loc9_21.2, %.loc9_21.4 +// CHECK:STDOUT: %.loc9_21.6: ref %C = temporary %.loc9_21.3, %.loc9_21.5 +// CHECK:STDOUT: %.loc9_21.7: %C = acquire_value %.loc9_21.6 +// CHECK:STDOUT: %c2: %C = value_binding c2, %.loc9_21.7 +// CHECK:STDOUT: %C.cpp_destructor.bound.loc9: = bound_method %.loc9_21.6, constants.%C.cpp_destructor +// CHECK:STDOUT: %C.cpp_destructor.call.loc9: init %empty_tuple.type = call %C.cpp_destructor.bound.loc9(%.loc9_21.6) +// CHECK:STDOUT: %C.cpp_destructor.bound.loc8: = bound_method %.loc8_28.3, constants.%C.cpp_destructor +// CHECK:STDOUT: %C.cpp_destructor.call.loc8: init %empty_tuple.type = call %C.cpp_destructor.bound.loc8(%.loc8_28.3) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @DestroyOp(%self.param: %C) = "no_op"; // CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_import_implicit_multi_arguments.carbon +// CHECK:STDOUT: --- import_implicit_multi_arguments.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] @@ -1081,22 +1075,30 @@ fn F() { // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %c3.patt: %pattern_type.217 = value_binding_pattern c3 [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %int_8.loc17: Core.IntLiteral = int_value 8 [concrete = constants.%int_8.b85] +// CHECK:STDOUT: %int_8.loc10: Core.IntLiteral = int_value 8 [concrete = constants.%int_8.b85] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %impl.elem0.loc17: %.97a = impl_witness_access constants.%As.impl_witness.ab6, element0 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.29b] -// CHECK:STDOUT: %bound_method.loc17_21.1: = bound_method %int_8.loc17, %impl.elem0.loc17 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.bound] -// CHECK:STDOUT: %specific_fn.loc17: = specific_function %impl.elem0.loc17, @Core.IntLiteral.as.As.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc17_21.2: = bound_method %int_8.loc17, %specific_fn.loc17 [concrete = constants.%bound_method.530] -// CHECK:STDOUT: %Core.IntLiteral.as.As.impl.Convert.call: init %i32 = call %bound_method.loc17_21.2(%int_8.loc17) [concrete = constants.%int_8.98c] -// CHECK:STDOUT: %.loc17_21.1: %i32 = value_of_initializer %Core.IntLiteral.as.As.impl.Convert.call [concrete = constants.%int_8.98c] -// CHECK:STDOUT: %.loc17_21.2: %i32 = converted %int_8.loc17, %.loc17_21.1 [concrete = constants.%int_8.98c] -// CHECK:STDOUT: %.loc17_14: type = splice_block %C.ref.loc17 [concrete = constants.%C] { -// CHECK:STDOUT: %Cpp.ref.loc17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %C.ref.loc17: type = name_ref C, imports.%C.decl [concrete = constants.%C] +// CHECK:STDOUT: %impl.elem0.loc10: %.97a = impl_witness_access constants.%As.impl_witness.ab6, element0 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.29b] +// CHECK:STDOUT: %bound_method.loc10_21.1: = bound_method %int_8.loc10, %impl.elem0.loc10 [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.bound] +// CHECK:STDOUT: %specific_fn.loc10: = specific_function %impl.elem0.loc10, @Core.IntLiteral.as.As.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.As.impl.Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc10_21.2: = bound_method %int_8.loc10, %specific_fn.loc10 [concrete = constants.%bound_method.530] +// CHECK:STDOUT: %Core.IntLiteral.as.As.impl.Convert.call: init %i32 = call %bound_method.loc10_21.2(%int_8.loc10) [concrete = constants.%int_8.98c] +// CHECK:STDOUT: %.loc10_21.1: %i32 = value_of_initializer %Core.IntLiteral.as.As.impl.Convert.call [concrete = constants.%int_8.98c] +// CHECK:STDOUT: %.loc10_21.2: %i32 = converted %int_8.loc10, %.loc10_21.1 [concrete = constants.%int_8.98c] +// CHECK:STDOUT: %.loc10_14: type = splice_block %C.ref.loc10 [concrete = constants.%C] { +// CHECK:STDOUT: %Cpp.ref.loc10: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %C.ref.loc10: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: } -// CHECK:STDOUT: %.loc17_21.3: %C = converted %.loc17_21.2, [concrete = ] -// CHECK:STDOUT: %c3: %C = value_binding c3, [concrete = ] +// CHECK:STDOUT: %.loc10_21.3: ref %C = temporary_storage +// CHECK:STDOUT: %addr.loc10: %ptr.d9e = addr_of %.loc10_21.3 +// CHECK:STDOUT: %C__carbon_thunk.call.loc10: init %empty_tuple.type = call imports.%C__carbon_thunk.decl.8acdfe.2(%.loc10_21.2, %addr.loc10) +// CHECK:STDOUT: %.loc10_21.4: init %C to %.loc10_21.3 = in_place_init %C__carbon_thunk.call.loc10 +// CHECK:STDOUT: %.loc10_21.5: init %C = converted %.loc10_21.2, %.loc10_21.4 +// CHECK:STDOUT: %.loc10_21.6: ref %C = temporary %.loc10_21.3, %.loc10_21.5 +// CHECK:STDOUT: %.loc10_21.7: %C = acquire_value %.loc10_21.6 +// CHECK:STDOUT: %c3: %C = value_binding c3, %.loc10_21.7 +// CHECK:STDOUT: %C.cpp_destructor.bound.loc10: = bound_method %.loc10_21.6, constants.%C.cpp_destructor +// CHECK:STDOUT: %C.cpp_destructor.call.loc10: init %empty_tuple.type = call %C.cpp_destructor.bound.loc10(%.loc10_21.6) // CHECK:STDOUT: %C.cpp_destructor.bound.loc9: = bound_method %.loc9_28.3, constants.%C.cpp_destructor // CHECK:STDOUT: %C.cpp_destructor.call.loc9: init %empty_tuple.type = call %C.cpp_destructor.bound.loc9(%.loc9_28.3) // CHECK:STDOUT: %C.cpp_destructor.bound.loc8: = bound_method %.loc8_31.3, constants.%C.cpp_destructor diff --git a/toolchain/check/testdata/interop/cpp/function/class.carbon b/toolchain/check/testdata/interop/cpp/function/class.carbon index 796e6656695e..8ace75123a3b 100644 --- a/toolchain/check/testdata/interop/cpp/function/class.carbon +++ b/toolchain/check/testdata/interop/cpp/function/class.carbon @@ -183,10 +183,9 @@ import Cpp library "definition_single_data_member_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.C` with `as` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({} as Cpp.C); - // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.C)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+6]]:11: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: zero initialization [class C] -> list initialization via constructor [class C] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.foo({} as Cpp.C); // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: @@ -218,10 +217,9 @@ import Cpp library "definition_multiple_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.C` with `as` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({} as Cpp.C); - // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.C)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+6]]:11: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: zero initialization [class C] -> list initialization via constructor [class C] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.foo({} as Cpp.C); // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: @@ -652,12 +650,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc14_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %.loc14_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %Cpp.ref.loc14_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc15_14: %C = converted %.loc15_12, [concrete = ] +// CHECK:STDOUT: %.loc14_14: %C = converted %.loc14_12, [concrete = ] // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -683,12 +681,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc14_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %.loc14_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %Cpp.ref.loc14_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %C.ref: type = name_ref C, imports.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc15_14: %C = converted %.loc15_12, [concrete = ] +// CHECK:STDOUT: %.loc14_14: %C = converted %.loc14_12, [concrete = ] // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/function/operators.carbon b/toolchain/check/testdata/interop/cpp/function/operators.carbon index 7f422f445bef..5578b64299a0 100644 --- a/toolchain/check/testdata/interop/cpp/function/operators.carbon +++ b/toolchain/check/testdata/interop/cpp/function/operators.carbon @@ -435,7 +435,7 @@ class C { }; auto operator+(C lhs, C rhs) -> C; -// --- fail_todo_plus_with_int_conversion.carbon +// --- plus_with_int_conversion.carbon library "[[@TEST_NAME]]"; @@ -443,29 +443,7 @@ import Cpp library "plus_with_int_conversion.h"; fn F() { let c1: Cpp.C = Cpp.C.C(4); - // CHECK:STDERR: fail_todo_plus_with_int_conversion.carbon:[[@LINE+11]]:24: error: cannot implicitly convert expression of type `Core.IntLiteral` to `Cpp.C` [ConversionFailure] - // CHECK:STDERR: let c2: Cpp.C = c1 + 5; - // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_plus_with_int_conversion.carbon:[[@LINE+8]]:24: note: type `Core.IntLiteral` does not implement interface `Core.ImplicitAs(Cpp.C)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: let c2: Cpp.C = c1 + 5; - // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_plus_with_int_conversion.carbon:[[@LINE-10]]:10: in file included here [InCppInclude] - // CHECK:STDERR: ./plus_with_int_conversion.h:6:25: note: initializing function parameter [InCallToFunctionParam] - // CHECK:STDERR: auto operator+(C lhs, C rhs) -> C; - // CHECK:STDERR: ^ - // CHECK:STDERR: let c2: Cpp.C = c1 + 5; - // CHECK:STDERR: fail_todo_plus_with_int_conversion.carbon:[[@LINE+11]]:19: error: cannot implicitly convert expression of type `Core.IntLiteral` to `Cpp.C` [ConversionFailure] - // CHECK:STDERR: let c3: Cpp.C = 6 + c1; - // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_plus_with_int_conversion.carbon:[[@LINE+8]]:19: note: type `Core.IntLiteral` does not implement interface `Core.ImplicitAs(Cpp.C)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: let c3: Cpp.C = 6 + c1; - // CHECK:STDERR: ^ - // CHECK:STDERR: fail_todo_plus_with_int_conversion.carbon:[[@LINE-22]]:10: in file included here [InCppInclude] - // CHECK:STDERR: ./plus_with_int_conversion.h:6:18: note: initializing function parameter [InCallToFunctionParam] - // CHECK:STDERR: auto operator+(C lhs, C rhs) -> C; - // CHECK:STDERR: ^ - // CHECK:STDERR: let c3: Cpp.C = 6 + c1; } diff --git a/toolchain/check/testdata/interop/cpp/function/overloads.carbon b/toolchain/check/testdata/interop/cpp/function/overloads.carbon index fc8bb6efcf1e..64ba52f46fed 100644 --- a/toolchain/check/testdata/interop/cpp/function/overloads.carbon +++ b/toolchain/check/testdata/interop/cpp/function/overloads.carbon @@ -262,65 +262,60 @@ import Cpp library "struct_init.h"; fn MakeThreeFields() -> {.a: i32, .b: i32, .c: i32}; fn ThreeFields(value: {.a: i32, .b: i32, .c: i32}, ref reference: {.a: i32, .b: i32, .c: i32}) { - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `{.a: Core.IntLiteral, .b: Core.IntLiteral, .c: Core.IntLiteral}` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields({.a = 1, .b = 2, .c = 3}); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+8]]:23: note: type `{.a: Core.IntLiteral, .b: Core.IntLiteral, .c: Core.IntLiteral}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields({.a = 1, .b = 2, .c = 3}); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-11]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-10]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassThreeFields({.a = 1, .b = 2, .c = 3}); - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `{.a: i32, .b: i32, .c: i32}` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields(value); // CHECK:STDERR: ^~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+8]]:23: note: type `{.a: i32, .b: i32, .c: i32}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields(value); - // CHECK:STDERR: ^~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-24]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-22]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassThreeFields(value); - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `{.a: i32, .b: i32, .c: i32}` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields(reference); // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+8]]:23: note: type `{.a: i32, .b: i32, .c: i32}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields(reference); - // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-37]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-34]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassThreeFields(reference); - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `{.a: i32, .b: i32, .c: i32}` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields(MakeThreeFields()); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+8]]:23: note: type `{.a: i32, .b: i32, .c: i32}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields(MakeThreeFields()); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-50]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-46]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassThreeFields(MakeThreeFields()); - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `{.b: Core.IntLiteral, .c: Core.IntLiteral, .a: Core.IntLiteral}` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields({.b = 1, .c = 2, .a = 3}); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+8]]:23: note: type `{.b: Core.IntLiteral, .c: Core.IntLiteral, .a: Core.IntLiteral}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields({.b = 1, .c = 2, .a = 3}); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-63]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE-58]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ @@ -382,52 +377,48 @@ import Cpp library "struct_init.h"; fn MakeEmpty() -> (); fn Empty(value: (), ref reference: ()) { - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:20: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:20: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct NoFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassNoFields(()); // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:20: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassNoFields(()); - // CHECK:STDERR: ^~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-14]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-13]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassNoFields(NoFields s) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassNoFields(()); - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:20: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:20: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct NoFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassNoFields(value); // CHECK:STDERR: ^~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:20: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassNoFields(value); - // CHECK:STDERR: ^~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-27]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-25]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassNoFields(NoFields s) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassNoFields(value); - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:20: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:20: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct NoFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassNoFields(reference); // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:20: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassNoFields(reference); - // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-40]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-37]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassNoFields(NoFields s) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassNoFields(reference); - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:20: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:20: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct NoFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassNoFields(MakeEmpty()); // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:20: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassNoFields(MakeEmpty()); - // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-53]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-49]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassNoFields(NoFields s) -> void; // CHECK:STDERR: ^ @@ -438,52 +429,48 @@ fn Empty(value: (), ref reference: ()) { fn MakeThreeFields() -> (i32, i32, i32); fn ThreeFields(value: (i32, i32, i32), ref reference: (i32, i32, i32)) { - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `(Core.IntLiteral, Core.IntLiteral, Core.IntLiteral)` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields((1, 2, 3)); // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:23: note: type `(Core.IntLiteral, Core.IntLiteral, Core.IntLiteral)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields((1, 2, 3)); - // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-70]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-65]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassThreeFields((1, 2, 3)); - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `(i32, i32, i32)` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields(value); // CHECK:STDERR: ^~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:23: note: type `(i32, i32, i32)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields(value); - // CHECK:STDERR: ^~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-83]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-77]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassThreeFields(value); - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `(i32, i32, i32)` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields(reference); // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:23: note: type `(i32, i32, i32)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields(reference); - // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-96]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-89]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ // CHECK:STDERR: Cpp.PassThreeFields(reference); - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+11]]:23: error: cannot implicitly convert expression of type `(i32, i32, i32)` to `Cpp.ThreeFields` [ConversionFailure] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+10]]:23: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct ThreeFields] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.PassThreeFields(MakeThreeFields()); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+8]]:23: note: type `(i32, i32, i32)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.PassThreeFields(MakeThreeFields()); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-109]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE-101]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: auto PassThreeFields(ThreeFields t) -> void; // CHECK:STDERR: ^ @@ -611,13 +598,12 @@ library "[[@TEST_NAME]]"; import Cpp library "nested_structs.h"; fn F() { - // CHECK:STDERR: fail_todo_pass_nested_structs.carbon:[[@LINE+11]]:13: error: cannot implicitly convert expression of type `{.a: {.x: Core.IntLiteral, .y: Core.IntLiteral}, .n: Core.IntLiteral}` to `Cpp.B` [ConversionFailure] + // CHECK:STDERR: fail_todo_pass_nested_structs.carbon:[[@LINE+10]]:13: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct B] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.TakeB({.a = {.x = 1, .y = 2}, .n = 3}); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_pass_nested_structs.carbon:[[@LINE+8]]:13: note: type `{.a: {.x: Core.IntLiteral, .y: Core.IntLiteral}, .n: Core.IntLiteral}` does not implement interface `Core.ImplicitAs(Cpp.B)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: Cpp.TakeB({.a = {.x = 1, .y = 2}, .n = 3}); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_todo_pass_nested_structs.carbon:[[@LINE-9]]:10: in file included here [InCppInclude] + // CHECK:STDERR: fail_todo_pass_nested_structs.carbon:[[@LINE-8]]:10: in file included here [InCppInclude] // CHECK:STDERR: ./nested_structs.h:11:13: note: initializing function parameter [InCallToFunctionParam] // CHECK:STDERR: void TakeB(B); // CHECK:STDERR: ^ @@ -2556,8 +2542,6 @@ fn F() { // CHECK:STDOUT: %ThreeFields.elem: type = unbound_element_type %ThreeFields.942, %i32 [concrete] // CHECK:STDOUT: %.c77: type = custom_layout_type {size=12, align=4, .a@0: %i32, .b@4: %i32, .c@8: %i32} [concrete] // CHECK:STDOUT: %complete_type.702: = complete_type_witness %.c77 [concrete] -// CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] -// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] // CHECK:STDOUT: %struct_type.b.c.a: type = struct_type {.b: Core.IntLiteral, .c: Core.IntLiteral, .a: Core.IntLiteral} [concrete] // CHECK:STDOUT: %struct.d34: %struct_type.b.c.a = struct_value (%int_1, %int_2, %int_3) [concrete] // CHECK:STDOUT: } @@ -2565,7 +2549,6 @@ fn F() { // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { // CHECK:STDOUT: .Int = %Core.Int -// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } @@ -2582,7 +2565,6 @@ fn F() { // CHECK:STDOUT: %t.param: %ptr.f81 = value_param call_param0 // CHECK:STDOUT: %t: %ptr.f81 = value_binding t, %t.param // CHECK:STDOUT: } -// CHECK:STDOUT: %Core.ImplicitAs: %ImplicitAs.type.cc7 = import_ref Core//prelude/parts/as, ImplicitAs, loaded [concrete = constants.%ImplicitAs.generic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -2664,44 +2646,44 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @ThreeFields.loc8(%value.param: %struct_type.a.b.c.0b6, %reference.param: %struct_type.a.b.c.0b6) { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc20: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc20: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] -// CHECK:STDOUT: %int_1.loc20: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] -// CHECK:STDOUT: %int_2.loc20: Core.IntLiteral = int_value 2 [concrete = constants.%int_2] -// CHECK:STDOUT: %int_3.loc20: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] -// CHECK:STDOUT: %.loc20_46.1: %struct_type.a.b.c.90d = struct_literal (%int_1.loc20, %int_2.loc20, %int_3.loc20) [concrete = constants.%struct.ec0] -// CHECK:STDOUT: %.loc20_46.2: %ThreeFields.942 = converted %.loc20_46.1, [concrete = ] -// CHECK:STDOUT: %addr.loc20: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc20: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc20) -// CHECK:STDOUT: %Cpp.ref.loc33: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc33: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc19: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc19: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %int_1.loc19: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] +// CHECK:STDOUT: %int_2.loc19: Core.IntLiteral = int_value 2 [concrete = constants.%int_2] +// CHECK:STDOUT: %int_3.loc19: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] +// CHECK:STDOUT: %.loc19_46.1: %struct_type.a.b.c.90d = struct_literal (%int_1.loc19, %int_2.loc19, %int_3.loc19) [concrete = constants.%struct.ec0] +// CHECK:STDOUT: %.loc19_46.2: %ThreeFields.942 = converted %.loc19_46.1, [concrete = ] +// CHECK:STDOUT: %addr.loc19: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc19: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc19) +// CHECK:STDOUT: %Cpp.ref.loc31: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc31: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %value.ref: %struct_type.a.b.c.0b6 = name_ref value, %value -// CHECK:STDOUT: %.loc33: %ThreeFields.942 = converted %value.ref, [concrete = ] -// CHECK:STDOUT: %addr.loc33: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc33: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc33) -// CHECK:STDOUT: %Cpp.ref.loc46: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc46: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc31: %ThreeFields.942 = converted %value.ref, [concrete = ] +// CHECK:STDOUT: %addr.loc31: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc31: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc31) +// CHECK:STDOUT: %Cpp.ref.loc43: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc43: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %reference.ref: ref %struct_type.a.b.c.0b6 = name_ref reference, %reference -// CHECK:STDOUT: %.loc46: %ThreeFields.942 = converted %reference.ref, [concrete = ] -// CHECK:STDOUT: %addr.loc46: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc46: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc46) -// CHECK:STDOUT: %Cpp.ref.loc59: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc59: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc43: %ThreeFields.942 = converted %reference.ref, [concrete = ] +// CHECK:STDOUT: %addr.loc43: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc43: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc43) +// CHECK:STDOUT: %Cpp.ref.loc55: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc55: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %MakeThreeFields.ref: %MakeThreeFields.type = name_ref MakeThreeFields, file.%MakeThreeFields.decl [concrete = constants.%MakeThreeFields] -// CHECK:STDOUT: %.loc59_39.1: ref %struct_type.a.b.c.0b6 = temporary_storage -// CHECK:STDOUT: %MakeThreeFields.call: init %struct_type.a.b.c.0b6 to %.loc59_39.1 = call %MakeThreeFields.ref() -// CHECK:STDOUT: %.loc59_39.2: %ThreeFields.942 = converted %MakeThreeFields.call, [concrete = ] -// CHECK:STDOUT: %addr.loc59: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc59: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc59) -// CHECK:STDOUT: %Cpp.ref.loc72: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc72: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] -// CHECK:STDOUT: %int_1.loc72: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] -// CHECK:STDOUT: %int_2.loc72: Core.IntLiteral = int_value 2 [concrete = constants.%int_2] -// CHECK:STDOUT: %int_3.loc72: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] -// CHECK:STDOUT: %.loc72_46.1: %struct_type.b.c.a = struct_literal (%int_1.loc72, %int_2.loc72, %int_3.loc72) [concrete = constants.%struct.d34] -// CHECK:STDOUT: %.loc72_46.2: %ThreeFields.942 = converted %.loc72_46.1, [concrete = ] -// CHECK:STDOUT: %addr.loc72: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc72: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc72) +// CHECK:STDOUT: %.loc55_39.1: ref %struct_type.a.b.c.0b6 = temporary_storage +// CHECK:STDOUT: %MakeThreeFields.call: init %struct_type.a.b.c.0b6 to %.loc55_39.1 = call %MakeThreeFields.ref() +// CHECK:STDOUT: %.loc55_39.2: %ThreeFields.942 = converted %MakeThreeFields.call, [concrete = ] +// CHECK:STDOUT: %addr.loc55: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc55: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc55) +// CHECK:STDOUT: %Cpp.ref.loc67: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc67: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %int_1.loc67: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] +// CHECK:STDOUT: %int_2.loc67: Core.IntLiteral = int_value 2 [concrete = constants.%int_2] +// CHECK:STDOUT: %int_3.loc67: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] +// CHECK:STDOUT: %.loc67_46.1: %struct_type.b.c.a = struct_literal (%int_1.loc67, %int_2.loc67, %int_3.loc67) [concrete = constants.%struct.d34] +// CHECK:STDOUT: %.loc67_46.2: %ThreeFields.942 = converted %.loc67_46.1, [concrete = ] +// CHECK:STDOUT: %addr.loc67: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc67: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc67) // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2835,8 +2817,6 @@ fn F() { // CHECK:STDOUT: %PassNoFields__carbon_thunk: %PassNoFields__carbon_thunk.type = struct_value () [concrete] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] // CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [concrete] -// CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] -// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] // CHECK:STDOUT: %Int.type: type = generic_class_type @Int [concrete] // CHECK:STDOUT: %Int.generic: %Int.type = struct_value () [concrete] @@ -2848,7 +2828,7 @@ fn F() { // CHECK:STDOUT: %pattern_type.b5a: type = pattern_type %tuple.type.189 [concrete] // CHECK:STDOUT: %MakeThreeFields.type: type = fn_type @MakeThreeFields [concrete] // CHECK:STDOUT: %MakeThreeFields: %MakeThreeFields.type = struct_value () [concrete] -// CHECK:STDOUT: %ThreeFields.type: type = fn_type @ThreeFields.loc67 [concrete] +// CHECK:STDOUT: %ThreeFields.type: type = fn_type @ThreeFields.loc63 [concrete] // CHECK:STDOUT: %ThreeFields.c3a: %ThreeFields.type = struct_value () [concrete] // CHECK:STDOUT: %PassThreeFields.cpp_overload_set.type: type = cpp_overload_set_type @PassThreeFields.cpp_overload_set [concrete] // CHECK:STDOUT: %PassThreeFields.cpp_overload_set.value: %PassThreeFields.cpp_overload_set.type = cpp_overload_set_value @PassThreeFields.cpp_overload_set [concrete] @@ -2869,7 +2849,6 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs // CHECK:STDOUT: .Int = %Core.Int // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... @@ -2887,7 +2866,6 @@ fn F() { // CHECK:STDOUT: %s.param: %ptr.dd0 = value_param call_param0 // CHECK:STDOUT: %s: %ptr.dd0 = value_binding s, %s.param // CHECK:STDOUT: } -// CHECK:STDOUT: %Core.ImplicitAs: %ImplicitAs.type.cc7 = import_ref Core//prelude/parts/as, ImplicitAs, loaded [concrete = constants.%ImplicitAs.generic] // CHECK:STDOUT: %Core.Int: %Int.type = import_ref Core//prelude/parts/int, Int, loaded [concrete = constants.%Int.generic] // CHECK:STDOUT: %PassThreeFields.cpp_overload_set.value: %PassThreeFields.cpp_overload_set.type = cpp_overload_set_value @PassThreeFields.cpp_overload_set [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %PassThreeFields__carbon_thunk.decl: %PassThreeFields__carbon_thunk.type = fn_decl @PassThreeFields__carbon_thunk [concrete = constants.%PassThreeFields__carbon_thunk] { @@ -2945,46 +2923,46 @@ fn F() { // CHECK:STDOUT: %return.patt: %pattern_type.b5a = return_slot_pattern [concrete] // CHECK:STDOUT: %return.param_patt: %pattern_type.b5a = out_param_pattern %return.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc65_26: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc65_26: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc65_31: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc65_31: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc65_36: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc65_36: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc65_39.1: %tuple.type.ff9 = tuple_literal (%i32.loc65_26, %i32.loc65_31, %i32.loc65_36) [concrete = constants.%tuple.e64] -// CHECK:STDOUT: %.loc65_39.2: type = converted %.loc65_39.1, constants.%tuple.type.189 [concrete = constants.%tuple.type.189] -// CHECK:STDOUT: %.loc65_39.3: form = init_form %.loc65_39.2, call_param0 [concrete = constants.%.084] +// CHECK:STDOUT: %int_32.loc61_26: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc61_26: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc61_31: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc61_31: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc61_36: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc61_36: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc61_39.1: %tuple.type.ff9 = tuple_literal (%i32.loc61_26, %i32.loc61_31, %i32.loc61_36) [concrete = constants.%tuple.e64] +// CHECK:STDOUT: %.loc61_39.2: type = converted %.loc61_39.1, constants.%tuple.type.189 [concrete = constants.%tuple.type.189] +// CHECK:STDOUT: %.loc61_39.3: form = init_form %.loc61_39.2, call_param0 [concrete = constants.%.084] // CHECK:STDOUT: %return.param: ref %tuple.type.189 = out_param call_param0 // CHECK:STDOUT: %return: ref %tuple.type.189 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %ThreeFields.decl: %ThreeFields.type = fn_decl @ThreeFields.loc67 [concrete = constants.%ThreeFields.c3a] { +// CHECK:STDOUT: %ThreeFields.decl: %ThreeFields.type = fn_decl @ThreeFields.loc63 [concrete = constants.%ThreeFields.c3a] { // CHECK:STDOUT: %value.patt: %pattern_type.b5a = value_binding_pattern value [concrete] // CHECK:STDOUT: %value.param_patt: %pattern_type.b5a = value_param_pattern %value.patt, call_param0 [concrete] // CHECK:STDOUT: %reference.patt: %pattern_type.b5a = ref_binding_pattern reference [concrete] // CHECK:STDOUT: %reference.param_patt: %pattern_type.b5a = ref_param_pattern %reference.patt, call_param1 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %value.param: %tuple.type.189 = value_param call_param0 -// CHECK:STDOUT: %.loc67_37.1: type = splice_block %.loc67_37.3 [concrete = constants.%tuple.type.189] { -// CHECK:STDOUT: %int_32.loc67_24: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc67_24: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc67_29: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc67_29: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc67_34: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc67_34: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc67_37.2: %tuple.type.ff9 = tuple_literal (%i32.loc67_24, %i32.loc67_29, %i32.loc67_34) [concrete = constants.%tuple.e64] -// CHECK:STDOUT: %.loc67_37.3: type = converted %.loc67_37.2, constants.%tuple.type.189 [concrete = constants.%tuple.type.189] +// CHECK:STDOUT: %.loc63_37.1: type = splice_block %.loc63_37.3 [concrete = constants.%tuple.type.189] { +// CHECK:STDOUT: %int_32.loc63_24: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc63_24: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc63_29: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc63_29: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc63_34: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc63_34: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc63_37.2: %tuple.type.ff9 = tuple_literal (%i32.loc63_24, %i32.loc63_29, %i32.loc63_34) [concrete = constants.%tuple.e64] +// CHECK:STDOUT: %.loc63_37.3: type = converted %.loc63_37.2, constants.%tuple.type.189 [concrete = constants.%tuple.type.189] // CHECK:STDOUT: } // CHECK:STDOUT: %value: %tuple.type.189 = value_binding value, %value.param // CHECK:STDOUT: %reference.param: ref %tuple.type.189 = ref_param call_param1 -// CHECK:STDOUT: %.loc67_69.1: type = splice_block %.loc67_69.3 [concrete = constants.%tuple.type.189] { -// CHECK:STDOUT: %int_32.loc67_56: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc67_56: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc67_61: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc67_61: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %int_32.loc67_66: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc67_66: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.loc67_69.2: %tuple.type.ff9 = tuple_literal (%i32.loc67_56, %i32.loc67_61, %i32.loc67_66) [concrete = constants.%tuple.e64] -// CHECK:STDOUT: %.loc67_69.3: type = converted %.loc67_69.2, constants.%tuple.type.189 [concrete = constants.%tuple.type.189] +// CHECK:STDOUT: %.loc63_69.1: type = splice_block %.loc63_69.3 [concrete = constants.%tuple.type.189] { +// CHECK:STDOUT: %int_32.loc63_56: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc63_56: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc63_61: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc63_61: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %int_32.loc63_66: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc63_66: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc63_69.2: %tuple.type.ff9 = tuple_literal (%i32.loc63_56, %i32.loc63_61, %i32.loc63_66) [concrete = constants.%tuple.e64] +// CHECK:STDOUT: %.loc63_69.3: type = converted %.loc63_69.2, constants.%tuple.type.189 [concrete = constants.%tuple.type.189] // CHECK:STDOUT: } // CHECK:STDOUT: %reference: ref %tuple.type.189 = ref_binding reference, %reference.param // CHECK:STDOUT: } @@ -3021,31 +2999,31 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @Empty(%value.param: %empty_tuple.type, %reference.param: %empty_tuple.type) { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc23: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassNoFields.ref.loc23: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] -// CHECK:STDOUT: %.loc23_21.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc23_21.2: %NoFields = converted %.loc23_21.1, [concrete = ] -// CHECK:STDOUT: %addr.loc23: %ptr.dd0 = addr_of [concrete = ] -// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc23: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc23) -// CHECK:STDOUT: %Cpp.ref.loc36: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassNoFields.ref.loc36: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc22: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassNoFields.ref.loc22: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc22_21.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc22_21.2: %NoFields = converted %.loc22_21.1, [concrete = ] +// CHECK:STDOUT: %addr.loc22: %ptr.dd0 = addr_of [concrete = ] +// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc22: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc22) +// CHECK:STDOUT: %Cpp.ref.loc34: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassNoFields.ref.loc34: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] // CHECK:STDOUT: %value.ref: %empty_tuple.type = name_ref value, %value -// CHECK:STDOUT: %.loc36: %NoFields = converted %value.ref, [concrete = ] -// CHECK:STDOUT: %addr.loc36: %ptr.dd0 = addr_of [concrete = ] -// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc36: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc36) -// CHECK:STDOUT: %Cpp.ref.loc49: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassNoFields.ref.loc49: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc34: %NoFields = converted %value.ref, [concrete = ] +// CHECK:STDOUT: %addr.loc34: %ptr.dd0 = addr_of [concrete = ] +// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc34: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc34) +// CHECK:STDOUT: %Cpp.ref.loc46: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassNoFields.ref.loc46: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] // CHECK:STDOUT: %reference.ref: ref %empty_tuple.type = name_ref reference, %reference -// CHECK:STDOUT: %.loc49: %NoFields = converted %reference.ref, [concrete = ] -// CHECK:STDOUT: %addr.loc49: %ptr.dd0 = addr_of [concrete = ] -// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc49: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc49) -// CHECK:STDOUT: %Cpp.ref.loc62: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassNoFields.ref.loc62: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc46: %NoFields = converted %reference.ref, [concrete = ] +// CHECK:STDOUT: %addr.loc46: %ptr.dd0 = addr_of [concrete = ] +// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc46: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc46) +// CHECK:STDOUT: %Cpp.ref.loc58: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassNoFields.ref.loc58: %PassNoFields.cpp_overload_set.type = name_ref PassNoFields, imports.%PassNoFields.cpp_overload_set.value [concrete = constants.%PassNoFields.cpp_overload_set.value] // CHECK:STDOUT: %MakeEmpty.ref: %MakeEmpty.type = name_ref MakeEmpty, file.%MakeEmpty.decl [concrete = constants.%MakeEmpty] // CHECK:STDOUT: %MakeEmpty.call: init %empty_tuple.type = call %MakeEmpty.ref() -// CHECK:STDOUT: %.loc62: %NoFields = converted %MakeEmpty.call, [concrete = ] -// CHECK:STDOUT: %addr.loc62: %ptr.dd0 = addr_of [concrete = ] -// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc62: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc62) +// CHECK:STDOUT: %.loc58: %NoFields = converted %MakeEmpty.call, [concrete = ] +// CHECK:STDOUT: %addr.loc58: %ptr.dd0 = addr_of [concrete = ] +// CHECK:STDOUT: %PassNoFields__carbon_thunk.call.loc58: init %empty_tuple.type = call imports.%PassNoFields__carbon_thunk.decl(%addr.loc58) // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: @@ -3055,37 +3033,37 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @MakeThreeFields() -> out %return.param: %tuple.type.189; // CHECK:STDOUT: -// CHECK:STDOUT: fn @ThreeFields.loc67(%value.param: %tuple.type.189, %reference.param: %tuple.type.189) { +// CHECK:STDOUT: fn @ThreeFields.loc63(%value.param: %tuple.type.189, %reference.param: %tuple.type.189) { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc79: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc79: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %Cpp.ref.loc74: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc74: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [concrete = constants.%int_2] // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] -// CHECK:STDOUT: %.loc79_31.1: %tuple.type.37f = tuple_literal (%int_1, %int_2, %int_3) [concrete = constants.%tuple.2d5] -// CHECK:STDOUT: %.loc79_31.2: %ThreeFields.942 = converted %.loc79_31.1, [concrete = ] -// CHECK:STDOUT: %addr.loc79: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc79: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc79) -// CHECK:STDOUT: %Cpp.ref.loc92: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc92: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc74_31.1: %tuple.type.37f = tuple_literal (%int_1, %int_2, %int_3) [concrete = constants.%tuple.2d5] +// CHECK:STDOUT: %.loc74_31.2: %ThreeFields.942 = converted %.loc74_31.1, [concrete = ] +// CHECK:STDOUT: %addr.loc74: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc74: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc74) +// CHECK:STDOUT: %Cpp.ref.loc86: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc86: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %value.ref: %tuple.type.189 = name_ref value, %value -// CHECK:STDOUT: %.loc92: %ThreeFields.942 = converted %value.ref, [concrete = ] -// CHECK:STDOUT: %addr.loc92: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc92: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc92) -// CHECK:STDOUT: %Cpp.ref.loc105: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc105: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc86: %ThreeFields.942 = converted %value.ref, [concrete = ] +// CHECK:STDOUT: %addr.loc86: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc86: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc86) +// CHECK:STDOUT: %Cpp.ref.loc98: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc98: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %reference.ref: ref %tuple.type.189 = name_ref reference, %reference -// CHECK:STDOUT: %.loc105: %ThreeFields.942 = converted %reference.ref, [concrete = ] -// CHECK:STDOUT: %addr.loc105: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc105: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc105) -// CHECK:STDOUT: %Cpp.ref.loc118: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] -// CHECK:STDOUT: %PassThreeFields.ref.loc118: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] +// CHECK:STDOUT: %.loc98: %ThreeFields.942 = converted %reference.ref, [concrete = ] +// CHECK:STDOUT: %addr.loc98: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc98: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc98) +// CHECK:STDOUT: %Cpp.ref.loc110: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %PassThreeFields.ref.loc110: %PassThreeFields.cpp_overload_set.type = name_ref PassThreeFields, imports.%PassThreeFields.cpp_overload_set.value [concrete = constants.%PassThreeFields.cpp_overload_set.value] // CHECK:STDOUT: %MakeThreeFields.ref: %MakeThreeFields.type = name_ref MakeThreeFields, file.%MakeThreeFields.decl [concrete = constants.%MakeThreeFields] -// CHECK:STDOUT: %.loc118_39.1: ref %tuple.type.189 = temporary_storage -// CHECK:STDOUT: %MakeThreeFields.call: init %tuple.type.189 to %.loc118_39.1 = call %MakeThreeFields.ref() -// CHECK:STDOUT: %.loc118_39.2: %ThreeFields.942 = converted %MakeThreeFields.call, [concrete = ] -// CHECK:STDOUT: %addr.loc118: %ptr.f81 = addr_of [concrete = ] -// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc118: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc118) +// CHECK:STDOUT: %.loc110_39.1: ref %tuple.type.189 = temporary_storage +// CHECK:STDOUT: %MakeThreeFields.call: init %tuple.type.189 to %.loc110_39.1 = call %MakeThreeFields.ref() +// CHECK:STDOUT: %.loc110_39.2: %ThreeFields.942 = converted %MakeThreeFields.call, [concrete = ] +// CHECK:STDOUT: %addr.loc110: %ptr.f81 = addr_of [concrete = ] +// CHECK:STDOUT: %PassThreeFields__carbon_thunk.call.loc110: init %empty_tuple.type = call imports.%PassThreeFields__carbon_thunk.decl(%addr.loc110) // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: @@ -3336,14 +3314,11 @@ fn F() { // CHECK:STDOUT: %A.elem: type = unbound_element_type %A, %i32 [concrete] // CHECK:STDOUT: %.7b6: type = custom_layout_type {size=8, align=4, .x@0: %i32, .y@4: %i32} [concrete] // CHECK:STDOUT: %complete_type.1e0: = complete_type_witness %.7b6 [concrete] -// CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] -// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { // CHECK:STDOUT: .Int = %Core.Int -// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } @@ -3360,7 +3335,6 @@ fn F() { // CHECK:STDOUT: %_: %ptr.a04 = value_binding _, %_.param // CHECK:STDOUT: } // CHECK:STDOUT: %Core.Int: %Int.type = import_ref Core//prelude/parts/int, Int, loaded [concrete = constants.%Int.generic] -// CHECK:STDOUT: %Core.ImplicitAs: %ImplicitAs.type.cc7 = import_ref Core//prelude/parts/as, ImplicitAs, loaded [concrete = constants.%ImplicitAs.generic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -3410,10 +3384,10 @@ fn F() { // CHECK:STDOUT: %TakeB.ref: %TakeB.cpp_overload_set.type = name_ref TakeB, imports.%TakeB.cpp_overload_set.value [concrete = constants.%TakeB.cpp_overload_set.value] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [concrete = constants.%int_2] -// CHECK:STDOUT: %.loc18_34: %struct_type.x.y = struct_literal (%int_1, %int_2) [concrete = constants.%struct.004] +// CHECK:STDOUT: %.loc17_34: %struct_type.x.y = struct_literal (%int_1, %int_2) [concrete = constants.%struct.004] // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3] -// CHECK:STDOUT: %.loc18_43.1: %struct_type.a.n.988 = struct_literal (%.loc18_34, %int_3) [concrete = constants.%struct.516] -// CHECK:STDOUT: %.loc18_43.2: %B = converted %.loc18_43.1, [concrete = ] +// CHECK:STDOUT: %.loc17_43.1: %struct_type.a.n.988 = struct_literal (%.loc17_34, %int_3) [concrete = constants.%struct.516] +// CHECK:STDOUT: %.loc17_43.2: %B = converted %.loc17_43.1, [concrete = ] // CHECK:STDOUT: %addr: %ptr.a04 = addr_of [concrete = ] // CHECK:STDOUT: %TakeB__carbon_thunk.call: init %empty_tuple.type = call imports.%TakeB__carbon_thunk.decl(%addr) // CHECK:STDOUT: return diff --git a/toolchain/check/testdata/interop/cpp/function/struct.carbon b/toolchain/check/testdata/interop/cpp/function/struct.carbon index 00f3d2744218..3d33219cf144 100644 --- a/toolchain/check/testdata/interop/cpp/function/struct.carbon +++ b/toolchain/check/testdata/interop/cpp/function/struct.carbon @@ -183,10 +183,9 @@ import Cpp library "definition_single_data_member_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.S` with `as` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({} as Cpp.S); - // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.S)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: fail_todo_import_definition_single_data_member_value_param_type.carbon:[[@LINE+6]]:11: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct S] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.foo({} as Cpp.S); // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: @@ -218,10 +217,9 @@ import Cpp library "definition_multiple_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.S` with `as` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({} as Cpp.S); - // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.S)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: fail_todo_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+6]]:11: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [struct S] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.foo({} as Cpp.S); // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: @@ -651,12 +649,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc14_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %.loc14_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %Cpp.ref.loc14_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] -// CHECK:STDOUT: %.loc15_14: %S = converted %.loc15_12, [concrete = ] +// CHECK:STDOUT: %.loc14_14: %S = converted %.loc14_12, [concrete = ] // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -682,12 +680,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc14_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %.loc14_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %Cpp.ref.loc14_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %S.ref: type = name_ref S, imports.%S.decl [concrete = constants.%S] -// CHECK:STDOUT: %.loc15_14: %S = converted %.loc15_12, [concrete = ] +// CHECK:STDOUT: %.loc14_14: %S = converted %.loc14_12, [concrete = ] // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/function/union.carbon b/toolchain/check/testdata/interop/cpp/function/union.carbon index 1a63598d7fc4..8c2ad2d57e6e 100644 --- a/toolchain/check/testdata/interop/cpp/function/union.carbon +++ b/toolchain/check/testdata/interop/cpp/function/union.carbon @@ -145,10 +145,9 @@ import Cpp library "definition_single_data_member_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_import_definition_single_data_member_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.U` with `as` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({} as Cpp.U); - // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_import_definition_single_data_member_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.U)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: fail_import_definition_single_data_member_value_param_type.carbon:[[@LINE+6]]:11: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [union U] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.foo({} as Cpp.U); // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: @@ -180,10 +179,9 @@ import Cpp library "definition_multiple_data_members_value_param_type.h"; fn F() { //@dump-sem-ir-begin - // CHECK:STDERR: fail_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+7]]:11: error: cannot convert expression of type `{}` to `Cpp.U` with `as` [ConversionFailure] - // CHECK:STDERR: Cpp.foo({} as Cpp.U); - // CHECK:STDERR: ^~~~~~~~~~~ - // CHECK:STDERR: fail_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+4]]:11: note: type `{}` does not implement interface `Core.As(Cpp.U)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: fail_import_definition_multiple_data_members_value_param_type.carbon:[[@LINE+6]]:11: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list aggregate initialization [union U] + // CHECK:STDERR: ` [SemanticsTodo] // CHECK:STDERR: Cpp.foo({} as Cpp.U); // CHECK:STDERR: ^~~~~~~~~~~ // CHECK:STDERR: @@ -592,12 +590,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc14_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %.loc14_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %Cpp.ref.loc14_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] -// CHECK:STDOUT: %.loc15_14: %U = converted %.loc15_12, [concrete = ] +// CHECK:STDOUT: %.loc14_14: %U = converted %.loc14_12, [concrete = ] // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -623,12 +621,12 @@ fn F() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %Cpp.ref.loc15_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Cpp.ref.loc14_3: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %foo.ref: %foo.cpp_overload_set.type = name_ref foo, imports.%foo.cpp_overload_set.value [concrete = constants.%foo.cpp_overload_set.value] -// CHECK:STDOUT: %.loc15_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %Cpp.ref.loc15_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %.loc14_12: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %Cpp.ref.loc14_17: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %U.ref: type = name_ref U, imports.%U.decl [concrete = constants.%U] -// CHECK:STDOUT: %.loc15_14: %U = converted %.loc15_12, [concrete = ] +// CHECK:STDOUT: %.loc14_14: %U = converted %.loc14_12, [concrete = ] // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/impls/as.carbon b/toolchain/check/testdata/interop/cpp/impls/as.carbon new file mode 100644 index 000000000000..5a8d93187bc2 --- /dev/null +++ b/toolchain/check/testdata/interop/cpp/impls/as.carbon @@ -0,0 +1,572 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// INCLUDE-FILE: toolchain/testing/testdata/min_prelude/primitives.carbon +// EXTRA-ARGS: --target=x86_64-linux-gnu --clang-arg=-std=c++20 +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/interop/cpp/impls/as.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/interop/cpp/impls/as.carbon + +// --- conversions.h + +struct Dest {}; + +struct Source { + operator Dest() const; +}; + +struct Source2 { + int x; +}; +struct Dest2 { + Dest2(Source2); +}; + +struct ExplicitConstructor { + explicit ExplicitConstructor(Source); +}; + +struct ExplicitConversion { + explicit operator Dest() const; +}; + +template struct ConditionallyExplicit { + explicit(B) ConditionallyExplicit(Source); + explicit(B) operator Dest() const; +}; + +using ConditionallyExplicitFalse = ConditionallyExplicit; +using ConditionallyExplicitTrue = ConditionallyExplicit; + +// --- conversions.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "conversions.h"; + +fn UserConversion(s: Cpp.Source) { + //@dump-sem-ir-begin + s as Cpp.Dest; + //@dump-sem-ir-end +} + +fn ConstructorConversion(s: Cpp.Source2) { + //@dump-sem-ir-begin + s as Cpp.Dest2; + //@dump-sem-ir-end +} + +fn ExplicitConstructorTest(s: Cpp.Source) { + //@dump-sem-ir-begin + s as Cpp.ExplicitConstructor; + //@dump-sem-ir-end +} + +fn ExplicitConversionTest(s: Cpp.ExplicitConversion) { + //@dump-sem-ir-begin + s as Cpp.Dest; + //@dump-sem-ir-end +} + +// --- conditionally_explicit.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "conversions.h"; + +fn ConstructorNotExplicit(s: Cpp.Source) { + //@dump-sem-ir-begin + let _: Cpp.ConditionallyExplicitFalse = s; + s as Cpp.ConditionallyExplicitFalse; + //@dump-sem-ir-end +} + +fn ConstructorExplicit(s: Cpp.Source) { + //@dump-sem-ir-begin + s as Cpp.ConditionallyExplicitTrue; + //@dump-sem-ir-end +} + +fn ConversionNotExplicit(s: Cpp.ConditionallyExplicitFalse) { + //@dump-sem-ir-begin + let _: Cpp.Dest = s; + s as Cpp.Dest; + //@dump-sem-ir-end +} + +fn ConversionExplicit(s: Cpp.ConditionallyExplicitFalse) { + //@dump-sem-ir-begin + s as Cpp.Dest; + //@dump-sem-ir-end +} + +// --- fail_conditionally_explicit_implicit.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "conversions.h"; + +fn ConstructorExplicit(s: Cpp.Source) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_conditionally_explicit_implicit.carbon:[[@LINE+7]]:42: error: cannot implicitly convert expression of type `Cpp.Source` to `Cpp.ConditionallyExplicit` [ConversionFailure] + // CHECK:STDERR: let _: Cpp.ConditionallyExplicitTrue = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_conditionally_explicit_implicit.carbon:[[@LINE+4]]:42: note: type `Cpp.Source` does not implement interface `Core.ImplicitAs(Cpp.ConditionallyExplicit)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: let _: Cpp.ConditionallyExplicitTrue = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.ConditionallyExplicitTrue = s; + //@dump-sem-ir-end +} + +fn ConversionExplicit(s: Cpp.ConditionallyExplicitFalse) { + //@dump-sem-ir-begin + let _: Cpp.Dest = s; + //@dump-sem-ir-end +} + +// CHECK:STDOUT: --- conversions.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Source: type = class_type @Source [concrete] +// CHECK:STDOUT: %pattern_type.78c: type = pattern_type %Source [concrete] +// CHECK:STDOUT: %Dest: type = class_type @Dest [concrete] +// CHECK:STDOUT: %Source.cpp_operator.type: type = fn_type @Source.cpp_operator [concrete] +// CHECK:STDOUT: %Source.cpp_operator: %Source.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.551: type = ptr_type %Dest [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type.2ffc9e.1: type = fn_type @Dest__carbon_thunk.1 [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.f8fa06.1: %Dest__carbon_thunk.type.2ffc9e.1 = struct_value () [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor.type: type = fn_type @Dest.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor: %Dest.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: %Source2: type = class_type @Source2 [concrete] +// CHECK:STDOUT: %Dest2: type = class_type @Dest2 [concrete] +// CHECK:STDOUT: %ptr.472: type = ptr_type %Source2 [concrete] +// CHECK:STDOUT: %ptr.9ae: type = ptr_type %Dest2 [concrete] +// CHECK:STDOUT: %Dest2__carbon_thunk.type: type = fn_type @Dest2__carbon_thunk [concrete] +// CHECK:STDOUT: %Dest2__carbon_thunk: %Dest2__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest2.cpp_destructor.type: type = fn_type @Dest2.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest2.cpp_destructor: %Dest2.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: %ExplicitConstructor: type = class_type @ExplicitConstructor [concrete] +// CHECK:STDOUT: %ptr.1fc: type = ptr_type %Source [concrete] +// CHECK:STDOUT: %ptr.5b5: type = ptr_type %ExplicitConstructor [concrete] +// CHECK:STDOUT: %ExplicitConstructor__carbon_thunk.type: type = fn_type @ExplicitConstructor__carbon_thunk [concrete] +// CHECK:STDOUT: %ExplicitConstructor__carbon_thunk: %ExplicitConstructor__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %ExplicitConstructor.cpp_destructor.type: type = fn_type @ExplicitConstructor.cpp_destructor [concrete] +// CHECK:STDOUT: %ExplicitConstructor.cpp_destructor: %ExplicitConstructor.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: %ExplicitConversion: type = class_type @ExplicitConversion [concrete] +// CHECK:STDOUT: %pattern_type.a70: type = pattern_type %ExplicitConversion [concrete] +// CHECK:STDOUT: %ExplicitConversion.cpp_operator.type: type = fn_type @ExplicitConversion.cpp_operator [concrete] +// CHECK:STDOUT: %ExplicitConversion.cpp_operator: %ExplicitConversion.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type.2ffc9e.2: type = fn_type @Dest__carbon_thunk.2 [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.f8fa06.2: %Dest__carbon_thunk.type.2ffc9e.2 = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Source = %Source.decl +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: .Source2 = %Source2.decl +// CHECK:STDOUT: .Dest2 = %Dest2.decl +// CHECK:STDOUT: .ExplicitConstructor = %ExplicitConstructor.decl +// CHECK:STDOUT: .ExplicitConversion = %ExplicitConversion.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.decl: type = class_decl @Source [concrete = constants.%Source] {} {} +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest] {} {} +// CHECK:STDOUT: %Source.cpp_operator.decl: %Source.cpp_operator.type = fn_decl @Source.cpp_operator [concrete = constants.%Source.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.78c = value_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.78c = value_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: %Source = value_param call_param0 +// CHECK:STDOUT: %self: %Source = value_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl.b58ecd.1: %Dest__carbon_thunk.type.2ffc9e.1 = fn_decl @Dest__carbon_thunk.1 [concrete = constants.%Dest__carbon_thunk.f8fa06.1] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source2.decl: type = class_decl @Source2 [concrete = constants.%Source2] {} {} +// CHECK:STDOUT: %Dest2.decl: type = class_decl @Dest2 [concrete = constants.%Dest2] {} {} +// CHECK:STDOUT: %Dest2__carbon_thunk.decl: %Dest2__carbon_thunk.type = fn_decl @Dest2__carbon_thunk [concrete = constants.%Dest2__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %ExplicitConstructor.decl: type = class_decl @ExplicitConstructor [concrete = constants.%ExplicitConstructor] {} {} +// CHECK:STDOUT: %ExplicitConstructor__carbon_thunk.decl: %ExplicitConstructor__carbon_thunk.type = fn_decl @ExplicitConstructor__carbon_thunk [concrete = constants.%ExplicitConstructor__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %ExplicitConversion.decl: type = class_decl @ExplicitConversion [concrete = constants.%ExplicitConversion] {} {} +// CHECK:STDOUT: %ExplicitConversion.cpp_operator.decl: %ExplicitConversion.cpp_operator.type = fn_decl @ExplicitConversion.cpp_operator [concrete = constants.%ExplicitConversion.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.a70 = value_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.a70 = value_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: %ExplicitConversion = value_param call_param0 +// CHECK:STDOUT: %self: %ExplicitConversion = value_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl.b58ecd.2: %Dest__carbon_thunk.type.2ffc9e.2 = fn_decl @Dest__carbon_thunk.2 [concrete = constants.%Dest__carbon_thunk.f8fa06.2] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @UserConversion(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: %Source.cpp_operator.bound: = bound_method %s.ref, imports.%Source.cpp_operator.decl +// CHECK:STDOUT: %.loc8_5.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc8_5.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl.b58ecd.1(%s.ref, %addr) +// CHECK:STDOUT: %.loc8_5.2: init %Dest to %.loc8_5.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc8_5.3: init %Dest = converted %s.ref, %.loc8_5.2 +// CHECK:STDOUT: %.loc8_5.4: ref %Dest = temporary %.loc8_5.1, %.loc8_5.3 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc8_5.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc8_5.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc8(%self.param: %Dest) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConstructorConversion(%s.param: %Source2) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %s.ref: %Source2 = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc14: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest2.ref: type = name_ref Dest2, imports.%Dest2.decl [concrete = constants.%Dest2] +// CHECK:STDOUT: %.loc14_5.1: ref %Dest2 = temporary_storage +// CHECK:STDOUT: %.loc14_3: ref %Source2 = value_as_ref %s.ref +// CHECK:STDOUT: %addr.loc14_5.1: %ptr.472 = addr_of %.loc14_3 +// CHECK:STDOUT: %addr.loc14_5.2: %ptr.9ae = addr_of %.loc14_5.1 +// CHECK:STDOUT: %Dest2__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest2__carbon_thunk.decl(%addr.loc14_5.1, %addr.loc14_5.2) +// CHECK:STDOUT: %.loc14_5.2: init %Dest2 to %.loc14_5.1 = in_place_init %Dest2__carbon_thunk.call +// CHECK:STDOUT: %.loc14_5.3: init %Dest2 = converted %s.ref, %.loc14_5.2 +// CHECK:STDOUT: %.loc14_5.4: ref %Dest2 = temporary %.loc14_5.1, %.loc14_5.3 +// CHECK:STDOUT: %Dest2.cpp_destructor.bound: = bound_method %.loc14_5.4, constants.%Dest2.cpp_destructor +// CHECK:STDOUT: %Dest2.cpp_destructor.call: init %empty_tuple.type = call %Dest2.cpp_destructor.bound(%.loc14_5.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc14(%self.param: %Dest2) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ExplicitConstructorTest(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc20: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ExplicitConstructor.ref: type = name_ref ExplicitConstructor, imports.%ExplicitConstructor.decl [concrete = constants.%ExplicitConstructor] +// CHECK:STDOUT: %.loc20_5.1: ref %ExplicitConstructor = temporary_storage +// CHECK:STDOUT: %.loc20_3: ref %Source = value_as_ref %s.ref +// CHECK:STDOUT: %addr.loc20_5.1: %ptr.1fc = addr_of %.loc20_3 +// CHECK:STDOUT: %addr.loc20_5.2: %ptr.5b5 = addr_of %.loc20_5.1 +// CHECK:STDOUT: %ExplicitConstructor__carbon_thunk.call: init %empty_tuple.type = call imports.%ExplicitConstructor__carbon_thunk.decl(%addr.loc20_5.1, %addr.loc20_5.2) +// CHECK:STDOUT: %.loc20_5.2: init %ExplicitConstructor to %.loc20_5.1 = in_place_init %ExplicitConstructor__carbon_thunk.call +// CHECK:STDOUT: %.loc20_5.3: init %ExplicitConstructor = converted %s.ref, %.loc20_5.2 +// CHECK:STDOUT: %.loc20_5.4: ref %ExplicitConstructor = temporary %.loc20_5.1, %.loc20_5.3 +// CHECK:STDOUT: %ExplicitConstructor.cpp_destructor.bound: = bound_method %.loc20_5.4, constants.%ExplicitConstructor.cpp_destructor +// CHECK:STDOUT: %ExplicitConstructor.cpp_destructor.call: init %empty_tuple.type = call %ExplicitConstructor.cpp_destructor.bound(%.loc20_5.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc20(%self.param: %ExplicitConstructor) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ExplicitConversionTest(%s.param: %ExplicitConversion) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %s.ref: %ExplicitConversion = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc26: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: %ExplicitConversion.cpp_operator.bound: = bound_method %s.ref, imports.%ExplicitConversion.cpp_operator.decl +// CHECK:STDOUT: %.loc26_5.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc26_5.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl.b58ecd.2(%s.ref, %addr) +// CHECK:STDOUT: %.loc26_5.2: init %Dest to %.loc26_5.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc26_5.3: init %Dest = converted %s.ref, %.loc26_5.2 +// CHECK:STDOUT: %.loc26_5.4: ref %Dest = temporary %.loc26_5.1, %.loc26_5.3 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc26_5.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc26_5.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- conditionally_explicit.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Source: type = class_type @Source [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.c52b91.1: type = class_type @ConditionallyExplicit.1 [concrete] +// CHECK:STDOUT: %pattern_type.285f84.1: type = pattern_type %ConditionallyExplicit.c52b91.1 [concrete] +// CHECK:STDOUT: %ptr.1fc: type = ptr_type %Source [concrete] +// CHECK:STDOUT: %ptr.ca4178.1: type = ptr_type %ConditionallyExplicit.c52b91.1 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.type.805b57.1: type = fn_type @ConditionallyExplicit__carbon_thunk.1 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.b68c64.1: %ConditionallyExplicit__carbon_thunk.type.805b57.1 = struct_value () [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.type.a865b6.1: type = fn_type @ConditionallyExplicit.cpp_destructor.1 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.1ba031.1: %ConditionallyExplicit.cpp_destructor.type.a865b6.1 = struct_value () [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.c52b91.2: type = class_type @ConditionallyExplicit.2 [concrete] +// CHECK:STDOUT: %ptr.ca4178.2: type = ptr_type %ConditionallyExplicit.c52b91.2 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.type.805b57.2: type = fn_type @ConditionallyExplicit__carbon_thunk.2 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.b68c64.2: %ConditionallyExplicit__carbon_thunk.type.805b57.2 = struct_value () [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.type.a865b6.2: type = fn_type @ConditionallyExplicit.cpp_destructor.2 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.1ba031.2: %ConditionallyExplicit.cpp_destructor.type.a865b6.2 = struct_value () [concrete] +// CHECK:STDOUT: %Dest: type = class_type @Dest [concrete] +// CHECK:STDOUT: %pattern_type.69a: type = pattern_type %Dest [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.type: type = fn_type @ConditionallyExplicit.cpp_operator [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator: %ConditionallyExplicit.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.551: type = ptr_type %Dest [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type: type = fn_type @Dest__carbon_thunk [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk: %Dest__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor.type: type = fn_type @Dest.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor: %Dest.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Source = %Source.decl +// CHECK:STDOUT: .ConditionallyExplicitFalse = %ConditionallyExplicit.decl.7acffe.1 +// CHECK:STDOUT: .ConditionallyExplicitTrue = %ConditionallyExplicit.decl.7acffe.2 +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.decl: type = class_decl @Source [concrete = constants.%Source] {} {} +// CHECK:STDOUT: %ConditionallyExplicit.decl.7acffe.1: type = class_decl @ConditionallyExplicit.1 [concrete = constants.%ConditionallyExplicit.c52b91.1] {} {} +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.decl.22daaa.1: %ConditionallyExplicit__carbon_thunk.type.805b57.1 = fn_decl @ConditionallyExplicit__carbon_thunk.1 [concrete = constants.%ConditionallyExplicit__carbon_thunk.b68c64.1] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %ConditionallyExplicit.decl.7acffe.2: type = class_decl @ConditionallyExplicit.2 [concrete = constants.%ConditionallyExplicit.c52b91.2] {} {} +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.decl.22daaa.2: %ConditionallyExplicit__carbon_thunk.type.805b57.2 = fn_decl @ConditionallyExplicit__carbon_thunk.2 [concrete = constants.%ConditionallyExplicit__carbon_thunk.b68c64.2] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest] {} {} +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.decl: %ConditionallyExplicit.cpp_operator.type = fn_decl @ConditionallyExplicit.cpp_operator [concrete = constants.%ConditionallyExplicit.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.285f84.1 = value_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.285f84.1 = value_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: %ConditionallyExplicit.c52b91.1 = value_param call_param0 +// CHECK:STDOUT: %self: %ConditionallyExplicit.c52b91.1 = value_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl: %Dest__carbon_thunk.type = fn_decl @Dest__carbon_thunk [concrete = constants.%Dest__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConstructorNotExplicit(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.285f84.1 = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref.loc8: %Source = name_ref s, %s +// CHECK:STDOUT: %.loc8_13: type = splice_block %ConditionallyExplicitFalse.ref.loc8 [concrete = constants.%ConditionallyExplicit.c52b91.1] { +// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ConditionallyExplicitFalse.ref.loc8: type = name_ref ConditionallyExplicitFalse, imports.%ConditionallyExplicit.decl.7acffe.1 [concrete = constants.%ConditionallyExplicit.c52b91.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc8_43.1: ref %ConditionallyExplicit.c52b91.1 = temporary_storage +// CHECK:STDOUT: %.loc8_43.2: ref %Source = value_as_ref %s.ref.loc8 +// CHECK:STDOUT: %addr.loc8_43.1: %ptr.1fc = addr_of %.loc8_43.2 +// CHECK:STDOUT: %addr.loc8_43.2: %ptr.ca4178.1 = addr_of %.loc8_43.1 +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.call.loc8: init %empty_tuple.type = call imports.%ConditionallyExplicit__carbon_thunk.decl.22daaa.1(%addr.loc8_43.1, %addr.loc8_43.2) +// CHECK:STDOUT: %.loc8_43.3: init %ConditionallyExplicit.c52b91.1 to %.loc8_43.1 = in_place_init %ConditionallyExplicit__carbon_thunk.call.loc8 +// CHECK:STDOUT: %.loc8_43.4: init %ConditionallyExplicit.c52b91.1 = converted %s.ref.loc8, %.loc8_43.3 +// CHECK:STDOUT: %.loc8_43.5: ref %ConditionallyExplicit.c52b91.1 = temporary %.loc8_43.1, %.loc8_43.4 +// CHECK:STDOUT: %.loc8_43.6: %ConditionallyExplicit.c52b91.1 = acquire_value %.loc8_43.5 +// CHECK:STDOUT: %_: %ConditionallyExplicit.c52b91.1 = value_binding _, %.loc8_43.6 +// CHECK:STDOUT: %s.ref.loc9: %Source = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ConditionallyExplicitFalse.ref.loc9: type = name_ref ConditionallyExplicitFalse, imports.%ConditionallyExplicit.decl.7acffe.1 [concrete = constants.%ConditionallyExplicit.c52b91.1] +// CHECK:STDOUT: %.loc9_5.1: ref %ConditionallyExplicit.c52b91.1 = temporary_storage +// CHECK:STDOUT: %.loc9_3: ref %Source = value_as_ref %s.ref.loc9 +// CHECK:STDOUT: %addr.loc9_5.1: %ptr.1fc = addr_of %.loc9_3 +// CHECK:STDOUT: %addr.loc9_5.2: %ptr.ca4178.1 = addr_of %.loc9_5.1 +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.call.loc9: init %empty_tuple.type = call imports.%ConditionallyExplicit__carbon_thunk.decl.22daaa.1(%addr.loc9_5.1, %addr.loc9_5.2) +// CHECK:STDOUT: %.loc9_5.2: init %ConditionallyExplicit.c52b91.1 to %.loc9_5.1 = in_place_init %ConditionallyExplicit__carbon_thunk.call.loc9 +// CHECK:STDOUT: %.loc9_5.3: init %ConditionallyExplicit.c52b91.1 = converted %s.ref.loc9, %.loc9_5.2 +// CHECK:STDOUT: %.loc9_5.4: ref %ConditionallyExplicit.c52b91.1 = temporary %.loc9_5.1, %.loc9_5.3 +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.bound.loc9: = bound_method %.loc9_5.4, constants.%ConditionallyExplicit.cpp_destructor.1ba031.1 +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.call.loc9: init %empty_tuple.type = call %ConditionallyExplicit.cpp_destructor.bound.loc9(%.loc9_5.4) +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.bound.loc8: = bound_method %.loc8_43.5, constants.%ConditionallyExplicit.cpp_destructor.1ba031.1 +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.call.loc8: init %empty_tuple.type = call %ConditionallyExplicit.cpp_destructor.bound.loc8(%.loc8_43.5) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc9(%self.param: %ConditionallyExplicit.c52b91.1) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConstructorExplicit(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc15: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ConditionallyExplicitTrue.ref: type = name_ref ConditionallyExplicitTrue, imports.%ConditionallyExplicit.decl.7acffe.2 [concrete = constants.%ConditionallyExplicit.c52b91.2] +// CHECK:STDOUT: %.loc15_5.1: ref %ConditionallyExplicit.c52b91.2 = temporary_storage +// CHECK:STDOUT: %.loc15_3: ref %Source = value_as_ref %s.ref +// CHECK:STDOUT: %addr.loc15_5.1: %ptr.1fc = addr_of %.loc15_3 +// CHECK:STDOUT: %addr.loc15_5.2: %ptr.ca4178.2 = addr_of %.loc15_5.1 +// CHECK:STDOUT: %ConditionallyExplicit__carbon_thunk.call: init %empty_tuple.type = call imports.%ConditionallyExplicit__carbon_thunk.decl.22daaa.2(%addr.loc15_5.1, %addr.loc15_5.2) +// CHECK:STDOUT: %.loc15_5.2: init %ConditionallyExplicit.c52b91.2 to %.loc15_5.1 = in_place_init %ConditionallyExplicit__carbon_thunk.call +// CHECK:STDOUT: %.loc15_5.3: init %ConditionallyExplicit.c52b91.2 = converted %s.ref, %.loc15_5.2 +// CHECK:STDOUT: %.loc15_5.4: ref %ConditionallyExplicit.c52b91.2 = temporary %.loc15_5.1, %.loc15_5.3 +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.bound: = bound_method %.loc15_5.4, constants.%ConditionallyExplicit.cpp_destructor.1ba031.2 +// CHECK:STDOUT: %ConditionallyExplicit.cpp_destructor.call: init %empty_tuple.type = call %ConditionallyExplicit.cpp_destructor.bound(%.loc15_5.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc15(%self.param: %ConditionallyExplicit.c52b91.2) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConversionNotExplicit(%s.param: %ConditionallyExplicit.c52b91.1) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref.loc21: %ConditionallyExplicit.c52b91.1 = name_ref s, %s +// CHECK:STDOUT: %.loc21_13: type = splice_block %Dest.ref.loc21 [concrete = constants.%Dest] { +// CHECK:STDOUT: %Cpp.ref.loc21: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref.loc21: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: } +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.bound.loc21: = bound_method %s.ref.loc21, imports.%ConditionallyExplicit.cpp_operator.decl +// CHECK:STDOUT: %.loc21_21.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr.loc21: %ptr.551 = addr_of %.loc21_21.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call.loc21: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl(%s.ref.loc21, %addr.loc21) +// CHECK:STDOUT: %.loc21_21.2: init %Dest to %.loc21_21.1 = in_place_init %Dest__carbon_thunk.call.loc21 +// CHECK:STDOUT: %.loc21_21.3: init %Dest = converted %s.ref.loc21, %.loc21_21.2 +// CHECK:STDOUT: %.loc21_21.4: ref %Dest = temporary %.loc21_21.1, %.loc21_21.3 +// CHECK:STDOUT: %.loc21_21.5: %Dest = acquire_value %.loc21_21.4 +// CHECK:STDOUT: %_: %Dest = value_binding _, %.loc21_21.5 +// CHECK:STDOUT: %s.ref.loc22: %ConditionallyExplicit.c52b91.1 = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc22: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref.loc22: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.bound.loc22: = bound_method %s.ref.loc22, imports.%ConditionallyExplicit.cpp_operator.decl +// CHECK:STDOUT: %.loc22_5.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr.loc22: %ptr.551 = addr_of %.loc22_5.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call.loc22: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl(%s.ref.loc22, %addr.loc22) +// CHECK:STDOUT: %.loc22_5.2: init %Dest to %.loc22_5.1 = in_place_init %Dest__carbon_thunk.call.loc22 +// CHECK:STDOUT: %.loc22_5.3: init %Dest = converted %s.ref.loc22, %.loc22_5.2 +// CHECK:STDOUT: %.loc22_5.4: ref %Dest = temporary %.loc22_5.1, %.loc22_5.3 +// CHECK:STDOUT: %Dest.cpp_destructor.bound.loc22: = bound_method %.loc22_5.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call.loc22: init %empty_tuple.type = call %Dest.cpp_destructor.bound.loc22(%.loc22_5.4) +// CHECK:STDOUT: %Dest.cpp_destructor.bound.loc21: = bound_method %.loc21_21.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call.loc21: init %empty_tuple.type = call %Dest.cpp_destructor.bound.loc21(%.loc21_21.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc22(%self.param: %Dest) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConversionExplicit(%s.param: %ConditionallyExplicit.c52b91.1) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %s.ref: %ConditionallyExplicit.c52b91.1 = name_ref s, %s +// CHECK:STDOUT: %Cpp.ref.loc28: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.bound: = bound_method %s.ref, imports.%ConditionallyExplicit.cpp_operator.decl +// CHECK:STDOUT: %.loc28_5.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc28_5.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl(%s.ref, %addr) +// CHECK:STDOUT: %.loc28_5.2: init %Dest to %.loc28_5.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc28_5.3: init %Dest = converted %s.ref, %.loc28_5.2 +// CHECK:STDOUT: %.loc28_5.4: ref %Dest = temporary %.loc28_5.1, %.loc28_5.3 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc28_5.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc28_5.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_conditionally_explicit_implicit.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Source: type = class_type @Source [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.c52b91.1: type = class_type @ConditionallyExplicit.1 [concrete] +// CHECK:STDOUT: %pattern_type.285f84.1: type = pattern_type %ConditionallyExplicit.c52b91.1 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.c52b91.2: type = class_type @ConditionallyExplicit.2 [concrete] +// CHECK:STDOUT: %pattern_type.285f84.2: type = pattern_type %ConditionallyExplicit.c52b91.2 [concrete] +// CHECK:STDOUT: %Dest.5e7: type = class_type @Dest [concrete] +// CHECK:STDOUT: %pattern_type.69a: type = pattern_type %Dest.5e7 [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.type: type = fn_type @ConditionallyExplicit.cpp_operator [concrete] +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator: %ConditionallyExplicit.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.551: type = ptr_type %Dest.5e7 [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type: type = fn_type @Dest__carbon_thunk [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk: %Dest__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor.type: type = fn_type @Dest.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor: %Dest.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Source = %Source.decl +// CHECK:STDOUT: .ConditionallyExplicitTrue = %ConditionallyExplicit.decl.7acffe.1 +// CHECK:STDOUT: .ConditionallyExplicitFalse = %ConditionallyExplicit.decl.7acffe.2 +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.decl: type = class_decl @Source [concrete = constants.%Source] {} {} +// CHECK:STDOUT: %ConditionallyExplicit.decl.7acffe.1: type = class_decl @ConditionallyExplicit.1 [concrete = constants.%ConditionallyExplicit.c52b91.1] {} {} +// CHECK:STDOUT: %ConditionallyExplicit.decl.7acffe.2: type = class_decl @ConditionallyExplicit.2 [concrete = constants.%ConditionallyExplicit.c52b91.2] {} {} +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest.5e7] {} {} +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.decl: %ConditionallyExplicit.cpp_operator.type = fn_decl @ConditionallyExplicit.cpp_operator [concrete = constants.%ConditionallyExplicit.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.285f84.2 = value_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.285f84.2 = value_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: %ConditionallyExplicit.c52b91.2 = value_param call_param0 +// CHECK:STDOUT: %self: %ConditionallyExplicit.c52b91.2 = value_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl: %Dest__carbon_thunk.type = fn_decl @Dest__carbon_thunk [concrete = constants.%Dest__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConstructorExplicit(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.285f84.1 = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %.loc15_13: type = splice_block %ConditionallyExplicitTrue.ref [concrete = constants.%ConditionallyExplicit.c52b91.1] { +// CHECK:STDOUT: %Cpp.ref.loc15: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ConditionallyExplicitTrue.ref: type = name_ref ConditionallyExplicitTrue, imports.%ConditionallyExplicit.decl.7acffe.1 [concrete = constants.%ConditionallyExplicit.c52b91.1] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc15_42: %ConditionallyExplicit.c52b91.1 = converted %s.ref, [concrete = ] +// CHECK:STDOUT: %_: %ConditionallyExplicit.c52b91.1 = value_binding _, [concrete = ] +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConversionExplicit(%s.param: %ConditionallyExplicit.c52b91.2) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %ConditionallyExplicit.c52b91.2 = name_ref s, %s +// CHECK:STDOUT: %.loc21_13: type = splice_block %Dest.ref [concrete = constants.%Dest.5e7] { +// CHECK:STDOUT: %Cpp.ref.loc21: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest.5e7] +// CHECK:STDOUT: } +// CHECK:STDOUT: %ConditionallyExplicit.cpp_operator.bound: = bound_method %s.ref, imports.%ConditionallyExplicit.cpp_operator.decl +// CHECK:STDOUT: %.loc21_21.1: ref %Dest.5e7 = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc21_21.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl(%s.ref, %addr) +// CHECK:STDOUT: %.loc21_21.2: init %Dest.5e7 to %.loc21_21.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc21_21.3: init %Dest.5e7 = converted %s.ref, %.loc21_21.2 +// CHECK:STDOUT: %.loc21_21.4: ref %Dest.5e7 = temporary %.loc21_21.1, %.loc21_21.3 +// CHECK:STDOUT: %.loc21_21.5: %Dest.5e7 = acquire_value %.loc21_21.4 +// CHECK:STDOUT: %_: %Dest.5e7 = value_binding _, %.loc21_21.5 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc21_21.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc21_21.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp(%self.param: %Dest.5e7) = "no_op"; +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/impls/copy.carbon b/toolchain/check/testdata/interop/cpp/impls/copy.carbon index ca4dfdb0be95..370fdb580eb4 100644 --- a/toolchain/check/testdata/interop/cpp/impls/copy.carbon +++ b/toolchain/check/testdata/interop/cpp/impls/copy.carbon @@ -144,20 +144,26 @@ fn CopyAmbiguousCopy(c: Cpp.AmbiguousCopy) -> Cpp.AmbiguousCopy { fn CopyPrivateCopy(c: Cpp.PrivateCopy) -> Cpp.PrivateCopy { // TODO: Note is missing location. - // CHECK:STDERR: fail_copy_noncopyable.carbon:[[@LINE+5]]:10: error: cannot access private member `PrivateCopy` of type `Cpp.PrivateCopy` [ClassInvalidMemberAccess] + // CHECK:STDERR: fail_copy_noncopyable.carbon:[[@LINE+8]]:10: error: cannot access private member `PrivateCopy` of type `Cpp.PrivateCopy` [ClassInvalidMemberAccess] // CHECK:STDERR: return c; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_copy_noncopyable.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: fail_copy_noncopyable.carbon:[[@LINE-67]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./types.h:40:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: PrivateCopy(const PrivateCopy&); + // CHECK:STDERR: ^ // CHECK:STDERR: return c; } fn CopyProtectedCopy(c: Cpp.ProtectedCopy) -> Cpp.ProtectedCopy { // TODO: Note is missing location. - // CHECK:STDERR: fail_copy_noncopyable.carbon:[[@LINE+5]]:10: error: cannot access protected member `ProtectedCopy` of type `Cpp.ProtectedCopy` [ClassInvalidMemberAccess] + // CHECK:STDERR: fail_copy_noncopyable.carbon:[[@LINE+8]]:10: error: cannot access protected member `ProtectedCopy` of type `Cpp.ProtectedCopy` [ClassInvalidMemberAccess] // CHECK:STDERR: return c; // CHECK:STDERR: ^ - // CHECK:STDERR: fail_copy_noncopyable.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: fail_copy_noncopyable.carbon:[[@LINE-80]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./types.h:45:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: ProtectedCopy(const ProtectedCopy&); + // CHECK:STDERR: ^ // CHECK:STDERR: return c; } diff --git a/toolchain/check/testdata/interop/cpp/impls/destroy.carbon b/toolchain/check/testdata/interop/cpp/impls/destroy.carbon index 06fee574d0c3..665d13c9fbaf 100644 --- a/toolchain/check/testdata/interop/cpp/impls/destroy.carbon +++ b/toolchain/check/testdata/interop/cpp/impls/destroy.carbon @@ -141,19 +141,25 @@ fn DeletedDestroy() { } fn PrivateDestroy() { - // CHECK:STDERR: fail_destroy_nondestroyable.carbon:[[@LINE+5]]:3: error: cannot access private member `` of type `Cpp.PrivateDestructor` [ClassInvalidMemberAccess] + // CHECK:STDERR: fail_destroy_nondestroyable.carbon:[[@LINE+8]]:3: error: cannot access private member `` of type `Cpp.PrivateDestructor` [ClassInvalidMemberAccess] // CHECK:STDERR: var a: Cpp.PrivateDestructor = {}; // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_destroy_nondestroyable.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: fail_destroy_nondestroyable.carbon:[[@LINE-26]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./types.h:28:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: ~PrivateDestructor(); + // CHECK:STDERR: ^ // CHECK:STDERR: var a: Cpp.PrivateDestructor = {}; } fn ProtectedDestroy() { - // CHECK:STDERR: fail_destroy_nondestroyable.carbon:[[@LINE+5]]:3: error: cannot access protected member `` of type `Cpp.ProtectedDestructor` [ClassInvalidMemberAccess] + // CHECK:STDERR: fail_destroy_nondestroyable.carbon:[[@LINE+8]]:3: error: cannot access protected member `` of type `Cpp.ProtectedDestructor` [ClassInvalidMemberAccess] // CHECK:STDERR: var a: Cpp.ProtectedDestructor = {}; // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_destroy_nondestroyable.carbon: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: fail_destroy_nondestroyable.carbon:[[@LINE-38]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./types.h:33:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: ~ProtectedDestructor(); + // CHECK:STDERR: ^ // CHECK:STDERR: var a: Cpp.ProtectedDestructor = {}; } diff --git a/toolchain/check/testdata/interop/cpp/impls/implicit_as.carbon b/toolchain/check/testdata/interop/cpp/impls/implicit_as.carbon new file mode 100644 index 000000000000..961d37fdedff --- /dev/null +++ b/toolchain/check/testdata/interop/cpp/impls/implicit_as.carbon @@ -0,0 +1,853 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// INCLUDE-FILE: toolchain/testing/testdata/min_prelude/primitives.carbon +// EXTRA-ARGS: --target=x86_64-linux-gnu --clang-arg=-std=c++20 +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/interop/cpp/impls/implicit_as.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/interop/cpp/impls/implicit_as.carbon + +// --- implicit_conversions.h + +struct Dest {}; + +struct Source { + operator Dest() const; +}; + +struct Source2 { + int x; +}; +struct Dest2 { + Dest2(Source2); +}; + +struct NonConstConversion { + operator Dest(); +}; + +struct InaccessibleConstructor { +private: + InaccessibleConstructor(Source); +}; + +struct InaccessibleConversion { +private: + operator Dest() const; +}; + +struct DeletedConstructor { + DeletedConstructor(Source) = delete; +}; + +struct DeletedConversion { + operator Dest() const = delete; +}; + +struct IntConstructor { + IntConstructor(int); +}; + +struct ExplicitConstructor { + explicit ExplicitConstructor(Source); +}; + +struct ExplicitConversion { + explicit operator Dest() const; +}; + +// --- implicit_conversions.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "implicit_conversions.h"; + +fn UserConversion(s: Cpp.Source) { + //@dump-sem-ir-begin + let _: Cpp.Dest = s; + //@dump-sem-ir-end +} + +fn NonConstConversion(ref s: Cpp.NonConstConversion) { + //@dump-sem-ir-begin + let _: Cpp.Dest = s; + //@dump-sem-ir-end +} + +fn ConstructorConversion(s: Cpp.Source2) { + //@dump-sem-ir-begin + let _: Cpp.Dest2 = s; + //@dump-sem-ir-end +} + +// --- fail_expr_category.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "implicit_conversions.h"; + +fn NonConstConversionTest(s: Cpp.NonConstConversion) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_expr_category.carbon:[[@LINE+7]]:21: error: value expression passed to reference parameter [ValueForRefParam] + // CHECK:STDERR: let _: Cpp.Dest = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_expr_category.carbon:[[@LINE+4]]:21: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: let _: Cpp.Dest = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.Dest = s; + //@dump-sem-ir-end +} + +// --- fail_access.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "implicit_conversions.h"; + +fn InaccessibleConstructorTest(s: Cpp.Source) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_access.carbon:[[@LINE+8]]:40: error: cannot access private member `InaccessibleConstructor` of type `Cpp.InaccessibleConstructor` [ClassInvalidMemberAccess] + // CHECK:STDERR: let _: Cpp.InaccessibleConstructor = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_access.carbon:[[@LINE-7]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./implicit_conversions.h:21:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: InaccessibleConstructor(Source); + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.InaccessibleConstructor = s; + //@dump-sem-ir-end +} + +fn InaccessibleConversionTest(s: Cpp.InaccessibleConversion) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_access.carbon:[[@LINE+8]]:21: error: cannot access private member `` of type `Cpp.InaccessibleConversion` [ClassInvalidMemberAccess] + // CHECK:STDERR: let _: Cpp.Dest = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_access.carbon:[[@LINE-21]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./implicit_conversions.h:26:3: note: declared here [ClassMemberDeclaration] + // CHECK:STDERR: operator Dest() const; + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.Dest = s; + //@dump-sem-ir-end +} + +// --- fail_deleted.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "implicit_conversions.h"; + +fn DeletedConstructorTest(s: Cpp.Source) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_deleted.carbon:[[@LINE+7]]:35: error: cannot implicitly convert expression of type `Cpp.Source` to `Cpp.DeletedConstructor` [ConversionFailure] + // CHECK:STDERR: let _: Cpp.DeletedConstructor = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_deleted.carbon:[[@LINE+4]]:35: note: type `Cpp.Source` does not implement interface `Core.ImplicitAs(Cpp.DeletedConstructor)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: let _: Cpp.DeletedConstructor = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.DeletedConstructor = s; + //@dump-sem-ir-end +} + +fn DeletedConversionTest(s: Cpp.DeletedConversion) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_deleted.carbon:[[@LINE+7]]:21: error: cannot implicitly convert expression of type `Cpp.DeletedConversion` to `Cpp.Dest` [ConversionFailure] + // CHECK:STDERR: let _: Cpp.Dest = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_deleted.carbon:[[@LINE+4]]:21: note: type `Cpp.DeletedConversion` does not implement interface `Core.ImplicitAs(Cpp.Dest)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: let _: Cpp.Dest = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.Dest = s; + //@dump-sem-ir-end +} + +// --- fail_explicit.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "implicit_conversions.h"; + +fn ExplicitConstructorTest(s: Cpp.Source) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_explicit.carbon:[[@LINE+7]]:36: error: cannot implicitly convert expression of type `Cpp.Source` to `Cpp.ExplicitConstructor` [ConversionFailure] + // CHECK:STDERR: let _: Cpp.ExplicitConstructor = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_explicit.carbon:[[@LINE+4]]:36: note: type `Cpp.Source` does not implement interface `Core.ImplicitAs(Cpp.ExplicitConstructor)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: let _: Cpp.ExplicitConstructor = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.ExplicitConstructor = s; + //@dump-sem-ir-end +} + +fn ExplicitConversionTest(s: Cpp.ExplicitConversion) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_explicit.carbon:[[@LINE+7]]:21: error: cannot implicitly convert expression of type `Cpp.ExplicitConversion` to `Cpp.Dest` [ConversionFailure] + // CHECK:STDERR: let _: Cpp.Dest = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_explicit.carbon:[[@LINE+4]]:21: note: type `Cpp.ExplicitConversion` does not implement interface `Core.ImplicitAs(Cpp.Dest)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: let _: Cpp.Dest = s; + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.Dest = s; + //@dump-sem-ir-end +} + +// --- i32_to_int.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "implicit_conversions.h"; + +fn IntConstructor(i: i32) { + //@dump-sem-ir-begin + let _: Cpp.IntConstructor = i; + //@dump-sem-ir-end +} + +// --- fail_no_u32_to_int_conversion_in_carbon.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "implicit_conversions.h"; + +fn IntConstructorTest(u: u32) { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_no_u32_to_int_conversion_in_carbon.carbon:[[@LINE+11]]:31: error: cannot implicitly convert expression of type `u32` to `i32` [ConversionFailure] + // CHECK:STDERR: let _: Cpp.IntConstructor = u; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_no_u32_to_int_conversion_in_carbon.carbon:[[@LINE+8]]:31: note: type `u32` does not implement interface `Core.ImplicitAs(i32)` [MissingImplInMemberAccessNote] + // CHECK:STDERR: let _: Cpp.IntConstructor = u; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_no_u32_to_int_conversion_in_carbon.carbon:[[@LINE-10]]:10: in file included here [InCppInclude] + // CHECK:STDERR: ./implicit_conversions.h:38:21: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: IntConstructor(int); + // CHECK:STDERR: ^ + // CHECK:STDERR: + let _: Cpp.IntConstructor = u; + //@dump-sem-ir-end +} + +// --- multi_argument.h + +struct Two { + Two(int, int); +}; + +// --- fail_todo_construct_multi_argument.carbon + +library "[[@TEST_NAME]]"; + +import Cpp library "multi_argument.h"; + +fn ImplicitConvert() { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_todo_construct_multi_argument.carbon:[[@LINE+6]]:20: error: semantics TODO: `Unsupported initialization sequence: + // CHECK:STDERR: Normal sequence: list initialization via constructor [struct Two] + // CHECK:STDERR: ` [SemanticsTodo] + // CHECK:STDERR: let _: Cpp.Two = (1, 2); + // CHECK:STDERR: ^~~~~~ + // CHECK:STDERR: + let _: Cpp.Two = (1, 2); + //@dump-sem-ir-end +} + +// CHECK:STDOUT: --- implicit_conversions.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Source: type = class_type @Source [concrete] +// CHECK:STDOUT: %pattern_type.78c: type = pattern_type %Source [concrete] +// CHECK:STDOUT: %Dest: type = class_type @Dest [concrete] +// CHECK:STDOUT: %pattern_type.69a: type = pattern_type %Dest [concrete] +// CHECK:STDOUT: %Source.cpp_operator.type: type = fn_type @Source.cpp_operator [concrete] +// CHECK:STDOUT: %Source.cpp_operator: %Source.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.551: type = ptr_type %Dest [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type.2ffc9e.1: type = fn_type @Dest__carbon_thunk.1 [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.f8fa06.1: %Dest__carbon_thunk.type.2ffc9e.1 = struct_value () [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor.type: type = fn_type @Dest.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor: %Dest.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: %NonConstConversion.480: type = class_type @NonConstConversion.1 [concrete] +// CHECK:STDOUT: %pattern_type.b08: type = pattern_type %NonConstConversion.480 [concrete] +// CHECK:STDOUT: %NonConstConversion.cpp_operator.type: type = fn_type @NonConstConversion.cpp_operator [concrete] +// CHECK:STDOUT: %NonConstConversion.cpp_operator: %NonConstConversion.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type.2ffc9e.2: type = fn_type @Dest__carbon_thunk.2 [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.f8fa06.2: %Dest__carbon_thunk.type.2ffc9e.2 = struct_value () [concrete] +// CHECK:STDOUT: %Source2: type = class_type @Source2 [concrete] +// CHECK:STDOUT: %Dest2: type = class_type @Dest2 [concrete] +// CHECK:STDOUT: %pattern_type.39d: type = pattern_type %Dest2 [concrete] +// CHECK:STDOUT: %ptr.472: type = ptr_type %Source2 [concrete] +// CHECK:STDOUT: %ptr.9ae: type = ptr_type %Dest2 [concrete] +// CHECK:STDOUT: %Dest2__carbon_thunk.type: type = fn_type @Dest2__carbon_thunk [concrete] +// CHECK:STDOUT: %Dest2__carbon_thunk: %Dest2__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest2.cpp_destructor.type: type = fn_type @Dest2.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest2.cpp_destructor: %Dest2.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Source = %Source.decl +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: .NonConstConversion = %NonConstConversion.decl +// CHECK:STDOUT: .Source2 = %Source2.decl +// CHECK:STDOUT: .Dest2 = %Dest2.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.decl: type = class_decl @Source [concrete = constants.%Source] {} {} +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest] {} {} +// CHECK:STDOUT: %Source.cpp_operator.decl: %Source.cpp_operator.type = fn_decl @Source.cpp_operator [concrete = constants.%Source.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.78c = value_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.78c = value_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: %Source = value_param call_param0 +// CHECK:STDOUT: %self: %Source = value_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl.b58ecd.1: %Dest__carbon_thunk.type.2ffc9e.1 = fn_decl @Dest__carbon_thunk.1 [concrete = constants.%Dest__carbon_thunk.f8fa06.1] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %NonConstConversion.decl: type = class_decl @NonConstConversion.1 [concrete = constants.%NonConstConversion.480] {} {} +// CHECK:STDOUT: %NonConstConversion.cpp_operator.decl: %NonConstConversion.cpp_operator.type = fn_decl @NonConstConversion.cpp_operator [concrete = constants.%NonConstConversion.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.b08 = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.b08 = ref_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: ref %NonConstConversion.480 = ref_param call_param0 +// CHECK:STDOUT: %self: ref %NonConstConversion.480 = ref_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl.b58ecd.2: %Dest__carbon_thunk.type.2ffc9e.2 = fn_decl @Dest__carbon_thunk.2 [concrete = constants.%Dest__carbon_thunk.f8fa06.2] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source2.decl: type = class_decl @Source2 [concrete = constants.%Source2] {} {} +// CHECK:STDOUT: %Dest2.decl: type = class_decl @Dest2 [concrete = constants.%Dest2] {} {} +// CHECK:STDOUT: %Dest2__carbon_thunk.decl: %Dest2__carbon_thunk.type = fn_decl @Dest2__carbon_thunk [concrete = constants.%Dest2__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @UserConversion(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %.loc8_13: type = splice_block %Dest.ref [concrete = constants.%Dest] { +// CHECK:STDOUT: %Cpp.ref.loc8: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.cpp_operator.bound: = bound_method %s.ref, imports.%Source.cpp_operator.decl +// CHECK:STDOUT: %.loc8_21.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc8_21.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl.b58ecd.1(%s.ref, %addr) +// CHECK:STDOUT: %.loc8_21.2: init %Dest to %.loc8_21.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc8_21.3: init %Dest = converted %s.ref, %.loc8_21.2 +// CHECK:STDOUT: %.loc8_21.4: ref %Dest = temporary %.loc8_21.1, %.loc8_21.3 +// CHECK:STDOUT: %.loc8_21.5: %Dest = acquire_value %.loc8_21.4 +// CHECK:STDOUT: %_: %Dest = value_binding _, %.loc8_21.5 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc8_21.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc8_21.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc8(%self.param: %Dest) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @NonConstConversion.loc12(%s.param: %NonConstConversion.480) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: ref %NonConstConversion.480 = name_ref s, %s +// CHECK:STDOUT: %.loc14_13: type = splice_block %Dest.ref [concrete = constants.%Dest] { +// CHECK:STDOUT: %Cpp.ref.loc14: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: } +// CHECK:STDOUT: %NonConstConversion.cpp_operator.bound: = bound_method %s.ref, imports.%NonConstConversion.cpp_operator.decl +// CHECK:STDOUT: %.loc14_21.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc14_21.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl.b58ecd.2(%s.ref, %addr) +// CHECK:STDOUT: %.loc14_21.2: init %Dest to %.loc14_21.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc14_21.3: init %Dest = converted %s.ref, %.loc14_21.2 +// CHECK:STDOUT: %.loc14_21.4: ref %Dest = temporary %.loc14_21.1, %.loc14_21.3 +// CHECK:STDOUT: %.loc14_21.5: %Dest = acquire_value %.loc14_21.4 +// CHECK:STDOUT: %_: %Dest = value_binding _, %.loc14_21.5 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc14_21.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc14_21.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ConstructorConversion(%s.param: %Source2) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.39d = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %Source2 = name_ref s, %s +// CHECK:STDOUT: %.loc20_13: type = splice_block %Dest2.ref [concrete = constants.%Dest2] { +// CHECK:STDOUT: %Cpp.ref.loc20: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest2.ref: type = name_ref Dest2, imports.%Dest2.decl [concrete = constants.%Dest2] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc20_22.1: ref %Dest2 = temporary_storage +// CHECK:STDOUT: %.loc20_22.2: ref %Source2 = value_as_ref %s.ref +// CHECK:STDOUT: %addr.loc20_22.1: %ptr.472 = addr_of %.loc20_22.2 +// CHECK:STDOUT: %addr.loc20_22.2: %ptr.9ae = addr_of %.loc20_22.1 +// CHECK:STDOUT: %Dest2__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest2__carbon_thunk.decl(%addr.loc20_22.1, %addr.loc20_22.2) +// CHECK:STDOUT: %.loc20_22.3: init %Dest2 to %.loc20_22.1 = in_place_init %Dest2__carbon_thunk.call +// CHECK:STDOUT: %.loc20_22.4: init %Dest2 = converted %s.ref, %.loc20_22.3 +// CHECK:STDOUT: %.loc20_22.5: ref %Dest2 = temporary %.loc20_22.1, %.loc20_22.4 +// CHECK:STDOUT: %.loc20_22.6: %Dest2 = acquire_value %.loc20_22.5 +// CHECK:STDOUT: %_: %Dest2 = value_binding _, %.loc20_22.6 +// CHECK:STDOUT: %Dest2.cpp_destructor.bound: = bound_method %.loc20_22.5, constants.%Dest2.cpp_destructor +// CHECK:STDOUT: %Dest2.cpp_destructor.call: init %empty_tuple.type = call %Dest2.cpp_destructor.bound(%.loc20_22.5) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc20(%self.param: %Dest2) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_expr_category.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %NonConstConversion: type = class_type @NonConstConversion [concrete] +// CHECK:STDOUT: %pattern_type.b08: type = pattern_type %NonConstConversion [concrete] +// CHECK:STDOUT: %Dest: type = class_type @Dest [concrete] +// CHECK:STDOUT: %pattern_type.69a: type = pattern_type %Dest [concrete] +// CHECK:STDOUT: %NonConstConversion.cpp_operator.type: type = fn_type @NonConstConversion.cpp_operator [concrete] +// CHECK:STDOUT: %NonConstConversion.cpp_operator: %NonConstConversion.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.551: type = ptr_type %Dest [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type: type = fn_type @Dest__carbon_thunk [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk: %Dest__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor.type: type = fn_type @Dest.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor: %Dest.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .NonConstConversion = %NonConstConversion.decl +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %NonConstConversion.decl: type = class_decl @NonConstConversion [concrete = constants.%NonConstConversion] {} {} +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest] {} {} +// CHECK:STDOUT: %NonConstConversion.cpp_operator.decl: %NonConstConversion.cpp_operator.type = fn_decl @NonConstConversion.cpp_operator [concrete = constants.%NonConstConversion.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.b08 = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.b08 = ref_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: ref %NonConstConversion = ref_param call_param0 +// CHECK:STDOUT: %self: ref %NonConstConversion = ref_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl: %Dest__carbon_thunk.type = fn_decl @Dest__carbon_thunk [concrete = constants.%Dest__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @NonConstConversionTest(%s.param: %NonConstConversion) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %NonConstConversion = name_ref s, %s +// CHECK:STDOUT: %.loc15_13: type = splice_block %Dest.ref [concrete = constants.%Dest] { +// CHECK:STDOUT: %Cpp.ref.loc15: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: } +// CHECK:STDOUT: %NonConstConversion.cpp_operator.bound: = bound_method %s.ref, imports.%NonConstConversion.cpp_operator.decl +// CHECK:STDOUT: %.loc15_21.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc15_21.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl(, %addr) +// CHECK:STDOUT: %.loc15_21.2: init %Dest to %.loc15_21.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc15_21.3: init %Dest = converted %s.ref, %.loc15_21.2 +// CHECK:STDOUT: %.loc15_21.4: ref %Dest = temporary %.loc15_21.1, %.loc15_21.3 +// CHECK:STDOUT: %.loc15_21.5: %Dest = acquire_value %.loc15_21.4 +// CHECK:STDOUT: %_: %Dest = value_binding _, %.loc15_21.5 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc15_21.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc15_21.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp(%self.param: %Dest) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_access.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %Source: type = class_type @Source [concrete] +// CHECK:STDOUT: %InaccessibleConstructor: type = class_type @InaccessibleConstructor [concrete] +// CHECK:STDOUT: %pattern_type.b73: type = pattern_type %InaccessibleConstructor [concrete] +// CHECK:STDOUT: %ptr.1fc: type = ptr_type %Source [concrete] +// CHECK:STDOUT: %ptr.12d: type = ptr_type %InaccessibleConstructor [concrete] +// CHECK:STDOUT: %InaccessibleConstructor__carbon_thunk.type: type = fn_type @InaccessibleConstructor__carbon_thunk [concrete] +// CHECK:STDOUT: %InaccessibleConstructor__carbon_thunk: %InaccessibleConstructor__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %InaccessibleConstructor.cpp_destructor.type: type = fn_type @InaccessibleConstructor.cpp_destructor [concrete] +// CHECK:STDOUT: %InaccessibleConstructor.cpp_destructor: %InaccessibleConstructor.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: %InaccessibleConversion: type = class_type @InaccessibleConversion [concrete] +// CHECK:STDOUT: %pattern_type.510: type = pattern_type %InaccessibleConversion [concrete] +// CHECK:STDOUT: %Dest: type = class_type @Dest [concrete] +// CHECK:STDOUT: %pattern_type.69a: type = pattern_type %Dest [concrete] +// CHECK:STDOUT: %InaccessibleConversion.cpp_operator.type: type = fn_type @InaccessibleConversion.cpp_operator [concrete] +// CHECK:STDOUT: %InaccessibleConversion.cpp_operator: %InaccessibleConversion.cpp_operator.type = struct_value () [concrete] +// CHECK:STDOUT: %ptr.551: type = ptr_type %Dest [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk.type: type = fn_type @Dest__carbon_thunk [concrete] +// CHECK:STDOUT: %Dest__carbon_thunk: %Dest__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor.type: type = fn_type @Dest.cpp_destructor [concrete] +// CHECK:STDOUT: %Dest.cpp_destructor: %Dest.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Source = %Source.decl +// CHECK:STDOUT: .InaccessibleConstructor = %InaccessibleConstructor.decl +// CHECK:STDOUT: .InaccessibleConversion = %InaccessibleConversion.decl +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.decl: type = class_decl @Source [concrete = constants.%Source] {} {} +// CHECK:STDOUT: %InaccessibleConstructor.decl: type = class_decl @InaccessibleConstructor [concrete = constants.%InaccessibleConstructor] {} {} +// CHECK:STDOUT: %InaccessibleConstructor__carbon_thunk.decl: %InaccessibleConstructor__carbon_thunk.type = fn_decl @InaccessibleConstructor__carbon_thunk [concrete = constants.%InaccessibleConstructor__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %InaccessibleConversion.decl: type = class_decl @InaccessibleConversion [concrete = constants.%InaccessibleConversion] {} {} +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest] {} {} +// CHECK:STDOUT: %InaccessibleConversion.cpp_operator.decl: %InaccessibleConversion.cpp_operator.type = fn_decl @InaccessibleConversion.cpp_operator [concrete = constants.%InaccessibleConversion.cpp_operator] { +// CHECK:STDOUT: %self.patt: %pattern_type.510 = value_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.510 = value_param_pattern %self.patt, call_param0 [concrete] +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: %self.param: %InaccessibleConversion = value_param call_param0 +// CHECK:STDOUT: %self: %InaccessibleConversion = value_binding self, %self.param +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: %Dest__carbon_thunk.decl: %Dest__carbon_thunk.type = fn_decl @Dest__carbon_thunk [concrete = constants.%Dest__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @InaccessibleConstructorTest(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.b73 = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %.loc16_13: type = splice_block %InaccessibleConstructor.ref [concrete = constants.%InaccessibleConstructor] { +// CHECK:STDOUT: %Cpp.ref.loc16: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %InaccessibleConstructor.ref: type = name_ref InaccessibleConstructor, imports.%InaccessibleConstructor.decl [concrete = constants.%InaccessibleConstructor] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc16_40.1: ref %InaccessibleConstructor = temporary_storage +// CHECK:STDOUT: %.loc16_40.2: ref %Source = value_as_ref %s.ref +// CHECK:STDOUT: %addr.loc16_40.1: %ptr.1fc = addr_of %.loc16_40.2 +// CHECK:STDOUT: %addr.loc16_40.2: %ptr.12d = addr_of %.loc16_40.1 +// CHECK:STDOUT: %InaccessibleConstructor__carbon_thunk.call: init %empty_tuple.type = call imports.%InaccessibleConstructor__carbon_thunk.decl(%addr.loc16_40.1, %addr.loc16_40.2) +// CHECK:STDOUT: %.loc16_40.3: init %InaccessibleConstructor to %.loc16_40.1 = in_place_init %InaccessibleConstructor__carbon_thunk.call +// CHECK:STDOUT: %.loc16_40.4: init %InaccessibleConstructor = converted %s.ref, %.loc16_40.3 +// CHECK:STDOUT: %.loc16_40.5: ref %InaccessibleConstructor = temporary %.loc16_40.1, %.loc16_40.4 +// CHECK:STDOUT: %.loc16_40.6: %InaccessibleConstructor = acquire_value %.loc16_40.5 +// CHECK:STDOUT: %_: %InaccessibleConstructor = value_binding _, %.loc16_40.6 +// CHECK:STDOUT: %InaccessibleConstructor.cpp_destructor.bound: = bound_method %.loc16_40.5, constants.%InaccessibleConstructor.cpp_destructor +// CHECK:STDOUT: %InaccessibleConstructor.cpp_destructor.call: init %empty_tuple.type = call %InaccessibleConstructor.cpp_destructor.bound(%.loc16_40.5) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc16(%self.param: %InaccessibleConstructor) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: fn @InaccessibleConversionTest(%s.param: %InaccessibleConversion) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %InaccessibleConversion = name_ref s, %s +// CHECK:STDOUT: %.loc30_13: type = splice_block %Dest.ref [concrete = constants.%Dest] { +// CHECK:STDOUT: %Cpp.ref.loc30: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest] +// CHECK:STDOUT: } +// CHECK:STDOUT: %InaccessibleConversion.cpp_operator.bound: = bound_method %s.ref, imports.%InaccessibleConversion.cpp_operator.decl +// CHECK:STDOUT: %.loc30_21.1: ref %Dest = temporary_storage +// CHECK:STDOUT: %addr: %ptr.551 = addr_of %.loc30_21.1 +// CHECK:STDOUT: %Dest__carbon_thunk.call: init %empty_tuple.type = call imports.%Dest__carbon_thunk.decl(%s.ref, %addr) +// CHECK:STDOUT: %.loc30_21.2: init %Dest to %.loc30_21.1 = in_place_init %Dest__carbon_thunk.call +// CHECK:STDOUT: %.loc30_21.3: init %Dest = converted %s.ref, %.loc30_21.2 +// CHECK:STDOUT: %.loc30_21.4: ref %Dest = temporary %.loc30_21.1, %.loc30_21.3 +// CHECK:STDOUT: %.loc30_21.5: %Dest = acquire_value %.loc30_21.4 +// CHECK:STDOUT: %_: %Dest = value_binding _, %.loc30_21.5 +// CHECK:STDOUT: %Dest.cpp_destructor.bound: = bound_method %.loc30_21.4, constants.%Dest.cpp_destructor +// CHECK:STDOUT: %Dest.cpp_destructor.call: init %empty_tuple.type = call %Dest.cpp_destructor.bound(%.loc30_21.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp.loc30(%self.param: %Dest) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_deleted.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Source: type = class_type @Source [concrete] +// CHECK:STDOUT: %DeletedConstructor: type = class_type @DeletedConstructor [concrete] +// CHECK:STDOUT: %pattern_type.158: type = pattern_type %DeletedConstructor [concrete] +// CHECK:STDOUT: %DeletedConversion: type = class_type @DeletedConversion [concrete] +// CHECK:STDOUT: %Dest.5e7: type = class_type @Dest [concrete] +// CHECK:STDOUT: %pattern_type.69a: type = pattern_type %Dest.5e7 [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Source = %Source.decl +// CHECK:STDOUT: .DeletedConstructor = %DeletedConstructor.decl +// CHECK:STDOUT: .DeletedConversion = %DeletedConversion.decl +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.decl: type = class_decl @Source [concrete = constants.%Source] {} {} +// CHECK:STDOUT: %DeletedConstructor.decl: type = class_decl @DeletedConstructor [concrete = constants.%DeletedConstructor] {} {} +// CHECK:STDOUT: %DeletedConversion.decl: type = class_decl @DeletedConversion [concrete = constants.%DeletedConversion] {} {} +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest.5e7] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DeletedConstructorTest(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.158 = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %.loc15_13: type = splice_block %DeletedConstructor.ref [concrete = constants.%DeletedConstructor] { +// CHECK:STDOUT: %Cpp.ref.loc15: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %DeletedConstructor.ref: type = name_ref DeletedConstructor, imports.%DeletedConstructor.decl [concrete = constants.%DeletedConstructor] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc15_35: %DeletedConstructor = converted %s.ref, [concrete = ] +// CHECK:STDOUT: %_: %DeletedConstructor = value_binding _, [concrete = ] +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DeletedConversionTest(%s.param: %DeletedConversion) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %DeletedConversion = name_ref s, %s +// CHECK:STDOUT: %.loc28_13: type = splice_block %Dest.ref [concrete = constants.%Dest.5e7] { +// CHECK:STDOUT: %Cpp.ref.loc28: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest.5e7] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc28_21: %Dest.5e7 = converted %s.ref, [concrete = ] +// CHECK:STDOUT: %_: %Dest.5e7 = value_binding _, [concrete = ] +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_explicit.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Source: type = class_type @Source [concrete] +// CHECK:STDOUT: %ExplicitConstructor: type = class_type @ExplicitConstructor [concrete] +// CHECK:STDOUT: %pattern_type.1eb: type = pattern_type %ExplicitConstructor [concrete] +// CHECK:STDOUT: %ExplicitConversion: type = class_type @ExplicitConversion [concrete] +// CHECK:STDOUT: %Dest.5e7: type = class_type @Dest [concrete] +// CHECK:STDOUT: %pattern_type.69a: type = pattern_type %Dest.5e7 [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Source = %Source.decl +// CHECK:STDOUT: .ExplicitConstructor = %ExplicitConstructor.decl +// CHECK:STDOUT: .ExplicitConversion = %ExplicitConversion.decl +// CHECK:STDOUT: .Dest = %Dest.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Source.decl: type = class_decl @Source [concrete = constants.%Source] {} {} +// CHECK:STDOUT: %ExplicitConstructor.decl: type = class_decl @ExplicitConstructor [concrete = constants.%ExplicitConstructor] {} {} +// CHECK:STDOUT: %ExplicitConversion.decl: type = class_decl @ExplicitConversion [concrete = constants.%ExplicitConversion] {} {} +// CHECK:STDOUT: %Dest.decl: type = class_decl @Dest [concrete = constants.%Dest.5e7] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ExplicitConstructorTest(%s.param: %Source) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.1eb = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %Source = name_ref s, %s +// CHECK:STDOUT: %.loc15_13: type = splice_block %ExplicitConstructor.ref [concrete = constants.%ExplicitConstructor] { +// CHECK:STDOUT: %Cpp.ref.loc15: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %ExplicitConstructor.ref: type = name_ref ExplicitConstructor, imports.%ExplicitConstructor.decl [concrete = constants.%ExplicitConstructor] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc15_36: %ExplicitConstructor = converted %s.ref, [concrete = ] +// CHECK:STDOUT: %_: %ExplicitConstructor = value_binding _, [concrete = ] +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ExplicitConversionTest(%s.param: %ExplicitConversion) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.69a = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %s.ref: %ExplicitConversion = name_ref s, %s +// CHECK:STDOUT: %.loc28_13: type = splice_block %Dest.ref [concrete = constants.%Dest.5e7] { +// CHECK:STDOUT: %Cpp.ref.loc28: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Dest.ref: type = name_ref Dest, imports.%Dest.decl [concrete = constants.%Dest.5e7] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc28_21: %Dest.5e7 = converted %s.ref, [concrete = ] +// CHECK:STDOUT: %_: %Dest.5e7 = value_binding _, [concrete = ] +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- i32_to_int.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] +// CHECK:STDOUT: %IntConstructor.f49: type = class_type @IntConstructor.1 [concrete] +// CHECK:STDOUT: %pattern_type.3c3: type = pattern_type %IntConstructor.f49 [concrete] +// CHECK:STDOUT: %ptr.d59: type = ptr_type %IntConstructor.f49 [concrete] +// CHECK:STDOUT: %IntConstructor__carbon_thunk.type: type = fn_type @IntConstructor__carbon_thunk [concrete] +// CHECK:STDOUT: %IntConstructor__carbon_thunk: %IntConstructor__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %IntConstructor.cpp_destructor.type: type = fn_type @IntConstructor.cpp_destructor [concrete] +// CHECK:STDOUT: %IntConstructor.cpp_destructor: %IntConstructor.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .IntConstructor = %IntConstructor.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %IntConstructor.decl: type = class_decl @IntConstructor.1 [concrete = constants.%IntConstructor.f49] {} {} +// CHECK:STDOUT: %IntConstructor__carbon_thunk.decl: %IntConstructor__carbon_thunk.type = fn_decl @IntConstructor__carbon_thunk [concrete = constants.%IntConstructor__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @IntConstructor.loc6(%i.param: %i32) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.3c3 = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %i.ref: %i32 = name_ref i, %i +// CHECK:STDOUT: %.loc8_13: type = splice_block %IntConstructor.ref [concrete = constants.%IntConstructor.f49] { +// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %IntConstructor.ref: type = name_ref IntConstructor, imports.%IntConstructor.decl [concrete = constants.%IntConstructor.f49] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc8_31.1: ref %IntConstructor.f49 = temporary_storage +// CHECK:STDOUT: %addr: %ptr.d59 = addr_of %.loc8_31.1 +// CHECK:STDOUT: %IntConstructor__carbon_thunk.call: init %empty_tuple.type = call imports.%IntConstructor__carbon_thunk.decl(%i.ref, %addr) +// CHECK:STDOUT: %.loc8_31.2: init %IntConstructor.f49 to %.loc8_31.1 = in_place_init %IntConstructor__carbon_thunk.call +// CHECK:STDOUT: %.loc8_31.3: init %IntConstructor.f49 = converted %i.ref, %.loc8_31.2 +// CHECK:STDOUT: %.loc8_31.4: ref %IntConstructor.f49 = temporary %.loc8_31.1, %.loc8_31.3 +// CHECK:STDOUT: %.loc8_31.5: %IntConstructor.f49 = acquire_value %.loc8_31.4 +// CHECK:STDOUT: %_: %IntConstructor.f49 = value_binding _, %.loc8_31.5 +// CHECK:STDOUT: %IntConstructor.cpp_destructor.bound: = bound_method %.loc8_31.4, constants.%IntConstructor.cpp_destructor +// CHECK:STDOUT: %IntConstructor.cpp_destructor.call: init %empty_tuple.type = call %IntConstructor.cpp_destructor.bound(%.loc8_31.4) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp(%self.param: %IntConstructor.f49) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_no_u32_to_int_conversion_in_carbon.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] +// CHECK:STDOUT: %u32: type = class_type @UInt, @UInt(%int_32) [concrete] +// CHECK:STDOUT: %IntConstructor: type = class_type @IntConstructor [concrete] +// CHECK:STDOUT: %pattern_type.3c3: type = pattern_type %IntConstructor [concrete] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] +// CHECK:STDOUT: %ptr.d59: type = ptr_type %IntConstructor [concrete] +// CHECK:STDOUT: %IntConstructor__carbon_thunk.type: type = fn_type @IntConstructor__carbon_thunk [concrete] +// CHECK:STDOUT: %IntConstructor__carbon_thunk: %IntConstructor__carbon_thunk.type = struct_value () [concrete] +// CHECK:STDOUT: %IntConstructor.cpp_destructor.type: type = fn_type @IntConstructor.cpp_destructor [concrete] +// CHECK:STDOUT: %IntConstructor.cpp_destructor: %IntConstructor.cpp_destructor.type = struct_value () [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .IntConstructor = %IntConstructor.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %IntConstructor.decl: type = class_decl @IntConstructor [concrete = constants.%IntConstructor] {} {} +// CHECK:STDOUT: %IntConstructor__carbon_thunk.decl: %IntConstructor__carbon_thunk.type = fn_decl @IntConstructor__carbon_thunk [concrete = constants.%IntConstructor__carbon_thunk] { +// CHECK:STDOUT: +// CHECK:STDOUT: } { +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @IntConstructorTest(%u.param: %u32) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type.3c3 = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %u.ref: %u32 = name_ref u, %u +// CHECK:STDOUT: %.loc19_13: type = splice_block %IntConstructor.ref [concrete = constants.%IntConstructor] { +// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %IntConstructor.ref: type = name_ref IntConstructor, imports.%IntConstructor.decl [concrete = constants.%IntConstructor] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc19_31.1: ref %IntConstructor = temporary_storage +// CHECK:STDOUT: %.loc19_31.2: %i32 = converted %u.ref, [concrete = ] +// CHECK:STDOUT: %addr: %ptr.d59 = addr_of %.loc19_31.1 +// CHECK:STDOUT: %IntConstructor__carbon_thunk.call: init %empty_tuple.type = call imports.%IntConstructor__carbon_thunk.decl(, %addr) +// CHECK:STDOUT: %.loc19_31.3: init %IntConstructor to %.loc19_31.1 = in_place_init %IntConstructor__carbon_thunk.call +// CHECK:STDOUT: %.loc19_31.4: init %IntConstructor = converted %u.ref, %.loc19_31.3 +// CHECK:STDOUT: %.loc19_31.5: ref %IntConstructor = temporary %.loc19_31.1, %.loc19_31.4 +// CHECK:STDOUT: %.loc19_31.6: %IntConstructor = acquire_value %.loc19_31.5 +// CHECK:STDOUT: %_: %IntConstructor = value_binding _, %.loc19_31.6 +// CHECK:STDOUT: %IntConstructor.cpp_destructor.bound: = bound_method %.loc19_31.5, constants.%IntConstructor.cpp_destructor +// CHECK:STDOUT: %IntConstructor.cpp_destructor.call: init %empty_tuple.type = call %IntConstructor.cpp_destructor.bound(%.loc19_31.5) +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @DestroyOp(%self.param: %IntConstructor) = "no_op"; +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_todo_construct_multi_argument.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %Two: type = class_type @Two [concrete] +// CHECK:STDOUT: %pattern_type: type = pattern_type %Two [concrete] +// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete] +// CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [concrete] +// CHECK:STDOUT: %tuple.type: type = tuple_type (Core.IntLiteral, Core.IntLiteral) [concrete] +// CHECK:STDOUT: %tuple: %tuple.type = tuple_value (%int_1, %int_2) [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Cpp: = namespace file.%Cpp.import_cpp, [concrete] { +// CHECK:STDOUT: .Two = %Two.decl +// CHECK:STDOUT: import Cpp//... +// CHECK:STDOUT: } +// CHECK:STDOUT: %Two.decl: type = class_decl @Two [concrete = constants.%Two] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @ImplicitConvert() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %_.patt: %pattern_type = value_binding_pattern _ [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1] +// CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [concrete = constants.%int_2] +// CHECK:STDOUT: %.loc14_25.1: %tuple.type = tuple_literal (%int_1, %int_2) [concrete = constants.%tuple] +// CHECK:STDOUT: %.loc14_13: type = splice_block %Two.ref [concrete = constants.%Two] { +// CHECK:STDOUT: %Cpp.ref: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] +// CHECK:STDOUT: %Two.ref: type = name_ref Two, imports.%Two.decl [concrete = constants.%Two] +// CHECK:STDOUT: } +// CHECK:STDOUT: %.loc14_25.2: %Two = converted %.loc14_25.1, [concrete = ] +// CHECK:STDOUT: %_: %Two = value_binding _, [concrete = ] +// CHECK:STDOUT: +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/lower/file_context.cpp b/toolchain/lower/file_context.cpp index a0b617d366d2..c244226d4cef 100644 --- a/toolchain/lower/file_context.cpp +++ b/toolchain/lower/file_context.cpp @@ -1187,8 +1187,21 @@ auto FileContext::BuildGlobalVariableDecl(SemIR::VarStorage var_storage) } auto FileContext::GetLocForDI(SemIR::InstId inst_id) -> Context::LocForDI { - return context().GetLocForDI( - GetAbsoluteNodeId(sem_ir_, SemIR::LocId(inst_id)).back()); + auto abs_node_id = GetAbsoluteNodeId(sem_ir_, SemIR::LocId(inst_id)).back(); + + if (abs_node_id.check_ir_id() == SemIR::CheckIRId::Cpp) { + // TODO: Consider asking our cpp_code_generator to map the location to a + // debug location, in order to use Clang's rules for (eg) macro handling. + auto loc = + sem_ir().clang_source_locs().Get(abs_node_id.clang_source_loc_id()); + auto presumed_loc = + sem_ir().cpp_file()->source_manager().getPresumedLoc(loc); + return {.filename = presumed_loc.getFilename(), + .line_number = static_cast(presumed_loc.getLine()), + .column_number = static_cast(presumed_loc.getColumn())}; + } + + return context().GetLocForDI(abs_node_id); } auto FileContext::BuildVtable(const SemIR::Vtable& vtable, diff --git a/toolchain/lower/testdata/interop/cpp/constructor.carbon b/toolchain/lower/testdata/interop/cpp/constructor.carbon index 4e7dbf7ad776..ed2e99a90c6e 100644 --- a/toolchain/lower/testdata/interop/cpp/constructor.carbon +++ b/toolchain/lower/testdata/interop/cpp/constructor.carbon @@ -188,8 +188,8 @@ fn F() { // CHECK:STDOUT: ; Function Attrs: alwaysinline nounwind // CHECK:STDOUT: define void @"_COp:thunk.Copy.Cpp"(ptr sret([4 x i8]) %return, ptr %self) #3 !dbg !23 { // CHECK:STDOUT: entry: -// CHECK:STDOUT: call void @_ZN4CopyC1ERKS_.carbon_thunk(ptr %self, ptr %return), !dbg !26 -// CHECK:STDOUT: ret void, !dbg !26 +// CHECK:STDOUT: call void @_ZN4CopyC1ERKS_.carbon_thunk(ptr %self, ptr %return), !dbg !27 +// CHECK:STDOUT: ret void, !dbg !27 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) @@ -228,10 +228,11 @@ fn F() { // CHECK:STDOUT: !20 = !DILocalVariable(arg: 1, scope: !15, type: !18) // CHECK:STDOUT: !21 = !DILocation(line: 7, column: 10, scope: !15) // CHECK:STDOUT: !22 = !DILocation(line: 7, column: 3, scope: !15) -// CHECK:STDOUT: !23 = distinct !DISubprogram(name: "Op", linkageName: "_COp:thunk.Copy.Cpp", scope: null, file: !7, type: !16, spFlags: DISPFlagDefinition, unit: !6, retainedNodes: !24) -// CHECK:STDOUT: !24 = !{!25} -// CHECK:STDOUT: !25 = !DILocalVariable(arg: 1, scope: !23, type: !18) -// CHECK:STDOUT: !26 = !DILocation(line: 0, scope: !23) +// CHECK:STDOUT: !23 = distinct !DISubprogram(name: "Op", linkageName: "_COp:thunk.Copy.Cpp", scope: null, file: !24, line: 5, type: !16, spFlags: DISPFlagDefinition, unit: !6, retainedNodes: !25) +// CHECK:STDOUT: !24 = !DIFile(filename: "./copy.h", directory: "") +// CHECK:STDOUT: !25 = !{!26} +// CHECK:STDOUT: !26 = !DILocalVariable(arg: 1, scope: !23, type: !18) +// CHECK:STDOUT: !27 = !DILocation(line: 5, column: 3, scope: !23) // CHECK:STDOUT: ; ModuleID = 'call_c1_in_thunk.carbon' // CHECK:STDOUT: source_filename = "call_c1_in_thunk.carbon" // CHECK:STDOUT: target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"