diff --git a/toolchain/check/cpp/import.cpp b/toolchain/check/cpp/import.cpp index c013b4f7ea83..b1e211f27136 100644 --- a/toolchain/check/cpp/import.cpp +++ b/toolchain/check/cpp/import.cpp @@ -1342,10 +1342,8 @@ namespace { struct ParameterTypeInfo { // The type to use for the Carbon parameter. TypeExpr type; - // Whether to build an `addr` pattern. - bool want_addr_pattern; - // If building an `addr` pattern, the type matched by that pattern. - TypeExpr pointee_type; + // Whether to build a `ref` pattern. + bool want_ref_pattern; }; } // namespace @@ -1355,17 +1353,13 @@ struct ParameterTypeInfo { // Note that if the parameter has a type for which `IsSimpleAbiType` returns // true, we must produce a parameter type that has the same calling convention // as the C++ type. -// -// TODO: Use `ref` instead of `addr`. static auto MapParameterType(Context& context, SemIR::LocId loc_id, clang::QualType param_type) -> ParameterTypeInfo { - ParameterTypeInfo info = {.type = TypeExpr::None, - .want_addr_pattern = false, - .pointee_type = TypeExpr::None}; + ParameterTypeInfo info = {.type = TypeExpr::None, .want_ref_pattern = false}; // Perform some custom mapping for parameters of reference type: // - // * `T& x` -> `addr x: T*`. + // * `T& x` -> `ref x: T`. // * `const T& x` -> `x: T`. // * `T&& x` -> `x: T`. // @@ -1381,37 +1375,17 @@ static auto MapParameterType(Context& context, SemIR::LocId loc_id, split_type.Quals.removeConst(); pointee_type = context.ast_context().getQualifiedType(split_type); } else { - // The reference will map to a pointer. Request an `addr` pattern. - info.want_addr_pattern = true; + // The reference will map to a `ref` pattern. + info.want_ref_pattern = true; } } param_type = pointee_type; } info.type = MapType(context, loc_id, param_type); - if (info.want_addr_pattern && info.type.inst_id.has_value()) { - info.pointee_type = info.type; - info.type = TypeExpr::ForUnsugared( - context, GetPointerType(context, info.pointee_type.inst_id)); - } return info; } -// Finishes building the pattern to use for a function parameter, given the -// binding pattern and information about how the parameter is being mapped into -// Carbon. -static auto FinishParameterPattern(Context& context, SemIR::InstId pattern_id, - ParameterTypeInfo info) -> SemIR::InstId { - if (!info.want_addr_pattern || pattern_id == SemIR::ErrorInst::InstId) { - return pattern_id; - } - return AddPatternInst( - context, {SemIR::LocId(pattern_id), - SemIR::AddrPattern({.type_id = GetPatternType( - context, info.pointee_type.type_id), - .inner_id = pattern_id})}); -} - // Returns a block for the implicit parameters of the given function // declaration. Because function templates are not yet supported, this currently // only contains the `self` parameter. On error, produces a diagnostic and @@ -1443,9 +1417,9 @@ static auto MakeImplicitParamPatternsBlockId( } // TODO: Fill in a location once available. - auto pattern_id = - AddSelfParamPattern(context, loc_id, type_expr_region_id, type_id); - pattern_id = FinishParameterPattern(context, pattern_id, param_info); + auto pattern_id = AddParamPattern(context, loc_id, SemIR::NameId::SelfValue, + type_expr_region_id, type_id, + param_info.want_ref_pattern); return context.inst_blocks().Add({pattern_id}); } @@ -1508,21 +1482,10 @@ static auto MakeParamPatternsBlockId(Context& context, SemIR::LocId loc_id, SemIR::LocId param_loc_id = AddImportIRInst(context.sem_ir(), param->getLocation()); - // TODO: Fix this once templates are supported. - bool is_template = false; - // TODO: Model reference parameters as ref bindings. + // TODO: Add template support. SemIR::InstId pattern_id = - AddBindingPattern(context, param_loc_id, name_id, type_id, - type_expr_region_id, SemIR::ValueBindingPattern::Kind, - is_template) - .pattern_id; - pattern_id = AddPatternInst( - context, {param_loc_id, - SemIR::ValueParamPattern( - {.type_id = context.insts().Get(pattern_id).type_id(), - .subpattern_id = pattern_id, - .index = SemIR::CallParamIndex::None})}); - pattern_id = FinishParameterPattern(context, pattern_id, param_info); + AddParamPattern(context, param_loc_id, name_id, type_expr_region_id, + type_id, param_info.want_ref_pattern); params.push_back(pattern_id); } return context.inst_blocks().Add(params); diff --git a/toolchain/check/cpp/thunk.h b/toolchain/check/cpp/thunk.h index 0256e70b4c48..80c4ee03637b 100644 --- a/toolchain/check/cpp/thunk.h +++ b/toolchain/check/cpp/thunk.h @@ -11,8 +11,9 @@ namespace Carbon::Check { // Returns whether the given C++ imported function requires a C++ thunk to be -// used to call it. A C++ thunk is required for functions that use any type -// except void, pointer types and signed 32-bit and 64-bit integers. +// used to call it. A C++ thunk is required for functions whose ABI uses any +// type except void, pointer and reference types, and signed 32-bit and 64-bit +// integers. auto IsCppThunkRequired(Context& context, const SemIR::Function& function) -> bool; diff --git a/toolchain/check/pattern.cpp b/toolchain/check/pattern.cpp index 4d19bcd47e7b..1689f19adeb5 100644 --- a/toolchain/check/pattern.cpp +++ b/toolchain/check/pattern.cpp @@ -139,20 +139,28 @@ auto AddPatternVarStorage(Context& context, SemIR::InstBlockId pattern_block_id, } } -auto AddSelfParamPattern(Context& context, SemIR::LocId loc_id, - SemIR::ExprRegionId type_expr_region_id, - SemIR::TypeId type_id) -> SemIR::InstId { +auto AddParamPattern(Context& context, SemIR::LocId loc_id, + SemIR::NameId name_id, + SemIR::ExprRegionId type_expr_region_id, + SemIR::TypeId type_id, bool is_ref) -> SemIR::InstId { + const auto& binding_pattern_kind = is_ref ? SemIR::RefBindingPattern::Kind + : SemIR::ValueBindingPattern::Kind; SemIR::InstId pattern_id = - AddBindingPattern(context, loc_id, SemIR::NameId::SelfValue, type_id, - type_expr_region_id, SemIR::ValueBindingPattern::Kind, + AddBindingPattern(context, loc_id, name_id, type_id, type_expr_region_id, + binding_pattern_kind, /*is_template=*/false) .pattern_id; - pattern_id = AddPatternInst( - context, loc_id, - {.type_id = context.insts().Get(pattern_id).type_id(), - .subpattern_id = pattern_id, - .index = SemIR::CallParamIndex::None}); + const auto& param_pattern_kind = + is_ref ? SemIR::RefParamPattern::Kind : SemIR::ValueParamPattern::Kind; + pattern_id = AddPatternInst( + context, + SemIR::LocIdAndInst::UncheckedLoc( + loc_id, SemIR::AnyParamPattern{ + .kind = param_pattern_kind, + .type_id = context.insts().Get(pattern_id).type_id(), + .subpattern_id = pattern_id, + .index = SemIR::CallParamIndex::None})); return pattern_id; } diff --git a/toolchain/check/pattern.h b/toolchain/check/pattern.h index 216e9579dfc3..6e254d4b442e 100644 --- a/toolchain/check/pattern.h +++ b/toolchain/check/pattern.h @@ -51,13 +51,16 @@ auto AddBindingPattern(Context& context, SemIR::LocId name_loc, auto AddPatternVarStorage(Context& context, SemIR::InstBlockId pattern_block_id, bool is_returned_var) -> void; -// Adds a `self` parameter pattern with the specified type information. This -// only sets up the binding pattern and type; callers are expected to add the -// returned instruction to appropriate blocks. This is used when generating -// functions, rather than processing a user-authored `self: Self`. -auto AddSelfParamPattern(Context& context, SemIR::LocId loc_id, - SemIR::ExprRegionId type_expr_region_id, - SemIR::TypeId type_id) -> SemIR::InstId; +// Adds a parameter pattern with the specified name and type information. The +// pattern emulates `x: T` or `ref x: T` depending on the value of +// `is_ref` (`var x: T` is not supported). This only sets up the parameter +// pattern, binding pattern and type; callers are expected to add the returned +// parameter pattern instruction to appropriate blocks. This is used when +// generating functions, rather than processing a user-authored declaration. +auto AddParamPattern(Context& context, SemIR::LocId loc_id, + SemIR::NameId name_id, + SemIR::ExprRegionId type_expr_region_id, + SemIR::TypeId type_id, bool is_ref) -> SemIR::InstId; } // namespace Carbon::Check diff --git a/toolchain/check/testdata/interop/cpp/builtins.carbon b/toolchain/check/testdata/interop/cpp/builtins.carbon index c7d1c011cb82..3928ee4b6d15 100644 --- a/toolchain/check/testdata/interop/cpp/builtins.carbon +++ b/toolchain/check/testdata/interop/cpp/builtins.carbon @@ -551,14 +551,13 @@ fn F() { // CHECK:STDOUT: %pattern_type.4a9: type = pattern_type %u32 [concrete] // CHECK:STDOUT: %unsigned_int.foo.cpp_overload_set.type: type = cpp_overload_set_type @unsigned_int.foo.cpp_overload_set [concrete] // CHECK:STDOUT: %unsigned_int.foo.cpp_overload_set.value: %unsigned_int.foo.cpp_overload_set.type = cpp_overload_set_value @unsigned_int.foo.cpp_overload_set [concrete] -// CHECK:STDOUT: %ptr.d47: type = ptr_type %unsigned_int [concrete] -// CHECK:STDOUT: %pattern_type.539: type = pattern_type %ptr.d47 [concrete] // CHECK:STDOUT: %unsigned_int.foo.type: type = fn_type @unsigned_int.foo [concrete] // CHECK:STDOUT: %unsigned_int.foo: %unsigned_int.foo.type = struct_value () [concrete] // CHECK:STDOUT: %type_where: type = facet_type > [concrete] // CHECK:STDOUT: %facet_value: %type_where = facet_value %unsigned_int, () [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.420: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.b85: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.420 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.d47: type = ptr_type %unsigned_int [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -569,14 +568,13 @@ fn F() { // CHECK:STDOUT: %unsigned_int.decl: type = class_decl @unsigned_int [concrete = constants.%unsigned_int] {} {} // CHECK:STDOUT: %unsigned_int.foo.cpp_overload_set.value: %unsigned_int.foo.cpp_overload_set.type = cpp_overload_set_value @unsigned_int.foo.cpp_overload_set [concrete = constants.%unsigned_int.foo.cpp_overload_set.value] // CHECK:STDOUT: %unsigned_int.foo.decl: %unsigned_int.foo.type = fn_decl @unsigned_int.foo [concrete = constants.%unsigned_int.foo] { -// CHECK:STDOUT: %self.patt: %pattern_type.539 = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.539 = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc13: %pattern_type.5ec = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.5ec = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.5ec = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: // CHECK:STDOUT: } { // CHECK:STDOUT: -// CHECK:STDOUT: %self.param: %ptr.d47 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.d47 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %unsigned_int = ref_param call_param0 +// CHECK:STDOUT: %self: ref %unsigned_int = ref_binding self, %self.param // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: } @@ -599,8 +597,7 @@ fn F() { // CHECK:STDOUT: %unsigned_int.ref.loc13: ref %unsigned_int = name_ref unsigned_int, %unsigned_int // CHECK:STDOUT: %foo.ref: %unsigned_int.foo.cpp_overload_set.type = name_ref foo, imports.%unsigned_int.foo.cpp_overload_set.value [concrete = constants.%unsigned_int.foo.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc13: = bound_method %unsigned_int.ref.loc13, %foo.ref -// CHECK:STDOUT: %addr.loc13: %ptr.d47 = addr_of %unsigned_int.ref.loc13 -// CHECK:STDOUT: %unsigned_int.foo.call: init %u32 = call imports.%unsigned_int.foo.decl(%addr.loc13) +// CHECK:STDOUT: %unsigned_int.foo.call: init %u32 = call imports.%unsigned_int.foo.decl(%unsigned_int.ref.loc13) // CHECK:STDOUT: %.loc13_10: type = splice_block %u32 [concrete = constants.%u32] { // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] // CHECK:STDOUT: %u32: type = class_type @UInt, @UInt(constants.%int_32) [concrete = constants.%u32] @@ -611,8 +608,8 @@ fn F() { // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %unsigned_int.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.b85 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method.loc12: = bound_method %unsigned_int.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn -// CHECK:STDOUT: %addr.loc12: %ptr.d47 = addr_of %unsigned_int.var -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc12(%addr.loc12) +// CHECK:STDOUT: %addr: %ptr.d47 = addr_of %unsigned_int.var +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc12(%addr) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/class/access.carbon b/toolchain/check/testdata/interop/cpp/class/access.carbon index f979bd301003..9546e3bdc4f1 100644 --- a/toolchain/check/testdata/interop/cpp/class/access.carbon +++ b/toolchain/check/testdata/interop/cpp/class/access.carbon @@ -1754,7 +1754,6 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] // CHECK:STDOUT: %S: type = class_type @S [concrete] // CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] -// CHECK:STDOUT: %pattern_type.259: type = pattern_type %ptr.5c7 [concrete] // CHECK:STDOUT: %S.instance_fn.cpp_overload_set.type: type = cpp_overload_set_type @S.instance_fn.cpp_overload_set [concrete] // CHECK:STDOUT: %S.instance_fn.cpp_overload_set.value: %S.instance_fn.cpp_overload_set.type = cpp_overload_set_value @S.instance_fn.cpp_overload_set [concrete] // CHECK:STDOUT: %pattern_type.7da: type = pattern_type %S [concrete] @@ -1774,12 +1773,11 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %S.decl: type = class_decl @S [concrete = constants.%S] {} {} // CHECK:STDOUT: %S.instance_fn.cpp_overload_set.value: %S.instance_fn.cpp_overload_set.type = cpp_overload_set_value @S.instance_fn.cpp_overload_set [concrete = constants.%S.instance_fn.cpp_overload_set.value] // CHECK:STDOUT: %S.instance_fn.decl: %S.instance_fn.type = fn_decl @S.instance_fn [concrete = constants.%S.instance_fn] { -// CHECK:STDOUT: %self.patt: %pattern_type.259 = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.259 = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc8: %pattern_type.7da = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.7da = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.7da = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.5c7 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.5c7 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %S = ref_param call_param0 +// CHECK:STDOUT: %self: ref %S = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: %S.static_fn.cpp_overload_set.value: %S.static_fn.cpp_overload_set.type = cpp_overload_set_value @S.static_fn.cpp_overload_set [concrete = constants.%S.static_fn.cpp_overload_set.value] // CHECK:STDOUT: %S.static_fn.decl: %S.static_fn.type = fn_decl @S.static_fn [concrete = constants.%S.static_fn] {} {} @@ -1791,8 +1789,7 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %.loc8: ref %S = deref %s.ref // CHECK:STDOUT: %instance_fn.ref: %S.instance_fn.cpp_overload_set.type = name_ref instance_fn, imports.%S.instance_fn.cpp_overload_set.value [concrete = constants.%S.instance_fn.cpp_overload_set.value] // CHECK:STDOUT: %bound_method: = bound_method %.loc8, %instance_fn.ref -// CHECK:STDOUT: %addr: %ptr.5c7 = addr_of %.loc8 -// CHECK:STDOUT: %S.instance_fn.call: init %empty_tuple.type = call imports.%S.instance_fn.decl(%addr) +// CHECK:STDOUT: %S.instance_fn.call: init %empty_tuple.type = call imports.%S.instance_fn.decl(%.loc8) // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %S.ref.loc9: type = name_ref S, imports.%S.decl [concrete = constants.%S] // CHECK:STDOUT: %static_fn.ref: %S.static_fn.cpp_overload_set.type = name_ref static_fn, imports.%S.static_fn.cpp_overload_set.value [concrete = constants.%S.static_fn.cpp_overload_set.value] @@ -2527,12 +2524,9 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %Base.ProtectedStatic: %Base.ProtectedStatic.type = struct_value () [concrete] // CHECK:STDOUT: %Public.PublicInstance.cpp_overload_set.type: type = cpp_overload_set_type @Public.PublicInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %Public.PublicInstance.cpp_overload_set.value: %Public.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Public.PublicInstance.cpp_overload_set [concrete] -// CHECK:STDOUT: %ptr.fb2: type = ptr_type %Base [concrete] -// CHECK:STDOUT: %pattern_type.72a: type = pattern_type %ptr.fb2 [concrete] // CHECK:STDOUT: %pattern_type.a3a: type = pattern_type %Base [concrete] // CHECK:STDOUT: %Base.PublicInstance.type: type = fn_type @Base.PublicInstance [concrete] // CHECK:STDOUT: %Base.PublicInstance: %Base.PublicInstance.type = struct_value () [concrete] -// CHECK:STDOUT: %ptr.1e8: type = ptr_type %Public [concrete] // CHECK:STDOUT: %Public.ProtectedInstance.cpp_overload_set.type: type = cpp_overload_set_type @Public.ProtectedInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %Public.ProtectedInstance.cpp_overload_set.value: %Public.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Public.ProtectedInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %Base.ProtectedInstance.type: type = fn_type @Base.ProtectedInstance [concrete] @@ -2551,21 +2545,19 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %Base.ProtectedStatic.decl: %Base.ProtectedStatic.type = fn_decl @Base.ProtectedStatic [concrete = constants.%Base.ProtectedStatic] {} {} // CHECK:STDOUT: %Public.PublicInstance.cpp_overload_set.value: %Public.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Public.PublicInstance.cpp_overload_set [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %Base.PublicInstance.decl: %Base.PublicInstance.type = fn_decl @Base.PublicInstance [concrete = constants.%Base.PublicInstance] { -// CHECK:STDOUT: %self.patt: %pattern_type.72a = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.72a = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc24: %pattern_type.a3a = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.a3a = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.a3a = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.fb2 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.fb2 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %Base = ref_param call_param0 +// CHECK:STDOUT: %self: ref %Base = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: %Public.ProtectedInstance.cpp_overload_set.value: %Public.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Public.ProtectedInstance.cpp_overload_set [concrete = constants.%Public.ProtectedInstance.cpp_overload_set.value] // CHECK:STDOUT: %Base.ProtectedInstance.decl: %Base.ProtectedInstance.type = fn_decl @Base.ProtectedInstance [concrete = constants.%Base.ProtectedInstance] { -// CHECK:STDOUT: %self.patt: %pattern_type.72a = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.72a = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc26: %pattern_type.a3a = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.a3a = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.a3a = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.fb2 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.fb2 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %Base = ref_param call_param0 +// CHECK:STDOUT: %self: ref %Base = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2607,21 +2599,15 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %instance.ref.loc24: ref %Public = name_ref instance, %instance // CHECK:STDOUT: %PublicInstance.ref: %Public.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Public.PublicInstance.cpp_overload_set.value [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc24: = bound_method %instance.ref.loc24, %PublicInstance.ref -// CHECK:STDOUT: %addr.loc24_5.1: %ptr.1e8 = addr_of %instance.ref.loc24 -// CHECK:STDOUT: %.loc24_5.1: ref %Public = deref %addr.loc24_5.1 -// CHECK:STDOUT: %.loc24_5.2: ref %Base = class_element_access %.loc24_5.1, element0 -// CHECK:STDOUT: %addr.loc24_5.2: %ptr.fb2 = addr_of %.loc24_5.2 -// CHECK:STDOUT: %.loc24_5.3: %ptr.fb2 = converted %addr.loc24_5.1, %addr.loc24_5.2 -// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.3) +// CHECK:STDOUT: %.loc24_5.1: ref %Base = class_element_access %instance.ref.loc24, element0 +// CHECK:STDOUT: %.loc24_5.2: ref %Base = converted %instance.ref.loc24, %.loc24_5.1 +// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.2) // CHECK:STDOUT: %instance.ref.loc26: ref %Public = name_ref instance, %instance // CHECK:STDOUT: %ProtectedInstance.ref: %Public.ProtectedInstance.cpp_overload_set.type = name_ref ProtectedInstance, imports.%Public.ProtectedInstance.cpp_overload_set.value [concrete = constants.%Public.ProtectedInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc26: = bound_method %instance.ref.loc26, %ProtectedInstance.ref -// CHECK:STDOUT: %addr.loc26_5.1: %ptr.1e8 = addr_of %instance.ref.loc26 -// CHECK:STDOUT: %.loc26_5.1: ref %Public = deref %addr.loc26_5.1 -// CHECK:STDOUT: %.loc26_5.2: ref %Base = class_element_access %.loc26_5.1, element0 -// CHECK:STDOUT: %addr.loc26_5.2: %ptr.fb2 = addr_of %.loc26_5.2 -// CHECK:STDOUT: %.loc26_5.3: %ptr.fb2 = converted %addr.loc26_5.1, %addr.loc26_5.2 -// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.3) +// CHECK:STDOUT: %.loc26_5.1: ref %Base = class_element_access %instance.ref.loc26, element0 +// CHECK:STDOUT: %.loc26_5.2: ref %Base = converted %instance.ref.loc26, %.loc26_5.1 +// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.2) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2637,21 +2623,15 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %instance.ref.loc36: ref %Public = name_ref instance, %instance // CHECK:STDOUT: %PublicInstance.ref.loc36: %Public.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Public.PublicInstance.cpp_overload_set.value [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc36: = bound_method %instance.ref.loc36, %PublicInstance.ref.loc36 -// CHECK:STDOUT: %addr.loc36_3.1: %ptr.1e8 = addr_of %instance.ref.loc36 -// CHECK:STDOUT: %.loc36_3.1: ref %Public = deref %addr.loc36_3.1 -// CHECK:STDOUT: %.loc36_3.2: ref %Base = class_element_access %.loc36_3.1, element0 -// CHECK:STDOUT: %addr.loc36_3.2: %ptr.fb2 = addr_of %.loc36_3.2 -// CHECK:STDOUT: %.loc36_3.3: %ptr.fb2 = converted %addr.loc36_3.1, %addr.loc36_3.2 -// CHECK:STDOUT: %Base.PublicInstance.call.loc36: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc36_3.3) +// CHECK:STDOUT: %.loc36_3.1: ref %Base = class_element_access %instance.ref.loc36, element0 +// CHECK:STDOUT: %.loc36_3.2: ref %Base = converted %instance.ref.loc36, %.loc36_3.1 +// CHECK:STDOUT: %Base.PublicInstance.call.loc36: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc36_3.2) // CHECK:STDOUT: %instance.ref.loc37: ref %Public = name_ref instance, %instance // CHECK:STDOUT: %PublicInstance.ref.loc37: %Public.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Public.PublicInstance.cpp_overload_set.value [concrete = constants.%Public.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc37: = bound_method %instance.ref.loc37, %PublicInstance.ref.loc37 -// CHECK:STDOUT: %addr.loc37_3.1: %ptr.1e8 = addr_of %instance.ref.loc37 -// CHECK:STDOUT: %.loc37_3.1: ref %Public = deref %addr.loc37_3.1 -// CHECK:STDOUT: %.loc37_3.2: ref %Base = class_element_access %.loc37_3.1, element0 -// CHECK:STDOUT: %addr.loc37_3.2: %ptr.fb2 = addr_of %.loc37_3.2 -// CHECK:STDOUT: %.loc37_3.3: %ptr.fb2 = converted %addr.loc37_3.1, %addr.loc37_3.2 -// CHECK:STDOUT: %Base.PublicInstance.call.loc37: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc37_3.3) +// CHECK:STDOUT: %.loc37_3.1: ref %Base = class_element_access %instance.ref.loc37, element0 +// CHECK:STDOUT: %.loc37_3.2: ref %Base = converted %instance.ref.loc37, %.loc37_3.1 +// CHECK:STDOUT: %Base.PublicInstance.call.loc37: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc37_3.2) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2703,12 +2683,9 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %Base.ProtectedStatic: %Base.ProtectedStatic.type = struct_value () [concrete] // CHECK:STDOUT: %Protected.PublicInstance.cpp_overload_set.type: type = cpp_overload_set_type @Protected.PublicInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %Protected.PublicInstance.cpp_overload_set.value: %Protected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.PublicInstance.cpp_overload_set [concrete] -// CHECK:STDOUT: %ptr.fb2: type = ptr_type %Base [concrete] -// CHECK:STDOUT: %pattern_type.72a: type = pattern_type %ptr.fb2 [concrete] // CHECK:STDOUT: %pattern_type.a3a: type = pattern_type %Base [concrete] // CHECK:STDOUT: %Base.PublicInstance.type: type = fn_type @Base.PublicInstance [concrete] // CHECK:STDOUT: %Base.PublicInstance: %Base.PublicInstance.type = struct_value () [concrete] -// CHECK:STDOUT: %ptr.f97: type = ptr_type %Protected [concrete] // CHECK:STDOUT: %Protected.ProtectedInstance.cpp_overload_set.type: type = cpp_overload_set_type @Protected.ProtectedInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %Protected.ProtectedInstance.cpp_overload_set.value: %Protected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.ProtectedInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %Base.ProtectedInstance.type: type = fn_type @Base.ProtectedInstance [concrete] @@ -2727,21 +2704,19 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %Base.ProtectedStatic.decl: %Base.ProtectedStatic.type = fn_decl @Base.ProtectedStatic [concrete = constants.%Base.ProtectedStatic] {} {} // CHECK:STDOUT: %Protected.PublicInstance.cpp_overload_set.value: %Protected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.PublicInstance.cpp_overload_set [concrete = constants.%Protected.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %Base.PublicInstance.decl: %Base.PublicInstance.type = fn_decl @Base.PublicInstance [concrete = constants.%Base.PublicInstance] { -// CHECK:STDOUT: %self.patt: %pattern_type.72a = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.72a = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc24: %pattern_type.a3a = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.a3a = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.a3a = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.fb2 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.fb2 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %Base = ref_param call_param0 +// CHECK:STDOUT: %self: ref %Base = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: %Protected.ProtectedInstance.cpp_overload_set.value: %Protected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @Protected.ProtectedInstance.cpp_overload_set [concrete = constants.%Protected.ProtectedInstance.cpp_overload_set.value] // CHECK:STDOUT: %Base.ProtectedInstance.decl: %Base.ProtectedInstance.type = fn_decl @Base.ProtectedInstance [concrete = constants.%Base.ProtectedInstance] { -// CHECK:STDOUT: %self.patt: %pattern_type.72a = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.72a = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc26: %pattern_type.a3a = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.a3a = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.a3a = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.fb2 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.fb2 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %Base = ref_param call_param0 +// CHECK:STDOUT: %self: ref %Base = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2783,21 +2758,15 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %instance.ref.loc24: ref %Protected = name_ref instance, %instance // CHECK:STDOUT: %PublicInstance.ref: %Protected.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%Protected.PublicInstance.cpp_overload_set.value [concrete = constants.%Protected.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc24: = bound_method %instance.ref.loc24, %PublicInstance.ref -// CHECK:STDOUT: %addr.loc24_5.1: %ptr.f97 = addr_of %instance.ref.loc24 -// CHECK:STDOUT: %.loc24_5.1: ref %Protected = deref %addr.loc24_5.1 -// CHECK:STDOUT: %.loc24_5.2: ref %Base = class_element_access %.loc24_5.1, element0 -// CHECK:STDOUT: %addr.loc24_5.2: %ptr.fb2 = addr_of %.loc24_5.2 -// CHECK:STDOUT: %.loc24_5.3: %ptr.fb2 = converted %addr.loc24_5.1, %addr.loc24_5.2 -// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.3) +// CHECK:STDOUT: %.loc24_5.1: ref %Base = class_element_access %instance.ref.loc24, element0 +// CHECK:STDOUT: %.loc24_5.2: ref %Base = converted %instance.ref.loc24, %.loc24_5.1 +// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.2) // CHECK:STDOUT: %instance.ref.loc26: ref %Protected = name_ref instance, %instance // CHECK:STDOUT: %ProtectedInstance.ref: %Protected.ProtectedInstance.cpp_overload_set.type = name_ref ProtectedInstance, imports.%Protected.ProtectedInstance.cpp_overload_set.value [concrete = constants.%Protected.ProtectedInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc26: = bound_method %instance.ref.loc26, %ProtectedInstance.ref -// CHECK:STDOUT: %addr.loc26_5.1: %ptr.f97 = addr_of %instance.ref.loc26 -// CHECK:STDOUT: %.loc26_5.1: ref %Protected = deref %addr.loc26_5.1 -// CHECK:STDOUT: %.loc26_5.2: ref %Base = class_element_access %.loc26_5.1, element0 -// CHECK:STDOUT: %addr.loc26_5.2: %ptr.fb2 = addr_of %.loc26_5.2 -// CHECK:STDOUT: %.loc26_5.3: %ptr.fb2 = converted %addr.loc26_5.1, %addr.loc26_5.2 -// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.3) +// CHECK:STDOUT: %.loc26_5.1: ref %Base = class_element_access %instance.ref.loc26, element0 +// CHECK:STDOUT: %.loc26_5.2: ref %Base = converted %instance.ref.loc26, %.loc26_5.1 +// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.2) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2819,12 +2788,9 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %Base.ProtectedStatic: %Base.ProtectedStatic.type = struct_value () [concrete] // CHECK:STDOUT: %PublicProtected.PublicInstance.cpp_overload_set.type: type = cpp_overload_set_type @PublicProtected.PublicInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %PublicProtected.PublicInstance.cpp_overload_set.value: %PublicProtected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.PublicInstance.cpp_overload_set [concrete] -// CHECK:STDOUT: %ptr.fb2: type = ptr_type %Base [concrete] -// CHECK:STDOUT: %pattern_type.72a: type = pattern_type %ptr.fb2 [concrete] // CHECK:STDOUT: %pattern_type.a3a: type = pattern_type %Base [concrete] // CHECK:STDOUT: %Base.PublicInstance.type: type = fn_type @Base.PublicInstance [concrete] // CHECK:STDOUT: %Base.PublicInstance: %Base.PublicInstance.type = struct_value () [concrete] -// CHECK:STDOUT: %ptr.dc4: type = ptr_type %PublicProtected [concrete] // CHECK:STDOUT: %PublicProtected.ProtectedInstance.cpp_overload_set.type: type = cpp_overload_set_type @PublicProtected.ProtectedInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %PublicProtected.ProtectedInstance.cpp_overload_set.value: %PublicProtected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.ProtectedInstance.cpp_overload_set [concrete] // CHECK:STDOUT: %Base.ProtectedInstance.type: type = fn_type @Base.ProtectedInstance [concrete] @@ -2843,21 +2809,19 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %Base.ProtectedStatic.decl: %Base.ProtectedStatic.type = fn_decl @Base.ProtectedStatic [concrete = constants.%Base.ProtectedStatic] {} {} // CHECK:STDOUT: %PublicProtected.PublicInstance.cpp_overload_set.value: %PublicProtected.PublicInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.PublicInstance.cpp_overload_set [concrete = constants.%PublicProtected.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %Base.PublicInstance.decl: %Base.PublicInstance.type = fn_decl @Base.PublicInstance [concrete = constants.%Base.PublicInstance] { -// CHECK:STDOUT: %self.patt: %pattern_type.72a = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.72a = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc24: %pattern_type.a3a = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.a3a = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.a3a = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.fb2 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.fb2 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %Base = ref_param call_param0 +// CHECK:STDOUT: %self: ref %Base = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: %PublicProtected.ProtectedInstance.cpp_overload_set.value: %PublicProtected.ProtectedInstance.cpp_overload_set.type = cpp_overload_set_value @PublicProtected.ProtectedInstance.cpp_overload_set [concrete = constants.%PublicProtected.ProtectedInstance.cpp_overload_set.value] // CHECK:STDOUT: %Base.ProtectedInstance.decl: %Base.ProtectedInstance.type = fn_decl @Base.ProtectedInstance [concrete = constants.%Base.ProtectedInstance] { -// CHECK:STDOUT: %self.patt: %pattern_type.72a = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.72a = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc26: %pattern_type.a3a = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.a3a = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.a3a = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.fb2 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.fb2 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %Base = ref_param call_param0 +// CHECK:STDOUT: %self: ref %Base = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -2899,23 +2863,17 @@ fn Call(var instance: Cpp.PublicPrivate) { // CHECK:STDOUT: %instance.ref.loc24: ref %PublicProtected = name_ref instance, %instance // CHECK:STDOUT: %PublicInstance.ref: %PublicProtected.PublicInstance.cpp_overload_set.type = name_ref PublicInstance, imports.%PublicProtected.PublicInstance.cpp_overload_set.value [concrete = constants.%PublicProtected.PublicInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc24: = bound_method %instance.ref.loc24, %PublicInstance.ref -// CHECK:STDOUT: %addr.loc24_5.1: %ptr.dc4 = addr_of %instance.ref.loc24 -// CHECK:STDOUT: %.loc24_5.1: ref %PublicProtected = deref %addr.loc24_5.1 -// CHECK:STDOUT: %.loc24_5.2: ref %Protected = class_element_access %.loc24_5.1, element0 -// CHECK:STDOUT: %.loc24_5.3: ref %Base = class_element_access %.loc24_5.2, element0 -// CHECK:STDOUT: %addr.loc24_5.2: %ptr.fb2 = addr_of %.loc24_5.3 -// CHECK:STDOUT: %.loc24_5.4: %ptr.fb2 = converted %addr.loc24_5.1, %addr.loc24_5.2 -// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.4) +// CHECK:STDOUT: %.loc24_5.1: ref %Protected = class_element_access %instance.ref.loc24, element0 +// CHECK:STDOUT: %.loc24_5.2: ref %Base = class_element_access %.loc24_5.1, element0 +// CHECK:STDOUT: %.loc24_5.3: ref %Base = converted %instance.ref.loc24, %.loc24_5.2 +// CHECK:STDOUT: %Base.PublicInstance.call: init %empty_tuple.type = call imports.%Base.PublicInstance.decl(%.loc24_5.3) // CHECK:STDOUT: %instance.ref.loc26: ref %PublicProtected = name_ref instance, %instance // CHECK:STDOUT: %ProtectedInstance.ref: %PublicProtected.ProtectedInstance.cpp_overload_set.type = name_ref ProtectedInstance, imports.%PublicProtected.ProtectedInstance.cpp_overload_set.value [concrete = constants.%PublicProtected.ProtectedInstance.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc26: = bound_method %instance.ref.loc26, %ProtectedInstance.ref -// CHECK:STDOUT: %addr.loc26_5.1: %ptr.dc4 = addr_of %instance.ref.loc26 -// CHECK:STDOUT: %.loc26_5.1: ref %PublicProtected = deref %addr.loc26_5.1 -// CHECK:STDOUT: %.loc26_5.2: ref %Protected = class_element_access %.loc26_5.1, element0 -// CHECK:STDOUT: %.loc26_5.3: ref %Base = class_element_access %.loc26_5.2, element0 -// CHECK:STDOUT: %addr.loc26_5.2: %ptr.fb2 = addr_of %.loc26_5.3 -// CHECK:STDOUT: %.loc26_5.4: %ptr.fb2 = converted %addr.loc26_5.1, %addr.loc26_5.2 -// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.4) +// CHECK:STDOUT: %.loc26_5.1: ref %Protected = class_element_access %instance.ref.loc26, element0 +// CHECK:STDOUT: %.loc26_5.2: ref %Base = class_element_access %.loc26_5.1, element0 +// CHECK:STDOUT: %.loc26_5.3: ref %Base = converted %instance.ref.loc26, %.loc26_5.2 +// CHECK:STDOUT: %Base.ProtectedInstance.call: init %empty_tuple.type = call imports.%Base.ProtectedInstance.decl(%.loc26_5.3) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/class/class.carbon b/toolchain/check/testdata/interop/cpp/class/class.carbon index ab451b35b172..e06c4709f4d0 100644 --- a/toolchain/check/testdata/interop/cpp/class/class.carbon +++ b/toolchain/check/testdata/interop/cpp/class/class.carbon @@ -477,12 +477,11 @@ fn MyF(bar: Cpp.Bar*); // CHECK:STDOUT: %Bar.decl: type = class_decl @Bar [concrete = constants.%Bar] {} {} // CHECK:STDOUT: %Bar.f.cpp_overload_set.value: %Bar.f.cpp_overload_set.type = cpp_overload_set_value @Bar.f.cpp_overload_set [concrete = constants.%Bar.f.cpp_overload_set.value] // CHECK:STDOUT: %Bar.f.decl: %Bar.f.type = fn_decl @Bar.f [concrete = constants.%Bar.f] { -// CHECK:STDOUT: %self.patt: %pattern_type.146 = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.146 = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc8: %pattern_type.07b = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.07b = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.07b = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.f68 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.f68 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %Bar = ref_param call_param0 +// CHECK:STDOUT: %self: ref %Bar = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -507,8 +506,7 @@ fn MyF(bar: Cpp.Bar*); // CHECK:STDOUT: %.loc8: ref %Bar = deref %bar.ref // CHECK:STDOUT: %f.ref: %Bar.f.cpp_overload_set.type = name_ref f, imports.%Bar.f.cpp_overload_set.value [concrete = constants.%Bar.f.cpp_overload_set.value] // CHECK:STDOUT: %bound_method: = bound_method %.loc8, %f.ref -// CHECK:STDOUT: %addr: %ptr.f68 = addr_of %.loc8 -// CHECK:STDOUT: %Bar.f.call: init %empty_tuple.type = call imports.%Bar.f.decl(%addr) +// CHECK:STDOUT: %Bar.f.call: init %empty_tuple.type = call imports.%Bar.f.decl(%.loc8) // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/class/method.carbon b/toolchain/check/testdata/interop/cpp/class/method.carbon index fd03e83f2678..e415041d8614 100644 --- a/toolchain/check/testdata/interop/cpp/class/method.carbon +++ b/toolchain/check/testdata/interop/cpp/class/method.carbon @@ -83,7 +83,7 @@ fn Value(v: Cpp.HasQualifiers) { // CHECK:STDERR: v.const_ref_ref_this(); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: - // CHECK:STDERR: fail_bad_object_param_qualifiers_by_value.carbon:[[@LINE-25]]:3: error: `addr self` method cannot be invoked on a value [AddrSelfIsNonRef] + // CHECK:STDERR: fail_bad_object_param_qualifiers_by_value.carbon:[[@LINE-25]]:3: error: value expression passed to reference parameter [ValueForRefParam] // CHECK:STDERR: v.plain(); // CHECK:STDERR: ^ // CHECK:STDERR: fail_bad_object_param_qualifiers_by_value.carbon:[[@LINE-28]]:3: note: initializing function parameter [InCallToFunctionParam] @@ -244,7 +244,6 @@ fn Call(e: Cpp.ExplicitObjectParam, n: i32, a: Cpp.Another) { // CHECK:STDOUT: %HasQualifiers: type = class_type @HasQualifiers [concrete] // CHECK:STDOUT: %pattern_type.e15: type = pattern_type %HasQualifiers [concrete] // CHECK:STDOUT: %ptr.ec3: type = ptr_type %HasQualifiers [concrete] -// CHECK:STDOUT: %pattern_type.bc1: type = pattern_type %ptr.ec3 [concrete] // CHECK:STDOUT: %HasQualifiers.const_this.cpp_overload_set.type: type = cpp_overload_set_type @HasQualifiers.const_this.cpp_overload_set [concrete] // CHECK:STDOUT: %HasQualifiers.const_this.cpp_overload_set.value: %HasQualifiers.const_this.cpp_overload_set.type = cpp_overload_set_value @HasQualifiers.const_this.cpp_overload_set [concrete] // CHECK:STDOUT: %const_this__carbon_thunk.type: type = fn_type @const_this__carbon_thunk [concrete] @@ -278,21 +277,19 @@ fn Call(e: Cpp.ExplicitObjectParam, n: i32, a: Cpp.Another) { // CHECK:STDOUT: } // CHECK:STDOUT: %HasQualifiers.plain.cpp_overload_set.value: %HasQualifiers.plain.cpp_overload_set.type = cpp_overload_set_value @HasQualifiers.plain.cpp_overload_set [concrete = constants.%HasQualifiers.plain.cpp_overload_set.value] // CHECK:STDOUT: %HasQualifiers.plain.decl: %HasQualifiers.plain.type = fn_decl @HasQualifiers.plain [concrete = constants.%HasQualifiers.plain] { -// CHECK:STDOUT: %self.patt: %pattern_type.bc1 = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.bc1 = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc11: %pattern_type.e15 = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.e15 = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.e15 = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.ec3 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.ec3 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %HasQualifiers = ref_param call_param0 +// CHECK:STDOUT: %self: ref %HasQualifiers = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: %HasQualifiers.ref_this.cpp_overload_set.value: %HasQualifiers.ref_this.cpp_overload_set.type = cpp_overload_set_value @HasQualifiers.ref_this.cpp_overload_set [concrete = constants.%HasQualifiers.ref_this.cpp_overload_set.value] // CHECK:STDOUT: %HasQualifiers.ref_this.decl: %HasQualifiers.ref_this.type = fn_decl @HasQualifiers.ref_this [concrete = constants.%HasQualifiers.ref_this] { -// CHECK:STDOUT: %self.patt: %pattern_type.bc1 = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.bc1 = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc12: %pattern_type.e15 = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.e15 = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.e15 = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.ec3 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.ec3 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %HasQualifiers = ref_param call_param0 +// CHECK:STDOUT: %self: ref %HasQualifiers = ref_binding self, %self.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -310,14 +307,12 @@ fn Call(e: Cpp.ExplicitObjectParam, n: i32, a: Cpp.Another) { // CHECK:STDOUT: %.loc11: ref %HasQualifiers = deref %p.ref.loc11 // CHECK:STDOUT: %plain.ref: %HasQualifiers.plain.cpp_overload_set.type = name_ref plain, imports.%HasQualifiers.plain.cpp_overload_set.value [concrete = constants.%HasQualifiers.plain.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc11: = bound_method %.loc11, %plain.ref -// CHECK:STDOUT: %addr.loc11: %ptr.ec3 = addr_of %.loc11 -// CHECK:STDOUT: %HasQualifiers.plain.call: init %empty_tuple.type = call imports.%HasQualifiers.plain.decl(%addr.loc11) +// CHECK:STDOUT: %HasQualifiers.plain.call: init %empty_tuple.type = call imports.%HasQualifiers.plain.decl(%.loc11) // CHECK:STDOUT: %p.ref.loc12: %ptr.ec3 = name_ref p, %p // CHECK:STDOUT: %.loc12: ref %HasQualifiers = deref %p.ref.loc12 // CHECK:STDOUT: %ref_this.ref: %HasQualifiers.ref_this.cpp_overload_set.type = name_ref ref_this, imports.%HasQualifiers.ref_this.cpp_overload_set.value [concrete = constants.%HasQualifiers.ref_this.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc12: = bound_method %.loc12, %ref_this.ref -// CHECK:STDOUT: %addr.loc12: %ptr.ec3 = addr_of %.loc12 -// CHECK:STDOUT: %HasQualifiers.ref_this.call: init %empty_tuple.type = call imports.%HasQualifiers.ref_this.decl(%addr.loc12) +// CHECK:STDOUT: %HasQualifiers.ref_this.call: init %empty_tuple.type = call imports.%HasQualifiers.ref_this.decl(%.loc12) // CHECK:STDOUT: %p.ref.loc13: %ptr.ec3 = name_ref p, %p // CHECK:STDOUT: %.loc13_4.1: ref %HasQualifiers = deref %p.ref.loc13 // CHECK:STDOUT: %const_this.ref.loc13: %HasQualifiers.const_this.cpp_overload_set.type = name_ref const_this, imports.%HasQualifiers.const_this.cpp_overload_set.value [concrete = constants.%HasQualifiers.const_this.cpp_overload_set.value] @@ -340,7 +335,6 @@ fn Call(e: Cpp.ExplicitObjectParam, n: i32, a: Cpp.Another) { // CHECK:STDOUT: %HasQualifiers: type = class_type @HasQualifiers [concrete] // CHECK:STDOUT: %pattern_type.e15: type = pattern_type %HasQualifiers [concrete] // CHECK:STDOUT: %ptr.ec3: type = ptr_type %HasQualifiers [concrete] -// CHECK:STDOUT: %pattern_type.bc1: type = pattern_type %ptr.ec3 [concrete] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] // CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] @@ -370,14 +364,13 @@ fn Call(e: Cpp.ExplicitObjectParam, n: i32, a: Cpp.Another) { // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: %HasQualifiers.F.decl.f862ea.2: %HasQualifiers.F.type.d208f0.2 = fn_decl @HasQualifiers.F.2 [concrete = constants.%HasQualifiers.F.efd4e4.2] { -// CHECK:STDOUT: %self.patt: %pattern_type.bc1 = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.bc1 = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc9: %pattern_type.e15 = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.e15 = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.e15 = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: // CHECK:STDOUT: } { // CHECK:STDOUT: -// CHECK:STDOUT: %self.param: %ptr.ec3 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.ec3 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %HasQualifiers = ref_param call_param0 +// CHECK:STDOUT: %self: ref %HasQualifiers = ref_binding self, %self.param // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: } @@ -408,8 +401,7 @@ fn Call(e: Cpp.ExplicitObjectParam, n: i32, a: Cpp.Another) { // CHECK:STDOUT: %.loc9_18: ref %HasQualifiers = deref %p.ref // CHECK:STDOUT: %F.ref.loc9: %HasQualifiers.F.cpp_overload_set.type = name_ref F, imports.%HasQualifiers.F.cpp_overload_set.value [concrete = constants.%HasQualifiers.F.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc9_18: = bound_method %.loc9_18, %F.ref.loc9 -// CHECK:STDOUT: %addr.loc9_18: %ptr.ec3 = addr_of %.loc9_18 -// CHECK:STDOUT: %HasQualifiers.F.call: init %ptr.235 = call imports.%HasQualifiers.F.decl.f862ea.2(%addr.loc9_18) +// CHECK:STDOUT: %HasQualifiers.F.call: init %ptr.235 = call imports.%HasQualifiers.F.decl.f862ea.2(%.loc9_18) // CHECK:STDOUT: assign %b.var, %HasQualifiers.F.call // CHECK:STDOUT: %.loc9_13: type = splice_block %ptr.loc9 [concrete = constants.%ptr.235] { // CHECK:STDOUT: %int_32.loc9: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] @@ -420,8 +412,8 @@ fn Call(e: Cpp.ExplicitObjectParam, n: i32, a: Cpp.Another) { // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc9: = bound_method %b.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.6d0 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method.loc9_3: = bound_method %b.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1 -// CHECK:STDOUT: %addr.loc9_3: %ptr.5d5 = addr_of %b.var -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc9: init %empty_tuple.type = call %bound_method.loc9_3(%addr.loc9_3) +// CHECK:STDOUT: %addr.loc9: %ptr.5d5 = addr_of %b.var +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc9: init %empty_tuple.type = call %bound_method.loc9_3(%addr.loc9) // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc8: = bound_method %a.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.424 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method.loc8_3: = bound_method %a.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 diff --git a/toolchain/check/testdata/interop/cpp/enum/anonymous.carbon b/toolchain/check/testdata/interop/cpp/enum/anonymous.carbon index 33f8188d9111..a994bf90aca5 100644 --- a/toolchain/check/testdata/interop/cpp/enum/anonymous.carbon +++ b/toolchain/check/testdata/interop/cpp/enum/anonymous.carbon @@ -54,7 +54,6 @@ fn G() { // CHECK:STDOUT: %C.C.cpp_overload_set.value: %C.C.cpp_overload_set.type = cpp_overload_set_value @C.C.cpp_overload_set [concrete] // CHECK:STDOUT: %pattern_type.217: type = pattern_type %C [concrete] // CHECK:STDOUT: %ptr.d9e: type = ptr_type %C [concrete] -// CHECK:STDOUT: %pattern_type.a31: type = pattern_type %ptr.d9e [concrete] // CHECK:STDOUT: %C__carbon_thunk.type: type = fn_type @C__carbon_thunk [concrete] // CHECK:STDOUT: %C__carbon_thunk: %C__carbon_thunk.type = struct_value () [concrete] // CHECK:STDOUT: %C.F.cpp_overload_set.type: type = cpp_overload_set_type @C.F.cpp_overload_set [concrete] @@ -93,13 +92,12 @@ fn G() { // CHECK:STDOUT: %C.F.cpp_overload_set.value: %C.F.cpp_overload_set.type = cpp_overload_set_value @C.F.cpp_overload_set [concrete = constants.%C.F.cpp_overload_set.value] // CHECK:STDOUT: %int_1.1d6: %.bb7 = int_value 1 [concrete = constants.%int_1.1d6] // CHECK:STDOUT: %C.F.decl: %C.F.type = fn_decl @C.F [concrete = constants.%C.F] { -// CHECK:STDOUT: %self.patt: %pattern_type.a31 = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.a31 = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc10: %pattern_type.217 = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.217 = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.217 = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.d9e = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.d9e = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %C = ref_param call_param0 +// CHECK:STDOUT: %self: ref %C = ref_binding self, %self.param // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: } @@ -128,13 +126,12 @@ fn G() { // CHECK:STDOUT: %Cpp.ref.loc10_15: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %C.ref.loc10_18: type = name_ref C, imports.%C.decl [concrete = constants.%C] // CHECK:STDOUT: %e.ref: %.bb7 = name_ref e, imports.%int_1.1d6 [concrete = constants.%int_1.1d6] -// CHECK:STDOUT: %addr.loc10_11.2: %ptr.d9e = addr_of %.loc10_11.3 -// CHECK:STDOUT: %C.F.call: init %empty_tuple.type = call imports.%C.F.decl(%addr.loc10_11.2, %e.ref) +// CHECK:STDOUT: %C.F.call: init %empty_tuple.type = call imports.%C.F.decl(%.loc10_11.3, %e.ref) // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc10_11.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.f77 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method.loc10_11: = bound_method %.loc10_11.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn -// CHECK:STDOUT: %addr.loc10_11.3: %ptr.d9e = addr_of %.loc10_11.3 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc10_11(%addr.loc10_11.3) +// CHECK:STDOUT: %addr.loc10_11.2: %ptr.d9e = addr_of %.loc10_11.3 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc10_11(%addr.loc10_11.2) // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/function/default_arg.carbon b/toolchain/check/testdata/interop/cpp/function/default_arg.carbon index 7a79093b60ca..851db68e0e8a 100644 --- a/toolchain/check/testdata/interop/cpp/function/default_arg.carbon +++ b/toolchain/check/testdata/interop/cpp/function/default_arg.carbon @@ -182,8 +182,6 @@ fn Call() { // CHECK:STDOUT: %X.val: %X = struct_value () [concrete] // CHECK:STDOUT: %X.B.cpp_overload_set.type: type = cpp_overload_set_type @X.B.cpp_overload_set [concrete] // CHECK:STDOUT: %X.B.cpp_overload_set.value: %X.B.cpp_overload_set.type = cpp_overload_set_value @X.B.cpp_overload_set [concrete] -// CHECK:STDOUT: %ptr.1f9: type = ptr_type %X [concrete] -// CHECK:STDOUT: %pattern_type.45c: type = pattern_type %ptr.1f9 [concrete] // CHECK:STDOUT: %pattern_type.46b: type = pattern_type %X [concrete] // CHECK:STDOUT: %X.B.type: type = fn_type @X.B [concrete] // CHECK:STDOUT: %X.B: %X.B.type = struct_value () [concrete] @@ -193,6 +191,7 @@ fn Call() { // CHECK:STDOUT: %X.C: %X.C.type = struct_value () [concrete] // CHECK:STDOUT: %X.D.cpp_overload_set.type: type = cpp_overload_set_type @X.D.cpp_overload_set [concrete] // CHECK:STDOUT: %X.D.cpp_overload_set.value: %X.D.cpp_overload_set.type = cpp_overload_set_value @X.D.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.1f9: type = ptr_type %X [concrete] // CHECK:STDOUT: %D__carbon_thunk.type: type = fn_type @D__carbon_thunk [concrete] // CHECK:STDOUT: %D__carbon_thunk: %D__carbon_thunk.type = struct_value () [concrete] // CHECK:STDOUT: %type_where: type = facet_type > [concrete] @@ -225,13 +224,12 @@ fn Call() { // CHECK:STDOUT: %X.decl: type = class_decl @X [concrete = constants.%X] {} {} // CHECK:STDOUT: %X.B.cpp_overload_set.value: %X.B.cpp_overload_set.type = cpp_overload_set_value @X.B.cpp_overload_set [concrete = constants.%X.B.cpp_overload_set.value] // CHECK:STDOUT: %X.B.decl: %X.B.type = fn_decl @X.B [concrete = constants.%X.B] { -// CHECK:STDOUT: %self.patt: %pattern_type.45c = value_binding_pattern self [concrete] -// CHECK:STDOUT: %self.param_patt: %pattern_type.45c = value_param_pattern %self.patt, call_param0 [concrete] -// CHECK:STDOUT: %.loc10: %pattern_type.46b = addr_pattern %self.param_patt [concrete] +// CHECK:STDOUT: %self.patt: %pattern_type.46b = ref_binding_pattern self [concrete] +// CHECK:STDOUT: %self.param_patt: %pattern_type.46b = ref_param_pattern %self.patt, call_param0 [concrete] // CHECK:STDOUT: // CHECK:STDOUT: } { -// CHECK:STDOUT: %self.param: %ptr.1f9 = value_param call_param0 -// CHECK:STDOUT: %self: %ptr.1f9 = value_binding self, %self.param +// CHECK:STDOUT: %self.param: ref %X = ref_param call_param0 +// CHECK:STDOUT: %self: ref %X = ref_binding self, %self.param // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: %X.C.cpp_overload_set.value: %X.C.cpp_overload_set.type = cpp_overload_set_value @X.C.cpp_overload_set [concrete = constants.%X.C.cpp_overload_set.value] @@ -341,7 +339,6 @@ fn Call() { // CHECK:STDOUT: %bound_method.loc10_16: = bound_method %.loc10_7, %B.ref // CHECK:STDOUT: %int_1.loc10: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] // CHECK:STDOUT: %int_2.loc10: Core.IntLiteral = int_value 2 [concrete = constants.%int_2.ecc] -// CHECK:STDOUT: %addr.loc10_7: %ptr.1f9 = addr_of %.loc10_7 // CHECK:STDOUT: %impl.elem0.loc10_19: %.322 = impl_witness_access constants.%ImplicitAs.impl_witness.bc9, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e9b] // CHECK:STDOUT: %bound_method.loc10_19.1: = bound_method %int_1.loc10, %impl.elem0.loc10_19 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.265] // CHECK:STDOUT: %specific_fn.loc10_19: = specific_function %impl.elem0.loc10_19, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] @@ -356,7 +353,7 @@ fn Call() { // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_22: init %i32 = call %bound_method.loc10_22.2(%int_2.loc10) [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc10_22.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc10_22 [concrete = constants.%int_2.ef8] // CHECK:STDOUT: %.loc10_22.2: %i32 = converted %int_2.loc10, %.loc10_22.1 [concrete = constants.%int_2.ef8] -// CHECK:STDOUT: %X.B.call: init %empty_tuple.type = call imports.%X.B.decl(%addr.loc10_7, %.loc10_19.2, %.loc10_22.2) +// CHECK:STDOUT: %X.B.call: init %empty_tuple.type = call imports.%X.B.decl(%.loc10_7, %.loc10_19.2, %.loc10_22.2) // CHECK:STDOUT: %Cpp.ref.loc11: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %X.ref.loc11: type = name_ref X, imports.%X.decl [concrete = constants.%X] // CHECK:STDOUT: %C.ref: %X.C.cpp_overload_set.type = name_ref C, imports.%X.C.cpp_overload_set.value [concrete = constants.%X.C.cpp_overload_set.value] @@ -414,8 +411,8 @@ fn Call() { // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc10: = bound_method %.loc10_5.4, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.4c7 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method.loc10_5: = bound_method %.loc10_5.4, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 -// CHECK:STDOUT: %addr.loc10_5: %ptr.1f9 = addr_of %.loc10_5.4 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc10: init %empty_tuple.type = call %bound_method.loc10_5(%addr.loc10_5) +// CHECK:STDOUT: %addr.loc10: %ptr.1f9 = addr_of %.loc10_5.4 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc10: init %empty_tuple.type = call %bound_method.loc10_5(%addr.loc10) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: @@ -471,8 +468,6 @@ fn Call() { // CHECK:STDOUT: %X.val: %X = struct_value () [concrete] // CHECK:STDOUT: %X.B.cpp_overload_set.type: type = cpp_overload_set_type @X.B.cpp_overload_set [concrete] // CHECK:STDOUT: %X.B.cpp_overload_set.value: %X.B.cpp_overload_set.type = cpp_overload_set_value @X.B.cpp_overload_set [concrete] -// CHECK:STDOUT: %ptr.1f9: type = ptr_type %X [concrete] -// CHECK:STDOUT: %pattern_type.45c: type = pattern_type %ptr.1f9 [concrete] // CHECK:STDOUT: %pattern_type.46b: type = pattern_type %X [concrete] // CHECK:STDOUT: %B__carbon_thunk.type: type = fn_type @B__carbon_thunk [concrete] // CHECK:STDOUT: %B__carbon_thunk: %B__carbon_thunk.type = struct_value () [concrete] @@ -482,6 +477,8 @@ fn Call() { // CHECK:STDOUT: %C__carbon_thunk: %C__carbon_thunk.type = struct_value () [concrete] // CHECK:STDOUT: %X.D.cpp_overload_set.type: type = cpp_overload_set_type @X.D.cpp_overload_set [concrete] // CHECK:STDOUT: %X.D.cpp_overload_set.value: %X.D.cpp_overload_set.type = cpp_overload_set_value @X.D.cpp_overload_set [concrete] +// CHECK:STDOUT: %ptr.1f9: type = ptr_type %X [concrete] +// CHECK:STDOUT: %pattern_type.45c: type = pattern_type %ptr.1f9 [concrete] // CHECK:STDOUT: %D__carbon_thunk.type: type = fn_type @D__carbon_thunk [concrete] // CHECK:STDOUT: %D__carbon_thunk: %D__carbon_thunk.type = struct_value () [concrete] // CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] @@ -586,16 +583,15 @@ fn Call() { // CHECK:STDOUT: %X.decl: type = class_decl @X [concrete = constants.%X] {} {} // CHECK:STDOUT: %X.B.cpp_overload_set.value: %X.B.cpp_overload_set.type = cpp_overload_set_value @X.B.cpp_overload_set [concrete = constants.%X.B.cpp_overload_set.value] // CHECK:STDOUT: %B__carbon_thunk.decl: %B__carbon_thunk.type = fn_decl @B__carbon_thunk [concrete = constants.%B__carbon_thunk] { -// CHECK:STDOUT: %this.patt: %pattern_type.45c = value_binding_pattern this [concrete] -// CHECK:STDOUT: %this.param_patt: %pattern_type.45c = value_param_pattern %this.patt, call_param0 [concrete] -// CHECK:STDOUT: %.1: %pattern_type.46b = addr_pattern %this.param_patt [concrete] +// CHECK:STDOUT: %this.patt: %pattern_type.46b = ref_binding_pattern this [concrete] +// CHECK:STDOUT: %this.param_patt: %pattern_type.46b = ref_param_pattern %this.patt, call_param0 [concrete] // CHECK:STDOUT: %a.patt: %pattern_type.7ce = value_binding_pattern a [concrete] // CHECK:STDOUT: %a.param_patt: %pattern_type.7ce = value_param_pattern %a.patt, call_param1 [concrete] // CHECK:STDOUT: } { -// CHECK:STDOUT: %this.param: %ptr.1f9 = value_param call_param0 -// CHECK:STDOUT: %this: %ptr.1f9 = value_binding this, %this.param +// CHECK:STDOUT: %this.param: ref %X = ref_param call_param0 +// CHECK:STDOUT: %this: ref %X = ref_binding this, %this.param // CHECK:STDOUT: %a.param: %i32 = value_param call_param1 -// CHECK:STDOUT: %.2: type = splice_block %i32 [concrete = constants.%i32] { +// CHECK:STDOUT: %.1: type = splice_block %i32 [concrete = constants.%i32] { // 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: } @@ -744,7 +740,6 @@ fn Call() { // CHECK:STDOUT: %B.ref: %X.B.cpp_overload_set.type = name_ref B, imports.%X.B.cpp_overload_set.value [concrete = constants.%X.B.cpp_overload_set.value] // CHECK:STDOUT: %bound_method.loc11_16: = bound_method %.loc11_7, %B.ref // CHECK:STDOUT: %int_1.loc11: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] -// CHECK:STDOUT: %addr.loc11_7: %ptr.1f9 = addr_of %.loc11_7 // CHECK:STDOUT: %impl.elem0.loc11: %.322 = impl_witness_access constants.%ImplicitAs.impl_witness.bc9, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e9b] // CHECK:STDOUT: %bound_method.loc11_19.1: = bound_method %int_1.loc11, %impl.elem0.loc11 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.265] // CHECK:STDOUT: %specific_fn.loc11: = specific_function %impl.elem0.loc11, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] @@ -752,7 +747,7 @@ fn Call() { // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc11: init %i32 = call %bound_method.loc11_19.2(%int_1.loc11) [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc11_19.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc11 [concrete = constants.%int_1.5d2] // CHECK:STDOUT: %.loc11_19.2: %i32 = converted %int_1.loc11, %.loc11_19.1 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %B__carbon_thunk.call: init %empty_tuple.type = call imports.%B__carbon_thunk.decl(%addr.loc11_7, %.loc11_19.2) +// CHECK:STDOUT: %B__carbon_thunk.call: init %empty_tuple.type = call imports.%B__carbon_thunk.decl(%.loc11_7, %.loc11_19.2) // CHECK:STDOUT: %Cpp.ref.loc12: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %X.ref.loc12: type = name_ref X, imports.%X.decl [concrete = constants.%X] // CHECK:STDOUT: %C.ref: %X.C.cpp_overload_set.type = name_ref C, imports.%X.C.cpp_overload_set.value [concrete = constants.%X.C.cpp_overload_set.value] @@ -794,8 +789,8 @@ fn Call() { // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc11: = bound_method %.loc11_5.4, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.4c7 // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.4c7, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn] // CHECK:STDOUT: %bound_method.loc11_5: = bound_method %.loc11_5.4, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 -// CHECK:STDOUT: %addr.loc11_5: %ptr.1f9 = addr_of %.loc11_5.4 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc11: init %empty_tuple.type = call %bound_method.loc11_5(%addr.loc11_5) +// CHECK:STDOUT: %addr.loc11: %ptr.1f9 = addr_of %.loc11_5.4 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc11: init %empty_tuple.type = call %bound_method.loc11_5(%addr.loc11) // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: @@ -811,9 +806,9 @@ fn Call() { // CHECK:STDOUT: // CHECK:STDOUT: fn @GlobalNoReturn__carbon_thunk.2(%a.param: %i32, %b.param: %i32, %c.param: %i32); // CHECK:STDOUT: -// CHECK:STDOUT: fn @X.B(%self.param: %ptr.1f9, %a.param: %i32); +// CHECK:STDOUT: fn @X.B(%self.param: %X, %a.param: %i32); // CHECK:STDOUT: -// CHECK:STDOUT: fn @B__carbon_thunk(%this.param: %ptr.1f9, %a.param: %i32); +// CHECK:STDOUT: fn @B__carbon_thunk(%this.param: %X, %a.param: %i32); // CHECK:STDOUT: // CHECK:STDOUT: fn @X.C(%a.param: %i32); // CHECK:STDOUT: diff --git a/toolchain/check/testdata/interop/cpp/function/operators.carbon b/toolchain/check/testdata/interop/cpp/function/operators.carbon index 99ea9fd43a34..3bb266e98f07 100644 --- a/toolchain/check/testdata/interop/cpp/function/operators.carbon +++ b/toolchain/check/testdata/interop/cpp/function/operators.carbon @@ -1078,11 +1078,9 @@ fn F() { // CHECK:STDOUT: } // CHECK:STDOUT: %c: ref %C = ref_binding c, %c.var // CHECK:STDOUT: %c.ref.loc11: ref %C = name_ref c, %c -// CHECK:STDOUT: %addr.loc11: %ptr.d9e = addr_of %c.ref.loc11 -// CHECK:STDOUT: %cpp_operator.call.loc11: init %const = call imports.%cpp_operator.decl.4206c9.1(%addr.loc11) +// CHECK:STDOUT: %cpp_operator.call.loc11: init %const = call imports.%cpp_operator.decl.4206c9.1(%c.ref.loc11) // CHECK:STDOUT: %c.ref.loc12: ref %C = name_ref c, %c -// CHECK:STDOUT: %addr.loc12: %ptr.d9e = addr_of %c.ref.loc12 -// CHECK:STDOUT: %cpp_operator.call.loc12: init %const = call imports.%cpp_operator.decl.4206c9.2(%addr.loc12) +// CHECK:STDOUT: %cpp_operator.call.loc12: init %const = call imports.%cpp_operator.decl.4206c9.2(%c.ref.loc12) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %minus.patt: %pattern_type.217 = value_binding_pattern minus [concrete] // CHECK:STDOUT: } @@ -1623,63 +1621,54 @@ fn F() { // CHECK:STDOUT: %right_shift: %C = value_binding right_shift, %.loc23_31.4 // CHECK:STDOUT: %c1.ref.loc26: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc26: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc26_3: %ptr.d9e = addr_of %c1.ref.loc26 // CHECK:STDOUT: %.loc26_9.1: %C = acquire_value %c2.ref.loc26 // CHECK:STDOUT: %.loc26_9.2: ref %C = value_as_ref %.loc26_9.1 -// CHECK:STDOUT: %addr.loc26_6: %ptr.d9e = addr_of %.loc26_9.2 -// CHECK:STDOUT: %operator+=__carbon_thunk.call: init %const.7c5 = call imports.%operator+=__carbon_thunk.decl(%addr.loc26_3, %addr.loc26_6) +// CHECK:STDOUT: %addr.loc26: %ptr.d9e = addr_of %.loc26_9.2 +// CHECK:STDOUT: %operator+=__carbon_thunk.call: init %const.7c5 = call imports.%operator+=__carbon_thunk.decl(%c1.ref.loc26, %addr.loc26) // CHECK:STDOUT: %c1.ref.loc27: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc27: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc27_3: %ptr.d9e = addr_of %c1.ref.loc27 // CHECK:STDOUT: %.loc27_9.1: %C = acquire_value %c2.ref.loc27 // CHECK:STDOUT: %.loc27_9.2: ref %C = value_as_ref %.loc27_9.1 -// CHECK:STDOUT: %addr.loc27_6: %ptr.d9e = addr_of %.loc27_9.2 -// CHECK:STDOUT: %operator-=__carbon_thunk.call: init %const.7c5 = call imports.%operator-=__carbon_thunk.decl(%addr.loc27_3, %addr.loc27_6) +// CHECK:STDOUT: %addr.loc27: %ptr.d9e = addr_of %.loc27_9.2 +// CHECK:STDOUT: %operator-=__carbon_thunk.call: init %const.7c5 = call imports.%operator-=__carbon_thunk.decl(%c1.ref.loc27, %addr.loc27) // CHECK:STDOUT: %c1.ref.loc28: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc28: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc28_3: %ptr.d9e = addr_of %c1.ref.loc28 // CHECK:STDOUT: %.loc28_9.1: %C = acquire_value %c2.ref.loc28 // CHECK:STDOUT: %.loc28_9.2: ref %C = value_as_ref %.loc28_9.1 -// CHECK:STDOUT: %addr.loc28_6: %ptr.d9e = addr_of %.loc28_9.2 -// CHECK:STDOUT: %operator*=__carbon_thunk.call: init %const.7c5 = call imports.%operator*=__carbon_thunk.decl(%addr.loc28_3, %addr.loc28_6) +// CHECK:STDOUT: %addr.loc28: %ptr.d9e = addr_of %.loc28_9.2 +// CHECK:STDOUT: %operator*=__carbon_thunk.call: init %const.7c5 = call imports.%operator*=__carbon_thunk.decl(%c1.ref.loc28, %addr.loc28) // CHECK:STDOUT: %c1.ref.loc29: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc29: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc29_3: %ptr.d9e = addr_of %c1.ref.loc29 // CHECK:STDOUT: %.loc29_9.1: %C = acquire_value %c2.ref.loc29 // CHECK:STDOUT: %.loc29_9.2: ref %C = value_as_ref %.loc29_9.1 -// CHECK:STDOUT: %addr.loc29_6: %ptr.d9e = addr_of %.loc29_9.2 -// CHECK:STDOUT: %operator/=__carbon_thunk.call: init %const.7c5 = call imports.%operator/=__carbon_thunk.decl(%addr.loc29_3, %addr.loc29_6) +// CHECK:STDOUT: %addr.loc29: %ptr.d9e = addr_of %.loc29_9.2 +// CHECK:STDOUT: %operator/=__carbon_thunk.call: init %const.7c5 = call imports.%operator/=__carbon_thunk.decl(%c1.ref.loc29, %addr.loc29) // CHECK:STDOUT: %c1.ref.loc30: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc30: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc30_3: %ptr.d9e = addr_of %c1.ref.loc30 // CHECK:STDOUT: %.loc30_9.1: %C = acquire_value %c2.ref.loc30 // CHECK:STDOUT: %.loc30_9.2: ref %C = value_as_ref %.loc30_9.1 -// CHECK:STDOUT: %addr.loc30_6: %ptr.d9e = addr_of %.loc30_9.2 -// CHECK:STDOUT: %operator%=__carbon_thunk.call: init %const.7c5 = call imports.%operator%=__carbon_thunk.decl(%addr.loc30_3, %addr.loc30_6) +// CHECK:STDOUT: %addr.loc30: %ptr.d9e = addr_of %.loc30_9.2 +// CHECK:STDOUT: %operator%=__carbon_thunk.call: init %const.7c5 = call imports.%operator%=__carbon_thunk.decl(%c1.ref.loc30, %addr.loc30) // CHECK:STDOUT: %c1.ref.loc33: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc33: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc33_3: %ptr.d9e = addr_of %c1.ref.loc33 // CHECK:STDOUT: %.loc33_9.1: %C = acquire_value %c2.ref.loc33 // CHECK:STDOUT: %.loc33_9.2: ref %C = value_as_ref %.loc33_9.1 -// CHECK:STDOUT: %addr.loc33_6: %ptr.d9e = addr_of %.loc33_9.2 -// CHECK:STDOUT: %operator&=__carbon_thunk.call: init %const.7c5 = call imports.%operator&=__carbon_thunk.decl(%addr.loc33_3, %addr.loc33_6) +// CHECK:STDOUT: %addr.loc33: %ptr.d9e = addr_of %.loc33_9.2 +// CHECK:STDOUT: %operator&=__carbon_thunk.call: init %const.7c5 = call imports.%operator&=__carbon_thunk.decl(%c1.ref.loc33, %addr.loc33) // CHECK:STDOUT: %c1.ref.loc34: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc34: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc34_3: %ptr.d9e = addr_of %c1.ref.loc34 // CHECK:STDOUT: %.loc34_9.1: %C = acquire_value %c2.ref.loc34 // CHECK:STDOUT: %.loc34_9.2: ref %C = value_as_ref %.loc34_9.1 -// CHECK:STDOUT: %addr.loc34_6: %ptr.d9e = addr_of %.loc34_9.2 -// CHECK:STDOUT: %operator|=__carbon_thunk.call: init %const.7c5 = call imports.%operator|=__carbon_thunk.decl(%addr.loc34_3, %addr.loc34_6) +// CHECK:STDOUT: %addr.loc34: %ptr.d9e = addr_of %.loc34_9.2 +// CHECK:STDOUT: %operator|=__carbon_thunk.call: init %const.7c5 = call imports.%operator|=__carbon_thunk.decl(%c1.ref.loc34, %addr.loc34) // CHECK:STDOUT: %c1.ref.loc35: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref.loc35: ref %C = name_ref c2, %c2 -// CHECK:STDOUT: %addr.loc35_3: %ptr.d9e = addr_of %c1.ref.loc35 // CHECK:STDOUT: %.loc35_9.1: %C = acquire_value %c2.ref.loc35 // CHECK:STDOUT: %.loc35_9.2: ref %C = value_as_ref %.loc35_9.1 -// CHECK:STDOUT: %addr.loc35_6: %ptr.d9e = addr_of %.loc35_9.2 -// CHECK:STDOUT: %operator^=__carbon_thunk.call: init %const.7c5 = call imports.%operator^=__carbon_thunk.decl(%addr.loc35_3, %addr.loc35_6) +// CHECK:STDOUT: %addr.loc35: %ptr.d9e = addr_of %.loc35_9.2 +// CHECK:STDOUT: %operator^=__carbon_thunk.call: init %const.7c5 = call imports.%operator^=__carbon_thunk.decl(%c1.ref.loc35, %addr.loc35) // CHECK:STDOUT: %c1.ref.loc36: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %int_3.loc36: Core.IntLiteral = int_value 3 [concrete = constants.%int_3.1ba] -// CHECK:STDOUT: %addr.loc36: %ptr.d9e = addr_of %c1.ref.loc36 // CHECK:STDOUT: %impl.elem0.loc36: %.322 = impl_witness_access constants.%ImplicitAs.impl_witness.bc9, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e9b] // CHECK:STDOUT: %bound_method.loc36_10.1: = bound_method %int_3.loc36, %impl.elem0.loc36 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.87d] // CHECK:STDOUT: %specific_fn.loc36: = specific_function %impl.elem0.loc36, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] @@ -1687,10 +1676,9 @@ fn F() { // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc36: init %i32 = call %bound_method.loc36_10.2(%int_3.loc36) [concrete = constants.%int_3.822] // CHECK:STDOUT: %.loc36_10.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc36 [concrete = constants.%int_3.822] // CHECK:STDOUT: %.loc36_10.2: %i32 = converted %int_3.loc36, %.loc36_10.1 [concrete = constants.%int_3.822] -// CHECK:STDOUT: %cpp_operator.call.loc36: init %const.7c5 = call imports.%cpp_operator.decl.4206c9.19(%addr.loc36, %.loc36_10.2) +// CHECK:STDOUT: %cpp_operator.call.loc36: init %const.7c5 = call imports.%cpp_operator.decl.4206c9.19(%c1.ref.loc36, %.loc36_10.2) // CHECK:STDOUT: %c1.ref.loc37: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %int_5.loc37: Core.IntLiteral = int_value 5 [concrete = constants.%int_5.64b] -// CHECK:STDOUT: %addr.loc37: %ptr.d9e = addr_of %c1.ref.loc37 // CHECK:STDOUT: %impl.elem0.loc37: %.322 = impl_witness_access constants.%ImplicitAs.impl_witness.bc9, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.e9b] // CHECK:STDOUT: %bound_method.loc37_10.1: = bound_method %int_5.loc37, %impl.elem0.loc37 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.451] // CHECK:STDOUT: %specific_fn.loc37: = specific_function %impl.elem0.loc37, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] @@ -1698,7 +1686,7 @@ fn F() { // CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc37: init %i32 = call %bound_method.loc37_10.2(%int_5.loc37) [concrete = constants.%int_5.0f6] // CHECK:STDOUT: %.loc37_10.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc37 [concrete = constants.%int_5.0f6] // CHECK:STDOUT: %.loc37_10.2: %i32 = converted %int_5.loc37, %.loc37_10.1 [concrete = constants.%int_5.0f6] -// CHECK:STDOUT: %cpp_operator.call.loc37: init %const.7c5 = call imports.%cpp_operator.decl.4206c9.20(%addr.loc37, %.loc37_10.2) +// CHECK:STDOUT: %cpp_operator.call.loc37: init %const.7c5 = call imports.%cpp_operator.decl.4206c9.20(%c1.ref.loc37, %.loc37_10.2) // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %equal.patt: %pattern_type.831 = value_binding_pattern equal [concrete] // CHECK:STDOUT: } @@ -3072,9 +3060,8 @@ fn F() { // CHECK:STDOUT: %c2.var: ref %C = var %c2.var_patt // CHECK:STDOUT: %c1.ref.loc9: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %.loc9_3: ref %C = splice_block %c2.var {} -// CHECK:STDOUT: %addr.loc9_20: %ptr.d9e = addr_of %c1.ref.loc9 // CHECK:STDOUT: %addr.loc9_19: %ptr.d9e = addr_of %.loc9_3 -// CHECK:STDOUT: %operator-__carbon_thunk.call: init %empty_tuple.type = call imports.%operator-__carbon_thunk.decl(%addr.loc9_20, %addr.loc9_19) +// CHECK:STDOUT: %operator-__carbon_thunk.call: init %empty_tuple.type = call imports.%operator-__carbon_thunk.decl(%c1.ref.loc9, %addr.loc9_19) // CHECK:STDOUT: %.loc9_19: init %C = in_place_init %operator-__carbon_thunk.call, %.loc9_3 // CHECK:STDOUT: assign %c2.var, %.loc9_19 // CHECK:STDOUT: %.loc9_14: type = splice_block %C.ref.loc9 [concrete = constants.%C] { @@ -3090,12 +3077,11 @@ fn F() { // CHECK:STDOUT: %c1.ref.loc10: ref %C = name_ref c1, %c1 // CHECK:STDOUT: %c2.ref: ref %C = name_ref c2, %c2 // CHECK:STDOUT: %.loc10_3: ref %C = splice_block %c3.var {} -// CHECK:STDOUT: %addr.loc10_19: %ptr.d9e = addr_of %c1.ref.loc10 // CHECK:STDOUT: %.loc10_24.1: %C = acquire_value %c2.ref // CHECK:STDOUT: %.loc10_24.2: ref %C = value_as_ref %.loc10_24.1 // CHECK:STDOUT: %addr.loc10_22.1: %ptr.d9e = addr_of %.loc10_24.2 // CHECK:STDOUT: %addr.loc10_22.2: %ptr.d9e = addr_of %.loc10_3 -// CHECK:STDOUT: %operator+__carbon_thunk.call: init %empty_tuple.type = call imports.%operator+__carbon_thunk.decl(%addr.loc10_19, %addr.loc10_22.1, %addr.loc10_22.2) +// CHECK:STDOUT: %operator+__carbon_thunk.call: init %empty_tuple.type = call imports.%operator+__carbon_thunk.decl(%c1.ref.loc10, %addr.loc10_22.1, %addr.loc10_22.2) // CHECK:STDOUT: %.loc10_22: init %C = in_place_init %operator+__carbon_thunk.call, %.loc10_3 // CHECK:STDOUT: assign %c3.var, %.loc10_22 // CHECK:STDOUT: %.loc10_14: type = splice_block %C.ref.loc10 [concrete = constants.%C] { diff --git a/toolchain/check/testdata/interop/cpp/function/reference.carbon b/toolchain/check/testdata/interop/cpp/function/reference.carbon index 5e0d5afe87e5..ed27023bc476 100644 --- a/toolchain/check/testdata/interop/cpp/function/reference.carbon +++ b/toolchain/check/testdata/interop/cpp/function/reference.carbon @@ -30,7 +30,7 @@ import Cpp library "param_lvalue_ref.h"; fn F() { //@dump-sem-ir-begin var s: Cpp.S = {}; - Cpp.TakesLValue(s); + Cpp.TakesLValue(ref s); //@dump-sem-ir-end } @@ -323,13 +323,13 @@ fn F() { // CHECK:STDOUT: %S.val: %S = struct_value () [concrete] // CHECK:STDOUT: %TakesLValue.cpp_overload_set.type: type = cpp_overload_set_type @TakesLValue.cpp_overload_set [concrete] // CHECK:STDOUT: %TakesLValue.cpp_overload_set.value: %TakesLValue.cpp_overload_set.type = cpp_overload_set_value @TakesLValue.cpp_overload_set [concrete] -// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] // CHECK:STDOUT: %TakesLValue.type: type = fn_type @TakesLValue [concrete] // CHECK:STDOUT: %TakesLValue: %TakesLValue.type = struct_value () [concrete] // CHECK:STDOUT: %type_where: type = facet_type > [concrete] // CHECK:STDOUT: %facet_value: %type_where = facet_value %S, () [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.552: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.572: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.552 = struct_value () [concrete] +// CHECK:STDOUT: %ptr.5c7: type = ptr_type %S [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -366,13 +366,12 @@ fn F() { // CHECK:STDOUT: %Cpp.ref.loc9: = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp] // CHECK:STDOUT: %TakesLValue.ref: %TakesLValue.cpp_overload_set.type = name_ref TakesLValue, imports.%TakesLValue.cpp_overload_set.value [concrete = constants.%TakesLValue.cpp_overload_set.value] // CHECK:STDOUT: %s.ref: ref %S = name_ref s, %s -// CHECK:STDOUT: %addr.loc9: %ptr.5c7 = addr_of %s.ref -// CHECK:STDOUT: %TakesLValue.call: init %empty_tuple.type = call imports.%TakesLValue.decl(%addr.loc9) +// CHECK:STDOUT: %TakesLValue.call: init %empty_tuple.type = call imports.%TakesLValue.decl(%s.ref) // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %s.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.572 // CHECK:STDOUT: // CHECK:STDOUT: %bound_method: = bound_method %s.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn -// CHECK:STDOUT: %addr.loc8: %ptr.5c7 = addr_of %s.var -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr.loc8) +// CHECK:STDOUT: %addr: %ptr.5c7 = addr_of %s.var +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method(%addr) // CHECK:STDOUT: // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/lower/testdata/interop/cpp/base.carbon b/toolchain/lower/testdata/interop/cpp/base.carbon index b72f6fad8714..0f42c1bee2df 100644 --- a/toolchain/lower/testdata/interop/cpp/base.carbon +++ b/toolchain/lower/testdata/interop/cpp/base.carbon @@ -141,8 +141,8 @@ fn Call(b: Cpp.B*) { // CHECK:STDOUT: ; Function Attrs: nounwind // CHECK:STDOUT: define void @_CCall.Main(ptr %b) #0 !dbg !7 { // CHECK:STDOUT: entry: -// CHECK:STDOUT: %.loc7_4.3.base = getelementptr inbounds nuw [8 x i8], ptr %b, i32 0, i32 0, !dbg !10 -// CHECK:STDOUT: call void @_ZN1A1fEv(ptr %.loc7_4.3.base), !dbg !10 +// CHECK:STDOUT: %.loc7_4.2.base = getelementptr inbounds nuw [8 x i8], ptr %b, i32 0, i32 0, !dbg !10 +// CHECK:STDOUT: call void @_ZN1A1fEv(ptr %.loc7_4.2.base), !dbg !10 // CHECK:STDOUT: ret void, !dbg !11 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/lower/testdata/interop/cpp/method.carbon b/toolchain/lower/testdata/interop/cpp/method.carbon index 5862cf93ed73..46f956838095 100644 --- a/toolchain/lower/testdata/interop/cpp/method.carbon +++ b/toolchain/lower/testdata/interop/cpp/method.carbon @@ -185,11 +185,11 @@ fn Call(n: Cpp.NeedThunk) { // CHECK:STDOUT: ; Function Attrs: nounwind // CHECK:STDOUT: define void @_CUseVal.Main(ptr %a) #0 !dbg !7 { // CHECK:STDOUT: entry: -// CHECK:STDOUT: %.loc7_4.3.base = getelementptr inbounds nuw [16 x i8], ptr %a, i32 0, i32 0, !dbg !10 -// CHECK:STDOUT: %Base.virt0.call.vtable = load ptr, ptr %.loc7_4.3.base, align 8, !dbg !10 +// CHECK:STDOUT: %.loc7_4.2.base = getelementptr inbounds nuw [16 x i8], ptr %a, i32 0, i32 0, !dbg !10 +// CHECK:STDOUT: %Base.virt0.call.vtable = load ptr, ptr %.loc7_4.2.base, align 8, !dbg !10 // CHECK:STDOUT: %Base.virt0.call = getelementptr ptr, ptr %Base.virt0.call.vtable, i32 0, !dbg !10 // CHECK:STDOUT: %Base.virt0.call.memptr.virtualfn = load ptr, ptr %Base.virt0.call, align 8, !dbg !10 -// CHECK:STDOUT: call void %Base.virt0.call.memptr.virtualfn(ptr %.loc7_4.3.base), !dbg !10 +// CHECK:STDOUT: call void %Base.virt0.call.memptr.virtualfn(ptr %.loc7_4.2.base), !dbg !10 // CHECK:STDOUT: %A.virt1.call.vtable = load ptr, ptr %a, align 8, !dbg !11 // CHECK:STDOUT: %A.virt1.call = getelementptr ptr, ptr %A.virt1.call.vtable, i32 1, !dbg !11 // CHECK:STDOUT: %A.virt1.call.memptr.virtualfn = load ptr, ptr %A.virt1.call, align 8, !dbg !11 diff --git a/toolchain/lower/testdata/interop/cpp/reference.carbon b/toolchain/lower/testdata/interop/cpp/reference.carbon index 76dc8fc41407..d8c2741d0d21 100644 --- a/toolchain/lower/testdata/interop/cpp/reference.carbon +++ b/toolchain/lower/testdata/interop/cpp/reference.carbon @@ -32,12 +32,12 @@ auto TakeConstIntRef(const int&) -> void; fn PassRefs() { var c: Cpp.C; - Cpp.TakeCRef(c); + Cpp.TakeCRef(ref c); Cpp.TakeCRRef({} as Cpp.C); Cpp.TakeConstCRef(c); var n: i32; - Cpp.TakeIntRef(n); + Cpp.TakeIntRef(ref n); Cpp.TakeIntRRef(42 as i32); Cpp.TakeConstIntRef(n); } @@ -61,12 +61,12 @@ auto TakeConstIntRef(const int&, ForceThunk = {}) -> void; fn PassRefs() { var c: Cpp.C; - Cpp.TakeCRef(c); + Cpp.TakeCRef(ref c); Cpp.TakeCRRef({} as Cpp.C); Cpp.TakeConstCRef(c); var n: i32; - Cpp.TakeIntRef(n); + Cpp.TakeIntRef(ref n); Cpp.TakeIntRRef(42 as i32); Cpp.TakeConstIntRef(n); } diff --git a/toolchain/sem_ir/pattern.h b/toolchain/sem_ir/pattern.h index 1bff0e184eda..f374b4ef5623 100644 --- a/toolchain/sem_ir/pattern.h +++ b/toolchain/sem_ir/pattern.h @@ -11,7 +11,7 @@ namespace Carbon::SemIR { // Returns true if `pattern_id` is a `self` parameter pattern, such as -// `self: Foo` or `addr self: Self*`. +// `self: Foo` or `ref self: Self`. auto IsSelfPattern(const File& sem_ir, InstId pattern_id) -> bool; // If `pattern_id` introduces any name bindings, this returns the `EntityNameId`