carbon-language/carbon-lang
1
0 Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-11-15 16:28:10 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity

Switch tests to use the rendered form of diagnostics (#8070)

Browse Source 
Historically, we disabled the rendered form in tests outside of
`toolchain/diagnostics`. The idea was to keep tests shorter and avoid
very long chains of autoupdate before stabilizing due to all the line
numbers and other artifacts in the rendered form.

This PR adds `--diagnostic-line-numbers=[all|first]` and defaults to
`first` in tests. This keeps the rendered form so that we can easily
code review that form and the visual cues it does or doesn't provide.
But it removes all but the first location's line numbers to provide
significantly more stability in tests.

By default, tests get the full unicode line-drawing form of diagnostics
so we can ensure all of the artifacts there make sense with the specific
case being diagnosed, but we do retain some focused ASCII-rendering
tests to ensure that fallback remains usable.

There are some issues here that will be fixed in subsequent PRs.
Notably, we try to keep the frame together in the check lines, and so
force some parts to use the first location. This largely works, but
fails in some edge cases, causing the entire frame to be located
incorrectly. There is a TODO about this that we need to fix, and it only
occurs 6 times across the test suite, so it didn't seem worth
front-loading a fix for here.

Assisted-by: Claude Code
This commit is contained in:
Chandler Carruth authored and GitHub committed 2026-11-05 07:19:59 +00:00
1 parent 0b7059a360
commit d0badecd2a
888 files changed
+39731 -12799
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

toolchain/check/testdata/interop/cpp/function/import/arithmetic_types_bridged.carbon
Vendored
+74 -21
View File
@@ -123,7 +123,12 @@ import Cpp library "wchar_t_param.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_import_wchar_t_param.carbon:[[@LINE+2]]:3-14: error: semantics TODO: `Unsupported: parameter type: wchar_t` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_import_wchar_t_param.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.foo('X');
// CHECK:STDERR: · ━━━━━━┳━━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: parameter type: wchar_t`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo('X');
//@dump-sem-ir-end
@@ -135,15 +140,19 @@ fn F() {
// --- char8_t_param.h
// CHECK:STDERR: ╷ ╭── included from: fail_todo_import_char8_t_param.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./char8_t_param.h:[[@LINE+6]]:10
// CHECK:STDERR: -> │ auto foo(char8_t c) -> void;
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ error: unknown type name 'char8_t' [CppInteropParseError]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo(char8_t c) -> void;
// --- fail_todo_import_char8_t_param.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_todo_import_char8_t_param.carbon:[[@LINE+3]]:10 [InCppInclude]
// CHECK:STDERR: ./char8_t_param.h:2:10: error: unknown type name 'char8_t' [CppInteropParseError]
// CHECK:STDERR:
import Cpp library "char8_t_param.h";
fn F() {
@@ -168,7 +177,12 @@ import Cpp library "char16_t_param.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_import_char16_t_param.carbon:[[@LINE+2]]:3-12: error: semantics TODO: `Unsupported: parameter type: char16_t` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_import_char16_t_param.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.foo(1);
// CHECK:STDERR: · ━━━━━┳━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: parameter type: char16_t`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(1);
//@dump-sem-ir-end
@@ -190,7 +204,12 @@ import Cpp library "char32_t_param.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_import_char32_t_param.carbon:[[@LINE+2]]:3-12: error: semantics TODO: `Unsupported: parameter type: char32_t` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_import_char32_t_param.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.foo(1);
// CHECK:STDERR: · ━━━━━┳━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: parameter type: char32_t`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(1);
//@dump-sem-ir-end
@@ -234,8 +253,17 @@ library "[[@TEST_NAME]]";
import Cpp library "short_param.h";
fn F() {
// CHECK:STDERR: fail_import_short_param_overflow_max.carbon:[[@LINE+3]]:11-16: error: integer value 32768 too large for type `i16` [IntTooLargeForType]
// CHECK:STDERR: ./short_param.h:2:16: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_short_param_overflow_max.carbon:[[@LINE+12]]:11
// CHECK:STDERR: -> │ Cpp.foo(0x8000);
// CHECK:STDERR: · ━━━┳━━
// CHECK:STDERR: · ┗━━┫ error: integer value 32768 too large for type `i16`
// CHECK:STDERR: · ┃ [IntTooLargeForType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./short_param.h
// CHECK:STDERR: │ auto foo(short a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(0x8000);
}
@@ -259,8 +287,17 @@ library "[[@TEST_NAME]]";
import Cpp library "short_param.h";
fn F() {
// CHECK:STDERR: fail_import_short_param_overflow_min.carbon:[[@LINE+3]]:11-17: error: integer value -32769 too large for type `i16` [IntTooLargeForType]
// CHECK:STDERR: ./short_param.h:2:16: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_short_param_overflow_min.carbon:[[@LINE+12]]:11
// CHECK:STDERR: -> │ Cpp.foo(-0x8001);
// CHECK:STDERR: · ━━━┳━━━
// CHECK:STDERR: · ┗━━┫ error: integer value -32769 too large for type `i16`
// CHECK:STDERR: · ┃ [IntTooLargeForType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./short_param.h
// CHECK:STDERR: │ auto foo(short a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(-0x8001);
}
@@ -272,9 +309,20 @@ library "[[@TEST_NAME]]";
import Cpp library "short_param.h";
fn F() {
// CHECK:STDERR: fail_import_short_param_int32_arg.carbon:[[@LINE+4]]:11-18: error: cannot implicitly convert expression of type `i32` to `i16` [ConversionFailure]
// CHECK:STDERR: fail_import_short_param_int32_arg.carbon:[[@LINE+3]]:11-18: note: type `i32` does not implement interface `Core.ImplicitAs(i16)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./short_param.h:2:16: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_short_param_int32_arg.carbon:[[@LINE+15]]:11
// CHECK:STDERR: -> │ Cpp.foo(1 as i32);
// CHECK:STDERR: · ┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type `i32` to
// CHECK:STDERR: · │ ┃ `i16`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `i32` does not implement interface `Core.ImplicitAs(i16)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./short_param.h
// CHECK:STDERR: │ auto foo(short a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(1 as i32);
}
@@ -502,7 +550,12 @@ import Cpp library "bit_int_24_param.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_import_bit_int_24_param.carbon:[[@LINE+2]]:3-12: error: semantics TODO: `Unsupported: parameter type: bit_int_24` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_import_bit_int_24_param.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.foo(1);
// CHECK:STDERR: · ━━━━━┳━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: parameter type: bit_int_24`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(1);
//@dump-sem-ir-end
@@ -1021,7 +1074,7 @@ fn F() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Cpp.ref: <namespace> = 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: %.loc10: Core.CharLiteral = char_value U+0058 [concrete = constants.%.d16]
// CHECK:STDOUT: %.loc15: Core.CharLiteral = char_value U+0058 [concrete = constants.%.d16]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
// CHECK:STDOUT:
@@ -1074,13 +1127,13 @@ fn F() {
// 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: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8]
// CHECK:STDOUT: %impl.elem0: %.33a = impl_witness_access constants.%ImplicitAs.impl_witness.d73, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.f60]
// CHECK:STDOUT: %bound_method.loc11_11.1: <bound method> = bound_method %int_1, %impl.elem0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound]
// CHECK:STDOUT: %bound_method.loc8_11.1: <bound method> = bound_method %int_1, %impl.elem0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound]
// CHECK:STDOUT: %specific_fn: <specific function> = specific_function %impl.elem0, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
// CHECK:STDOUT: %bound_method.loc11_11.2: <bound method> = bound_method %int_1, %specific_fn [concrete = constants.%bound_method]
// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc11_11.2(%int_1) [concrete = constants.%int_1.68a]
// CHECK:STDOUT: %.loc11_11.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.68a]
// CHECK:STDOUT: %.loc11_11.2: %i32 = converted %int_1, %.loc11_11.1 [concrete = constants.%int_1.68a]
// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call imports.%foo.decl(%.loc11_11.2)
// CHECK:STDOUT: %bound_method.loc8_11.2: <bound method> = bound_method %int_1, %specific_fn [concrete = constants.%bound_method]
// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc8_11.2(%int_1) [concrete = constants.%int_1.68a]
// CHECK:STDOUT: %.loc8_11.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_1.68a]
// CHECK:STDOUT: %.loc8_11.2: %i32 = converted %int_1, %.loc8_11.1 [concrete = constants.%int_1.68a]
// CHECK:STDOUT: %foo.call: init %empty_tuple.type = call imports.%foo.decl(%.loc8_11.2)
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/interop/cpp/function/import/arithmetic_types_direct.carbon
Vendored
+46 -8
View File
@@ -54,8 +54,17 @@ library "[[@TEST_NAME]]";
import Cpp library "int_param.h";
fn F() {
// CHECK:STDERR: fail_import_int_param_overflow_max.carbon:[[@LINE+3]]:11-21: error: integer value 2147483648 too large for type `i32` [IntTooLargeForType]
// CHECK:STDERR: ./int_param.h:2:14: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_int_param_overflow_max.carbon:[[@LINE+12]]:11
// CHECK:STDERR: -> │ Cpp.foo(0x8000_0000);
// CHECK:STDERR: · ━━━━━┳━━━━━
// CHECK:STDERR: · ┗━━┫ error: integer value 2147483648 too large for type `i32`
// CHECK:STDERR: · ┃ [IntTooLargeForType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./int_param.h
// CHECK:STDERR: │ auto foo(int a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(0x8000_0000);
}
@@ -79,8 +88,17 @@ library "[[@TEST_NAME]]";
import Cpp library "int_param.h";
fn F() {
// CHECK:STDERR: fail_import_int_param_overflow_min.carbon:[[@LINE+3]]:11-22: error: integer value -2147483649 too large for type `i32` [IntTooLargeForType]
// CHECK:STDERR: ./int_param.h:2:14: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_int_param_overflow_min.carbon:[[@LINE+12]]:11
// CHECK:STDERR: -> │ Cpp.foo(-0x8000_0001);
// CHECK:STDERR: · ━━━━━━┳━━━━━
// CHECK:STDERR: · ┗━━┫ error: integer value -2147483649 too large for type `i32`
// CHECK:STDERR: · ┃ [IntTooLargeForType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./int_param.h
// CHECK:STDERR: │ auto foo(int a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(-0x8000_0001);
}
@@ -154,15 +172,35 @@ import Cpp library "unsigned_int_param.h";
fn F() {
Cpp.foo(0);
// CHECK:STDERR: fail_import_unsigned_int_param_overflow.carbon:[[@LINE+3]]:11-12: error: negative integer value -1 converted to unsigned type `u32` [NegativeIntInUnsignedType]
// CHECK:STDERR: ./unsigned_int_param.h:2:23: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_unsigned_int_param_overflow.carbon:[[@LINE+13]]:11
// CHECK:STDERR: -> │ Cpp.foo(-1);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: negative integer value -1 converted to unsigned type `u32`
// CHECK:STDERR: · ┃ [NegativeIntInUnsignedType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./unsigned_int_param.h
// CHECK:STDERR: │ auto foo(unsigned int a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(-1);
Cpp.foo(0x0_FFFF_FFFF);
// CHECK:STDERR: fail_import_unsigned_int_param_overflow.carbon:[[@LINE+3]]:11-23: error: integer value 4294967296 too large for type `u32` [IntTooLargeForType]
// CHECK:STDERR: ./unsigned_int_param.h:2:23: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_unsigned_int_param_overflow.carbon:[[@LINE+13]]:11
// CHECK:STDERR: -> │ Cpp.foo(0x1_0000_0000);
// CHECK:STDERR: · ━━━━━━┳━━━━━━
// CHECK:STDERR: · ┗━━┫ error: integer value 4294967296 too large for type `u32`
// CHECK:STDERR: · ┃ [IntTooLargeForType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./unsigned_int_param.h
// CHECK:STDERR: │ auto foo(unsigned int a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(0x1_0000_0000);
}
toolchain/check/testdata/interop/cpp/function/import/class.carbon
Vendored
+211 -56
View File
@@ -18,36 +18,88 @@
class ForwardDeclaredClass;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h:[[@LINE+16]]:6
// CHECK:STDERR: │ class ForwardDeclaredClass;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'ForwardDeclaredClass' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_decl_param1(ForwardDeclaredClass) -> void;
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: argument type 'ForwardDeclaredClass' is incomplete
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_param_type.carbon
// CHECK:STDERR: │ Cpp.foo_decl_param1(*p);
// CHECK:STDERR: · ───────────┬───────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_decl_param1(ForwardDeclaredClass) -> void;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h:[[@LINE+16]]:6
// CHECK:STDERR: │ class ForwardDeclaredClass;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'ForwardDeclaredClass' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_decl_param2(ForwardDeclaredClass) -> void;
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: argument type 'ForwardDeclaredClass' is incomplete
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_param_type.carbon
// CHECK:STDERR: │ Cpp.foo_decl_param2(*p);
// CHECK:STDERR: · ───────────┬───────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_decl_param2(ForwardDeclaredClass) -> void;
// --- fail_import_decl_value_param_type.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE+3]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:4:6-20: error: argument type 'ForwardDeclaredClass' is incomplete [CppInteropParseError]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: forward declaration of 'ForwardDeclaredClass' [CppInteropParseNote]
import Cpp library "decl_value_param_type.h";
fn F(p: Cpp.ForwardDeclaredClass*) {
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+5]]:3-25: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_param_type.carbon:[[@LINE+19]]:23
// CHECK:STDERR: -> │ Cpp.foo_decl_param1(*p);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: forming value of incomplete type
// CHECK:STDERR: · ┃ `Cpp.ForwardDeclaredClass`
// CHECK:STDERR: · ┃ [IncompleteTypeInValueConversion]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h
// CHECK:STDERR: │ class ForwardDeclaredClass;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo_decl_param1(ForwardDeclaredClass) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-5]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:5:6-20: error: argument type 'ForwardDeclaredClass' is incomplete [CppInteropParseError]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: forward declaration of 'ForwardDeclaredClass' [CppInteropParseNote]
Cpp.foo_decl_param1(*p);
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+12]]:3-25: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE-3]]:23-24: error: forming value of incomplete type `Cpp.ForwardDeclaredClass` [IncompleteTypeInValueConversion]
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-12]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_param_type.h:4:42: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+5]]:23-24: error: forming value of incomplete type `Cpp.ForwardDeclaredClass` [IncompleteTypeInValueConversion]
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-17]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_param_type.h:5:42: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_param_type.carbon:[[@LINE+19]]:23
// CHECK:STDERR: -> │ Cpp.foo_decl_param2(*p);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: forming value of incomplete type
// CHECK:STDERR: · ┃ `Cpp.ForwardDeclaredClass`
// CHECK:STDERR: · ┃ [IncompleteTypeInValueConversion]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h
// CHECK:STDERR: │ class ForwardDeclaredClass;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo_decl_param2(ForwardDeclaredClass) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo_decl_param2(*p);
}
@@ -84,22 +136,39 @@ class NonCopyableClass {
NonCopyableClass(const NonCopyableClass&) = delete;
};
// CHECK:STDERR: ╷ ╭── included from: fail_import_non_copyable_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./non_copyable_param_type.h:[[@LINE+22]]:6
// CHECK:STDERR: │ NonCopyableClass(const NonCopyableClass&) = delete;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ 'NonCopyableClass' has been explicitly marked deleted here
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_non_copyable_param(NonCopyableClass) -> void;
// CHECK:STDERR: · ━━━━━━━━━━━┳━━━━━━━━━━ ┬
// CHECK:STDERR: · ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ error: call to deleted
// CHECK:STDERR: · │ ┃ constructor of
// CHECK:STDERR: · │ ┃ 'NonCopyableClass'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ passing argument to parameter
// CHECK:STDERR: · │ here
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_non_copyable_param_type.carbon
// CHECK:STDERR: │ Cpp.foo_non_copyable_param(c);
// CHECK:STDERR: · ──────────────┬──────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_non_copyable_param(NonCopyableClass) -> void;
// --- fail_import_non_copyable_param_type.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_import_non_copyable_param_type.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./non_copyable_param_type.h:6:6-27: error: call to deleted constructor of 'NonCopyableClass' [CppInteropParseError]
// CHECK:STDERR: ./non_copyable_param_type.h:3:3: note: 'NonCopyableClass' has been explicitly marked deleted here [CppInteropParseNote]
// CHECK:STDERR: ./non_copyable_param_type.h:6:45: note: passing argument to parameter here [CppInteropParseNote]
import Cpp library "non_copyable_param_type.h";
fn F(c: Cpp.NonCopyableClass) {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_import_non_copyable_param_type.carbon:[[@LINE+2]]:3-31: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
Cpp.foo_non_copyable_param(c);
//@dump-sem-ir-end
}
@@ -114,6 +183,75 @@ struct MoveOnlyClass {
MoveOnlyClass(MoveOnlyClass&&);
};
// CHECK:STDERR: ╷ ╭── included from: fail_pass_move_only_param_value.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./move_only_param_type.h:[[@LINE+68]]:6
// CHECK:STDERR: │ MoveOnlyClass(MoveOnlyClass&&);
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ copy constructor is implicitly deleted because 'MoveOnlyClass' has a
// CHECK:STDERR: · │ user-declared move constructor
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_move_only_param(MoveOnlyClass) -> void;
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━ ┬
// CHECK:STDERR: · ┗━━━━━━━━━━━━━━━━━━━━━━━━━━┫ error: call to implicitly-deleted
// CHECK:STDERR: · │ ┃ copy constructor of
// CHECK:STDERR: · │ ┃ 'MoveOnlyClass'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ passing argument to parameter here
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_pass_move_only_param_value.carbon
// CHECK:STDERR: │ Cpp.foo_move_only_param(c);
// CHECK:STDERR: · ─────────────┬────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: ╷ ╭── included from: fail_pass_move_only_param_ref.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./move_only_param_type.h:[[@LINE+45]]:6
// CHECK:STDERR: │ MoveOnlyClass(MoveOnlyClass&&);
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ copy constructor is implicitly deleted because 'MoveOnlyClass' has a
// CHECK:STDERR: · │ user-declared move constructor
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_move_only_param(MoveOnlyClass) -> void;
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━ ┬
// CHECK:STDERR: · ┗━━━━━━━━━━━━━━━━━━━━━━━━━━┫ error: call to implicitly-deleted
// CHECK:STDERR: · │ ┃ copy constructor of
// CHECK:STDERR: · │ ┃ 'MoveOnlyClass'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ passing argument to parameter here
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_pass_move_only_param_ref.carbon
// CHECK:STDERR: │ Cpp.foo_move_only_param(c);
// CHECK:STDERR: · ─────────────┬────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: ╷ ╭── included from: fail_todo_pass_move_only_param_ref_by_move.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./move_only_param_type.h:[[@LINE+22]]:6
// CHECK:STDERR: │ MoveOnlyClass(MoveOnlyClass&&);
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ copy constructor is implicitly deleted because 'MoveOnlyClass' has a
// CHECK:STDERR: · │ user-declared move constructor
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_move_only_param(MoveOnlyClass) -> void;
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━ ┬
// CHECK:STDERR: · ┗━━━━━━━━━━━━━━━━━━━━━━━━━━┫ error: call to implicitly-deleted
// CHECK:STDERR: · │ ┃ copy constructor of
// CHECK:STDERR: · │ ┃ 'MoveOnlyClass'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ passing argument to parameter here
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_todo_pass_move_only_param_ref_by_move.carbon
// CHECK:STDERR: │ Cpp.foo_move_only_param(Cpp.move_move_only(ref c));
// CHECK:STDERR: · ─────────────────────────┬────────────────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_move_only_param(MoveOnlyClass) -> void;
auto make_move_only() -> MoveOnlyClass;
auto move_move_only(MoveOnlyClass&) -> MoveOnlyClass&&;
@@ -134,15 +272,9 @@ fn F() {
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_pass_move_only_param_value.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./move_only_param_type.h:6:6-24: error: call to implicitly-deleted copy constructor of 'MoveOnlyClass' [CppInteropParseError]
// CHECK:STDERR: ./move_only_param_type.h:3:3: note: copy constructor is implicitly deleted because 'MoveOnlyClass' has a user-declared move constructor [CppInteropParseNote]
// CHECK:STDERR: ./move_only_param_type.h:6:39: note: passing argument to parameter here [CppInteropParseNote]
import Cpp library "move_only_param_type.h";
fn F(c: Cpp.MoveOnlyClass) {
// CHECK:STDERR: fail_pass_move_only_param_value.carbon:[[@LINE+2]]:3-28: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
Cpp.foo_move_only_param(c);
}
@@ -150,15 +282,9 @@ fn F(c: Cpp.MoveOnlyClass) {
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_pass_move_only_param_ref.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./move_only_param_type.h:6:6-24: error: call to implicitly-deleted copy constructor of 'MoveOnlyClass' [CppInteropParseError]
// CHECK:STDERR: ./move_only_param_type.h:3:3: note: copy constructor is implicitly deleted because 'MoveOnlyClass' has a user-declared move constructor [CppInteropParseNote]
// CHECK:STDERR: ./move_only_param_type.h:6:39: note: passing argument to parameter here [CppInteropParseNote]
import Cpp library "move_only_param_type.h";
fn F(ref c: Cpp.MoveOnlyClass) {
// CHECK:STDERR: fail_pass_move_only_param_ref.carbon:[[@LINE+2]]:3-28: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
Cpp.foo_move_only_param(c);
}
@@ -166,15 +292,9 @@ fn F(ref c: Cpp.MoveOnlyClass) {
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_todo_pass_move_only_param_ref_by_move.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./move_only_param_type.h:6:6-24: error: call to implicitly-deleted copy constructor of 'MoveOnlyClass' [CppInteropParseError]
// CHECK:STDERR: ./move_only_param_type.h:3:3: note: copy constructor is implicitly deleted because 'MoveOnlyClass' has a user-declared move constructor [CppInteropParseNote]
// CHECK:STDERR: ./move_only_param_type.h:6:39: note: passing argument to parameter here [CppInteropParseNote]
import Cpp library "move_only_param_type.h";
fn F(ref c: Cpp.MoveOnlyClass) {
// CHECK:STDERR: fail_todo_pass_move_only_param_ref_by_move.carbon:[[@LINE+2]]:3-52: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
Cpp.foo_move_only_param(Cpp.move_move_only(ref c));
}
@@ -359,9 +479,18 @@ library "[[@TEST_NAME]]";
import Cpp library "incomplete.h";
fn F() {
// CHECK:STDERR: fail_import_incomplete.carbon:[[@LINE+4]]:3-20: error: member access into incomplete class `Cpp.Incomplete` [QualifiedExprInIncompleteClassScope]
// CHECK:STDERR: included from: fail_import_incomplete.carbon:[[@LINE-4]]:10 [InCppInclude]
// CHECK:STDERR: ./incomplete.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ╭─┤ fail_import_incomplete.carbon:[[@LINE+13]]:3
// CHECK:STDERR: -> │ Cpp.Incomplete.foo();
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: member access into incomplete class `Cpp.Incomplete`
// CHECK:STDERR: · ┃ [QualifiedExprInIncompleteClassScope]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_incomplete.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./incomplete.h
// CHECK:STDERR: │ class Incomplete;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.Incomplete.foo();
}
@@ -418,25 +547,51 @@ fn F(c: Cpp.DefPointerParamClass*) {
class DeclValueReturnClass;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_return_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_return_type.h:[[@LINE+18]]:6
// CHECK:STDERR: │ class DeclValueReturnClass;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'DeclValueReturnClass' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_decl_value_return() -> DeclValueReturnClass;
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: calling 'foo_decl_value_return' with incomplete return type
// CHECK:STDERR: · │ ┃ 'DeclValueReturnClass'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ 'foo_decl_value_return' declared here [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_return_type.carbon
// CHECK:STDERR: │ Cpp.foo_decl_value_return();
// CHECK:STDERR: · ─────────────┬─────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_decl_value_return() -> DeclValueReturnClass;
// --- fail_import_decl_value_return_type.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_import_decl_value_return_type.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_return_type.h:4:6-26: error: calling 'foo_decl_value_return' with incomplete return type 'DeclValueReturnClass' [CppInteropParseError]
// CHECK:STDERR: ./decl_value_return_type.h:4:6: note: 'foo_decl_value_return' declared here [CppInteropParseNote]
// CHECK:STDERR: ./decl_value_return_type.h:2:7: note: forward declaration of 'DeclValueReturnClass' [CppInteropParseNote]
import Cpp library "decl_value_return_type.h";
fn F() {
// CHECK:STDERR: fail_import_decl_value_return_type.carbon:[[@LINE+7]]:3-29: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_return_type.carbon:[[@LINE+5]]:3-29: error: function returns incomplete type `Cpp.DeclValueReturnClass` [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: included from: fail_import_decl_value_return_type.carbon:[[@LINE-6]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_return_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_return_type.h:4:33: note: return type declared here [IncompleteReturnTypeHere]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_return_type.carbon:[[@LINE+18]]:3
// CHECK:STDERR: -> │ Cpp.foo_decl_value_return();
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: function returns incomplete type `Cpp.DeclValueReturnClass`
// CHECK:STDERR: · ┃ [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_return_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_return_type.h
// CHECK:STDERR: │ class DeclValueReturnClass;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo_decl_value_return() -> DeclValueReturnClass;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ return type declared here
// CHECK:STDERR: · │ [IncompleteReturnTypeHere]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo_decl_value_return();
}
@@ -575,7 +730,7 @@ fn F() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F(%c.param: %NonCopyableClass) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Cpp.ref.loc14: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %Cpp.ref.loc8: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %foo_non_copyable_param.ref: %foo_non_copyable_param.cpp_overload_set.type = name_ref foo_non_copyable_param, imports.%foo_non_copyable_param.cpp_overload_set.value [concrete = constants.%foo_non_copyable_param.cpp_overload_set.value]
// CHECK:STDOUT: %c.ref: %NonCopyableClass = name_ref c, %c
// CHECK:STDOUT: %foo_non_copyable_param.call: init %empty_tuple.type = call imports.%foo_non_copyable_param.decl(%c.ref)
toolchain/check/testdata/interop/cpp/function/import/constexpr.carbon
Vendored
+72 -39
View File
@@ -72,7 +72,12 @@ constexpr int invalid_const_fn(int a) {
}
''';
// CHECK:STDERR: fail_invalid_constant_eval.carbon:[[@LINE+2]]:19-41: error: array bound is not a constant [InvalidArrayExpr]
// CHECK:STDERR: ╭─┤ fail_invalid_constant_eval.carbon:[[@LINE+7]]:19
// CHECK:STDERR: -> │ let a: array(i32, Cpp.invalid_const_fn(5)) = (1, 2, 3);
// CHECK:STDERR: · ━━━━━━━━━━━┳━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: array bound is not a constant
// CHECK:STDERR: · ┃ [InvalidArrayExpr]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
let a: array(i32, Cpp.invalid_const_fn(5)) = (1, 2, 3);
@@ -101,16 +106,36 @@ var a: i32 = 0;
// TODO: This is failing when building the thunk, not when calling it.
inline Cpp '''
// CHECK:STDERR: fail_nonconstant_consteval_call.carbon:[[@LINE+3]]:15: error: call to consteval function 'nonconst_consteval_fn' is not a constant expression [CppInteropParseError]
// CHECK:STDERR: fail_nonconstant_consteval_call.carbon:[[@LINE+2]]:15: note: function parameter 'r' with unknown value cannot be used in a constant expression [CppInteropParseNote]
// CHECK:STDERR: fail_nonconstant_consteval_call.carbon:[[@LINE+1]]:15: note: declared here [CppInteropParseNote]
// CHECK:STDERR: ╭─┤ fail_nonconstant_consteval_call.carbon:[[@LINE+16]]:15
// CHECK:STDERR: -> │ consteval int nonconst_consteval_fn(const int &r) { return r; }
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ error: call to consteval function 'nonconst_consteval_fn' is
// CHECK:STDERR: · │ ┃ not a constant expression
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ function parameter 'r' with unknown value cannot be used in
// CHECK:STDERR: · │ │ a constant expression
// CHECK:STDERR: · │ │ [CppInteropParseNote]
// CHECK:STDERR: · ╰──────┤ declared here [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ var b: i32 = Cpp.nonconst_consteval_fn(a);
// CHECK:STDERR: · ──────────────┬─────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
consteval int nonconst_consteval_fn(const int &r) { return r; }
''';
// CHECK:STDERR: fail_nonconstant_consteval_call.carbon:[[@LINE+5]]:14-41: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_nonconstant_consteval_call.carbon:[[@LINE+3]]:14-41: error: non-constant call to compile-time-only function [NonConstantCallToCompTimeOnlyFunction]
// CHECK:STDERR: fail_nonconstant_consteval_call.carbon:[[@LINE-6]]:15: note: compile-time-only function declared here [CompTimeOnlyFunctionHere]
// CHECK:STDERR: ╭─┤ fail_nonconstant_consteval_call.carbon:[[@LINE+12]]:14
// CHECK:STDERR: │ consteval int nonconst_consteval_fn(const int &r) { return r; }
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ compile-time-only function declared here
// CHECK:STDERR: · │ [CompTimeOnlyFunctionHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ var b: i32 = Cpp.nonconst_consteval_fn(a);
// CHECK:STDERR: · ━━━━━━━━┳━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: non-constant call to compile-time-only function
// CHECK:STDERR: · ┃ [NonConstantCallToCompTimeOnlyFunction]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
var b: i32 = Cpp.nonconst_consteval_fn(a);
@@ -130,14 +155,22 @@ struct ConstexprC {
// TODO: This should probably be allowed.
eval fn F() -> i32 {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_constructor.carbon:[[@LINE+1]]:27: error: expression is runtime; expected constant [EvalRequiresConstantValue]
// CHECK:STDERR: ╭─┤ fail_todo_constructor.carbon:[[@LINE+11]]:27
// CHECK:STDERR: -> │ let c: Cpp.ConstexprC = 3;
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ error: expression is runtime; expected constant
// CHECK:STDERR: · ┃ [EvalRequiresConstantValue]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ let a: array(i32, F()) = (1, 2, 3);
// CHECK:STDERR: · ─┬─
// CHECK:STDERR: · ╰──┤ in call to F here [InCallToEvalFn]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
let c: Cpp.ConstexprC = 3;
return c.a;
//@dump-sem-ir-end
}
// CHECK:STDERR: fail_todo_constructor.carbon:[[@LINE+2]]:19-21: note: in call to F here [InCallToEvalFn]
// CHECK:STDERR:
let a: array(i32, F()) = (1, 2, 3);
// CHECK:STDOUT: --- fail_todo_constructor.carbon
@@ -215,43 +248,43 @@ let a: array(i32, F()) = (1, 2, 3);
// CHECK:STDOUT: fn @F() -> out %return.param: %i32 {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3.1ba]
// CHECK:STDOUT: %.loc17_27.1: ref %ConstexprC = temporary_storage
// CHECK:STDOUT: %impl.elem0.loc17: %.33a = impl_witness_access constants.%ImplicitAs.impl_witness.d73, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.f60]
// CHECK:STDOUT: %bound_method.loc17_27.1: <bound method> = bound_method %int_3, %impl.elem0.loc17 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound]
// CHECK:STDOUT: %specific_fn.loc17: <specific function> = specific_function %impl.elem0.loc17, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
// CHECK:STDOUT: %bound_method.loc17_27.2: <bound method> = bound_method %int_3, %specific_fn.loc17 [concrete = constants.%bound_method]
// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc17_27.2(%int_3) [concrete = constants.%int_3.9f3]
// CHECK:STDOUT: %.loc17_27.2: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_3.9f3]
// CHECK:STDOUT: %.loc17_27.3: %i32 = converted %int_3, %.loc17_27.2 [concrete = constants.%int_3.9f3]
// CHECK:STDOUT: %addr: %ptr.0b8 = addr_of %.loc17_27.1
// CHECK:STDOUT: %ConstexprC__carbon_thunk.call: init %empty_tuple.type = call imports.%ConstexprC__carbon_thunk.decl(%.loc17_27.3, %addr)
// CHECK:STDOUT: %.loc17_27.4: init %ConstexprC to %.loc17_27.1 = mark_in_place_init %ConstexprC__carbon_thunk.call
// CHECK:STDOUT: %.loc17_27.5: init %ConstexprC = converted %int_3, %.loc17_27.4
// CHECK:STDOUT: %.loc17_27.6: ref %ConstexprC = temporary %.loc17_27.1, %.loc17_27.5
// CHECK:STDOUT: %.loc17_27.7: %ConstexprC = acquire_value %.loc17_27.6
// CHECK:STDOUT: %.loc17_13: type = splice_block %ConstexprC.ref [concrete = constants.%ConstexprC] {
// CHECK:STDOUT: %.loc27_27.1: ref %ConstexprC = temporary_storage
// CHECK:STDOUT: %impl.elem0.loc27: %.33a = impl_witness_access constants.%ImplicitAs.impl_witness.d73, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.f60]
// CHECK:STDOUT: %bound_method.loc27_27.1: <bound method> = bound_method %int_3, %impl.elem0.loc27 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound]
// CHECK:STDOUT: %specific_fn.loc27: <specific function> = specific_function %impl.elem0.loc27, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
// CHECK:STDOUT: %bound_method.loc27_27.2: <bound method> = bound_method %int_3, %specific_fn.loc27 [concrete = constants.%bound_method]
// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc27_27.2(%int_3) [concrete = constants.%int_3.9f3]
// CHECK:STDOUT: %.loc27_27.2: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_3.9f3]
// CHECK:STDOUT: %.loc27_27.3: %i32 = converted %int_3, %.loc27_27.2 [concrete = constants.%int_3.9f3]
// CHECK:STDOUT: %addr: %ptr.0b8 = addr_of %.loc27_27.1
// CHECK:STDOUT: %ConstexprC__carbon_thunk.call: init %empty_tuple.type = call imports.%ConstexprC__carbon_thunk.decl(%.loc27_27.3, %addr)
// CHECK:STDOUT: %.loc27_27.4: init %ConstexprC to %.loc27_27.1 = mark_in_place_init %ConstexprC__carbon_thunk.call
// CHECK:STDOUT: %.loc27_27.5: init %ConstexprC = converted %int_3, %.loc27_27.4
// CHECK:STDOUT: %.loc27_27.6: ref %ConstexprC = temporary %.loc27_27.1, %.loc27_27.5
// CHECK:STDOUT: %.loc27_27.7: %ConstexprC = acquire_value %.loc27_27.6
// CHECK:STDOUT: %.loc27_13: type = splice_block %ConstexprC.ref [concrete = constants.%ConstexprC] {
// CHECK:STDOUT: %Cpp.ref: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %ConstexprC.ref: type = name_ref ConstexprC, imports.%ConstexprC.decl [concrete = constants.%ConstexprC]
// CHECK:STDOUT: }
// CHECK:STDOUT: %c: %ConstexprC = wrapper_binding c, %.loc17_27.7
// CHECK:STDOUT: %c: %ConstexprC = wrapper_binding c, %.loc27_27.7
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %c.patt: %pattern_type.3cc = value_binding_pattern c [concrete = constants.%c.patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %c.ref: %ConstexprC = name_ref c, %c
// CHECK:STDOUT: %a.ref: %ConstexprC.elem = name_ref a, @ConstexprC.%field_decl [concrete = @ConstexprC.%field_decl]
// CHECK:STDOUT: %.loc18_11.1: ref %i32 = class_element_access %c.ref, element0
// CHECK:STDOUT: %.loc18_11.2: %i32 = acquire_value %.loc18_11.1
// CHECK:STDOUT: %impl.elem0.loc18: %.2b9 = impl_witness_access constants.%Copy.impl_witness.8af, element0 [concrete = constants.%Int.as.Copy.impl.Op.cae]
// CHECK:STDOUT: %bound_method.loc18_11.1: <bound method> = bound_method %.loc18_11.2, %impl.elem0.loc18
// CHECK:STDOUT: %specific_fn.loc18: <specific function> = specific_function %impl.elem0.loc18, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn]
// CHECK:STDOUT: %bound_method.loc18_11.2: <bound method> = bound_method %.loc18_11.2, %specific_fn.loc18
// CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc18_11.2(%.loc18_11.2)
// CHECK:STDOUT: %Destroy.facet.loc17_27.1: %Destroy.type = facet_value constants.%ConstexprC, (constants.%DestroyImpl.impl_witness.a0d, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc17_27.8: %Destroy.type = converted constants.%ConstexprC, %Destroy.facet.loc17_27.1 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %Destroy.facet.loc17_27.2: %Destroy.type = facet_value constants.%ConstexprC, (constants.%DestroyImpl.impl_witness.a0d, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc17_27.9: %Destroy.type = converted constants.%ConstexprC, %Destroy.facet.loc17_27.2 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc28_11.1: ref %i32 = class_element_access %c.ref, element0
// CHECK:STDOUT: %.loc28_11.2: %i32 = acquire_value %.loc28_11.1
// CHECK:STDOUT: %impl.elem0.loc28: %.2b9 = impl_witness_access constants.%Copy.impl_witness.8af, element0 [concrete = constants.%Int.as.Copy.impl.Op.cae]
// CHECK:STDOUT: %bound_method.loc28_11.1: <bound method> = bound_method %.loc28_11.2, %impl.elem0.loc28
// CHECK:STDOUT: %specific_fn.loc28: <specific function> = specific_function %impl.elem0.loc28, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn]
// CHECK:STDOUT: %bound_method.loc28_11.2: <bound method> = bound_method %.loc28_11.2, %specific_fn.loc28
// CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc28_11.2(%.loc28_11.2)
// CHECK:STDOUT: %Destroy.facet.loc27_27.1: %Destroy.type = facet_value constants.%ConstexprC, (constants.%DestroyImpl.impl_witness.a0d, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc27_27.8: %Destroy.type = converted constants.%ConstexprC, %Destroy.facet.loc27_27.1 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %Destroy.facet.loc27_27.2: %Destroy.type = facet_value constants.%ConstexprC, (constants.%DestroyImpl.impl_witness.a0d, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc27_27.9: %Destroy.type = converted constants.%ConstexprC, %Destroy.facet.loc27_27.2 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call: init %empty_tuple.type = call %SelfDestruct.specific_fn(%.loc17_27.6)
// CHECK:STDOUT: %SelfDestruct.call: init %empty_tuple.type = call %SelfDestruct.specific_fn(%.loc27_27.6)
// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/interop/cpp/function/import/decayed_param.carbon
Vendored
+319 -289
View File
@@ -46,20 +46,50 @@ fn G(n: i32) -> i32;
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_call_params_2.carbon:[[@LINE+2]]:21-32: error: call argument of type `<type of Cpp.Function>` is not supported [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╭─┤ fail_todo_call_params_2.carbon:[[@LINE+8]]:21
// CHECK:STDERR: -> │ Cpp.TakesFunction(Cpp.Function);
// CHECK:STDERR: · ┳━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: call argument of type `<type of Cpp.Function>`
// CHECK:STDERR: · ┃ is not supported
// CHECK:STDERR: · ┃ [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesFunction(Cpp.Function);
var n: array(i32, 42);
// CHECK:STDERR: fail_todo_call_params_2.carbon:[[@LINE+4]]:3-19: error: no matching function for call to 'TakesFunction' [CppInteropParseError]
// CHECK:STDERR: ./params.h:3:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./params.h:3:20-29: note: no known conversion from 'int * _Nonnull' to 'int (*)(int)' for 1st argument [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_todo_call_params_2.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.TakesFunction(&n[0]);
// CHECK:STDERR: · ━━━━━━━━┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesFunction'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./params.h
// CHECK:STDERR: │ void TakesFunction(int f(int));
// CHECK:STDERR: · ┬ ┬─────────
// CHECK:STDERR: · ╰────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ no known conversion from 'int * _Nonnull' to 'int
// CHECK:STDERR: · │ (*)(int)' for 1st argument
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesFunction(&n[0]);
// CHECK:STDERR: fail_todo_call_params_2.carbon:[[@LINE+4]]:21-31: error: cannot implicitly convert expression of type `Cpp.nullptr_t` to `<C++ type int (*)(int)>` [ConversionFailure]
// CHECK:STDERR: fail_todo_call_params_2.carbon:[[@LINE+3]]:21-31: note: type `Cpp.nullptr_t` does not implement interface `Core.ImplicitAs(<C++ type int (*)(int)>)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./params.h:3:24: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_call_params_2.carbon:[[@LINE+17]]:21
// CHECK:STDERR: -> │ Cpp.TakesFunction(Cpp.nullptr);
// CHECK:STDERR: · ┳━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `Cpp.nullptr_t` to `<C++ type int (*)(int)>`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `Cpp.nullptr_t` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(<C++ type int (*)(int)>)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./params.h
// CHECK:STDERR: │ void TakesFunction(int f(int));
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesFunction(Cpp.nullptr);
//@dump-sem-ir-end
@@ -771,10 +801,10 @@ fn F() {
// CHECK:STDOUT: %.659: type = cpp_fn_ptr_type clang_function_pointer_type61000000 [concrete]
// CHECK:STDOUT: %TakesFunction.type: type = fn_type @TakesFunction [concrete]
// CHECK:STDOUT: %TakesFunction: %TakesFunction.type = struct_value () [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.type.6870fd.2: type = fn_type @SubobjectDestroy.WithSelf.Op.loc14_3.1 [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.type.6870fd.2: type = fn_type @SubobjectDestroy.WithSelf.Op.loc20_3.1 [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.30f1ee.2: %SubobjectDestroy.WithSelf.Op.type.6870fd.2 = struct_value () [concrete]
// CHECK:STDOUT: %custom_witness.b80ef6.2: <witness> = custom_witness (%SubobjectDestroy.WithSelf.Op.30f1ee.2), @SubobjectDestroy [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.type.6870fd.3: type = fn_type @SubobjectDestroy.WithSelf.Op.loc14_3.2 [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.type.6870fd.3: type = fn_type @SubobjectDestroy.WithSelf.Op.loc20_3.2 [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.30f1ee.3: %SubobjectDestroy.WithSelf.Op.type.6870fd.3 = struct_value () [concrete]
// CHECK:STDOUT: %int_41: Core.IntLiteral = int_value 41 [concrete]
// CHECK:STDOUT: %SubobjectDestroy.facet.49a: %SubobjectDestroy.type = facet_value %i32, (%custom_witness.b80ef6.2) [concrete]
@@ -851,20 +881,20 @@ fn F() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Cpp.ref.loc12_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesFunction.ref.loc12: %TakesFunction.cpp_overload_set.type = name_ref TakesFunction, imports.%TakesFunction.cpp_overload_set.value [concrete = constants.%TakesFunction.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc12_21: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %Cpp.ref.loc18_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesFunction.ref.loc18: %TakesFunction.cpp_overload_set.type = name_ref TakesFunction, imports.%TakesFunction.cpp_overload_set.value [concrete = constants.%TakesFunction.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc18_21: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %Function.ref: %Function.cpp_overload_set.type = name_ref Function, imports.%Function.cpp_overload_set.value [concrete = constants.%Function.cpp_overload_set.value]
// CHECK:STDOUT: %n.var: ref %Array.3b5 = var_storage %n.var_patt
// CHECK:STDOUT: %DefaultOrUnformed.facet: %DefaultOrUnformed.type = facet_value constants.%Array.3b5, (constants.%DefaultOrUnformed.impl_witness.4bc) [concrete = constants.%DefaultOrUnformed.facet]
// CHECK:STDOUT: %.loc14_24.1: %DefaultOrUnformed.type = converted constants.%Array.3b5, %DefaultOrUnformed.facet [concrete = constants.%DefaultOrUnformed.facet]
// CHECK:STDOUT: %as_type: type = facet_access_type %.loc14_24.1 [concrete = constants.%Array.3b5]
// CHECK:STDOUT: %.loc14_24.2: type = converted %.loc14_24.1, %as_type [concrete = constants.%Array.3b5]
// CHECK:STDOUT: %.loc20_24.1: %DefaultOrUnformed.type = converted constants.%Array.3b5, %DefaultOrUnformed.facet [concrete = constants.%DefaultOrUnformed.facet]
// CHECK:STDOUT: %as_type: type = facet_access_type %.loc20_24.1 [concrete = constants.%Array.3b5]
// CHECK:STDOUT: %.loc20_24.2: type = converted %.loc20_24.1, %as_type [concrete = constants.%Array.3b5]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %.loc14_3.1: ref %Array.3b5 = splice_block %n.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call: init %Array.3b5 to %.loc14_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn()
// CHECK:STDOUT: %.loc20_3.1: ref %Array.3b5 = splice_block %n.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call: init %Array.3b5 to %.loc20_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn()
// CHECK:STDOUT: assign %n.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call
// CHECK:STDOUT: %.loc14_23: type = splice_block %Array [concrete = constants.%Array.3b5] {
// CHECK:STDOUT: %.loc20_23: type = splice_block %Array [concrete = constants.%Array.3b5] {
// CHECK:STDOUT: %i32: type = type_literal constants.%i32 [concrete = constants.%i32]
// CHECK:STDOUT: %int_42: Core.IntLiteral = int_value 42 [concrete = constants.%int_42]
// CHECK:STDOUT: %Array: type = class_type @Array, @Array(constants.%i32, constants.%int_42) [concrete = constants.%Array.3b5]
@@ -874,375 +904,375 @@ fn F() {
// CHECK:STDOUT: %n.patt: %pattern_type.9c3 = ref_binding_pattern n [concrete = constants.%n.patt.368]
// CHECK:STDOUT: %n.var_patt: %pattern_type.9c3 = var_pattern %n.patt [concrete = constants.%n.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc19: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesFunction.ref.loc19: %TakesFunction.cpp_overload_set.type = name_ref TakesFunction, imports.%TakesFunction.cpp_overload_set.value [concrete = constants.%TakesFunction.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc36: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesFunction.ref.loc36: %TakesFunction.cpp_overload_set.type = name_ref TakesFunction, imports.%TakesFunction.cpp_overload_set.value [concrete = constants.%TakesFunction.cpp_overload_set.value]
// CHECK:STDOUT: %n.ref: ref %Array.3b5 = name_ref n, %n
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6]
// CHECK:STDOUT: %impl.elem0: %.33a = impl_witness_access constants.%ImplicitAs.impl_witness.d73, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.f60]
// CHECK:STDOUT: %bound_method.loc19_24.1: <bound method> = bound_method %int_0, %impl.elem0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound]
// CHECK:STDOUT: %bound_method.loc36_24.1: <bound method> = bound_method %int_0, %impl.elem0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound]
// CHECK:STDOUT: %specific_fn: <specific function> = specific_function %impl.elem0, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn]
// CHECK:STDOUT: %bound_method.loc19_24.2: <bound method> = bound_method %int_0, %specific_fn [concrete = constants.%bound_method]
// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc19_24.2(%int_0) [concrete = constants.%int_0.753]
// CHECK:STDOUT: %.loc19_24.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.753]
// CHECK:STDOUT: %.loc19_24.2: %i32 = converted %int_0, %.loc19_24.1 [concrete = constants.%int_0.753]
// CHECK:STDOUT: %.loc19_25: ref %i32 = array_index %n.ref, %.loc19_24.2
// CHECK:STDOUT: %addr: %ptr.a17 = addr_of %.loc19_25
// CHECK:STDOUT: %Cpp.ref.loc25_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesFunction.ref.loc25: %TakesFunction.cpp_overload_set.type = name_ref TakesFunction, imports.%TakesFunction.cpp_overload_set.value [concrete = constants.%TakesFunction.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc25_21: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %bound_method.loc36_24.2: <bound method> = bound_method %int_0, %specific_fn [concrete = constants.%bound_method]
// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc36_24.2(%int_0) [concrete = constants.%int_0.753]
// CHECK:STDOUT: %.loc36_24.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.753]
// CHECK:STDOUT: %.loc36_24.2: %i32 = converted %int_0, %.loc36_24.1 [concrete = constants.%int_0.753]
// CHECK:STDOUT: %.loc36_25: ref %i32 = array_index %n.ref, %.loc36_24.2
// CHECK:STDOUT: %addr: %ptr.a17 = addr_of %.loc36_25
// CHECK:STDOUT: %Cpp.ref.loc55_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesFunction.ref.loc55: %TakesFunction.cpp_overload_set.type = name_ref TakesFunction, imports.%TakesFunction.cpp_overload_set.value [concrete = constants.%TakesFunction.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc55_21: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %nullptr.ref: %Cpp.nullptr_t = name_ref nullptr, %uninit [concrete = constants.%uninit]
// CHECK:STDOUT: %.loc25: %.659 = converted %nullptr.ref, <error> [concrete = <error>]
// CHECK:STDOUT: %.loc55: %.659 = converted %nullptr.ref, <error> [concrete = <error>]
// CHECK:STDOUT: %TakesFunction.call: init %empty_tuple.type = call imports.%TakesFunction.decl(<error>)
// CHECK:STDOUT: %Destroy.facet.loc14_3.1: %Destroy.type = facet_value constants.%Array.3b5, (constants.%DestroyImpl.impl_witness.be3, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: %.loc14_3.2: %Destroy.type = converted constants.%Array.3b5, %Destroy.facet.loc14_3.1 [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: %Destroy.facet.loc14_3.2: %Destroy.type = facet_value constants.%Array.3b5, (constants.%DestroyImpl.impl_witness.be3, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: %.loc14_3.3: %Destroy.type = converted constants.%Array.3b5, %Destroy.facet.loc14_3.2 [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: %Destroy.facet.loc20_3.1: %Destroy.type = facet_value constants.%Array.3b5, (constants.%DestroyImpl.impl_witness.be3, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: %.loc20_3.2: %Destroy.type = converted constants.%Array.3b5, %Destroy.facet.loc20_3.1 [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: %Destroy.facet.loc20_3.2: %Destroy.type = facet_value constants.%Array.3b5, (constants.%DestroyImpl.impl_witness.be3, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: %.loc20_3.3: %Destroy.type = converted constants.%Array.3b5, %Destroy.facet.loc20_3.2 [concrete = constants.%Destroy.facet.843]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call: init %empty_tuple.type = call %SelfDestruct.specific_fn(%n.var)
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @SubobjectDestroy.WithSelf.Op.loc14_3.1(%self.param: ref %i32) = "no_op";
// CHECK:STDOUT: fn @SubobjectDestroy.WithSelf.Op.loc20_3.1(%self.param: ref %i32) = "no_op";
// CHECK:STDOUT:
// CHECK:STDOUT: fn @SubobjectDestroy.WithSelf.Op.loc14_3.2(%self.param: ref %Array.3b5) {
// CHECK:STDOUT: fn @SubobjectDestroy.WithSelf.Op.loc20_3.2(%self.param: ref %Array.3b5) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %int_41: Core.IntLiteral = int_value 41 [concrete = constants.%int_41]
// CHECK:STDOUT: %.loc14_3.1: ref %i32 = array_index %self.param, %int_41
// CHECK:STDOUT: %Destroy.facet.loc14_3.1: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.2: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.1 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.2: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.3: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.2 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.1: ref %i32 = array_index %self.param, %int_41
// CHECK:STDOUT: %Destroy.facet.loc20_3.1: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.2: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.1 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.2: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.3: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.2 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.1: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%.loc14_3.1)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.1: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%.loc20_3.1)
// CHECK:STDOUT: %int_40: Core.IntLiteral = int_value 40 [concrete = constants.%int_40]
// CHECK:STDOUT: %.loc14_3.4: ref %i32 = array_index %self.param, %int_40
// CHECK:STDOUT: %Destroy.facet.loc14_3.3: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.5: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.3 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.4: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.6: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.4 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.4: ref %i32 = array_index %self.param, %int_40
// CHECK:STDOUT: %Destroy.facet.loc20_3.3: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.5: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.3 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.4: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.6: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.4 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.2: init %empty_tuple.type = call %SelfDestruct.specific_fn.2(%.loc14_3.4)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.2: init %empty_tuple.type = call %SelfDestruct.specific_fn.2(%.loc20_3.4)
// CHECK:STDOUT: %int_39: Core.IntLiteral = int_value 39 [concrete = constants.%int_39]
// CHECK:STDOUT: %.loc14_3.7: ref %i32 = array_index %self.param, %int_39
// CHECK:STDOUT: %Destroy.facet.loc14_3.5: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.8: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.5 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.6: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.9: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.6 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.7: ref %i32 = array_index %self.param, %int_39
// CHECK:STDOUT: %Destroy.facet.loc20_3.5: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.8: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.5 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.6: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.9: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.6 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.3: init %empty_tuple.type = call %SelfDestruct.specific_fn.3(%.loc14_3.7)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.3: init %empty_tuple.type = call %SelfDestruct.specific_fn.3(%.loc20_3.7)
// CHECK:STDOUT: %int_38: Core.IntLiteral = int_value 38 [concrete = constants.%int_38]
// CHECK:STDOUT: %.loc14_3.10: ref %i32 = array_index %self.param, %int_38
// CHECK:STDOUT: %Destroy.facet.loc14_3.7: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.11: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.7 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.8: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.12: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.8 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.10: ref %i32 = array_index %self.param, %int_38
// CHECK:STDOUT: %Destroy.facet.loc20_3.7: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.11: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.7 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.8: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.12: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.8 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.4: init %empty_tuple.type = call %SelfDestruct.specific_fn.4(%.loc14_3.10)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.4: init %empty_tuple.type = call %SelfDestruct.specific_fn.4(%.loc20_3.10)
// CHECK:STDOUT: %int_37: Core.IntLiteral = int_value 37 [concrete = constants.%int_37]
// CHECK:STDOUT: %.loc14_3.13: ref %i32 = array_index %self.param, %int_37
// CHECK:STDOUT: %Destroy.facet.loc14_3.9: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.14: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.9 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.10: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.15: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.10 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.13: ref %i32 = array_index %self.param, %int_37
// CHECK:STDOUT: %Destroy.facet.loc20_3.9: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.14: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.9 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.10: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.15: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.10 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.5: init %empty_tuple.type = call %SelfDestruct.specific_fn.5(%.loc14_3.13)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.5: init %empty_tuple.type = call %SelfDestruct.specific_fn.5(%.loc20_3.13)
// CHECK:STDOUT: %int_36: Core.IntLiteral = int_value 36 [concrete = constants.%int_36]
// CHECK:STDOUT: %.loc14_3.16: ref %i32 = array_index %self.param, %int_36
// CHECK:STDOUT: %Destroy.facet.loc14_3.11: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.17: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.11 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.12: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.18: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.12 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.16: ref %i32 = array_index %self.param, %int_36
// CHECK:STDOUT: %Destroy.facet.loc20_3.11: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.17: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.11 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.12: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.18: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.12 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.6: init %empty_tuple.type = call %SelfDestruct.specific_fn.6(%.loc14_3.16)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.6: init %empty_tuple.type = call %SelfDestruct.specific_fn.6(%.loc20_3.16)
// CHECK:STDOUT: %int_35: Core.IntLiteral = int_value 35 [concrete = constants.%int_35]
// CHECK:STDOUT: %.loc14_3.19: ref %i32 = array_index %self.param, %int_35
// CHECK:STDOUT: %Destroy.facet.loc14_3.13: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.20: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.13 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.14: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.21: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.14 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.19: ref %i32 = array_index %self.param, %int_35
// CHECK:STDOUT: %Destroy.facet.loc20_3.13: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.20: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.13 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.14: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.21: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.14 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.7: init %empty_tuple.type = call %SelfDestruct.specific_fn.7(%.loc14_3.19)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.7: init %empty_tuple.type = call %SelfDestruct.specific_fn.7(%.loc20_3.19)
// CHECK:STDOUT: %int_34: Core.IntLiteral = int_value 34 [concrete = constants.%int_34]
// CHECK:STDOUT: %.loc14_3.22: ref %i32 = array_index %self.param, %int_34
// CHECK:STDOUT: %Destroy.facet.loc14_3.15: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.23: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.15 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.16: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.24: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.16 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.22: ref %i32 = array_index %self.param, %int_34
// CHECK:STDOUT: %Destroy.facet.loc20_3.15: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.23: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.15 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.16: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.24: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.16 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.8: init %empty_tuple.type = call %SelfDestruct.specific_fn.8(%.loc14_3.22)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.8: init %empty_tuple.type = call %SelfDestruct.specific_fn.8(%.loc20_3.22)
// CHECK:STDOUT: %int_33: Core.IntLiteral = int_value 33 [concrete = constants.%int_33]
// CHECK:STDOUT: %.loc14_3.25: ref %i32 = array_index %self.param, %int_33
// CHECK:STDOUT: %Destroy.facet.loc14_3.17: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.26: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.17 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.18: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.27: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.18 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.25: ref %i32 = array_index %self.param, %int_33
// CHECK:STDOUT: %Destroy.facet.loc20_3.17: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.26: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.17 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.18: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.27: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.18 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.9: init %empty_tuple.type = call %SelfDestruct.specific_fn.9(%.loc14_3.25)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.9: init %empty_tuple.type = call %SelfDestruct.specific_fn.9(%.loc20_3.25)
// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32]
// CHECK:STDOUT: %.loc14_3.28: ref %i32 = array_index %self.param, %int_32
// CHECK:STDOUT: %Destroy.facet.loc14_3.19: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.29: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.19 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.20: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.30: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.20 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.28: ref %i32 = array_index %self.param, %int_32
// CHECK:STDOUT: %Destroy.facet.loc20_3.19: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.29: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.19 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.20: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.30: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.20 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.10: init %empty_tuple.type = call %SelfDestruct.specific_fn.10(%.loc14_3.28)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.10: init %empty_tuple.type = call %SelfDestruct.specific_fn.10(%.loc20_3.28)
// CHECK:STDOUT: %int_31: Core.IntLiteral = int_value 31 [concrete = constants.%int_31]
// CHECK:STDOUT: %.loc14_3.31: ref %i32 = array_index %self.param, %int_31
// CHECK:STDOUT: %Destroy.facet.loc14_3.21: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.32: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.21 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.22: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.33: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.22 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.31: ref %i32 = array_index %self.param, %int_31
// CHECK:STDOUT: %Destroy.facet.loc20_3.21: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.32: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.21 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.22: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.33: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.22 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.11: init %empty_tuple.type = call %SelfDestruct.specific_fn.11(%.loc14_3.31)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.11: init %empty_tuple.type = call %SelfDestruct.specific_fn.11(%.loc20_3.31)
// CHECK:STDOUT: %int_30: Core.IntLiteral = int_value 30 [concrete = constants.%int_30]
// CHECK:STDOUT: %.loc14_3.34: ref %i32 = array_index %self.param, %int_30
// CHECK:STDOUT: %Destroy.facet.loc14_3.23: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.35: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.23 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.24: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.36: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.24 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.34: ref %i32 = array_index %self.param, %int_30
// CHECK:STDOUT: %Destroy.facet.loc20_3.23: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.35: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.23 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.24: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.36: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.24 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.12: init %empty_tuple.type = call %SelfDestruct.specific_fn.12(%.loc14_3.34)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.12: init %empty_tuple.type = call %SelfDestruct.specific_fn.12(%.loc20_3.34)
// CHECK:STDOUT: %int_29: Core.IntLiteral = int_value 29 [concrete = constants.%int_29]
// CHECK:STDOUT: %.loc14_3.37: ref %i32 = array_index %self.param, %int_29
// CHECK:STDOUT: %Destroy.facet.loc14_3.25: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.38: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.25 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.26: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.39: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.26 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.37: ref %i32 = array_index %self.param, %int_29
// CHECK:STDOUT: %Destroy.facet.loc20_3.25: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.38: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.25 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.26: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.39: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.26 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.13: init %empty_tuple.type = call %SelfDestruct.specific_fn.13(%.loc14_3.37)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.13: init %empty_tuple.type = call %SelfDestruct.specific_fn.13(%.loc20_3.37)
// CHECK:STDOUT: %int_28: Core.IntLiteral = int_value 28 [concrete = constants.%int_28]
// CHECK:STDOUT: %.loc14_3.40: ref %i32 = array_index %self.param, %int_28
// CHECK:STDOUT: %Destroy.facet.loc14_3.27: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.41: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.27 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.28: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.42: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.28 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.40: ref %i32 = array_index %self.param, %int_28
// CHECK:STDOUT: %Destroy.facet.loc20_3.27: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.41: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.27 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.28: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.42: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.28 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.14: init %empty_tuple.type = call %SelfDestruct.specific_fn.14(%.loc14_3.40)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.14: init %empty_tuple.type = call %SelfDestruct.specific_fn.14(%.loc20_3.40)
// CHECK:STDOUT: %int_27: Core.IntLiteral = int_value 27 [concrete = constants.%int_27]
// CHECK:STDOUT: %.loc14_3.43: ref %i32 = array_index %self.param, %int_27
// CHECK:STDOUT: %Destroy.facet.loc14_3.29: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.44: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.29 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.30: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.45: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.30 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.43: ref %i32 = array_index %self.param, %int_27
// CHECK:STDOUT: %Destroy.facet.loc20_3.29: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.44: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.29 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.30: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.45: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.30 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.15: init %empty_tuple.type = call %SelfDestruct.specific_fn.15(%.loc14_3.43)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.15: init %empty_tuple.type = call %SelfDestruct.specific_fn.15(%.loc20_3.43)
// CHECK:STDOUT: %int_26: Core.IntLiteral = int_value 26 [concrete = constants.%int_26]
// CHECK:STDOUT: %.loc14_3.46: ref %i32 = array_index %self.param, %int_26
// CHECK:STDOUT: %Destroy.facet.loc14_3.31: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.47: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.31 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.32: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.48: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.32 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.46: ref %i32 = array_index %self.param, %int_26
// CHECK:STDOUT: %Destroy.facet.loc20_3.31: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.47: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.31 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.32: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.48: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.32 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.16: init %empty_tuple.type = call %SelfDestruct.specific_fn.16(%.loc14_3.46)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.16: init %empty_tuple.type = call %SelfDestruct.specific_fn.16(%.loc20_3.46)
// CHECK:STDOUT: %int_25: Core.IntLiteral = int_value 25 [concrete = constants.%int_25]
// CHECK:STDOUT: %.loc14_3.49: ref %i32 = array_index %self.param, %int_25
// CHECK:STDOUT: %Destroy.facet.loc14_3.33: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.50: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.33 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.34: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.51: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.34 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.49: ref %i32 = array_index %self.param, %int_25
// CHECK:STDOUT: %Destroy.facet.loc20_3.33: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.50: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.33 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.34: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.51: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.34 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.17: init %empty_tuple.type = call %SelfDestruct.specific_fn.17(%.loc14_3.49)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.17: init %empty_tuple.type = call %SelfDestruct.specific_fn.17(%.loc20_3.49)
// CHECK:STDOUT: %int_24: Core.IntLiteral = int_value 24 [concrete = constants.%int_24]
// CHECK:STDOUT: %.loc14_3.52: ref %i32 = array_index %self.param, %int_24
// CHECK:STDOUT: %Destroy.facet.loc14_3.35: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.53: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.35 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.36: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.54: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.36 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.52: ref %i32 = array_index %self.param, %int_24
// CHECK:STDOUT: %Destroy.facet.loc20_3.35: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.53: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.35 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.36: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.54: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.36 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.18: init %empty_tuple.type = call %SelfDestruct.specific_fn.18(%.loc14_3.52)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.18: init %empty_tuple.type = call %SelfDestruct.specific_fn.18(%.loc20_3.52)
// CHECK:STDOUT: %int_23: Core.IntLiteral = int_value 23 [concrete = constants.%int_23]
// CHECK:STDOUT: %.loc14_3.55: ref %i32 = array_index %self.param, %int_23
// CHECK:STDOUT: %Destroy.facet.loc14_3.37: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.56: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.37 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.38: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.57: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.38 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.55: ref %i32 = array_index %self.param, %int_23
// CHECK:STDOUT: %Destroy.facet.loc20_3.37: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.56: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.37 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.38: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.57: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.38 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.19: init %empty_tuple.type = call %SelfDestruct.specific_fn.19(%.loc14_3.55)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.19: init %empty_tuple.type = call %SelfDestruct.specific_fn.19(%.loc20_3.55)
// CHECK:STDOUT: %int_22: Core.IntLiteral = int_value 22 [concrete = constants.%int_22]
// CHECK:STDOUT: %.loc14_3.58: ref %i32 = array_index %self.param, %int_22
// CHECK:STDOUT: %Destroy.facet.loc14_3.39: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.59: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.39 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.40: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.60: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.40 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.58: ref %i32 = array_index %self.param, %int_22
// CHECK:STDOUT: %Destroy.facet.loc20_3.39: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.59: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.39 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.40: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.60: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.40 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.20: init %empty_tuple.type = call %SelfDestruct.specific_fn.20(%.loc14_3.58)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.20: init %empty_tuple.type = call %SelfDestruct.specific_fn.20(%.loc20_3.58)
// CHECK:STDOUT: %int_21: Core.IntLiteral = int_value 21 [concrete = constants.%int_21]
// CHECK:STDOUT: %.loc14_3.61: ref %i32 = array_index %self.param, %int_21
// CHECK:STDOUT: %Destroy.facet.loc14_3.41: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.62: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.41 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.42: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.63: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.42 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.61: ref %i32 = array_index %self.param, %int_21
// CHECK:STDOUT: %Destroy.facet.loc20_3.41: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.62: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.41 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.42: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.63: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.42 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.21: init %empty_tuple.type = call %SelfDestruct.specific_fn.21(%.loc14_3.61)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.21: init %empty_tuple.type = call %SelfDestruct.specific_fn.21(%.loc20_3.61)
// CHECK:STDOUT: %int_20: Core.IntLiteral = int_value 20 [concrete = constants.%int_20]
// CHECK:STDOUT: %.loc14_3.64: ref %i32 = array_index %self.param, %int_20
// CHECK:STDOUT: %Destroy.facet.loc14_3.43: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.65: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.43 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.44: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.66: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.44 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.64: ref %i32 = array_index %self.param, %int_20
// CHECK:STDOUT: %Destroy.facet.loc20_3.43: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.65: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.43 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.44: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.66: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.44 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.22: init %empty_tuple.type = call %SelfDestruct.specific_fn.22(%.loc14_3.64)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.22: init %empty_tuple.type = call %SelfDestruct.specific_fn.22(%.loc20_3.64)
// CHECK:STDOUT: %int_19: Core.IntLiteral = int_value 19 [concrete = constants.%int_19]
// CHECK:STDOUT: %.loc14_3.67: ref %i32 = array_index %self.param, %int_19
// CHECK:STDOUT: %Destroy.facet.loc14_3.45: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.68: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.45 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.46: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.69: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.46 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.67: ref %i32 = array_index %self.param, %int_19
// CHECK:STDOUT: %Destroy.facet.loc20_3.45: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.68: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.45 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.46: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.69: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.46 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.23: init %empty_tuple.type = call %SelfDestruct.specific_fn.23(%.loc14_3.67)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.23: init %empty_tuple.type = call %SelfDestruct.specific_fn.23(%.loc20_3.67)
// CHECK:STDOUT: %int_18: Core.IntLiteral = int_value 18 [concrete = constants.%int_18]
// CHECK:STDOUT: %.loc14_3.70: ref %i32 = array_index %self.param, %int_18
// CHECK:STDOUT: %Destroy.facet.loc14_3.47: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.71: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.47 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.48: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.72: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.48 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.70: ref %i32 = array_index %self.param, %int_18
// CHECK:STDOUT: %Destroy.facet.loc20_3.47: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.71: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.47 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.48: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.72: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.48 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.24: init %empty_tuple.type = call %SelfDestruct.specific_fn.24(%.loc14_3.70)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.24: init %empty_tuple.type = call %SelfDestruct.specific_fn.24(%.loc20_3.70)
// CHECK:STDOUT: %int_17: Core.IntLiteral = int_value 17 [concrete = constants.%int_17]
// CHECK:STDOUT: %.loc14_3.73: ref %i32 = array_index %self.param, %int_17
// CHECK:STDOUT: %Destroy.facet.loc14_3.49: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.74: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.49 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.50: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.75: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.50 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.73: ref %i32 = array_index %self.param, %int_17
// CHECK:STDOUT: %Destroy.facet.loc20_3.49: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.74: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.49 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.50: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.75: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.50 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.25: init %empty_tuple.type = call %SelfDestruct.specific_fn.25(%.loc14_3.73)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.25: init %empty_tuple.type = call %SelfDestruct.specific_fn.25(%.loc20_3.73)
// CHECK:STDOUT: %int_16: Core.IntLiteral = int_value 16 [concrete = constants.%int_16]
// CHECK:STDOUT: %.loc14_3.76: ref %i32 = array_index %self.param, %int_16
// CHECK:STDOUT: %Destroy.facet.loc14_3.51: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.77: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.51 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.52: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.78: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.52 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.76: ref %i32 = array_index %self.param, %int_16
// CHECK:STDOUT: %Destroy.facet.loc20_3.51: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.77: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.51 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.52: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.78: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.52 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.26: init %empty_tuple.type = call %SelfDestruct.specific_fn.26(%.loc14_3.76)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.26: init %empty_tuple.type = call %SelfDestruct.specific_fn.26(%.loc20_3.76)
// CHECK:STDOUT: %int_15: Core.IntLiteral = int_value 15 [concrete = constants.%int_15]
// CHECK:STDOUT: %.loc14_3.79: ref %i32 = array_index %self.param, %int_15
// CHECK:STDOUT: %Destroy.facet.loc14_3.53: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.80: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.53 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.54: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.81: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.54 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.79: ref %i32 = array_index %self.param, %int_15
// CHECK:STDOUT: %Destroy.facet.loc20_3.53: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.80: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.53 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.54: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.81: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.54 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.27: init %empty_tuple.type = call %SelfDestruct.specific_fn.27(%.loc14_3.79)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.27: init %empty_tuple.type = call %SelfDestruct.specific_fn.27(%.loc20_3.79)
// CHECK:STDOUT: %int_14: Core.IntLiteral = int_value 14 [concrete = constants.%int_14]
// CHECK:STDOUT: %.loc14_3.82: ref %i32 = array_index %self.param, %int_14
// CHECK:STDOUT: %Destroy.facet.loc14_3.55: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.83: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.55 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.56: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.84: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.56 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.82: ref %i32 = array_index %self.param, %int_14
// CHECK:STDOUT: %Destroy.facet.loc20_3.55: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.83: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.55 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.56: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.84: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.56 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.28: init %empty_tuple.type = call %SelfDestruct.specific_fn.28(%.loc14_3.82)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.28: init %empty_tuple.type = call %SelfDestruct.specific_fn.28(%.loc20_3.82)
// CHECK:STDOUT: %int_13: Core.IntLiteral = int_value 13 [concrete = constants.%int_13]
// CHECK:STDOUT: %.loc14_3.85: ref %i32 = array_index %self.param, %int_13
// CHECK:STDOUT: %Destroy.facet.loc14_3.57: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.86: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.57 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.58: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.87: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.58 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.85: ref %i32 = array_index %self.param, %int_13
// CHECK:STDOUT: %Destroy.facet.loc20_3.57: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.86: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.57 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.58: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.87: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.58 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.29: init %empty_tuple.type = call %SelfDestruct.specific_fn.29(%.loc14_3.85)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.29: init %empty_tuple.type = call %SelfDestruct.specific_fn.29(%.loc20_3.85)
// CHECK:STDOUT: %int_12: Core.IntLiteral = int_value 12 [concrete = constants.%int_12]
// CHECK:STDOUT: %.loc14_3.88: ref %i32 = array_index %self.param, %int_12
// CHECK:STDOUT: %Destroy.facet.loc14_3.59: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.89: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.59 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.60: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.90: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.60 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.88: ref %i32 = array_index %self.param, %int_12
// CHECK:STDOUT: %Destroy.facet.loc20_3.59: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.89: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.59 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.60: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.90: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.60 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.30: init %empty_tuple.type = call %SelfDestruct.specific_fn.30(%.loc14_3.88)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.30: init %empty_tuple.type = call %SelfDestruct.specific_fn.30(%.loc20_3.88)
// CHECK:STDOUT: %int_11: Core.IntLiteral = int_value 11 [concrete = constants.%int_11]
// CHECK:STDOUT: %.loc14_3.91: ref %i32 = array_index %self.param, %int_11
// CHECK:STDOUT: %Destroy.facet.loc14_3.61: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.92: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.61 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.62: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.93: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.62 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.91: ref %i32 = array_index %self.param, %int_11
// CHECK:STDOUT: %Destroy.facet.loc20_3.61: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.92: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.61 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.62: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.93: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.62 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.31: init %empty_tuple.type = call %SelfDestruct.specific_fn.31(%.loc14_3.91)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.31: init %empty_tuple.type = call %SelfDestruct.specific_fn.31(%.loc20_3.91)
// CHECK:STDOUT: %int_10: Core.IntLiteral = int_value 10 [concrete = constants.%int_10]
// CHECK:STDOUT: %.loc14_3.94: ref %i32 = array_index %self.param, %int_10
// CHECK:STDOUT: %Destroy.facet.loc14_3.63: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.95: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.63 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.64: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.96: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.64 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.94: ref %i32 = array_index %self.param, %int_10
// CHECK:STDOUT: %Destroy.facet.loc20_3.63: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.95: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.63 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.64: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.96: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.64 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.32: init %empty_tuple.type = call %SelfDestruct.specific_fn.32(%.loc14_3.94)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.32: init %empty_tuple.type = call %SelfDestruct.specific_fn.32(%.loc20_3.94)
// CHECK:STDOUT: %int_9: Core.IntLiteral = int_value 9 [concrete = constants.%int_9]
// CHECK:STDOUT: %.loc14_3.97: ref %i32 = array_index %self.param, %int_9
// CHECK:STDOUT: %Destroy.facet.loc14_3.65: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.98: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.65 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.66: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.99: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.66 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.97: ref %i32 = array_index %self.param, %int_9
// CHECK:STDOUT: %Destroy.facet.loc20_3.65: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.98: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.65 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.66: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.99: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.66 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.33: init %empty_tuple.type = call %SelfDestruct.specific_fn.33(%.loc14_3.97)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.33: init %empty_tuple.type = call %SelfDestruct.specific_fn.33(%.loc20_3.97)
// CHECK:STDOUT: %int_8: Core.IntLiteral = int_value 8 [concrete = constants.%int_8]
// CHECK:STDOUT: %.loc14_3.100: ref %i32 = array_index %self.param, %int_8
// CHECK:STDOUT: %Destroy.facet.loc14_3.67: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.101: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.67 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.68: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.102: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.68 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.100: ref %i32 = array_index %self.param, %int_8
// CHECK:STDOUT: %Destroy.facet.loc20_3.67: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.101: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.67 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.68: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.102: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.68 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.34: init %empty_tuple.type = call %SelfDestruct.specific_fn.34(%.loc14_3.100)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.34: init %empty_tuple.type = call %SelfDestruct.specific_fn.34(%.loc20_3.100)
// CHECK:STDOUT: %int_7: Core.IntLiteral = int_value 7 [concrete = constants.%int_7]
// CHECK:STDOUT: %.loc14_3.103: ref %i32 = array_index %self.param, %int_7
// CHECK:STDOUT: %Destroy.facet.loc14_3.69: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.104: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.69 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.70: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.105: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.70 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.103: ref %i32 = array_index %self.param, %int_7
// CHECK:STDOUT: %Destroy.facet.loc20_3.69: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.104: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.69 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.70: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.105: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.70 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.35: init %empty_tuple.type = call %SelfDestruct.specific_fn.35(%.loc14_3.103)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.35: init %empty_tuple.type = call %SelfDestruct.specific_fn.35(%.loc20_3.103)
// CHECK:STDOUT: %int_6: Core.IntLiteral = int_value 6 [concrete = constants.%int_6]
// CHECK:STDOUT: %.loc14_3.106: ref %i32 = array_index %self.param, %int_6
// CHECK:STDOUT: %Destroy.facet.loc14_3.71: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.107: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.71 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.72: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.108: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.72 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.106: ref %i32 = array_index %self.param, %int_6
// CHECK:STDOUT: %Destroy.facet.loc20_3.71: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.107: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.71 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.72: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.108: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.72 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.36: init %empty_tuple.type = call %SelfDestruct.specific_fn.36(%.loc14_3.106)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.36: init %empty_tuple.type = call %SelfDestruct.specific_fn.36(%.loc20_3.106)
// CHECK:STDOUT: %int_5: Core.IntLiteral = int_value 5 [concrete = constants.%int_5]
// CHECK:STDOUT: %.loc14_3.109: ref %i32 = array_index %self.param, %int_5
// CHECK:STDOUT: %Destroy.facet.loc14_3.73: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.110: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.73 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.74: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.111: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.74 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.109: ref %i32 = array_index %self.param, %int_5
// CHECK:STDOUT: %Destroy.facet.loc20_3.73: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.110: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.73 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.74: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.111: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.74 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.37: init %empty_tuple.type = call %SelfDestruct.specific_fn.37(%.loc14_3.109)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.37: init %empty_tuple.type = call %SelfDestruct.specific_fn.37(%.loc20_3.109)
// CHECK:STDOUT: %int_4: Core.IntLiteral = int_value 4 [concrete = constants.%int_4]
// CHECK:STDOUT: %.loc14_3.112: ref %i32 = array_index %self.param, %int_4
// CHECK:STDOUT: %Destroy.facet.loc14_3.75: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.113: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.75 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.76: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.114: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.76 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.112: ref %i32 = array_index %self.param, %int_4
// CHECK:STDOUT: %Destroy.facet.loc20_3.75: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.113: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.75 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.76: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.114: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.76 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.38: init %empty_tuple.type = call %SelfDestruct.specific_fn.38(%.loc14_3.112)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.38: init %empty_tuple.type = call %SelfDestruct.specific_fn.38(%.loc20_3.112)
// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3]
// CHECK:STDOUT: %.loc14_3.115: ref %i32 = array_index %self.param, %int_3
// CHECK:STDOUT: %Destroy.facet.loc14_3.77: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.116: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.77 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.78: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.117: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.78 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.115: ref %i32 = array_index %self.param, %int_3
// CHECK:STDOUT: %Destroy.facet.loc20_3.77: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.116: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.77 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.78: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.117: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.78 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.39: init %empty_tuple.type = call %SelfDestruct.specific_fn.39(%.loc14_3.115)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.39: init %empty_tuple.type = call %SelfDestruct.specific_fn.39(%.loc20_3.115)
// CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [concrete = constants.%int_2]
// CHECK:STDOUT: %.loc14_3.118: ref %i32 = array_index %self.param, %int_2
// CHECK:STDOUT: %Destroy.facet.loc14_3.79: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.119: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.79 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.80: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.120: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.80 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.118: ref %i32 = array_index %self.param, %int_2
// CHECK:STDOUT: %Destroy.facet.loc20_3.79: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.119: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.79 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.80: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.120: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.80 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.40: init %empty_tuple.type = call %SelfDestruct.specific_fn.40(%.loc14_3.118)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.40: init %empty_tuple.type = call %SelfDestruct.specific_fn.40(%.loc20_3.118)
// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1]
// CHECK:STDOUT: %.loc14_3.121: ref %i32 = array_index %self.param, %int_1
// CHECK:STDOUT: %Destroy.facet.loc14_3.81: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.122: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.81 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.82: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.123: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.82 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.121: ref %i32 = array_index %self.param, %int_1
// CHECK:STDOUT: %Destroy.facet.loc20_3.81: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.122: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.81 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.82: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.123: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.82 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.41: init %empty_tuple.type = call %SelfDestruct.specific_fn.41(%.loc14_3.121)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.41: init %empty_tuple.type = call %SelfDestruct.specific_fn.41(%.loc20_3.121)
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6]
// CHECK:STDOUT: %.loc14_3.124: ref %i32 = array_index %self.param, %int_0
// CHECK:STDOUT: %Destroy.facet.loc14_3.83: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.125: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.83 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc14_3.84: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc14_3.126: %Destroy.type = converted constants.%i32, %Destroy.facet.loc14_3.84 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.124: ref %i32 = array_index %self.param, %int_0
// CHECK:STDOUT: %Destroy.facet.loc20_3.83: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.125: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.83 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %Destroy.facet.loc20_3.84: %Destroy.type = facet_value constants.%i32, (constants.%DestroyImpl.impl_witness.077, constants.%custom_witness.b80ef6.2) [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: %.loc20_3.126: %Destroy.type = converted constants.%i32, %Destroy.facet.loc20_3.84 [concrete = constants.%Destroy.facet.c2b]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc14_3.42: init %empty_tuple.type = call %SelfDestruct.specific_fn.42(%.loc14_3.124)
// CHECK:STDOUT: %SelfDestruct.call.loc20_3.42: init %empty_tuple.type = call %SelfDestruct.specific_fn.42(%.loc20_3.124)
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/interop/cpp/function/import/default_arg.carbon
Vendored
+128 -59
View File
@@ -63,45 +63,114 @@ import Cpp library "functions.h";
fn Call() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-20: error: no matching function for call to 'GlobalNoReturn' [CppInteropParseError]
// CHECK:STDERR: ./functions.h:2:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./functions.h:2:21-54: note: requires at least 2 arguments, but 1 was provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.GlobalNoReturn(1);
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'GlobalNoReturn'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./functions.h
// CHECK:STDERR: │ auto GlobalNoReturn(int a, int b, int c = 1, int d = 2) -> void;
// CHECK:STDERR: · ┬ ────┬─────────────────────────────
// CHECK:STDERR: · ╰─────────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires at least 2 arguments, but 1 was provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.GlobalNoReturn(1);
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-20: error: no matching function for call to 'GlobalNoReturn' [CppInteropParseError]
// CHECK:STDERR: ./functions.h:2:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./functions.h:2:21-54: note: requires at least 2 arguments, but 0 were provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.GlobalNoReturn();
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'GlobalNoReturn'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./functions.h
// CHECK:STDERR: │ auto GlobalNoReturn(int a, int b, int c = 1, int d = 2) -> void;
// CHECK:STDERR: · ┬ ───┬──────────────────────────────
// CHECK:STDERR: · ╰────────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires at least 2 arguments, but 0 were provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.GlobalNoReturn();
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-21: error: no matching function for call to 'GlobalReturnInt' [CppInteropParseError]
// CHECK:STDERR: ./functions.h:3:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./functions.h:3:22-55: note: requires at least 2 arguments, but 1 was provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.GlobalReturnInt(1);
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'GlobalReturnInt'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./functions.h
// CHECK:STDERR: │ auto GlobalReturnInt(int a, int b, int c = 1, int d = 2) -> int;
// CHECK:STDERR: · ┬ ───┬──────────────────────────────
// CHECK:STDERR: · ╰─────────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires at least 2 arguments, but 1 was provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.GlobalReturnInt(1);
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-21: error: no matching function for call to 'GlobalReturnInt' [CppInteropParseError]
// CHECK:STDERR: ./functions.h:3:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./functions.h:3:22-55: note: requires at least 2 arguments, but 0 were provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.GlobalReturnInt();
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'GlobalReturnInt'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./functions.h
// CHECK:STDERR: │ auto GlobalReturnInt(int a, int b, int c = 1, int d = 2) -> int;
// CHECK:STDERR: · ┬ ──┬───────────────────────────────
// CHECK:STDERR: · ╰────────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires at least 2 arguments, but 0 were provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.GlobalReturnInt();
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'B' [CppInteropParseError]
// CHECK:STDERR: ./functions.h:6:8: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./functions.h:6:10-25: note: requires at least argument 'a', but no arguments were provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+13]]:3
// CHECK:STDERR: -> │ ({} as Cpp.X).B();
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'B' [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./functions.h
// CHECK:STDERR: │ void B(int a, int b = 1);
// CHECK:STDERR: · ┬ ──┬─────────────
// CHECK:STDERR: · ╰──────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires at least argument 'a', but no arguments were provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
({} as Cpp.X).B();
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-9: error: no matching function for call to 'C' [CppInteropParseError]
// CHECK:STDERR: ./functions.h:7:15: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./functions.h:7:17-32: note: requires at least argument 'a', but no arguments were provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.X.C();
// CHECK:STDERR: · ━━━┳━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'C' [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./functions.h
// CHECK:STDERR: │ static void C(int a, int b = 1);
// CHECK:STDERR: · ┬ ┬───────────────
// CHECK:STDERR: · ╰────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires at least argument 'a', but no arguments were
// CHECK:STDERR: · │ provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.X.C();
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'D' [CppInteropParseError]
// CHECK:STDERR: ./functions.h:8:8: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./functions.h:8:10-33: note: requires at least non-object argument 'a', but no arguments were provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ ({} as Cpp.X).D();
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'D' [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./functions.h
// CHECK:STDERR: │ void D(this X, int a, int b = 1);
// CHECK:STDERR: · ┬ ┬───────────────────────
// CHECK:STDERR: · ╰────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires at least non-object argument 'a', but no arguments were
// CHECK:STDERR: · │ provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
({} as Cpp.X).D();
//@dump-sem-ir-end
@@ -921,49 +990,49 @@ fn Call() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Call() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Cpp.ref.loc12: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalNoReturn.ref.loc12: %GlobalNoReturn.cpp_overload_set.type = name_ref GlobalNoReturn, imports.%GlobalNoReturn.cpp_overload_set.value [concrete = constants.%GlobalNoReturn.cpp_overload_set.value]
// CHECK:STDOUT: %int_1.loc12: Core.IntLiteral = int_value 1 [concrete = constants.%int_1]
// CHECK:STDOUT: %Cpp.ref.loc18: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalNoReturn.ref.loc18: %GlobalNoReturn.cpp_overload_set.type = name_ref GlobalNoReturn, imports.%GlobalNoReturn.cpp_overload_set.value [concrete = constants.%GlobalNoReturn.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc24: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalReturnInt.ref.loc24: %GlobalReturnInt.cpp_overload_set.type = name_ref GlobalReturnInt, imports.%GlobalReturnInt.cpp_overload_set.value [concrete = constants.%GlobalReturnInt.cpp_overload_set.value]
// CHECK:STDOUT: %int_1.loc24: Core.IntLiteral = int_value 1 [concrete = constants.%int_1]
// CHECK:STDOUT: %Cpp.ref.loc30: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalReturnInt.ref.loc30: %GlobalReturnInt.cpp_overload_set.type = name_ref GlobalReturnInt, imports.%GlobalReturnInt.cpp_overload_set.value [concrete = constants.%GlobalReturnInt.cpp_overload_set.value]
// CHECK:STDOUT: %.loc36_5.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct]
// CHECK:STDOUT: %Cpp.ref.loc36: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %X.ref.loc36: type = name_ref X, imports.%X.decl [concrete = constants.%X]
// CHECK:STDOUT: %.loc36_5.2: ref %X = temporary_storage
// CHECK:STDOUT: %.loc36_5.3: init %X to %.loc36_5.2 = class_init () [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc36_7.1: init %X = converted %.loc36_5.1, %.loc36_5.3 [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc36_7.2: ref %X = temporary %.loc36_5.2, %.loc36_7.1 [concrete = constants.%.414]
// CHECK:STDOUT: %Cpp.ref.loc22: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalNoReturn.ref.loc22: %GlobalNoReturn.cpp_overload_set.type = name_ref GlobalNoReturn, imports.%GlobalNoReturn.cpp_overload_set.value [concrete = constants.%GlobalNoReturn.cpp_overload_set.value]
// CHECK:STDOUT: %int_1.loc22: Core.IntLiteral = int_value 1 [concrete = constants.%int_1]
// CHECK:STDOUT: %Cpp.ref.loc38: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalNoReturn.ref.loc38: %GlobalNoReturn.cpp_overload_set.type = name_ref GlobalNoReturn, imports.%GlobalNoReturn.cpp_overload_set.value [concrete = constants.%GlobalNoReturn.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc54: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalReturnInt.ref.loc54: %GlobalReturnInt.cpp_overload_set.type = name_ref GlobalReturnInt, imports.%GlobalReturnInt.cpp_overload_set.value [concrete = constants.%GlobalReturnInt.cpp_overload_set.value]
// CHECK:STDOUT: %int_1.loc54: Core.IntLiteral = int_value 1 [concrete = constants.%int_1]
// CHECK:STDOUT: %Cpp.ref.loc70: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %GlobalReturnInt.ref.loc70: %GlobalReturnInt.cpp_overload_set.type = name_ref GlobalReturnInt, imports.%GlobalReturnInt.cpp_overload_set.value [concrete = constants.%GlobalReturnInt.cpp_overload_set.value]
// CHECK:STDOUT: %.loc85_5.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct]
// CHECK:STDOUT: %Cpp.ref.loc85: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %X.ref.loc85: type = name_ref X, imports.%X.decl [concrete = constants.%X]
// CHECK:STDOUT: %.loc85_5.2: ref %X = temporary_storage
// CHECK:STDOUT: %.loc85_5.3: init %X to %.loc85_5.2 = class_init () [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc85_7.1: init %X = converted %.loc85_5.1, %.loc85_5.3 [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc85_7.2: ref %X = temporary %.loc85_5.2, %.loc85_7.1 [concrete = constants.%.414]
// 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.loc36: <bound method> = bound_method %.loc36_7.2, %B.ref [concrete = constants.%bound_method.f8c]
// CHECK:STDOUT: %Destroy.facet.loc36_7.1: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc36_7.3: %Destroy.type = converted constants.%X, %Destroy.facet.loc36_7.1 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %Destroy.facet.loc36_7.2: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc36_7.4: %Destroy.type = converted constants.%X, %Destroy.facet.loc36_7.2 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %bound_method.loc85: <bound method> = bound_method %.loc85_7.2, %B.ref [concrete = constants.%bound_method.f8c]
// CHECK:STDOUT: %Destroy.facet.loc85_7.1: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc85_7.3: %Destroy.type = converted constants.%X, %Destroy.facet.loc85_7.1 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %Destroy.facet.loc85_7.2: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc85_7.4: %Destroy.type = converted constants.%X, %Destroy.facet.loc85_7.2 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc36: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%.loc36_7.2)
// CHECK:STDOUT: %Cpp.ref.loc42: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %X.ref.loc42: type = name_ref X, imports.%X.decl [concrete = constants.%X]
// CHECK:STDOUT: %SelfDestruct.call.loc85: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%.loc85_7.2)
// CHECK:STDOUT: %Cpp.ref.loc101: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %X.ref.loc101: 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]
// CHECK:STDOUT: %.loc48_5.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct]
// CHECK:STDOUT: %Cpp.ref.loc48: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %X.ref.loc48: type = name_ref X, imports.%X.decl [concrete = constants.%X]
// CHECK:STDOUT: %.loc48_5.2: ref %X = temporary_storage
// CHECK:STDOUT: %.loc48_5.3: init %X to %.loc48_5.2 = class_init () [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc48_7.1: init %X = converted %.loc48_5.1, %.loc48_5.3 [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc48_7.2: ref %X = temporary %.loc48_5.2, %.loc48_7.1 [concrete = constants.%.414]
// CHECK:STDOUT: %.loc117_5.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct]
// CHECK:STDOUT: %Cpp.ref.loc117: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %X.ref.loc117: type = name_ref X, imports.%X.decl [concrete = constants.%X]
// CHECK:STDOUT: %.loc117_5.2: ref %X = temporary_storage
// CHECK:STDOUT: %.loc117_5.3: init %X to %.loc117_5.2 = class_init () [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc117_7.1: init %X = converted %.loc117_5.1, %.loc117_5.3 [concrete = constants.%X.val]
// CHECK:STDOUT: %.loc117_7.2: ref %X = temporary %.loc117_5.2, %.loc117_7.1 [concrete = constants.%.414]
// CHECK:STDOUT: %D.ref: %X.D.cpp_overload_set.type = name_ref D, imports.%X.D.cpp_overload_set.value [concrete = constants.%X.D.cpp_overload_set.value]
// CHECK:STDOUT: %bound_method.loc48: <bound method> = bound_method %.loc48_7.2, %D.ref [concrete = constants.%bound_method.9a8]
// CHECK:STDOUT: %Destroy.facet.loc48_7.1: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc48_7.3: %Destroy.type = converted constants.%X, %Destroy.facet.loc48_7.1 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %Destroy.facet.loc48_7.2: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc48_7.4: %Destroy.type = converted constants.%X, %Destroy.facet.loc48_7.2 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %bound_method.loc117: <bound method> = bound_method %.loc117_7.2, %D.ref [concrete = constants.%bound_method.9a8]
// CHECK:STDOUT: %Destroy.facet.loc117_7.1: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc117_7.3: %Destroy.type = converted constants.%X, %Destroy.facet.loc117_7.1 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %Destroy.facet.loc117_7.2: %Destroy.type = facet_value constants.%X, (constants.%DestroyImpl.impl_witness.a05, constants.%custom_witness.576) [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: %.loc117_7.4: %Destroy.type = converted constants.%X, %Destroy.facet.loc117_7.2 [concrete = constants.%Destroy.facet]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc48: init %empty_tuple.type = call %SelfDestruct.specific_fn.2(%.loc48_7.2)
// CHECK:STDOUT: %SelfDestruct.call.loc117: init %empty_tuple.type = call %SelfDestruct.specific_fn.2(%.loc117_7.2)
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/interop/cpp/function/import/function.carbon
Vendored
+44 -9
View File
@@ -37,7 +37,12 @@ library "[[@TEST_NAME]]";
import Cpp library "global.h";
fn MyF() {
// CHECK:STDERR: fail_import_global_use_different_name.carbon:[[@LINE+2]]:3-9: error: member name `bar` not found in `Cpp` [MemberNameNotFoundInInstScope]
// CHECK:STDERR: ╭─┤ fail_import_global_use_different_name.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.bar();
// CHECK:STDERR: · ━━━┳━━━
// CHECK:STDERR: · ┗━━┫ error: member name `bar` not found in `Cpp`
// CHECK:STDERR: · ┃ [MemberNameNotFoundInInstScope]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.bar();
}
@@ -57,7 +62,12 @@ library "[[@TEST_NAME]]";
import Cpp library "special_name.h";
fn MyF() {
// CHECK:STDERR: fail_import_special_name_call_unescaped.carbon:[[@LINE+2]]:3-10: error: member name `base` not found in `Cpp` [MemberNameNotFoundInInstScope]
// CHECK:STDERR: ╭─┤ fail_import_special_name_call_unescaped.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.base();
// CHECK:STDERR: · ━━━━┳━━━
// CHECK:STDERR: · ┗━━┫ error: member name `base` not found in `Cpp`
// CHECK:STDERR: · ┃ [MemberNameNotFoundInInstScope]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.base();
}
@@ -81,9 +91,19 @@ library "[[@TEST_NAME]]";
import Cpp library "special_name.h";
fn MyF() {
// CHECK:STDERR: fail_import_special_name_call_escaped_no_match.carbon:[[@LINE+4]]:3-12: error: no matching function for call to 'base' [CppInteropParseError]
// CHECK:STDERR: ./special_name.h:2:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./special_name.h:2:10-11: note: requires 0 arguments, but 1 was provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_import_special_name_call_escaped_no_match.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.r#base(1);
// CHECK:STDERR: · ━━━━━┳━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'base'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./special_name.h
// CHECK:STDERR: │ auto base() -> void;
// CHECK:STDERR: · ┬ ─┬
// CHECK:STDERR: · ╰───────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires 0 arguments, but 1 was provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.r#base(1);
}
@@ -125,7 +145,12 @@ import Cpp library "variadic.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_import_variadic.carbon:[[@LINE+2]]:3-21: error: semantics TODO: `Unsupported: Variadic function` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_import_variadic.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.variadic_foo(8);
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: Variadic function`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.variadic_foo(8);
//@dump-sem-ir-end
@@ -138,7 +163,19 @@ fn F() {
// --- static.h
// TODO: Promote this warning to an error by default.
// CHECK:STDERR: ./static.h:[[@LINE+1]]:13: warning: function 'static_foo' has internal linkage but is not defined [CppInteropParseWarning]
// CHECK:STDERR: ╭─┤ ./static.h:[[@LINE+13]]:13
// CHECK:STDERR: -> │ static auto static_foo() -> void;
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ warning: function 'static_foo' has internal linkage but is not
// CHECK:STDERR: · ┃ defined
// CHECK:STDERR: · ┃ [CppInteropParseWarning]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ todo_fail_import_static.carbon
// CHECK:STDERR: │ Cpp.static_foo();
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ used here [CppInteropParseNote]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
static auto static_foo() -> void;
// --- todo_fail_import_static.carbon
@@ -149,8 +186,6 @@ import Cpp library "static.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: todo_fail_import_static.carbon:[[@LINE+2]]:18: note: used here [CppInteropParseNote]
// CHECK:STDERR:
Cpp.static_foo();
//@dump-sem-ir-end
}
toolchain/check/testdata/interop/cpp/function/import/function_ptr.carbon
Vendored
+51 -11
View File
@@ -126,8 +126,22 @@ fn F() {
// --- forward_decl.h
// CHECK:STDERR: error: calling function with incomplete return type 'Incomplete' [CppInteropParseError]
// CHECK:STDERR: ./forward_decl.h:[[@LINE+1]]:7: note: forward declaration of 'Incomplete' [CppInteropParseNote]
// CHECK:STDERR: -> ╭─┤ <no location>
// CHECK:STDERR: · ┗━━┫ error: calling function with incomplete return type 'Incomplete'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./forward_decl.h:[[@LINE+12]]:7
// CHECK:STDERR: │ class Incomplete;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'Incomplete' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_use_forward_decl.carbon
// CHECK:STDERR: │ Cpp.ReturnCallback()();
// CHECK:STDERR: · ───────────┬──────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function pointer type used here
// CHECK:STDERR: · │ [InCppFunctionPointerThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
class Incomplete;
using CallbackType = Incomplete (*)();
@@ -151,12 +165,21 @@ library "[[@TEST_NAME]]";
import Cpp library "forward_decl.h";
fn F() {
// CHECK:STDERR: fail_use_forward_decl.carbon:[[@LINE+7]]:3-24: note: in thunk for C++ function pointer type used here [InCppFunctionPointerThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_use_forward_decl.carbon:[[@LINE+5]]:3-24: error: function returns incomplete type `Cpp.Incomplete` [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: included from: fail_use_forward_decl.carbon:[[@LINE-6]]:10 [InCppInclude]
// CHECK:STDERR: ./forward_decl.h:4:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: note: return type declared here [IncompleteReturnTypeHere]
// CHECK:STDERR: ╭─┤ fail_use_forward_decl.carbon:[[@LINE+16]]:3
// CHECK:STDERR: -> │ Cpp.ReturnCallback()();
// CHECK:STDERR: · ━━━━━━━━━━━┳━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: function returns incomplete type `Cpp.Incomplete`
// CHECK:STDERR: · ┃ [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_use_forward_decl.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./forward_decl.h
// CHECK:STDERR: │ class Incomplete;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ <no location>
// CHECK:STDERR: · ╰──┤ return type declared here [IncompleteReturnTypeHere]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.ReturnCallback()();
}
@@ -171,7 +194,13 @@ using MyCallbackType = void(*)(int);
fn MyCallback(generic arg: i32);
fn F() {
// CHECK:STDERR: fail_convert_generic_arg.carbon:[[@LINE+2]]:43-52: error: semantics TODO: `binding maps to a non-type template parameter` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_convert_generic_arg.carbon:[[@LINE+8]]:43
// CHECK:STDERR: -> │ var unused fn_ptr: Cpp.MyCallbackType = MyCallback;
// CHECK:STDERR: · ━━━━━┳━━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: semantics TODO: `binding maps to a non-type template parameter`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
var unused fn_ptr: Cpp.MyCallbackType = MyCallback;
}
@@ -186,8 +215,19 @@ using MyCallbackType = void(*)(int);
fn MyCallback(arg: i32) -> i32;
fn F() {
// CHECK:STDERR: fail_convert_type_mismatch.carbon:[[@LINE+3]]:43-52: error: can't convert exported function pointer to `void (*)(int)` [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: fail_convert_type_mismatch.carbon:[[@LINE-4]]:1-31: note: function exported with pointer type `int (*)(int)` [ExportedFromFunction]
// CHECK:STDERR: ╭─┤ fail_convert_type_mismatch.carbon:[[@LINE+14]]:43
// CHECK:STDERR: │ fn MyCallback(arg: i32) -> i32;
// CHECK:STDERR: · ───────────────┬───────────────
// CHECK:STDERR: · ╰──┤ function exported with pointer type `int (*)(int)`
// CHECK:STDERR: · │ [ExportedFromFunction]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ var unused fn_ptr: Cpp.MyCallbackType = MyCallback;
// CHECK:STDERR: · ┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: can't convert exported
// CHECK:STDERR: · ┃ function pointer to
// CHECK:STDERR: · ┃ `void (*)(int)`
// CHECK:STDERR: · ┃ [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
var unused fn_ptr: Cpp.MyCallbackType = MyCallback;
}
toolchain/check/testdata/interop/cpp/function/import/inline.carbon
Vendored
+18 -9
View File
@@ -37,7 +37,18 @@ fn MyF() {
// --- without_definition.h
// TODO: Promote this warning to an error by default.
// CHECK:STDERR: ./without_definition.h:[[@LINE+1]]:13: warning: inline function 'inline_without_def' is not defined [CppInteropParseWarning]
// CHECK:STDERR: ╭─┤ ./without_definition.h:[[@LINE+12]]:13
// CHECK:STDERR: -> │ inline void inline_without_def();
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ warning: inline function 'inline_without_def' is not defined
// CHECK:STDERR: · ┃ [CppInteropParseWarning]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ todo_fail_import_without_definition.carbon
// CHECK:STDERR: │ Cpp.inline_without_def();
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ used here [CppInteropParseNote]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
inline void inline_without_def();
// --- todo_fail_import_without_definition.carbon
@@ -48,8 +59,6 @@ import Cpp library "without_definition.h";
fn MyF() {
//@dump-sem-ir-begin
// CHECK:STDERR: todo_fail_import_without_definition.carbon:[[@LINE+2]]:26: note: used here [CppInteropParseNote]
// CHECK:STDERR:
Cpp.inline_without_def();
// Don't error on repeated calls.
@@ -131,12 +140,12 @@ fn MyF() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @MyF() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Cpp.ref.loc10: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %inline_without_def.ref.loc10: %inline_without_def.cpp_overload_set.type = name_ref inline_without_def, imports.%inline_without_def.cpp_overload_set.value [concrete = constants.%inline_without_def.cpp_overload_set.value]
// CHECK:STDOUT: %inline_without_def.call.loc10: init %empty_tuple.type = call imports.%inline_without_def.decl()
// CHECK:STDOUT: %Cpp.ref.loc13: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %inline_without_def.ref.loc13: %inline_without_def.cpp_overload_set.type = name_ref inline_without_def, imports.%inline_without_def.cpp_overload_set.value [concrete = constants.%inline_without_def.cpp_overload_set.value]
// CHECK:STDOUT: %inline_without_def.call.loc13: init %empty_tuple.type = call imports.%inline_without_def.decl()
// CHECK:STDOUT: %Cpp.ref.loc8: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %inline_without_def.ref.loc8: %inline_without_def.cpp_overload_set.type = name_ref inline_without_def, imports.%inline_without_def.cpp_overload_set.value [concrete = constants.%inline_without_def.cpp_overload_set.value]
// CHECK:STDOUT: %inline_without_def.call.loc8: init %empty_tuple.type = call imports.%inline_without_def.decl()
// CHECK:STDOUT: %Cpp.ref.loc11: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %inline_without_def.ref.loc11: %inline_without_def.cpp_overload_set.type = name_ref inline_without_def, imports.%inline_without_def.cpp_overload_set.value [concrete = constants.%inline_without_def.cpp_overload_set.value]
// CHECK:STDOUT: %inline_without_def.call.loc11: init %empty_tuple.type = call imports.%inline_without_def.decl()
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/interop/cpp/function/import/method_ptr.carbon
Vendored
+85 -21
View File
@@ -75,15 +75,44 @@ library "[[@TEST_NAME]]";
import Cpp library "method_ptr.h";
fn F(c: Cpp.C) {
// CHECK:STDERR: fail_todo_call_method_ptr.carbon:[[@LINE+10]]:3-24: error: member name of type `<C++ type void (C::*)(void) const>` in compound member access is not an instance member or an interface member [CompoundMemberAccessDoesNotUseBase]
// CHECK:STDERR: ╭─┤ fail_todo_call_method_ptr.carbon:[[@LINE+39]]:3
// CHECK:STDERR: -> │ c.(Cpp.GetMethodPtr())(42);
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: member name of type `<C++ type void (C::*)(void) const>` in
// CHECK:STDERR: · ┃ compound member access is not an instance member or an interface
// CHECK:STDERR: · ┃ member
// CHECK:STDERR: · ┃ [CompoundMemberAccessDoesNotUseBase]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: fail_todo_call_method_ptr.carbon:[[@LINE+8]]:3-28: error: semantics TODO: `invoking a C++ member function pointer is unsupported` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_call_method_ptr.carbon:[[@LINE+30]]:3
// CHECK:STDERR: -> │ c.(Cpp.GetMethodPtr())(42);
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO:
// CHECK:STDERR: · ┃ `invoking a C++ member function pointer is unsupported`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: error: called object type 'void (C::*)() const' is not a function or function pointer [CppInteropParseError]
// CHECK:STDERR: fail_todo_call_method_ptr.carbon:[[@LINE+5]]:3-28: note: in thunk for C++ function pointer type used here [InCppFunctionPointerThunk]
// CHECK:STDERR: -> ╭─┤ <no location>
// CHECK:STDERR: · ┗━━┫ error: called object type 'void (C::*)() const' is not a function or
// CHECK:STDERR: · ┃ function pointer
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_todo_call_method_ptr.carbon:[[@LINE+17]]:3
// CHECK:STDERR: │ c.(Cpp.GetMethodPtr())(42);
// CHECK:STDERR: · ─────────────┬────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function pointer type used here
// CHECK:STDERR: · │ [InCppFunctionPointerThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: fail_todo_call_method_ptr.carbon:[[@LINE+3]]:3-28: error: 1 argument passed to function expecting 0 arguments [CallArgCountMismatch]
// CHECK:STDERR: fail_todo_call_method_ptr.carbon: note: calling function declared here [InCallToEntity]
// CHECK:STDERR: ╭─┤ fail_todo_call_method_ptr.carbon:[[@LINE+10]]:3
// CHECK:STDERR: -> │ c.(Cpp.GetMethodPtr())(42);
// CHECK:STDERR: · ━━━━━━━━━━━━━┳━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: 1 argument passed to function expecting 0 arguments
// CHECK:STDERR: · ┃ [CallArgCountMismatch]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_todo_call_method_ptr.carbon
// CHECK:STDERR: · ╰──┤ calling function declared here [InCallToEntity]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
c.(Cpp.GetMethodPtr())(42);
}
@@ -96,8 +125,19 @@ import Cpp library "method_ptr.h";
fn F(ref c: Cpp.C);
fn G() {
// CHECK:STDERR: fail_pass_function_for_method.carbon:[[@LINE+3]]:39: error: can't convert exported function pointer to `void (C::*)(void) const` [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: fail_pass_function_for_method.carbon:[[@LINE-4]]:1-19: note: function exported with pointer type `void (*)(class C &)` [ExportedFromFunction]
// CHECK:STDERR: ╭─┤ fail_pass_function_for_method.carbon:[[@LINE+14]]:39
// CHECK:STDERR: │ fn F(ref c: Cpp.C);
// CHECK:STDERR: · ─────────┬─────────
// CHECK:STDERR: · ╰──┤ function exported with pointer type `void (*)(class C &)`
// CHECK:STDERR: · │ [ExportedFromFunction]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ var unused ptr: Cpp.MethodPtrType = F;
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ error: can't convert exported
// CHECK:STDERR: · ┃ function pointer to
// CHECK:STDERR: · ┃ `void (C::*)(void) const`
// CHECK:STDERR: · ┃ [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
var unused ptr: Cpp.MethodPtrType = F;
}
@@ -112,8 +152,20 @@ class C {
}
fn F() {
// CHECK:STDERR: fail_wrong_parent_type.carbon:[[@LINE+3]]:39-46: error: can't convert exported member function pointer to `void (C::*)(void) const` [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: fail_wrong_parent_type.carbon:[[@LINE-5]]:3-18: note: function exported with pointer type `void (Carbon::Main::C::*)(void) const` [ExportedFromFunction]
// CHECK:STDERR: ╭─┤ fail_wrong_parent_type.carbon:[[@LINE+15]]:39
// CHECK:STDERR: │ fn Method(self);
// CHECK:STDERR: · ┬───────────────
// CHECK:STDERR: · ╰──┤ function exported with pointer type
// CHECK:STDERR: · │ `void (Carbon::Main::C::*)(void) const`
// CHECK:STDERR: · │ [ExportedFromFunction]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ var unused ptr: Cpp.MethodPtrType = C.Method;
// CHECK:STDERR: · ┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: can't convert exported member
// CHECK:STDERR: · ┃ function pointer to
// CHECK:STDERR: · ┃ `void (C::*)(void) const`
// CHECK:STDERR: · ┃ [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
var unused ptr: Cpp.MethodPtrType = C.Method;
}
@@ -133,8 +185,20 @@ using MethodPtrType = void(Carbon::C::*)(float) const;
fn G() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+3]]:39-46: error: can't convert exported member function pointer to `void (Carbon::Main::C::*)(float) const` [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE-10]]:3-26: note: function exported with pointer type `void (Carbon::Main::C::*)(int) const` [ExportedFromFunction]
// CHECK:STDERR: ╭─┤ fail_type_mismatch.carbon:[[@LINE+15]]:39
// CHECK:STDERR: │ fn Method(self, i: i32);
// CHECK:STDERR: · ┬───────────────────────
// CHECK:STDERR: · ╰──┤ function exported with pointer type
// CHECK:STDERR: · │ `void (Carbon::Main::C::*)(int) const`
// CHECK:STDERR: · │ [ExportedFromFunction]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ var unused ptr: Cpp.MethodPtrType = C.Method;
// CHECK:STDERR: · ━━━━┳━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: can't convert exported member function pointer to
// CHECK:STDERR: · ┃ `void (Carbon::Main::C::*)(float) const`
// CHECK:STDERR: · ┃ [ExportedFunctionPtrTypeMismatch]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
var unused ptr: Cpp.MethodPtrType = C.Method;
//@dump-sem-ir-end
@@ -415,7 +479,7 @@ fn G() {
// CHECK:STDOUT: %T.09f: %SubobjectDestroy.type = symbolic_binding T, 0 [symbolic]
// CHECK:STDOUT: %T.as_type.as.DestroyImpl.impl.Op.type.dea: type = fn_type @T.as_type.as.DestroyImpl.impl.Op, @T.as_type.as.DestroyImpl.impl(%T.09f) [symbolic]
// CHECK:STDOUT: %T.as_type.as.DestroyImpl.impl.Op.6e5: %T.as_type.as.DestroyImpl.impl.Op.type.dea = struct_value () [symbolic]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.type.6870fd.3: type = fn_type @SubobjectDestroy.WithSelf.Op.loc18 [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.type.6870fd.3: type = fn_type @SubobjectDestroy.WithSelf.Op.loc30 [concrete]
// CHECK:STDOUT: %SubobjectDestroy.WithSelf.Op.30f1ee.3: %SubobjectDestroy.WithSelf.Op.type.6870fd.3 = struct_value () [concrete]
// CHECK:STDOUT: %custom_witness.b80ef6.3: <witness> = custom_witness (%SubobjectDestroy.WithSelf.Op.30f1ee.3), @SubobjectDestroy [concrete]
// CHECK:STDOUT: %SubobjectDestroy.facet.886: %SubobjectDestroy.type = facet_value %.659, (%custom_witness.b80ef6.3) [concrete]
@@ -438,7 +502,7 @@ fn G() {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [concrete = constants.%C]
// CHECK:STDOUT: %Method.ref: %C.Method.type = name_ref Method, @C.%C.Method.decl [concrete = constants.%C.Method]
// CHECK:STDOUT: assign %ptr.var, <error>
// CHECK:STDOUT: %.loc18_22: type = splice_block %MethodPtrType.ref [concrete = constants.%.659] {
// CHECK:STDOUT: %.loc30_22: type = splice_block %MethodPtrType.ref [concrete = constants.%.659] {
// CHECK:STDOUT: %Cpp.ref: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %MethodPtrType.ref: type = name_ref MethodPtrType, constants.%.659 [concrete = constants.%.659]
// CHECK:STDOUT: }
@@ -447,10 +511,10 @@ fn G() {
// CHECK:STDOUT: %ptr.patt: %pattern_type.4b7 = ref_binding_pattern ptr [concrete = constants.%ptr.patt]
// CHECK:STDOUT: %ptr.var_patt: %pattern_type.4b7 = var_pattern %ptr.patt [concrete = constants.%ptr.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Destroy.facet.loc18_3.1: %Destroy.type = facet_value constants.%.659, (constants.%DestroyImpl.impl_witness.381, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: %.loc18_3.1: %Destroy.type = converted constants.%.659, %Destroy.facet.loc18_3.1 [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: %Destroy.facet.loc18_3.2: %Destroy.type = facet_value constants.%.659, (constants.%DestroyImpl.impl_witness.381, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: %.loc18_3.2: %Destroy.type = converted constants.%.659, %Destroy.facet.loc18_3.2 [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: %Destroy.facet.loc30_3.1: %Destroy.type = facet_value constants.%.659, (constants.%DestroyImpl.impl_witness.381, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: %.loc30_3.1: %Destroy.type = converted constants.%.659, %Destroy.facet.loc30_3.1 [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: %Destroy.facet.loc30_3.2: %Destroy.type = facet_value constants.%.659, (constants.%DestroyImpl.impl_witness.381, constants.%custom_witness.b80ef6.3) [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: %.loc30_3.2: %Destroy.type = converted constants.%.659, %Destroy.facet.loc30_3.2 [concrete = constants.%Destroy.facet.f79]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call: init %empty_tuple.type = call %SelfDestruct.specific_fn(%ptr.var)
// CHECK:STDOUT: <elided>
@@ -459,10 +523,10 @@ fn G() {
// CHECK:STDOUT: fn @C.Method__carbon_thunk(%self.param: ref %C, %_.param: ref %i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %.loc18_40.1: %C = acquire_value %self.param
// CHECK:STDOUT: %.loc18_40.2: %i32 = acquire_value %_.param
// CHECK:STDOUT: %.loc30_40.1: %C = acquire_value %self.param
// CHECK:STDOUT: %.loc30_40.2: %i32 = acquire_value %_.param
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @SubobjectDestroy.WithSelf.Op.loc18(%self.param: ref %.659) = "no_op";
// CHECK:STDOUT: fn @SubobjectDestroy.WithSelf.Op.loc30(%self.param: ref %.659) = "no_op";
// CHECK:STDOUT:
toolchain/check/testdata/interop/cpp/function/import/multiple_too_few_args_calls.carbon
Vendored
+24 -8
View File
@@ -22,14 +22,30 @@ void F2(X x);
fn Call() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-8: error: no matching function for call to 'F1' [CppInteropParseError]
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE-7]]:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE-8]]:9-11: note: requires single argument 'x', but no arguments were provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+12]]:3
// CHECK:STDERR: │ void F1(X x);
// CHECK:STDERR: · ┬ ─┬─
// CHECK:STDERR: · ╰──────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires single argument 'x', but no arguments were provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ Cpp.F1();
// CHECK:STDERR: · ━━━┳━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'F1' [CppInteropParseError]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.F1();
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE+4]]:3-8: error: no matching function for call to 'F2' [CppInteropParseError]
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE-11]]:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: fail_call_too_few_args.carbon:[[@LINE-12]]:9-11: note: requires single argument 'x', but no arguments were provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_too_few_args.carbon:[[@LINE+12]]:3
// CHECK:STDERR: │ void F2(X x);
// CHECK:STDERR: · ┬ ─┬─
// CHECK:STDERR: · ╰──────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires single argument 'x', but no arguments were provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ Cpp.F2();
// CHECK:STDERR: · ━━━┳━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'F2' [CppInteropParseError]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.F2();
//@dump-sem-ir-end
@@ -57,9 +73,9 @@ fn Call() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @Call() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Cpp.ref.loc16: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %Cpp.ref.loc24: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %F1.ref: %F1.cpp_overload_set.type = name_ref F1, imports.%F1.cpp_overload_set.value [concrete = constants.%F1.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc21: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %Cpp.ref.loc37: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %F2.ref: %F2.cpp_overload_set.type = name_ref F2, imports.%F2.cpp_overload_set.value [concrete = constants.%F2.cpp_overload_set.value]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
toolchain/check/testdata/interop/cpp/function/import/overloads.carbon
Vendored
+479 -87
View File
@@ -140,9 +140,23 @@ import Cpp library "int_literal.h";
fn F() {
// TODO: get rid of the second error message here.
// i128_max + 1
// CHECK:STDERR: fail_import_large_int_literal.carbon:[[@LINE+4]]:44-82: error: integer value 170141183460469231731687303715884105728 too large to fit in a signed C++ integer type; requires 129 bits, but max is 128 [IntTooLargeForCppType]
// CHECK:STDERR: ╭─┤ fail_import_large_int_literal.carbon:[[@LINE+18]]:44
// CHECK:STDERR: -> │ ...ed h: i128 = Cpp.int_literal_foo(170141183460469231731687303715884105728);
// CHECK:STDERR: · ━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: integer value 170141183460469231731687303715884105728 too large to fit
// CHECK:STDERR: · ┃ in a signed C++ integer type; requires 129 bits, but max is 128
// CHECK:STDERR: · ┃ [IntTooLargeForCppType]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: fail_import_large_int_literal.carbon:[[@LINE+2]]:44-82: error: call argument of type `Core.IntLiteral` is not supported [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╭─┤ fail_import_large_int_literal.carbon:[[@LINE+9]]:44
// CHECK:STDERR: -> │ ...ed h: i128 = Cpp.int_literal_foo(170141183460469231731687303715884105728);
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: call argument of type
// CHECK:STDERR: · ┃ `Core.IntLiteral` is not
// CHECK:STDERR: · ┃ supported
// CHECK:STDERR: · ┃ [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
let unused h: i128 = Cpp.int_literal_foo(170141183460469231731687303715884105728);
}
@@ -174,8 +188,19 @@ library "[[@TEST_NAME]]";
import Cpp library "negative_literal_passed_to_unsigned.h";
fn F() {
// CHECK:STDERR: fail_import_negative_literal_passed_to_unsigned.carbon:[[@LINE+3]]:27-28: error: negative integer value -1 converted to unsigned type `u32` [NegativeIntInUnsignedType]
// CHECK:STDERR: ./negative_literal_passed_to_unsigned.h:2:39: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_negative_literal_passed_to_unsigned.carbon:[[@LINE+14]]:27
// CHECK:STDERR: -> │ Cpp.neg_to_unsigned_foo(-1);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: negative integer value -1 converted to
// CHECK:STDERR: · ┃ unsigned type `u32`
// CHECK:STDERR: · ┃ [NegativeIntInUnsignedType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./negative_literal_passed_to_unsigned.h
// CHECK:STDERR: │ auto neg_to_unsigned_foo(unsigned int a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.neg_to_unsigned_foo(-1);
}
@@ -202,8 +227,19 @@ library "[[@TEST_NAME]]";
import Cpp library "floating_point_literal.h";
fn F() {
// CHECK:STDERR: fail_import_large_floating_point_literal.carbon:[[@LINE+3]]:25-32: error: value 18*10^307 too large for floating-point type `f64` [FloatLiteralTooLargeForType]
// CHECK:STDERR: ./floating_point_literal.h:3:31: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_large_floating_point_literal.carbon:[[@LINE+14]]:25
// CHECK:STDERR: -> │ Cpp.float_literal_foo(1.8e+308);
// CHECK:STDERR: · ┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: value 18*10^307 too large for floating-point
// CHECK:STDERR: · ┃ type `f64`
// CHECK:STDERR: · ┃ [FloatLiteralTooLargeForType]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./floating_point_literal.h
// CHECK:STDERR: │ auto float_literal_foo(double a) -> double;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.float_literal_foo(1.8e+308);
}
@@ -247,33 +283,110 @@ 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+4]]:23-46: 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+3]]:23-46: note: type `{.a: Core.IntLiteral, .b: Core.IntLiteral, .c: Core.IntLiteral}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_struct_init_nonempty.carbon:[[@LINE+20]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields({.a = 1, .b = 2, .c = 3});
// CHECK:STDERR: · ━━━━━━━━━━━━┳━━━━━━━━━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: cannot implicitly convert expression of type
// CHECK:STDERR: · ┃ `{.a: Core.IntLiteral, .b: Core.IntLiteral, .c: Core.IntLiteral}` to
// CHECK:STDERR: · ┃ `Cpp.ThreeFields`
// CHECK:STDERR: · ┃ [ConversionFailure]
// CHECK:STDERR: · ╭─────────────────────────────────╯
// CHECK:STDERR: · │ type `{.a: Core.IntLiteral, .b: Core.IntLiteral, .c: Core.IntLiteral}` does
// CHECK:STDERR: · │ not implement interface `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields({.a = 1, .b = 2, .c = 3});
// CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+4]]:23-27: 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+3]]:23-27: note: type `{.a: i32, .b: i32, .c: i32}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_struct_init_nonempty.carbon:[[@LINE+19]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields(value);
// CHECK:STDERR: · ┳━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `{.a: i32, .b: i32, .c: i32}` to
// CHECK:STDERR: · │ ┃ `Cpp.ThreeFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `{.a: i32, .b: i32, .c: i32}` does not
// CHECK:STDERR: · │ implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields(value);
// CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+4]]:23-31: 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+3]]:23-31: note: type `{.a: i32, .b: i32, .c: i32}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_struct_init_nonempty.carbon:[[@LINE+19]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields(reference);
// CHECK:STDERR: · ┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `{.a: i32, .b: i32, .c: i32}` to
// CHECK:STDERR: · │ ┃ `Cpp.ThreeFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `{.a: i32, .b: i32, .c: i32}` does not
// CHECK:STDERR: · │ implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields(reference);
// CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+4]]:23-39: 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+3]]:23-39: note: type `{.a: i32, .b: i32, .c: i32}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_struct_init_nonempty.carbon:[[@LINE+19]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields(MakeThreeFields());
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `{.a: i32, .b: i32, .c: i32}` to
// CHECK:STDERR: · │ ┃ `Cpp.ThreeFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `{.a: i32, .b: i32, .c: i32}` does not
// CHECK:STDERR: · │ implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields(MakeThreeFields());
// CHECK:STDERR: fail_todo_struct_init_nonempty.carbon:[[@LINE+4]]:23-46: 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+3]]:23-46: note: type `{.b: Core.IntLiteral, .c: Core.IntLiteral, .a: Core.IntLiteral}` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_struct_init_nonempty.carbon:[[@LINE+20]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields({.b = 1, .c = 2, .a = 3});
// CHECK:STDERR: · ━━━━━━━━━━━━┳━━━━━━━━━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: cannot implicitly convert expression of type
// CHECK:STDERR: · ┃ `{.b: Core.IntLiteral, .c: Core.IntLiteral, .a: Core.IntLiteral}` to
// CHECK:STDERR: · ┃ `Cpp.ThreeFields`
// CHECK:STDERR: · ┃ [ConversionFailure]
// CHECK:STDERR: · ╭─────────────────────────────────╯
// CHECK:STDERR: · │ type `{.b: Core.IntLiteral, .c: Core.IntLiteral, .a: Core.IntLiteral}` does
// CHECK:STDERR: · │ not implement interface `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields({.b = 1, .c = 2, .a = 3});
}
@@ -285,15 +398,37 @@ library "[[@TEST_NAME]]";
import Cpp library "struct_init.h";
fn F() {
// CHECK:STDERR: fail_struct_init_field_mismatch.carbon:[[@LINE+4]]:3-21: error: no matching function for call to 'PassThreeFields' [CppInteropParseError]
// CHECK:STDERR: ./struct_init.h:10:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./struct_init.h:10:22-34: note: cannot convert initializer list argument to 'ThreeFields' [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_struct_init_field_mismatch.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.PassThreeFields({.a = 1, .b = 2, .c = 3, .d = 4});
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'PassThreeFields'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬ ┬────────────
// CHECK:STDERR: · ╰──────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ cannot convert initializer list argument to
// CHECK:STDERR: · │ 'ThreeFields'
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields({.a = 1, .b = 2, .c = 3, .d = 4});
// CHECK:STDERR: fail_struct_init_field_mismatch.carbon:[[@LINE+4]]:3-21: error: no matching function for call to 'PassThreeFields' [CppInteropParseError]
// CHECK:STDERR: ./struct_init.h:10:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./struct_init.h:10:22-34: note: cannot convert initializer list argument to 'ThreeFields' [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_struct_init_field_mismatch.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.PassThreeFields({.a = 1, .x = 2, .c = 3});
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'PassThreeFields'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬ ┬────────────
// CHECK:STDERR: · ╰──────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ cannot convert initializer list argument to
// CHECK:STDERR: · │ 'ThreeFields'
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields({.a = 1, .x = 2, .c = 3});
}
@@ -305,7 +440,12 @@ library "[[@TEST_NAME]]";
import Cpp library "struct_init.h";
fn F() {
// CHECK:STDERR: fail_struct_init_unsupported_field_name.carbon:[[@LINE+2]]:23-33: error: field name `base` cannot be mapped into C++ [CppCallFieldNameNotSupported]
// CHECK:STDERR: ╭─┤ fail_struct_init_unsupported_field_name.carbon:[[@LINE+7]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields({.base = 1});
// CHECK:STDERR: · ━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: field name `base` cannot be mapped into C++
// CHECK:STDERR: · ┃ [CppCallFieldNameNotSupported]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields({.base = 1});
}
@@ -322,27 +462,79 @@ import Cpp library "struct_init.h";
fn MakeEmpty() -> ();
fn Empty(value: (), ref reference: ()) {
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+4]]:20-21: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure]
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+3]]:20-21: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+17]]:20
// CHECK:STDERR: -> │ Cpp.PassNoFields(());
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type `()`
// CHECK:STDERR: · │ ┃ to `Cpp.NoFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `()` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.NoFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassNoFields(NoFields s) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassNoFields(());
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+4]]:20-24: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure]
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+3]]:20-24: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+17]]:20
// CHECK:STDERR: -> │ Cpp.PassNoFields(value);
// CHECK:STDERR: · ┳━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type `()`
// CHECK:STDERR: · │ ┃ to `Cpp.NoFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `()` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.NoFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassNoFields(NoFields s) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassNoFields(value);
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+4]]:20-28: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure]
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+3]]:20-28: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+17]]:20
// CHECK:STDERR: -> │ Cpp.PassNoFields(reference);
// CHECK:STDERR: · ┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type `()`
// CHECK:STDERR: · │ ┃ to `Cpp.NoFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `()` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.NoFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassNoFields(NoFields s) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassNoFields(reference);
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+4]]:20-30: error: cannot implicitly convert expression of type `()` to `Cpp.NoFields` [ConversionFailure]
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+3]]:20-30: note: type `()` does not implement interface `Core.ImplicitAs(Cpp.NoFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:4:28: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+17]]:20
// CHECK:STDERR: -> │ Cpp.PassNoFields(MakeEmpty());
// CHECK:STDERR: · ┳━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type `()`
// CHECK:STDERR: · │ ┃ to `Cpp.NoFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `()` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.NoFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassNoFields(NoFields s) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassNoFields(MakeEmpty());
}
@@ -350,27 +542,83 @@ 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+4]]:23-31: 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+3]]:23-31: note: type `(Core.IntLiteral, Core.IntLiteral, Core.IntLiteral)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+21]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields((1, 2, 3));
// CHECK:STDERR: · ┳━━━━━━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: cannot implicitly convert expression of type
// CHECK:STDERR: · ┃ `(Core.IntLiteral, Core.IntLiteral, Core.IntLiteral)` to
// CHECK:STDERR: · ┃ `Cpp.ThreeFields`
// CHECK:STDERR: · ┃ [ConversionFailure]
// CHECK:STDERR: · ╰──┤ type
// CHECK:STDERR: · │ `(Core.IntLiteral, Core.IntLiteral, Core.IntLiteral)`
// CHECK:STDERR: · │ does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields((1, 2, 3));
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+4]]:23-27: error: cannot implicitly convert expression of type `(i32, i32, i32)` to `Cpp.ThreeFields` [ConversionFailure]
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+3]]:23-27: note: type `(i32, i32, i32)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+17]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields(value);
// CHECK:STDERR: · ┳━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `(i32, i32, i32)` to `Cpp.ThreeFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `(i32, i32, i32)` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields(value);
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+4]]:23-31: error: cannot implicitly convert expression of type `(i32, i32, i32)` to `Cpp.ThreeFields` [ConversionFailure]
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+3]]:23-31: note: type `(i32, i32, i32)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+17]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields(reference);
// CHECK:STDERR: · ┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `(i32, i32, i32)` to `Cpp.ThreeFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `(i32, i32, i32)` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields(reference);
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+4]]:23-39: error: cannot implicitly convert expression of type `(i32, i32, i32)` to `Cpp.ThreeFields` [ConversionFailure]
// CHECK:STDERR: fail_struct_init_from_tuple.carbon:[[@LINE+3]]:23-39: note: type `(i32, i32, i32)` does not implement interface `Core.ImplicitAs(Cpp.ThreeFields)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./struct_init.h:10:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_struct_init_from_tuple.carbon:[[@LINE+17]]:23
// CHECK:STDERR: -> │ Cpp.PassThreeFields(MakeThreeFields());
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `(i32, i32, i32)` to `Cpp.ThreeFields`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `(i32, i32, i32)` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(Cpp.ThreeFields)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./struct_init.h
// CHECK:STDERR: │ auto PassThreeFields(ThreeFields t) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassThreeFields(MakeThreeFields());
}
@@ -393,15 +641,39 @@ import Cpp library "int_from_struct.h";
fn F() {
// C++ permits `{}` to be used to initialize an int, but Carbon does not.
// CHECK:STDERR: fail_int_from_struct.carbon:[[@LINE+4]]:15-16: error: cannot implicitly convert expression of type `{}` to `i32` [ConversionFailure]
// CHECK:STDERR: fail_int_from_struct.carbon:[[@LINE+3]]:15-16: note: type `{}` does not implement interface `Core.ImplicitAs(i32)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./int_from_struct.h:2:18: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_int_from_struct.carbon:[[@LINE+16]]:15
// CHECK:STDERR: -> │ Cpp.PassInt({});
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type `{}` to
// CHECK:STDERR: · │ ┃ `i32`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `{}` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(i32)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./int_from_struct.h
// CHECK:STDERR: │ auto PassInt(int n) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassInt({});
// CHECK:STDERR: fail_int_from_struct.carbon:[[@LINE+4]]:15-16: error: cannot implicitly convert expression of type `()` to `i32` [ConversionFailure]
// CHECK:STDERR: fail_int_from_struct.carbon:[[@LINE+3]]:15-16: note: type `()` does not implement interface `Core.ImplicitAs(i32)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./int_from_struct.h:2:18: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_int_from_struct.carbon:[[@LINE+16]]:15
// CHECK:STDERR: -> │ Cpp.PassInt(());
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type `()` to
// CHECK:STDERR: · │ ┃ `i32`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `()` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(i32)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./int_from_struct.h
// CHECK:STDERR: │ auto PassInt(int n) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassInt(());
}
@@ -416,15 +688,41 @@ fn F() {
// C++ overload resolution prefers to convert `{}` to `int` rather than to an
// empty struct. So that's the overload we pick, even though we can't call it.
// CHECK:STDERR: fail_int_from_struct_overloaded.carbon:[[@LINE+4]]:22-23: error: cannot implicitly convert expression of type `{}` to `i32` [ConversionFailure]
// CHECK:STDERR: fail_int_from_struct_overloaded.carbon:[[@LINE+3]]:22-23: note: type `{}` does not implement interface `Core.ImplicitAs(i32)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./int_from_struct.h:6:25: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_int_from_struct_overloaded.carbon:[[@LINE+17]]:22
// CHECK:STDERR: -> │ Cpp.PassOverloaded({});
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `{}` to `i32`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `{}` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(i32)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./int_from_struct.h
// CHECK:STDERR: │ auto PassOverloaded(int n) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassOverloaded({});
// CHECK:STDERR: fail_int_from_struct_overloaded.carbon:[[@LINE+4]]:22-23: error: cannot implicitly convert expression of type `()` to `i32` [ConversionFailure]
// CHECK:STDERR: fail_int_from_struct_overloaded.carbon:[[@LINE+3]]:22-23: note: type `()` does not implement interface `Core.ImplicitAs(i32)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./int_from_struct.h:6:25: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_int_from_struct_overloaded.carbon:[[@LINE+17]]:22
// CHECK:STDERR: -> │ Cpp.PassOverloaded(());
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `()` to `i32`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `()` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(i32)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./int_from_struct.h
// CHECK:STDERR: │ auto PassOverloaded(int n) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.PassOverloaded(());
}
@@ -449,9 +747,19 @@ library "[[@TEST_NAME]]";
import Cpp library "nested_structs.h";
fn F() {
// CHECK:STDERR: fail_pass_nested_structs_inner_field_mismatch.carbon:[[@LINE+4]]:3-11: error: no matching function for call to 'TakeB' [CppInteropParseError]
// CHECK:STDERR: ./nested_structs.h:11:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./nested_structs.h:11:12: note: cannot convert initializer list argument to 'B' [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_pass_nested_structs_inner_field_mismatch.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakeB({.a = {.x = 1, .z = 2}, .n = 3});
// CHECK:STDERR: · ━━━━┳━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakeB'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./nested_structs.h
// CHECK:STDERR: │ void TakeB(B);
// CHECK:STDERR: · ┬ ┬
// CHECK:STDERR: · ╰────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ cannot convert initializer list argument to 'B'
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakeB({.a = {.x = 1, .z = 2}, .n = 3});
}
@@ -463,9 +771,24 @@ library "[[@TEST_NAME]]";
import Cpp library "nested_structs.h";
fn F() {
// CHECK:STDERR: fail_todo_pass_nested_structs.carbon:[[@LINE+4]]:13-43: 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+3]]:13-43: note: type `{.a: {.x: Core.IntLiteral, .y: Core.IntLiteral}, .n: Core.IntLiteral}` does not implement interface `Core.ImplicitAs(Cpp.B)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./nested_structs.h:11:13: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_pass_nested_structs.carbon:[[@LINE+19]]:13
// CHECK:STDERR: -> │ Cpp.TakeB({.a = {.x = 1, .y = 2}, .n = 3});
// CHECK:STDERR: · ━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: cannot implicitly convert expression of type
// CHECK:STDERR: · ┃ `{.a: {.x: Core.IntLiteral, .y: Core.IntLiteral}, .n: Core.IntLiteral}`
// CHECK:STDERR: · ┃ to `Cpp.B`
// CHECK:STDERR: · ┃ [ConversionFailure]
// CHECK:STDERR: · ╭──────────────────────────╯
// CHECK:STDERR: · │ type `{.a: {.x: Core.IntLiteral, .y: Core.IntLiteral}, .n: Core.IntLiteral}`
// CHECK:STDERR: · │ does not implement interface `Core.ImplicitAs(Cpp.B)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./nested_structs.h
// CHECK:STDERR: │ void TakeB(B);
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakeB({.a = {.x = 1, .y = 2}, .n = 3});
}
@@ -499,9 +822,22 @@ library "[[@TEST_NAME]]";
import Cpp library "signedness_change.h";
fn F() {
// CHECK:STDERR: fail_signedness_change_rejected.carbon:[[@LINE+4]]:22-29: error: cannot implicitly convert expression of type `i32` to `u32` [ConversionFailure]
// CHECK:STDERR: fail_signedness_change_rejected.carbon:[[@LINE+3]]:22-29: note: type `i32` does not implement interface `Core.ImplicitAs(u32)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./signedness_change.h:2:34: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_signedness_change_rejected.carbon:[[@LINE+17]]:22
// CHECK:STDERR: -> │ Cpp.signedness_foo(1 as i32);
// CHECK:STDERR: · ┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `i32` to `u32`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `i32` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(u32)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./signedness_change.h
// CHECK:STDERR: │ auto signedness_foo(unsigned int a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.signedness_foo(1 as i32);
}
@@ -517,9 +853,22 @@ library "[[@TEST_NAME]]";
import Cpp library "downsizing_rejected.h";
fn F() {
// CHECK:STDERR: fail_import_downsizing_rejected.carbon:[[@LINE+4]]:22-29: error: cannot implicitly convert expression of type `i32` to `i16` [ConversionFailure]
// CHECK:STDERR: fail_import_downsizing_rejected.carbon:[[@LINE+3]]:22-29: note: type `i32` does not implement interface `Core.ImplicitAs(i16)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ./downsizing_rejected.h:2:27: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_downsizing_rejected.carbon:[[@LINE+17]]:22
// CHECK:STDERR: -> │ Cpp.downsizing_foo(1 as i32);
// CHECK:STDERR: · ┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of type
// CHECK:STDERR: · │ ┃ `i32` to `i16`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `i32` does not implement interface
// CHECK:STDERR: · │ `Core.ImplicitAs(i16)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./downsizing_rejected.h
// CHECK:STDERR: │ auto downsizing_foo(short a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.downsizing_foo(1 as i32);
}
@@ -539,9 +888,20 @@ library "[[@TEST_NAME]]";
import Cpp library "no_viable_function.h";
fn F() {
// CHECK:STDERR: fail_import_no_viable_function.carbon:[[@LINE+4]]:3-19: error: no matching function for call to 'no_viable_foo' [CppInteropParseError]
// CHECK:STDERR: ./no_viable_function.h:2:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./no_viable_function.h:2:20-33: note: requires 2 arguments, but 1 was provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_import_no_viable_function.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.no_viable_foo(1 as i64);
// CHECK:STDERR: · ━━━━━━━━┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'no_viable_foo'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./no_viable_function.h
// CHECK:STDERR: │ auto no_viable_foo(short a, int b) -> void;
// CHECK:STDERR: · ┬ ───────┬──────
// CHECK:STDERR: · ╰───────────────────────┤ candidate function not viable
// CHECK:STDERR: · │ │ [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires 2 arguments, but 1 was provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.no_viable_foo(1 as i64);
}
@@ -562,9 +922,20 @@ library "[[@TEST_NAME]]";
import Cpp library "ambiguous_overload.h";
fn F() {
// CHECK:STDERR: fail_import_ambiguous_overload.carbon:[[@LINE+4]]:3-19: error: call to 'ambiguous_foo' is ambiguous [CppInteropParseError]
// CHECK:STDERR: ./ambiguous_overload.h:2:6: note: candidate function [CppInteropParseNote]
// CHECK:STDERR: ./ambiguous_overload.h:3:6: note: candidate function [CppInteropParseNote]
// CHECK:STDERR: ╭─┤ fail_import_ambiguous_overload.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.ambiguous_foo(1 as i64);
// CHECK:STDERR: · ━━━━━━━━┳━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: call to 'ambiguous_foo' is ambiguous
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./ambiguous_overload.h
// CHECK:STDERR: │ auto ambiguous_foo(short a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ candidate function [CppInteropParseNote]
// CHECK:STDERR: │ auto ambiguous_foo(int a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ candidate function [CppInteropParseNote]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.ambiguous_foo(1 as i64);
}
@@ -585,9 +956,20 @@ library "[[@TEST_NAME]]";
import Cpp library "deleted_function.h";
fn F() {
// CHECK:STDERR: fail_import_deleted_function.carbon:[[@LINE+4]]:3-17: error: call to deleted function 'deleted_foo' [CppInteropParseError]
// CHECK:STDERR: ./deleted_function.h:3:6: note: candidate function has been explicitly deleted [CppInteropParseNote]
// CHECK:STDERR: ./deleted_function.h:2:6: note: candidate function [CppInteropParseNote]
// CHECK:STDERR: ╭─┤ fail_import_deleted_function.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.deleted_foo(1 as i32);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: call to deleted function 'deleted_foo'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./deleted_function.h
// CHECK:STDERR: │ auto deleted_foo(short a) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ candidate function [CppInteropParseNote]
// CHECK:STDERR: │ auto deleted_foo(int a) -> void = delete;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ candidate function has been explicitly deleted [CppInteropParseNote]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.deleted_foo(1 as i32);
}
@@ -605,8 +987,18 @@ interface I {}
fn EchoValue[ValueT: I](unused generic value: ValueT) {}
fn F() {
// CHECK:STDERR: fail_missing_impl.carbon:[[@LINE+3]]:3-33: error: cannot convert type `<type of Cpp.missing_impl_foo>` into type implementing `I` [ConversionFailureTypeToFacet]
// CHECK:STDERR: fail_missing_impl.carbon:[[@LINE-4]]:1-55: note: while deducing parameters of generic declared here [DeductionGenericHere]
// CHECK:STDERR: ╭─┤ fail_missing_impl.carbon:[[@LINE+13]]:3
// CHECK:STDERR: │ fn EchoValue[ValueT: I](unused generic value: ValueT) {}
// CHECK:STDERR: · ─────────────────────────┬─────────────────────────────
// CHECK:STDERR: · ╰──┤ while deducing parameters of generic declared here
// CHECK:STDERR: · │ [DeductionGenericHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ EchoValue(Cpp.missing_impl_foo);
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot convert type `<type of Cpp.missing_impl_foo>` into type
// CHECK:STDERR: · ┃ implementing `I`
// CHECK:STDERR: · ┃ [ConversionFailureTypeToFacet]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
EchoValue(Cpp.missing_impl_foo);
}
toolchain/check/testdata/interop/cpp/function/import/param_unsupported.carbon
Vendored
+30 -5
View File
@@ -26,7 +26,12 @@ import Cpp library "unsupported_primitive_type.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_import_unsupported_primitive_type.carbon:[[@LINE+2]]:3-13: error: semantics TODO: `Unsupported: parameter type: _BitInt(23)` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_import_unsupported_primitive_type.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.foo(11);
// CHECK:STDERR: · ━━━━━┳━━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: parameter type: _BitInt(23)`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(11);
//@dump-sem-ir-end
@@ -48,7 +53,12 @@ import Cpp library "unsupported_primitive_type_among_params.h";
fn F() {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_todo_import_unsupported_primitive_type_among_params.carbon:[[@LINE+2]]:3-16: error: semantics TODO: `Unsupported: parameter type: _BitInt(23)` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_todo_import_unsupported_primitive_type_among_params.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.foo(1, 20);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: parameter type: _BitInt(23)`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(1, 20);
//@dump-sem-ir-end
@@ -70,9 +80,19 @@ import Cpp library "int_param.h";
// This doesn't have a direct type mapping in `getIntTypeForBitwidth`.
fn F(x: i512) {
// CHECK:STDERR: fail_large_int.carbon:[[@LINE+4]]:11: error: call argument of type `i512` is not supported [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╭─┤ fail_large_int.carbon:[[@LINE+14]]:11
// CHECK:STDERR: -> │ Cpp.foo(x);
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ error: call argument of type `i512` is not supported
// CHECK:STDERR: · ┃ [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: min_prelude/parts/int.carbon:10:1-26: error: semantics TODO: `interop with non-identifier package name` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ min_prelude/parts/int.carbon:10:1
// CHECK:STDERR: -> │ class Int(N: IntLiteral) {
// CHECK:STDERR: · ━━━━━━━━━━┳━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `interop with non-identifier package name`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(x);
}
@@ -85,7 +105,12 @@ import Cpp library "int_param.h";
// This doesn't fit as an embedded `IntId` value.
fn F(x: i8388608) {
// CHECK:STDERR: fail_very_large_int.carbon:[[@LINE+2]]:11: error: call argument of type `i8388608` is not supported [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╭─┤ fail_very_large_int.carbon:[[@LINE+7]]:11
// CHECK:STDERR: -> │ Cpp.foo(x);
// CHECK:STDERR: · ┳
// CHECK:STDERR: · ┗━━┫ error: call argument of type `i8388608` is not supported
// CHECK:STDERR: · ┃ [CppCallArgTypeNotSupported]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo(x);
}
toolchain/check/testdata/interop/cpp/function/import/pointer.carbon
Vendored
+28 -5
View File
@@ -43,9 +43,21 @@ fn G() -> const Cpp.NonNullableParamS;
fn F() {
var s: const Cpp.NonNullableParamS = G();
// CHECK:STDERR: fail_import_non_nullable_pointer_param_using_const_value.carbon:[[@LINE+4]]:3-28: error: no matching function for call to 'non_nullable_param_foo' [CppInteropParseError]
// CHECK:STDERR: ./non_nullable_pointer_param.h:4:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./non_nullable_pointer_param.h:4:29-55: note: 1st argument ('const NonNullableParamS * _Nonnull') would lose const qualifier [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_import_non_nullable_pointer_param_using_const_value.carbon:[[@LINE+16]]:3
// CHECK:STDERR: -> │ Cpp.non_nullable_param_foo(&s);
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'non_nullable_param_foo'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./non_nullable_pointer_param.h
// CHECK:STDERR: │ auto non_nullable_param_foo(NonNullableParamS* _Nonnull) -> void;
// CHECK:STDERR: · ┬ ┬──────────────────────────
// CHECK:STDERR: · ╰─────────────────────────┤ candidate function not viable
// CHECK:STDERR: · │ │ [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ 1st argument ('const NonNullableParamS *
// CHECK:STDERR: · │ _Nonnull') would lose const qualifier
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.non_nullable_param_foo(&s);
}
@@ -413,8 +425,19 @@ import Cpp library "deduced_pointer_param.h";
fn F() {
// This could return a null pointer, so should not be given the type `Cpp.DeducedPointerS*`.
// CHECK:STDERR: fail_import_deduced_pointer_param_as_optional_pointer.carbon:[[@LINE+3]]:40-78: error: cannot implicitly convert expression of type `Core.Optional(Cpp.DeducedPointerS* as Core.OptionalStorage)` to `Cpp.DeducedPointerS*` [ConversionFailure]
// CHECK:STDERR: fail_import_deduced_pointer_param_as_optional_pointer.carbon:[[@LINE+2]]:40-78: note: type `Core.Optional(Cpp.DeducedPointerS* as Core.OptionalStorage)` does not implement interface `Core.ImplicitAs(Cpp.DeducedPointerS*)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ╭─┤ fail_import_deduced_pointer_param_as_optional_pointer.carbon:[[@LINE+14]]:40
// CHECK:STDERR: -> │ let unused a: Cpp.DeducedPointerS* = Cpp.Indirect({} as Cpp.DeducedPointerS);
// CHECK:STDERR: · ━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
// CHECK:STDERR: · ┃ error: cannot implicitly convert expression of type
// CHECK:STDERR: · ┃ `Core.Optional(Cpp.DeducedPointerS* as Core.OptionalStorage)` to
// CHECK:STDERR: · ┃ `Cpp.DeducedPointerS*`
// CHECK:STDERR: · ┃ [ConversionFailure]
// CHECK:STDERR: · ╭─────────────────────────────────────────────────────────╯
// CHECK:STDERR: · │ type `Core.Optional(Cpp.DeducedPointerS* as Core.OptionalStorage)` does not
// CHECK:STDERR: · │ implement interface `Core.ImplicitAs(Cpp.DeducedPointerS*)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
let unused a: Cpp.DeducedPointerS* = Cpp.Indirect({} as Cpp.DeducedPointerS);
}
toolchain/check/testdata/interop/cpp/function/import/reference.carbon
Vendored
+267 -135
View File
@@ -44,29 +44,69 @@ fn F() {
//@dump-sem-ir-begin
var v: Cpp.S;
let s: Cpp.S = v;
// CHECK:STDERR: fail_param_lvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesLValue' [CppInteropParseError]
// CHECK:STDERR: ./param_lvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_lvalue_ref.h:5:18-19: note: 1st argument ('const S') would lose const qualifier [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_lvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesLValue(s);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesLValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_lvalue_ref.h
// CHECK:STDERR: │ auto TakesLValue(S&) -> void;
// CHECK:STDERR: · ┬ ─┬
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ 1st argument ('const S') would lose const qualifier
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesLValue(s);
// CHECK:STDERR: fail_param_lvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesLValue' [CppInteropParseError]
// CHECK:STDERR: ./param_lvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_lvalue_ref.h:5:18-19: note: 1st argument ('const S') would lose const qualifier [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_lvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesLValue(s as const Cpp.S);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesLValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_lvalue_ref.h
// CHECK:STDERR: │ auto TakesLValue(S&) -> void;
// CHECK:STDERR: · ┬ ─┬
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ 1st argument ('const S') would lose const qualifier
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesLValue(s as const Cpp.S);
var t: Cpp.T;
// CHECK:STDERR: fail_param_lvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesLValue' [CppInteropParseError]
// CHECK:STDERR: ./param_lvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_lvalue_ref.h:5:18-19: note: no known conversion from 'T' to 'S &' for 1st argument [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_lvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesLValue(t);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesLValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_lvalue_ref.h
// CHECK:STDERR: │ auto TakesLValue(S&) -> void;
// CHECK:STDERR: · ┬ ─┬
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ no known conversion from 'T' to 'S &' for 1st argument
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesLValue(t);
var u: Cpp.S;
// CHECK:STDERR: fail_param_lvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesLValue' [CppInteropParseError]
// CHECK:STDERR: ./param_lvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_lvalue_ref.h:5:18-19: note: 1st argument ('const S') would lose const qualifier [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_lvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesLValue(u as const Cpp.S);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesLValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_lvalue_ref.h
// CHECK:STDERR: │ auto TakesLValue(S&) -> void;
// CHECK:STDERR: · ┬ ─┬
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ 1st argument ('const S') would lose const qualifier
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesLValue(u as const Cpp.S);
//@dump-sem-ir-end
@@ -119,9 +159,19 @@ import Cpp library "param_rvalue_ref.h";
fn F() {
let s: Cpp.S = {};
// CHECK:STDERR: fail_param_value_arg_for_rvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesRValue' [CppInteropParseError]
// CHECK:STDERR: ./param_rvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_rvalue_ref.h:5:18-20: note: 1st argument ('const S') would lose const qualifier [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_value_arg_for_rvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesRValue(s);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesRValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_rvalue_ref.h
// CHECK:STDERR: │ auto TakesRValue(S&&) -> void;
// CHECK:STDERR: · ┬ ─┬─
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ 1st argument ('const S') would lose const qualifier
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesRValue(s);
}
@@ -135,22 +185,52 @@ import Cpp library "param_rvalue_ref.h";
fn F() {
//@dump-sem-ir-begin
var s: Cpp.S;
// CHECK:STDERR: fail_param_rvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesRValue' [CppInteropParseError]
// CHECK:STDERR: ./param_rvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_rvalue_ref.h:5:18-20: note: expects an rvalue for 1st argument [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_rvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesRValue(s);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesRValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_rvalue_ref.h
// CHECK:STDERR: │ auto TakesRValue(S&&) -> void;
// CHECK:STDERR: · ┬ ─┬─
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ expects an rvalue for 1st argument
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesRValue(s);
var t: Cpp.T;
// CHECK:STDERR: fail_param_rvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesRValue' [CppInteropParseError]
// CHECK:STDERR: ./param_rvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_rvalue_ref.h:5:18-20: note: no known conversion from 'T' to 'S' for 1st argument [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_rvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesRValue(t);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesRValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_rvalue_ref.h
// CHECK:STDERR: │ auto TakesRValue(S&&) -> void;
// CHECK:STDERR: · ┬ ─┬─
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ no known conversion from 'T' to 'S' for 1st argument
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesRValue(t);
// CHECK:STDERR: fail_param_rvalue_ref.carbon:[[@LINE+4]]:3-17: error: no matching function for call to 'TakesRValue' [CppInteropParseError]
// CHECK:STDERR: ./param_rvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_rvalue_ref.h:5:18-20: note: 1st argument ('const S') would lose const qualifier [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_rvalue_ref.carbon:[[@LINE+14]]:3
// CHECK:STDERR: -> │ Cpp.TakesRValue(({} as Cpp.S) as const Cpp.S);
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesRValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_rvalue_ref.h
// CHECK:STDERR: │ auto TakesRValue(S&&) -> void;
// CHECK:STDERR: · ┬ ─┬─
// CHECK:STDERR: · ╰───────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ 1st argument ('const S') would lose const qualifier
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesRValue(({} as Cpp.S) as const Cpp.S);
//@dump-sem-ir-end
@@ -205,9 +285,20 @@ import Cpp library "param_const_lvalue_ref.h";
fn F() {
var t: Cpp.T;
// CHECK:STDERR: fail_call_param_const_lvalue_ref_with_wrong_type.carbon:[[@LINE+4]]:3-22: error: no matching function for call to 'TakesConstLValue' [CppInteropParseError]
// CHECK:STDERR: ./param_const_lvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_const_lvalue_ref.h:5:23-30: note: no known conversion from 'T' to 'const S' for 1st argument [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_call_param_const_lvalue_ref_with_wrong_type.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.TakesConstLValue(t);
// CHECK:STDERR: · ━━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesConstLValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_const_lvalue_ref.h
// CHECK:STDERR: │ auto TakesConstLValue(const S&) -> void;
// CHECK:STDERR: · ┬ ┬───────
// CHECK:STDERR: · ╰───────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ no known conversion from 'T' to 'const S' for 1st
// CHECK:STDERR: · │ argument
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesConstLValue(t);
}
@@ -260,16 +351,38 @@ import Cpp library "param_const_rvalue_ref.h";
fn F() {
//@dump-sem-ir-begin
var s: Cpp.S;
// CHECK:STDERR: fail_param_lvalue_ref_arg_const_rvalue_ref.carbon:[[@LINE+4]]:3-22: error: no matching function for call to 'TakesConstRValue' [CppInteropParseError]
// CHECK:STDERR: ./param_const_rvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_const_rvalue_ref.h:5:23-31: note: expects an rvalue for 1st argument [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_lvalue_ref_arg_const_rvalue_ref.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.TakesConstRValue(s);
// CHECK:STDERR: · ━━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesConstRValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_const_rvalue_ref.h
// CHECK:STDERR: │ auto TakesConstRValue(const S&&) -> void;
// CHECK:STDERR: · ┬ ────┬────
// CHECK:STDERR: · ╰───────────────────────┤ candidate function not viable
// CHECK:STDERR: · │ │ [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ expects an rvalue for 1st argument
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesConstRValue(s);
var t: Cpp.T;
// CHECK:STDERR: fail_param_lvalue_ref_arg_const_rvalue_ref.carbon:[[@LINE+4]]:3-22: error: no matching function for call to 'TakesConstRValue' [CppInteropParseError]
// CHECK:STDERR: ./param_const_rvalue_ref.h:5:6: note: candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: ./param_const_rvalue_ref.h:5:23-31: note: no known conversion from 'T' to 'const S' for 1st argument [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_param_lvalue_ref_arg_const_rvalue_ref.carbon:[[@LINE+15]]:3
// CHECK:STDERR: -> │ Cpp.TakesConstRValue(t);
// CHECK:STDERR: · ━━━━━━━━━━┳━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'TakesConstRValue'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ ./param_const_rvalue_ref.h
// CHECK:STDERR: │ auto TakesConstRValue(const S&&) -> void;
// CHECK:STDERR: · ┬ ┬────────
// CHECK:STDERR: · ╰───────────────────┤ candidate function not viable [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ no known conversion from 'T' to 'const S' for 1st
// CHECK:STDERR: · │ argument
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakesConstRValue(t);
//@dump-sem-ir-end
@@ -348,8 +461,16 @@ library "[[@TEST_NAME]]";
import Cpp library "return_const_lvalue_ref.h";
fn F() {
// CHECK:STDERR: fail_call_return_const_lvalue_ref_const_correctness.carbon:[[@LINE+3]]:29-51: error: cannot implicitly convert expression of type `const Cpp.S` to `Cpp.S` [ConversionFailure]
// CHECK:STDERR: fail_call_return_const_lvalue_ref_const_correctness.carbon:[[@LINE+2]]:29-51: note: type `const Cpp.S` does not implement interface `Core.ImplicitAs(Cpp.S)` [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ╭─┤ fail_call_return_const_lvalue_ref_const_correctness.carbon:[[@LINE+11]]:29
// CHECK:STDERR: -> │ let unused ref s: Cpp.S = Cpp.ReturnConstLValue();
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: cannot implicitly convert expression of
// CHECK:STDERR: · │ ┃ type `const Cpp.S` to `Cpp.S`
// CHECK:STDERR: · │ ┃ [ConversionFailure]
// CHECK:STDERR: · ╰────┤ type `const Cpp.S` does not implement
// CHECK:STDERR: · │ interface `Core.ImplicitAs(Cpp.S)`
// CHECK:STDERR: · │ [MissingImplInMemberAccessInContext]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
let unused ref s: Cpp.S = Cpp.ReturnConstLValue();
}
@@ -423,8 +544,19 @@ template<typename T> void TakeAnything_ExpectConstLRef_ByRef(T&&) {
''';
fn PassConstRef(ref x: const XByRef) {
// CHECK:STDERR: fail_todo_forwarding_reference_by_ref.carbon:[[@LINE+3]]:42-46: error: `ref` tag is not an argument to a `ref` parameter [RefTagNoRefParam]
// CHECK:STDERR: fail_todo_forwarding_reference_by_ref.carbon:[[@LINE-7]]:65: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_todo_forwarding_reference_by_ref.carbon:[[@LINE+14]]:42
// CHECK:STDERR: │ template<typename T> void TakeAnything_ExpectConstLRef_ByRef(T&&) {
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╭───────────────────────────────────────────────────────────────╯
// CHECK:STDERR: · │ initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ Cpp.TakeAnything_ExpectConstLRef_ByRef(ref x);
// CHECK:STDERR: · ┳━━━━
// CHECK:STDERR: · ┗━━┫ error: `ref` tag is not an
// CHECK:STDERR: · ┃ argument to a `ref`
// CHECK:STDERR: · ┃ parameter
// CHECK:STDERR: · ┃ [RefTagNoRefParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.TakeAnything_ExpectConstLRef_ByRef(ref x);
}
@@ -607,28 +739,28 @@ fn PassConstRef(ref x: const XByRef) {
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %s.patt: %pattern_type.0f5 = value_binding_pattern s [concrete = constants.%s.patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc14: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc14: %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.loc14: %S = name_ref s, %s
// CHECK:STDOUT: %Cpp.ref.loc20_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc20: %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.loc20: %S = name_ref s, %s
// CHECK:STDOUT: %Cpp.ref.loc20_30: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc20: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %const.loc20: type = const_type %S.ref.loc20 [concrete = constants.%const]
// CHECK:STDOUT: %.loc20_21.1: %const = as_compatible %s.ref.loc20
// CHECK:STDOUT: %.loc20_21.2: %const = converted %s.ref.loc20, %.loc20_21.1
// CHECK:STDOUT: %Cpp.ref.loc24: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc24: %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.loc24: %S = name_ref s, %s
// CHECK:STDOUT: %Cpp.ref.loc40_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc40: %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.loc40: %S = name_ref s, %s
// CHECK:STDOUT: %Cpp.ref.loc40_30: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc40: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %const.loc40: type = const_type %S.ref.loc40 [concrete = constants.%const]
// CHECK:STDOUT: %.loc40_21.1: %const = as_compatible %s.ref.loc40
// CHECK:STDOUT: %.loc40_21.2: %const = converted %s.ref.loc40, %.loc40_21.1
// CHECK:STDOUT: %t.var: ref %T.ed0 = var_storage %t.var_patt
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc22: %DefaultOrUnformed.type = facet_value constants.%T.ed0, (constants.%DefaultOrUnformed.impl_witness.307) [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %.loc22_15.1: %DefaultOrUnformed.type = converted constants.%T.ed0, %DefaultOrUnformed.facet.loc22 [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %as_type.loc22: type = facet_access_type %.loc22_15.1 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %.loc22_15.2: type = converted %.loc22_15.1, %as_type.loc22 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc42: %DefaultOrUnformed.type = facet_value constants.%T.ed0, (constants.%DefaultOrUnformed.impl_witness.307) [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %.loc42_15.1: %DefaultOrUnformed.type = converted constants.%T.ed0, %DefaultOrUnformed.facet.loc42 [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %as_type.loc42: type = facet_access_type %.loc42_15.1 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %.loc42_15.2: type = converted %.loc42_15.1, %as_type.loc42 [concrete = constants.%T.ed0]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %.loc22_3.1: ref %T.ed0 = splice_block %t.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc22: init %T.ed0 to %.loc22_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.2()
// CHECK:STDOUT: assign %t.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc22
// CHECK:STDOUT: %.loc22_13: type = splice_block %T.ref [concrete = constants.%T.ed0] {
// CHECK:STDOUT: %Cpp.ref.loc22: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %.loc42_3.1: ref %T.ed0 = splice_block %t.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc42: init %T.ed0 to %.loc42_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.2()
// CHECK:STDOUT: assign %t.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc42
// CHECK:STDOUT: %.loc42_13: type = splice_block %T.ref [concrete = constants.%T.ed0] {
// CHECK:STDOUT: %Cpp.ref.loc42: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %T.ref: type = name_ref T, imports.%T.decl [concrete = constants.%T.ed0]
// CHECK:STDOUT: }
// CHECK:STDOUT: %t: ref %T.ed0 = wrapper_binding t, %t.var
@@ -636,47 +768,47 @@ fn PassConstRef(ref x: const XByRef) {
// CHECK:STDOUT: %t.patt: %pattern_type.5f6 = ref_binding_pattern t [concrete = constants.%t.patt.420]
// CHECK:STDOUT: %t.var_patt: %pattern_type.5f6 = var_pattern %t.patt [concrete = constants.%t.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc27: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc27: %TakesLValue.cpp_overload_set.type = name_ref TakesLValue, imports.%TakesLValue.cpp_overload_set.value [concrete = constants.%TakesLValue.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc57: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc57: %TakesLValue.cpp_overload_set.type = name_ref TakesLValue, imports.%TakesLValue.cpp_overload_set.value [concrete = constants.%TakesLValue.cpp_overload_set.value]
// CHECK:STDOUT: %t.ref: ref %T.ed0 = name_ref t, %t
// CHECK:STDOUT: %u.var: ref %S = var_storage %u.var_patt
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc29: %DefaultOrUnformed.type = facet_value constants.%S, (constants.%DefaultOrUnformed.impl_witness.e4a) [concrete = constants.%DefaultOrUnformed.facet.cbb]
// CHECK:STDOUT: %.loc29_15.1: %DefaultOrUnformed.type = converted constants.%S, %DefaultOrUnformed.facet.loc29 [concrete = constants.%DefaultOrUnformed.facet.cbb]
// CHECK:STDOUT: %as_type.loc29: type = facet_access_type %.loc29_15.1 [concrete = constants.%S]
// CHECK:STDOUT: %.loc29_15.2: type = converted %.loc29_15.1, %as_type.loc29 [concrete = constants.%S]
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc59: %DefaultOrUnformed.type = facet_value constants.%S, (constants.%DefaultOrUnformed.impl_witness.e4a) [concrete = constants.%DefaultOrUnformed.facet.cbb]
// CHECK:STDOUT: %.loc59_15.1: %DefaultOrUnformed.type = converted constants.%S, %DefaultOrUnformed.facet.loc59 [concrete = constants.%DefaultOrUnformed.facet.cbb]
// CHECK:STDOUT: %as_type.loc59: type = facet_access_type %.loc59_15.1 [concrete = constants.%S]
// CHECK:STDOUT: %.loc59_15.2: type = converted %.loc59_15.1, %as_type.loc59 [concrete = constants.%S]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %.loc29_3.1: ref %S = splice_block %u.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc29: init %S to %.loc29_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.3()
// CHECK:STDOUT: assign %u.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc29
// CHECK:STDOUT: %.loc29_13: type = splice_block %S.ref.loc29 [concrete = constants.%S] {
// CHECK:STDOUT: %Cpp.ref.loc29: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc29: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %.loc59_3.1: ref %S = splice_block %u.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc59: init %S to %.loc59_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.3()
// CHECK:STDOUT: assign %u.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc59
// CHECK:STDOUT: %.loc59_13: type = splice_block %S.ref.loc59 [concrete = constants.%S] {
// CHECK:STDOUT: %Cpp.ref.loc59: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc59: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: }
// CHECK:STDOUT: %u: ref %S = wrapper_binding u, %u.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %u.patt: %pattern_type.0f5 = ref_binding_pattern u [concrete = constants.%u.patt]
// CHECK:STDOUT: %u.var_patt: %pattern_type.0f5 = var_pattern %u.patt [concrete = constants.%u.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc34_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc34: %TakesLValue.cpp_overload_set.type = name_ref TakesLValue, imports.%TakesLValue.cpp_overload_set.value [concrete = constants.%TakesLValue.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc74_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesLValue.ref.loc74: %TakesLValue.cpp_overload_set.type = name_ref TakesLValue, imports.%TakesLValue.cpp_overload_set.value [concrete = constants.%TakesLValue.cpp_overload_set.value]
// CHECK:STDOUT: %u.ref: ref %S = name_ref u, %u
// CHECK:STDOUT: %Cpp.ref.loc34_30: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc34: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %const.loc34: type = const_type %S.ref.loc34 [concrete = constants.%const]
// CHECK:STDOUT: %.loc34_21.1: ref %const = as_compatible %u.ref
// CHECK:STDOUT: %.loc34_21.2: ref %const = converted %u.ref, %.loc34_21.1
// CHECK:STDOUT: %Destroy.facet.loc29_3.1: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %.loc29_3.2: %Destroy.type = converted constants.%S, %Destroy.facet.loc29_3.1 [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %Destroy.facet.loc29_3.2: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %.loc29_3.3: %Destroy.type = converted constants.%S, %Destroy.facet.loc29_3.2 [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %Cpp.ref.loc74_30: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc74: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %const.loc74: type = const_type %S.ref.loc74 [concrete = constants.%const]
// CHECK:STDOUT: %.loc74_21.1: ref %const = as_compatible %u.ref
// CHECK:STDOUT: %.loc74_21.2: ref %const = converted %u.ref, %.loc74_21.1
// CHECK:STDOUT: %Destroy.facet.loc59_3.1: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %.loc59_3.2: %Destroy.type = converted constants.%S, %Destroy.facet.loc59_3.1 [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %Destroy.facet.loc59_3.2: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %.loc59_3.3: %Destroy.type = converted constants.%S, %Destroy.facet.loc59_3.2 [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc29: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%u.var)
// CHECK:STDOUT: %Destroy.facet.loc22_3.1: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc22_3.2: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc22_3.1 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Destroy.facet.loc22_3.2: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc22_3.3: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc22_3.2 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %SelfDestruct.call.loc59: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%u.var)
// CHECK:STDOUT: %Destroy.facet.loc42_3.1: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc42_3.2: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc42_3.1 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Destroy.facet.loc42_3.2: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc42_3.3: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc42_3.2 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc22: init %empty_tuple.type = call %SelfDestruct.specific_fn.2(%t.var)
// CHECK:STDOUT: %SelfDestruct.call.loc42: init %empty_tuple.type = call %SelfDestruct.specific_fn.2(%t.var)
// CHECK:STDOUT: %Destroy.facet.loc8_3.1: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %.loc8_3.2: %Destroy.type = converted constants.%S, %Destroy.facet.loc8_3.1 [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %Destroy.facet.loc8_3.2: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.580]
@@ -825,20 +957,20 @@ fn PassConstRef(ref x: const XByRef) {
// CHECK:STDOUT: %s.patt: %pattern_type.0f5 = ref_binding_pattern s [concrete = constants.%s.patt]
// CHECK:STDOUT: %s.var_patt: %pattern_type.0f5 = var_pattern %s.patt [concrete = constants.%s.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc13: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesRValue.ref.loc13: %TakesRValue.cpp_overload_set.type = name_ref TakesRValue, imports.%TakesRValue.cpp_overload_set.value [concrete = constants.%TakesRValue.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc23: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesRValue.ref.loc23: %TakesRValue.cpp_overload_set.type = name_ref TakesRValue, imports.%TakesRValue.cpp_overload_set.value [concrete = constants.%TakesRValue.cpp_overload_set.value]
// CHECK:STDOUT: %s.ref: ref %S = name_ref s, %s
// CHECK:STDOUT: %t.var: ref %T.ed0 = var_storage %t.var_patt
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc15: %DefaultOrUnformed.type = facet_value constants.%T.ed0, (constants.%DefaultOrUnformed.impl_witness.307) [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %.loc15_15.1: %DefaultOrUnformed.type = converted constants.%T.ed0, %DefaultOrUnformed.facet.loc15 [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %as_type.loc15: type = facet_access_type %.loc15_15.1 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %.loc15_15.2: type = converted %.loc15_15.1, %as_type.loc15 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc25: %DefaultOrUnformed.type = facet_value constants.%T.ed0, (constants.%DefaultOrUnformed.impl_witness.307) [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %.loc25_15.1: %DefaultOrUnformed.type = converted constants.%T.ed0, %DefaultOrUnformed.facet.loc25 [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %as_type.loc25: type = facet_access_type %.loc25_15.1 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %.loc25_15.2: type = converted %.loc25_15.1, %as_type.loc25 [concrete = constants.%T.ed0]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %.loc15_3.1: ref %T.ed0 = splice_block %t.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc15: init %T.ed0 to %.loc15_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.2()
// CHECK:STDOUT: assign %t.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc15
// CHECK:STDOUT: %.loc15_13: type = splice_block %T.ref [concrete = constants.%T.ed0] {
// CHECK:STDOUT: %Cpp.ref.loc15: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %.loc25_3.1: ref %T.ed0 = splice_block %t.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc25: init %T.ed0 to %.loc25_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.2()
// CHECK:STDOUT: assign %t.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc25
// CHECK:STDOUT: %.loc25_13: type = splice_block %T.ref [concrete = constants.%T.ed0] {
// CHECK:STDOUT: %Cpp.ref.loc25: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %T.ref: type = name_ref T, imports.%T.decl [concrete = constants.%T.ed0]
// CHECK:STDOUT: }
// CHECK:STDOUT: %t: ref %T.ed0 = wrapper_binding t, %t.var
@@ -846,28 +978,28 @@ fn PassConstRef(ref x: const XByRef) {
// CHECK:STDOUT: %t.patt: %pattern_type.5f6 = ref_binding_pattern t [concrete = constants.%t.patt.420]
// CHECK:STDOUT: %t.var_patt: %pattern_type.5f6 = var_pattern %t.patt [concrete = constants.%t.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc20: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesRValue.ref.loc20: %TakesRValue.cpp_overload_set.type = name_ref TakesRValue, imports.%TakesRValue.cpp_overload_set.value [concrete = constants.%TakesRValue.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc40: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesRValue.ref.loc40: %TakesRValue.cpp_overload_set.type = name_ref TakesRValue, imports.%TakesRValue.cpp_overload_set.value [concrete = constants.%TakesRValue.cpp_overload_set.value]
// CHECK:STDOUT: %t.ref: ref %T.ed0 = name_ref t, %t
// CHECK:STDOUT: %Cpp.ref.loc26_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesRValue.ref.loc26: %TakesRValue.cpp_overload_set.type = name_ref TakesRValue, imports.%TakesRValue.cpp_overload_set.value [concrete = constants.%TakesRValue.cpp_overload_set.value]
// CHECK:STDOUT: %.loc26_21.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct.a40]
// CHECK:STDOUT: %Cpp.ref.loc26_26: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc26_29: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %.loc26_21.2: ref %S = temporary_storage
// CHECK:STDOUT: %.loc26_21.3: init %S to %.loc26_21.2 = class_init () [concrete = constants.%S.val]
// CHECK:STDOUT: %.loc26_23: init %S = converted %.loc26_21.1, %.loc26_21.3 [concrete = constants.%S.val]
// CHECK:STDOUT: %Cpp.ref.loc26_42: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc26_45: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %const: type = const_type %S.ref.loc26_45 [concrete = constants.%const]
// CHECK:STDOUT: %.loc26_33.1: init %const = as_compatible %.loc26_23 [concrete = constants.%empty_struct.674]
// CHECK:STDOUT: %.loc26_33.2: init %const = converted %.loc26_23, %.loc26_33.1 [concrete = constants.%empty_struct.674]
// CHECK:STDOUT: %Destroy.facet.loc15_3.1: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc15_3.2: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc15_3.1 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Destroy.facet.loc15_3.2: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc15_3.3: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc15_3.2 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Cpp.ref.loc56_3: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesRValue.ref.loc56: %TakesRValue.cpp_overload_set.type = name_ref TakesRValue, imports.%TakesRValue.cpp_overload_set.value [concrete = constants.%TakesRValue.cpp_overload_set.value]
// CHECK:STDOUT: %.loc56_21.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct.a40]
// CHECK:STDOUT: %Cpp.ref.loc56_26: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc56_29: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %.loc56_21.2: ref %S = temporary_storage
// CHECK:STDOUT: %.loc56_21.3: init %S to %.loc56_21.2 = class_init () [concrete = constants.%S.val]
// CHECK:STDOUT: %.loc56_23: init %S = converted %.loc56_21.1, %.loc56_21.3 [concrete = constants.%S.val]
// CHECK:STDOUT: %Cpp.ref.loc56_42: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %S.ref.loc56_45: type = name_ref S, imports.%S.decl [concrete = constants.%S]
// CHECK:STDOUT: %const: type = const_type %S.ref.loc56_45 [concrete = constants.%const]
// CHECK:STDOUT: %.loc56_33.1: init %const = as_compatible %.loc56_23 [concrete = constants.%empty_struct.674]
// CHECK:STDOUT: %.loc56_33.2: init %const = converted %.loc56_23, %.loc56_33.1 [concrete = constants.%empty_struct.674]
// CHECK:STDOUT: %Destroy.facet.loc25_3.1: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc25_3.2: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc25_3.1 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Destroy.facet.loc25_3.2: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc25_3.3: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc25_3.2 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc15: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%t.var)
// CHECK:STDOUT: %SelfDestruct.call.loc25: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%t.var)
// CHECK:STDOUT: %Destroy.facet.loc8_3.1: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %.loc8_3.2: %Destroy.type = converted constants.%S, %Destroy.facet.loc8_3.1 [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %Destroy.facet.loc8_3.2: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.580]
@@ -1213,20 +1345,20 @@ fn PassConstRef(ref x: const XByRef) {
// CHECK:STDOUT: %s.patt: %pattern_type.0f5 = ref_binding_pattern s [concrete = constants.%s.patt]
// CHECK:STDOUT: %s.var_patt: %pattern_type.0f5 = var_pattern %s.patt [concrete = constants.%s.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc13: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesConstRValue.ref.loc13: %TakesConstRValue.cpp_overload_set.type = name_ref TakesConstRValue, imports.%TakesConstRValue.cpp_overload_set.value [concrete = constants.%TakesConstRValue.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc24: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesConstRValue.ref.loc24: %TakesConstRValue.cpp_overload_set.type = name_ref TakesConstRValue, imports.%TakesConstRValue.cpp_overload_set.value [concrete = constants.%TakesConstRValue.cpp_overload_set.value]
// CHECK:STDOUT: %s.ref: ref %S = name_ref s, %s
// CHECK:STDOUT: %t.var: ref %T.ed0 = var_storage %t.var_patt
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc15: %DefaultOrUnformed.type = facet_value constants.%T.ed0, (constants.%DefaultOrUnformed.impl_witness.307) [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %.loc15_15.1: %DefaultOrUnformed.type = converted constants.%T.ed0, %DefaultOrUnformed.facet.loc15 [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %as_type.loc15: type = facet_access_type %.loc15_15.1 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %.loc15_15.2: type = converted %.loc15_15.1, %as_type.loc15 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %DefaultOrUnformed.facet.loc26: %DefaultOrUnformed.type = facet_value constants.%T.ed0, (constants.%DefaultOrUnformed.impl_witness.307) [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %.loc26_15.1: %DefaultOrUnformed.type = converted constants.%T.ed0, %DefaultOrUnformed.facet.loc26 [concrete = constants.%DefaultOrUnformed.facet.d8b]
// CHECK:STDOUT: %as_type.loc26: type = facet_access_type %.loc26_15.1 [concrete = constants.%T.ed0]
// CHECK:STDOUT: %.loc26_15.2: type = converted %.loc26_15.1, %as_type.loc26 [concrete = constants.%T.ed0]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %.loc15_3.1: ref %T.ed0 = splice_block %t.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc15: init %T.ed0 to %.loc15_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.2()
// CHECK:STDOUT: assign %t.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc15
// CHECK:STDOUT: %.loc15_13: type = splice_block %T.ref [concrete = constants.%T.ed0] {
// CHECK:STDOUT: %Cpp.ref.loc15: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %.loc26_3.1: ref %T.ed0 = splice_block %t.var {}
// CHECK:STDOUT: %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc26: init %T.ed0 to %.loc26_3.1 = call %T.as_type.as.DefaultOrUnformed.impl.Op.specific_fn.2()
// CHECK:STDOUT: assign %t.var, %T.as_type.as.DefaultOrUnformed.impl.Op.call.loc26
// CHECK:STDOUT: %.loc26_13: type = splice_block %T.ref [concrete = constants.%T.ed0] {
// CHECK:STDOUT: %Cpp.ref.loc26: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %T.ref: type = name_ref T, imports.%T.decl [concrete = constants.%T.ed0]
// CHECK:STDOUT: }
// CHECK:STDOUT: %t: ref %T.ed0 = wrapper_binding t, %t.var
@@ -1234,15 +1366,15 @@ fn PassConstRef(ref x: const XByRef) {
// CHECK:STDOUT: %t.patt: %pattern_type.5f6 = ref_binding_pattern t [concrete = constants.%t.patt.420]
// CHECK:STDOUT: %t.var_patt: %pattern_type.5f6 = var_pattern %t.patt [concrete = constants.%t.var_patt]
// CHECK:STDOUT: }
// CHECK:STDOUT: %Cpp.ref.loc20: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesConstRValue.ref.loc20: %TakesConstRValue.cpp_overload_set.type = name_ref TakesConstRValue, imports.%TakesConstRValue.cpp_overload_set.value [concrete = constants.%TakesConstRValue.cpp_overload_set.value]
// CHECK:STDOUT: %Cpp.ref.loc42: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %TakesConstRValue.ref.loc42: %TakesConstRValue.cpp_overload_set.type = name_ref TakesConstRValue, imports.%TakesConstRValue.cpp_overload_set.value [concrete = constants.%TakesConstRValue.cpp_overload_set.value]
// CHECK:STDOUT: %t.ref: ref %T.ed0 = name_ref t, %t
// CHECK:STDOUT: %Destroy.facet.loc15_3.1: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc15_3.2: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc15_3.1 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Destroy.facet.loc15_3.2: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc15_3.3: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc15_3.2 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Destroy.facet.loc26_3.1: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc26_3.2: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc26_3.1 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %Destroy.facet.loc26_3.2: %Destroy.type = facet_value constants.%T.ed0, (constants.%DestroyImpl.impl_witness.68c, constants.%custom_witness.fe1878.1) [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: %.loc26_3.3: %Destroy.type = converted constants.%T.ed0, %Destroy.facet.loc26_3.2 [concrete = constants.%Destroy.facet.8f8]
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: %SelfDestruct.call.loc15: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%t.var)
// CHECK:STDOUT: %SelfDestruct.call.loc26: init %empty_tuple.type = call %SelfDestruct.specific_fn.1(%t.var)
// CHECK:STDOUT: %Destroy.facet.loc8_3.1: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %.loc8_3.2: %Destroy.type = converted constants.%S, %Destroy.facet.loc8_3.1 [concrete = constants.%Destroy.facet.580]
// CHECK:STDOUT: %Destroy.facet.loc8_3.2: %Destroy.type = facet_value constants.%S, (constants.%DestroyImpl.impl_witness.b60, constants.%custom_witness.fe1878.2) [concrete = constants.%Destroy.facet.580]
toolchain/check/testdata/interop/cpp/function/import/return.carbon
Vendored
+6 -1
View File
@@ -48,7 +48,12 @@ auto UndeducedReturn();
''';
fn Call() {
// CHECK:STDERR: fail_return_undeduced_auto.carbon:[[@LINE+2]]:3-23: error: semantics TODO: `Unsupported: return type: auto` [SemanticsTodo]
// CHECK:STDERR: ╭─┤ fail_return_undeduced_auto.carbon:[[@LINE+7]]:3
// CHECK:STDERR: -> │ Cpp.UndeducedReturn();
// CHECK:STDERR: · ━━━━━━━━━━┳━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: semantics TODO: `Unsupported: return type: auto`
// CHECK:STDERR: · ┃ [SemanticsTodo]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.UndeducedReturn();
}
toolchain/check/testdata/interop/cpp/function/import/struct.carbon
Vendored
+140 -38
View File
@@ -18,36 +18,88 @@
struct ForwardDeclaredStruct;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h:[[@LINE+16]]:6
// CHECK:STDERR: │ struct ForwardDeclaredStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'ForwardDeclaredStruct' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo1(ForwardDeclaredStruct) -> void;
// CHECK:STDERR: · ━━┳━
// CHECK:STDERR: · ┗━━┫ error: argument type 'ForwardDeclaredStruct' is incomplete
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_param_type.carbon
// CHECK:STDERR: │ Cpp.foo1(*p);
// CHECK:STDERR: · ──────┬─────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo1(ForwardDeclaredStruct) -> void;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h:[[@LINE+16]]:6
// CHECK:STDERR: │ struct ForwardDeclaredStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'ForwardDeclaredStruct' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo2(ForwardDeclaredStruct) -> void;
// CHECK:STDERR: · ━━┳━
// CHECK:STDERR: · ┗━━┫ error: argument type 'ForwardDeclaredStruct' is incomplete
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_param_type.carbon
// CHECK:STDERR: │ Cpp.foo2(*p);
// CHECK:STDERR: · ──────┬─────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo2(ForwardDeclaredStruct) -> void;
// --- fail_import_decl_value_param_type.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE+3]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:4:6-9: error: argument type 'ForwardDeclaredStruct' is incomplete [CppInteropParseError]
// CHECK:STDERR: ./decl_value_param_type.h:2:8: note: forward declaration of 'ForwardDeclaredStruct' [CppInteropParseNote]
import Cpp library "decl_value_param_type.h";
fn F(p: Cpp.ForwardDeclaredStruct*) {
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+5]]:3-14: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_param_type.carbon:[[@LINE+19]]:12
// CHECK:STDERR: -> │ Cpp.foo1(*p);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: forming value of incomplete type
// CHECK:STDERR: · ┃ `Cpp.ForwardDeclaredStruct`
// CHECK:STDERR: · ┃ [IncompleteTypeInValueConversion]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h
// CHECK:STDERR: │ struct ForwardDeclaredStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo1(ForwardDeclaredStruct) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-5]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:5:6-9: error: argument type 'ForwardDeclaredStruct' is incomplete [CppInteropParseError]
// CHECK:STDERR: ./decl_value_param_type.h:2:8: note: forward declaration of 'ForwardDeclaredStruct' [CppInteropParseNote]
Cpp.foo1(*p);
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+12]]:3-14: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE-3]]:12-13: error: forming value of incomplete type `Cpp.ForwardDeclaredStruct` [IncompleteTypeInValueConversion]
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-12]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:2:8: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_param_type.h:4:32: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+5]]:12-13: error: forming value of incomplete type `Cpp.ForwardDeclaredStruct` [IncompleteTypeInValueConversion]
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-17]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:2:8: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_param_type.h:5:32: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_param_type.carbon:[[@LINE+19]]:12
// CHECK:STDERR: -> │ Cpp.foo2(*p);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: forming value of incomplete type
// CHECK:STDERR: · ┃ `Cpp.ForwardDeclaredStruct`
// CHECK:STDERR: · ┃ [IncompleteTypeInValueConversion]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h
// CHECK:STDERR: │ struct ForwardDeclaredStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo2(ForwardDeclaredStruct) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo2(*p);
}
@@ -84,22 +136,37 @@ struct NonCopyableStruct {
NonCopyableStruct(const NonCopyableStruct&) = delete;
};
// CHECK:STDERR: ╷ ╭── included from: fail_import_non_copyable_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./non_copyable_param_type.h:[[@LINE+20]]:6
// CHECK:STDERR: │ NonCopyableStruct(const NonCopyableStruct&) = delete;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ 'NonCopyableStruct' has been explicitly marked deleted here
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_non_copyable(NonCopyableStruct) -> void;
// CHECK:STDERR: · ━━━━━━━━┳━━━━━━━ ┬
// CHECK:STDERR: · ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫ error: call to deleted constructor
// CHECK:STDERR: · │ ┃ of 'NonCopyableStruct'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ passing argument to parameter here
// CHECK:STDERR: · │ [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_non_copyable_param_type.carbon
// CHECK:STDERR: │ Cpp.foo_non_copyable(s);
// CHECK:STDERR: · ───────────┬───────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_non_copyable(NonCopyableStruct) -> void;
// --- fail_import_non_copyable_param_type.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_import_non_copyable_param_type.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./non_copyable_param_type.h:6:6-21: error: call to deleted constructor of 'NonCopyableStruct' [CppInteropParseError]
// CHECK:STDERR: ./non_copyable_param_type.h:3:3: note: 'NonCopyableStruct' has been explicitly marked deleted here [CppInteropParseNote]
// CHECK:STDERR: ./non_copyable_param_type.h:6:40: note: passing argument to parameter here [CppInteropParseNote]
import Cpp library "non_copyable_param_type.h";
fn F(s: Cpp.NonCopyableStruct) {
//@dump-sem-ir-begin
// CHECK:STDERR: fail_import_non_copyable_param_type.carbon:[[@LINE+2]]:3-25: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
Cpp.foo_non_copyable(s);
//@dump-sem-ir-end
}
@@ -283,9 +350,18 @@ library "[[@TEST_NAME]]";
import Cpp library "incomplete.h";
fn F() {
// CHECK:STDERR: fail_import_incomplete.carbon:[[@LINE+4]]:3-26: error: member access into incomplete class `Cpp.IncompleteStruct` [QualifiedExprInIncompleteClassScope]
// CHECK:STDERR: included from: fail_import_incomplete.carbon:[[@LINE-4]]:10 [InCppInclude]
// CHECK:STDERR: ./incomplete.h:2:8: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ╭─┤ fail_import_incomplete.carbon:[[@LINE+13]]:3
// CHECK:STDERR: -> │ Cpp.IncompleteStruct.foo();
// CHECK:STDERR: · ━━━━━━━━┳━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: member access into incomplete class `Cpp.IncompleteStruct`
// CHECK:STDERR: · ┃ [QualifiedExprInIncompleteClassScope]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_incomplete.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./incomplete.h
// CHECK:STDERR: │ struct IncompleteStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.IncompleteStruct.foo();
}
@@ -342,6 +418,25 @@ fn F(s: Cpp.DefPointerParamStruct*) {
struct DeclValueReturnStruct;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_return_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_return_type.h:[[@LINE+18]]:6
// CHECK:STDERR: │ struct DeclValueReturnStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'DeclValueReturnStruct' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_decl_value_return() -> DeclValueReturnStruct;
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: calling 'foo_decl_value_return' with incomplete return type
// CHECK:STDERR: · │ ┃ 'DeclValueReturnStruct'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ 'foo_decl_value_return' declared here [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_return_type.carbon
// CHECK:STDERR: │ Cpp.foo_decl_value_return();
// CHECK:STDERR: · ─────────────┬─────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_decl_value_return() -> DeclValueReturnStruct;
// --- fail_import_decl_value_return_type.carbon
@@ -349,19 +444,26 @@ auto foo_decl_value_return() -> DeclValueReturnStruct;
library "[[@TEST_NAME]]";
// TODO: We should only produce one error here.
// CHECK:STDERR: included from: fail_import_decl_value_return_type.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_return_type.h:4:6-26: error: calling 'foo_decl_value_return' with incomplete return type 'DeclValueReturnStruct' [CppInteropParseError]
// CHECK:STDERR: ./decl_value_return_type.h:4:6: note: 'foo_decl_value_return' declared here [CppInteropParseNote]
// CHECK:STDERR: ./decl_value_return_type.h:2:8: note: forward declaration of 'DeclValueReturnStruct' [CppInteropParseNote]
import Cpp library "decl_value_return_type.h";
fn F() {
// CHECK:STDERR: fail_import_decl_value_return_type.carbon:[[@LINE+7]]:3-29: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_return_type.carbon:[[@LINE+5]]:3-29: error: function returns incomplete type `Cpp.DeclValueReturnStruct` [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: included from: fail_import_decl_value_return_type.carbon:[[@LINE-6]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_return_type.h:2:8: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_return_type.h:4:33: note: return type declared here [IncompleteReturnTypeHere]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_return_type.carbon:[[@LINE+18]]:3
// CHECK:STDERR: -> │ Cpp.foo_decl_value_return();
// CHECK:STDERR: · ━━━━━━┳━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: function returns incomplete type `Cpp.DeclValueReturnStruct`
// CHECK:STDERR: · ┃ [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_return_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_return_type.h
// CHECK:STDERR: │ struct DeclValueReturnStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo_decl_value_return() -> DeclValueReturnStruct;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ return type declared here
// CHECK:STDERR: · │ [IncompleteReturnTypeHere]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo_decl_value_return();
}
@@ -500,7 +602,7 @@ fn F() {
// CHECK:STDOUT:
// CHECK:STDOUT: fn @F(%s.param: %NonCopyableStruct) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Cpp.ref.loc14: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %Cpp.ref.loc8: <namespace> = name_ref Cpp, imports.%Cpp [concrete = imports.%Cpp]
// CHECK:STDOUT: %foo_non_copyable.ref: %foo_non_copyable.cpp_overload_set.type = name_ref foo_non_copyable, imports.%foo_non_copyable.cpp_overload_set.value [concrete = constants.%foo_non_copyable.cpp_overload_set.value]
// CHECK:STDOUT: %s.ref: %NonCopyableStruct = name_ref s, %s
// CHECK:STDOUT: %foo_non_copyable.call: init %empty_tuple.type = call imports.%foo_non_copyable.decl(%s.ref)
toolchain/check/testdata/interop/cpp/function/import/template.carbon
Vendored
+15 -3
View File
@@ -87,9 +87,21 @@ template<int N> void fn_arg_not_template_arg_f();
fn Call() {
// We treat this as a function argument, even though that makes the call fail.
// CHECK:STDERR: fail_function_arg_not_template_arg.carbon:[[@LINE+4]]:3-31: error: no matching function for call to 'fn_arg_not_template_arg_f' [CppInteropParseError]
// CHECK:STDERR: fail_function_arg_not_template_arg.carbon:[[@LINE-6]]:22: note: candidate function template not viable [CppInteropParseNote]
// CHECK:STDERR: fail_function_arg_not_template_arg.carbon:[[@LINE-7]]:47-48: note: requires 0 arguments, but 1 was provided [CppInteropParseNoteReason]
// CHECK:STDERR: ╭─┤ fail_function_arg_not_template_arg.carbon:[[@LINE+16]]:3
// CHECK:STDERR: │ template<int N> void fn_arg_not_template_arg_f();
// CHECK:STDERR: · ┬ ┬─
// CHECK:STDERR: · ╰───────────────────────────┤ candidate function template
// CHECK:STDERR: · │ │ not viable
// CHECK:STDERR: · │ │ [CppInteropParseNote]
// CHECK:STDERR: · ╰────┤ requires 0 arguments, but 1
// CHECK:STDERR: · │ was provided
// CHECK:STDERR: · │ [CppInteropParseNoteReason]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ Cpp.fn_arg_not_template_arg_f(1);
// CHECK:STDERR: · ━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: no matching function for call to 'fn_arg_not_template_arg_f'
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.fn_arg_not_template_arg_f(1);
}
toolchain/check/testdata/interop/cpp/function/import/union.carbon
Vendored
+118 -31
View File
@@ -18,36 +18,88 @@
union ForwardDeclaredUnion;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h:[[@LINE+16]]:6
// CHECK:STDERR: │ union ForwardDeclaredUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'ForwardDeclaredUnion' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo1(ForwardDeclaredUnion) -> void;
// CHECK:STDERR: · ━━┳━
// CHECK:STDERR: · ┗━━┫ error: argument type 'ForwardDeclaredUnion' is incomplete
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_param_type.carbon
// CHECK:STDERR: │ Cpp.foo1(*p);
// CHECK:STDERR: · ──────┬─────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo1(ForwardDeclaredUnion) -> void;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h:[[@LINE+16]]:6
// CHECK:STDERR: │ union ForwardDeclaredUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'ForwardDeclaredUnion' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo2(ForwardDeclaredUnion) -> void;
// CHECK:STDERR: · ━━┳━
// CHECK:STDERR: · ┗━━┫ error: argument type 'ForwardDeclaredUnion' is incomplete
// CHECK:STDERR: · ┃ [CppInteropParseError]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_param_type.carbon
// CHECK:STDERR: │ Cpp.foo2(*p);
// CHECK:STDERR: · ──────┬─────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo2(ForwardDeclaredUnion) -> void;
// --- fail_import_decl_value_param_type.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE+3]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:4:6-9: error: argument type 'ForwardDeclaredUnion' is incomplete [CppInteropParseError]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: forward declaration of 'ForwardDeclaredUnion' [CppInteropParseNote]
import Cpp library "decl_value_param_type.h";
fn F(p: Cpp.ForwardDeclaredUnion*) {
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+5]]:3-14: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_param_type.carbon:[[@LINE+19]]:12
// CHECK:STDERR: -> │ Cpp.foo1(*p);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: forming value of incomplete type
// CHECK:STDERR: · ┃ `Cpp.ForwardDeclaredUnion`
// CHECK:STDERR: · ┃ [IncompleteTypeInValueConversion]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h
// CHECK:STDERR: │ union ForwardDeclaredUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo1(ForwardDeclaredUnion) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-5]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:5:6-9: error: argument type 'ForwardDeclaredUnion' is incomplete [CppInteropParseError]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: forward declaration of 'ForwardDeclaredUnion' [CppInteropParseNote]
Cpp.foo1(*p);
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+12]]:3-14: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE-3]]:12-13: error: forming value of incomplete type `Cpp.ForwardDeclaredUnion` [IncompleteTypeInValueConversion]
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-12]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_param_type.h:4:31: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_param_type.carbon:[[@LINE+5]]:12-13: error: forming value of incomplete type `Cpp.ForwardDeclaredUnion` [IncompleteTypeInValueConversion]
// CHECK:STDERR: included from: fail_import_decl_value_param_type.carbon:[[@LINE-17]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_param_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_param_type.h:5:31: note: initializing function parameter [InCallToFunctionParam]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_param_type.carbon:[[@LINE+19]]:12
// CHECK:STDERR: -> │ Cpp.foo2(*p);
// CHECK:STDERR: · ┳━
// CHECK:STDERR: · ┗━━┫ error: forming value of incomplete type
// CHECK:STDERR: · ┃ `Cpp.ForwardDeclaredUnion`
// CHECK:STDERR: · ┃ [IncompleteTypeInValueConversion]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_param_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_param_type.h
// CHECK:STDERR: │ union ForwardDeclaredUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo2(ForwardDeclaredUnion) -> void;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ initializing function parameter
// CHECK:STDERR: · │ [InCallToFunctionParam]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo2(*p);
}
@@ -254,9 +306,18 @@ library "[[@TEST_NAME]]";
import Cpp library "incomplete.h";
fn F() {
// CHECK:STDERR: fail_import_incomplete.carbon:[[@LINE+4]]:3-25: error: member access into incomplete class `Cpp.IncompleteUnion` [QualifiedExprInIncompleteClassScope]
// CHECK:STDERR: included from: fail_import_incomplete.carbon:[[@LINE-4]]:10 [InCppInclude]
// CHECK:STDERR: ./incomplete.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ╭─┤ fail_import_incomplete.carbon:[[@LINE+13]]:3
// CHECK:STDERR: -> │ Cpp.IncompleteUnion.foo();
// CHECK:STDERR: · ━━━━━━━━━┳━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: member access into incomplete class `Cpp.IncompleteUnion`
// CHECK:STDERR: · ┃ [QualifiedExprInIncompleteClassScope]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_incomplete.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./incomplete.h
// CHECK:STDERR: │ union IncompleteUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.IncompleteUnion.foo();
}
@@ -313,25 +374,51 @@ fn F(u: Cpp.DefPointerParamUnion*) {
union DeclValueReturnUnion;
// CHECK:STDERR: ╷ ╭── included from: fail_import_decl_value_return_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_return_type.h:[[@LINE+18]]:6
// CHECK:STDERR: │ union DeclValueReturnUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ forward declaration of 'DeclValueReturnUnion' [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: -> │ auto foo_decl_value_return() -> DeclValueReturnUnion;
// CHECK:STDERR: · ┳━━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: calling 'foo_decl_value_return' with incomplete return type
// CHECK:STDERR: · │ ┃ 'DeclValueReturnUnion'
// CHECK:STDERR: · │ ┃ [CppInteropParseError]
// CHECK:STDERR: · ╰────┤ 'foo_decl_value_return' declared here [CppInteropParseNote]
// CHECK:STDERR: ┆
// CHECK:STDERR: ├─┤ fail_import_decl_value_return_type.carbon
// CHECK:STDERR: │ Cpp.foo_decl_value_return();
// CHECK:STDERR: · ─────────────┬─────────────
// CHECK:STDERR: · ╰──┤ in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
auto foo_decl_value_return() -> DeclValueReturnUnion;
// --- fail_import_decl_value_return_type.carbon
library "[[@TEST_NAME]]";
// CHECK:STDERR: included from: fail_import_decl_value_return_type.carbon:[[@LINE+4]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_return_type.h:4:6-26: error: calling 'foo_decl_value_return' with incomplete return type 'DeclValueReturnUnion' [CppInteropParseError]
// CHECK:STDERR: ./decl_value_return_type.h:4:6: note: 'foo_decl_value_return' declared here [CppInteropParseNote]
// CHECK:STDERR: ./decl_value_return_type.h:2:7: note: forward declaration of 'DeclValueReturnUnion' [CppInteropParseNote]
import Cpp library "decl_value_return_type.h";
fn F() {
// CHECK:STDERR: fail_import_decl_value_return_type.carbon:[[@LINE+7]]:3-29: note: in thunk for C++ function used here [InCppThunk]
// CHECK:STDERR:
// CHECK:STDERR: fail_import_decl_value_return_type.carbon:[[@LINE+5]]:3-29: error: function returns incomplete type `Cpp.DeclValueReturnUnion` [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: included from: fail_import_decl_value_return_type.carbon:[[@LINE-6]]:10 [InCppInclude]
// CHECK:STDERR: ./decl_value_return_type.h:2:7: note: class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ./decl_value_return_type.h:4:33: note: return type declared here [IncompleteReturnTypeHere]
// CHECK:STDERR: ╭─┤ fail_import_decl_value_return_type.carbon:[[@LINE+18]]:3
// CHECK:STDERR: -> │ Cpp.foo_decl_value_return();
// CHECK:STDERR: · ━━━━━━━┳━━━━━━━━━━━━━━━━━━━
// CHECK:STDERR: · ┗━━┫ error: function returns incomplete type `Cpp.DeclValueReturnUnion`
// CHECK:STDERR: · ┃ [IncompleteTypeInFunctionReturnType]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ ╭── included from: fail_import_decl_value_return_type.carbon [InCppInclude]
// CHECK:STDERR: ├─┤ ./decl_value_return_type.h
// CHECK:STDERR: │ union DeclValueReturnUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ class was forward declared here [ClassForwardDeclaredHere]
// CHECK:STDERR: ┆
// CHECK:STDERR: │ auto foo_decl_value_return() -> DeclValueReturnUnion;
// CHECK:STDERR: · ┬
// CHECK:STDERR: · ╰──┤ return type declared here
// CHECK:STDERR: · │ [IncompleteReturnTypeHere]
// CHECK:STDERR: ╰────
// CHECK:STDERR:
Cpp.foo_decl_value_return();
}