From d31fc9ad02c09302b3eb91e8a8a7aab4492318f6 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Thu, 9 Jan 2025 14:46:22 -0800 Subject: [PATCH] Support array types with dependent bounds. (#4751) Given `N:! i32`, the type `[T; N]` is a valid but dependent array type. --- toolchain/check/convert.cpp | 15 +- toolchain/check/eval.cpp | 14 +- .../array/init_dependent_bound.carbon | 122 +++ toolchain/check/testdata/deduce/array.carbon | 766 ++++++++++++------ .../check/testdata/eval/fail_symbolic.carbon | 84 -- toolchain/check/testdata/eval/symbolic.carbon | 67 +- .../generic/fail_todo_param_in_type.carbon | 96 --- .../function/generic/param_in_type.carbon | 99 +++ toolchain/diagnostics/diagnostic_kind.def | 1 + toolchain/lower/file_context.cpp | 2 +- toolchain/sem_ir/file.h | 8 +- toolchain/sem_ir/stringify_type.cpp | 11 +- 12 files changed, 816 insertions(+), 469 deletions(-) create mode 100644 toolchain/check/testdata/array/init_dependent_bound.carbon delete mode 100644 toolchain/check/testdata/eval/fail_symbolic.carbon delete mode 100644 toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon create mode 100644 toolchain/check/testdata/function/generic/param_in_type.carbon diff --git a/toolchain/check/convert.cpp b/toolchain/check/convert.cpp index 13850664ea59..43e651cb0e6d 100644 --- a/toolchain/check/convert.cpp +++ b/toolchain/check/convert.cpp @@ -239,7 +239,16 @@ static auto ConvertTupleToArray(Context& context, SemIR::TupleType tuple_type, } // Check that the tuple is the right size. - uint64_t array_bound = sem_ir.GetArrayBoundValue(array_type.bound_id); + std::optional array_bound = + sem_ir.GetArrayBoundValue(array_type.bound_id); + if (!array_bound) { + // TODO: Should this fall back to using `ImplicitAs`? + CARBON_DIAGNOSTIC(ArrayInitDependentBound, Error, + "cannot initialize array with dependent bound from a " + "list of initializers"); + context.emitter().Emit(value_loc_id, ArrayInitDependentBound); + return SemIR::ErrorInst::SingletonInstId; + } if (tuple_elem_types.size() != array_bound) { CARBON_DIAGNOSTIC( ArrayInitFromLiteralArgCountMismatch, Error, @@ -253,7 +262,7 @@ static auto ConvertTupleToArray(Context& context, SemIR::TupleType tuple_type, literal_elems.empty() ? ArrayInitFromExprArgCountMismatch : ArrayInitFromLiteralArgCountMismatch, - array_bound, tuple_elem_types.size()); + *array_bound, tuple_elem_types.size()); return SemIR::ErrorInst::SingletonInstId; } @@ -274,7 +283,7 @@ static auto ConvertTupleToArray(Context& context, SemIR::TupleType tuple_type, // TODO: Annotate diagnostics coming from here with the array element index, // if initializing from a tuple literal. llvm::SmallVector inits; - inits.reserve(array_bound + 1); + inits.reserve(*array_bound + 1); for (auto [i, src_type_id] : llvm::enumerate(tuple_elem_types)) { // TODO: This call recurses back into conversion. Switch to an iterative // approach. diff --git a/toolchain/check/eval.cpp b/toolchain/check/eval.cpp index f9b01d4f9738..0c9a19e173f2 100644 --- a/toolchain/check/eval.cpp +++ b/toolchain/check/eval.cpp @@ -1527,13 +1527,15 @@ static auto TryEvalInstInContext(EvalContext& eval_context, eval_context, inst, [&](SemIR::ArrayType result) { auto bound_id = array_type.bound_id; - auto int_bound = - eval_context.insts().TryGetAs(result.bound_id); + auto bound_inst = eval_context.insts().Get(result.bound_id); + auto int_bound = bound_inst.TryAs(); if (!int_bound) { - // TODO: Permit symbolic array bounds. This will require fixing - // callers of `GetArrayBoundValue`. - eval_context.context().TODO(bound_id, "symbolic array bound"); - return false; + CARBON_CHECK(eval_context.constant_values() + .Get(result.bound_id) + .is_symbolic(), + "Unexpected inst {0} for template constant int", + bound_inst); + return true; } // TODO: We should check that the size of the resulting array type // fits in 64 bits, not just that the bound does. Should we use a diff --git a/toolchain/check/testdata/array/init_dependent_bound.carbon b/toolchain/check/testdata/array/init_dependent_bound.carbon new file mode 100644 index 000000000000..8bebd1012c1f --- /dev/null +++ b/toolchain/check/testdata/array/init_dependent_bound.carbon @@ -0,0 +1,122 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/array/init_dependent_bound.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/array/init_dependent_bound.carbon + +// --- fail_init_dependent_bound.carbon + +library "[[@TEST_NAME]]"; + +fn F(N:! i32) { + // CHECK:STDERR: fail_init_dependent_bound.carbon:[[@LINE+4]]:23: error: cannot initialize array with dependent bound from a list of initializers [ArrayInitDependentBound] + // CHECK:STDERR: var arr: [i32; N] = (1, 2, 3); + // CHECK:STDERR: ^~~~~~~~~ + // CHECK:STDERR: + var arr: [i32; N] = (1, 2, 3); +} + +// --- fail_todo_init_template_dependent_bound.carbon + +library "[[@TEST_NAME]]"; + +// TODO: This should be valid. +// CHECK:STDERR: fail_todo_init_template_dependent_bound.carbon:[[@LINE+3]]:6: error: semantics TODO: `HandleTemplate` [SemanticsTodo] +// CHECK:STDERR: fn G(template N:! i32) { +// CHECK:STDERR: ^~~~~~~~~~~~~~~~ +fn G(template N:! i32) { + var arr: [i32; N] = (1, 2, 3); +} + +fn H() { G(3); } + +// CHECK:STDOUT: --- fail_init_dependent_bound.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] +// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] +// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] +// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] +// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] +// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] +// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] +// CHECK:STDOUT: %array_type: type = array_type %int.convert_checked, %i32 [symbolic] +// CHECK:STDOUT: %require_complete.70c: = require_complete_type %array_type [symbolic] +// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template] +// CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template] +// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template] +// CHECK:STDOUT: %tuple.type: type = tuple_type (Core.IntLiteral, Core.IntLiteral, Core.IntLiteral) [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .Int = %import_ref.187 +// CHECK:STDOUT: .ImplicitAs = %import_ref.a69 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/... +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %N.patt.loc4_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc4_6.1, runtime_param [symbolic = %N.patt.loc4_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param +// CHECK:STDOUT: %.loc4: type = splice_block %i32 [template = constants.%i32] { +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: %N.loc4_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc4_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F(%N.loc4_6.1: %i32) { +// CHECK:STDOUT: %N.loc4_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc4_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %N.patt.loc4_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc4_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Convert.bound: = bound_method %N.loc4_6.2, constants.%Convert.079 [symbolic = %Convert.bound (constants.%Convert.bound)] +// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn (constants.%Convert.specific_fn)] +// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.loc4_6.2) [symbolic = %int.convert_checked (constants.%int.convert_checked)] +// CHECK:STDOUT: %array_type: type = array_type %int.convert_checked, %i32 [symbolic = %array_type (constants.%array_type)] +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%array_type (%array_type) [symbolic = %require_complete (constants.%require_complete.70c)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%N.param_patt: %i32) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %arr.var: ref @F.%array_type (%array_type) = var arr +// CHECK:STDOUT: %arr: ref @F.%array_type (%array_type) = bind_name arr, %arr.var +// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template = constants.%int_1] +// CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template = constants.%int_2] +// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template = constants.%int_3] +// CHECK:STDOUT: %.loc9: %tuple.type = tuple_literal (%int_1, %int_2, %int_3) +// CHECK:STDOUT: assign %arr.var, +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%N.3e4) { +// CHECK:STDOUT: %N.loc4_6.2 => constants.%N.3e4 +// CHECK:STDOUT: %N.patt.loc4_6.2 => constants.%N.3e4 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_todo_init_template_dependent_bound.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file {} +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/deduce/array.carbon b/toolchain/check/testdata/deduce/array.carbon index aa2a44c1abe6..cf6b60e234a2 100644 --- a/toolchain/check/testdata/deduce/array.carbon +++ b/toolchain/check/testdata/deduce/array.carbon @@ -21,38 +21,30 @@ fn G() -> C { return F(a); } -// --- fail_todo_bound_only.carbon +// --- bound_only.carbon library "[[@TEST_NAME]]"; class C {} -// CHECK:STDERR: fail_todo_bound_only.carbon:[[@LINE+4]]:22: error: semantics TODO: `symbolic array bound` [SemanticsTodo] -// CHECK:STDERR: fn F[N:! i32](a: [C; N]) -> i32 { return N; } -// CHECK:STDERR: ^ -// CHECK:STDERR: -fn F[N:! i32](a: [C; N]) -> i32 { return N; } +fn F[N:! Core.IntLiteral()](a: [C; N]) -> i32 { return N; } -fn G() -> C { +fn G() -> i32 { var a: [C; 3] = ({}, {}, {}); return F(a); } -// --- fail_todo_type_and_bound.carbon +// --- type_and_bound.carbon library "[[@TEST_NAME]]"; class C {} -// CHECK:STDERR: fail_todo_type_and_bound.carbon:[[@LINE+4]]:32: error: semantics TODO: `symbolic array bound` [SemanticsTodo] -// CHECK:STDERR: fn F[T:! type, N:! i32](a: [T; N]) -> T; -// CHECK:STDERR: ^ -// CHECK:STDERR: -fn F[T:! type, N:! i32](a: [T; N]) -> T; +fn F[T:! type, N:! Core.IntLiteral()](a: [T; N]) {} -fn G() -> C { +fn G() { var a: [C; 3] = ({}, {}, {}); - return F(a); + F(a); } // --- fail_bound_mismatch.carbon @@ -86,16 +78,47 @@ library "[[@TEST_NAME]]"; class C {} class D {} -// CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+3]]:22: error: semantics TODO: `symbolic array bound` [SemanticsTodo] -// CHECK:STDERR: fn F[N:! i32](a: [C; N]) -> i32 { return N; } -// CHECK:STDERR: ^ -fn F[N:! i32](a: [C; N]) -> i32 { return N; } +fn F[N:! Core.IntLiteral()](a: [C; N]) -> i32 { return N; } -fn G() -> C { +fn G() -> i32 { + // TODO: We succeed at deducing N here but fail to convert. Is this the right behavior? var a: [D; 3] = ({}, {}, {}); + // CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+10]]:12: error: cannot implicitly convert from `[D; 3]` to `[C; 3]` [ImplicitAsConversionFailure] + // CHECK:STDERR: return F(a); + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+7]]:12: note: type `[D; 3]` does not implement interface `Core.ImplicitAs([C; 3])` [MissingImplInMemberAccessNote] + // CHECK:STDERR: return F(a); + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE-11]]:29: note: initializing function parameter [InCallToFunctionParam] + // CHECK:STDERR: fn F[N:! Core.IntLiteral()](a: [C; N]) -> i32 { return N; } + // CHECK:STDERR: ^~~~~~~~~ + // CHECK:STDERR: return F(a); } +// --- fail_bound_type_mismatch.carbon + +library "[[@TEST_NAME]]"; + +class C {} + +fn F[N:! i32](a: [C; N]) -> i32 { return N; } + +fn G() -> i32 { + var a: [C; 3] = ({}, {}, {}); + // TODO: This fails because the array bound in `F` is effectively + // `N.(ImplicitAs(IntLiteral).Convert)()` + // which we can't deduce through. We should decide if we want to support + // deductions of that form. If not, it'd be nice to diagnose this situation + // better. + // CHECK:STDERR: fail_bound_type_mismatch.carbon:[[@LINE+6]]:10: error: cannot deduce value for generic parameter `N` [DeductionIncomplete] + // CHECK:STDERR: return F(a); + // CHECK:STDERR: ^~~~ + // CHECK:STDERR: fail_bound_type_mismatch.carbon:[[@LINE-12]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] + // CHECK:STDERR: fn F[N:! i32](a: [C; N]) -> i32 { return N; } + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + return F(a); +} // CHECK:STDOUT: --- type_only.carbon // CHECK:STDOUT: @@ -266,44 +289,55 @@ fn G() -> C { // CHECK:STDOUT: %require_complete.loc6_17 => constants.%complete_type.dd1 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_bound_only.carbon +// CHECK:STDOUT: --- bound_only.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template] +// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template] +// CHECK:STDOUT: %N.f0243b.1: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic] +// CHECK:STDOUT: %N.patt.7d2de8.1: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic] +// CHECK:STDOUT: %array_type.f81: type = array_type %N.f0243b.1, %C [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] -// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] -// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] -// CHECK:STDOUT: %Convert.type.a9b: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template] -// CHECK:STDOUT: %impl_witness.dd3: = impl_witness (imports.%import_ref.a80), @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] -// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] -// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] -// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.109: = require_complete_type %array_type.f81 [symbolic] +// CHECK:STDOUT: %Convert.type.cd1: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] +// CHECK:STDOUT: %impl_witness.5b0: = impl_witness (imports.%import_ref.723), @impl.1(%int_32) [template] +// CHECK:STDOUT: %Convert.type.466: type = fn_type @Convert.2, @impl.1(%int_32) [template] +// CHECK:STDOUT: %Convert.925: %Convert.type.466 = struct_value () [template] +// CHECK:STDOUT: %Convert.bound.2a5: = bound_method %N.f0243b.1, %Convert.925 [symbolic] +// CHECK:STDOUT: %Convert.specific_fn.660: = specific_function %Convert.bound.2a5, @Convert.2(%int_32) [symbolic] +// CHECK:STDOUT: %int.convert_checked: init %i32 = call %Convert.specific_fn.660(%N.f0243b.1) [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] -// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template] -// CHECK:STDOUT: %array_type: type = array_type %int_3, %C [template] +// CHECK:STDOUT: %int_3.1ba: Core.IntLiteral = int_value 3 [template] +// CHECK:STDOUT: %array_type.002: type = array_type %int_3.1ba, %C [template] // CHECK:STDOUT: %tuple.type: type = tuple_type (%empty_struct_type, %empty_struct_type, %empty_struct_type) [template] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %C.val: %C = struct_value () [template] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template] -// CHECK:STDOUT: %array: %array_type = tuple_value (%C.val, %C.val, %C.val) [template] +// CHECK:STDOUT: %array: %array_type.002 = tuple_value (%C.val, %C.val, %C.val) [template] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%int_3.1ba) [template] +// CHECK:STDOUT: %complete_type.dd1: = complete_type_witness %array_type.002 [template] +// CHECK:STDOUT: %Convert.bound.0db: = bound_method %int_3.1ba, %Convert.925 [template] +// CHECK:STDOUT: %Convert.specific_fn.456: = specific_function %Convert.bound.0db, @Convert.2(%int_32) [template] +// CHECK:STDOUT: %int_3.25b: %i32 = int_value 3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .IntLiteral = %import_ref.8ee // CHECK:STDOUT: .Int = %import_ref.187 // CHECK:STDOUT: .ImplicitAs = %import_ref.a69 // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref.8ee: %IntLiteral.type = import_ref Core//prelude/types/int_literal, IntLiteral, loaded [template = constants.%IntLiteral] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -316,44 +350,42 @@ fn G() -> C { // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {} // CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { -// CHECK:STDOUT: %N.patt.loc10_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc10_6.1, runtime_param [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %a.patt: = binding_pattern a -// CHECK:STDOUT: %a.param_patt: = value_param_pattern %a.patt, runtime_param0 +// CHECK:STDOUT: %N.patt.loc6_6.1: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc6_6.2 (constants.%N.patt.7d2de8.1)] +// CHECK:STDOUT: %N.param_patt: Core.IntLiteral = value_param_pattern %N.patt.loc6_6.1, runtime_param [symbolic = %N.patt.loc6_6.2 (constants.%N.patt.7d2de8.1)] +// CHECK:STDOUT: %a.patt: @F.%array_type.loc6_37.2 (%array_type.f81) = binding_pattern a +// CHECK:STDOUT: %a.param_patt: @F.%array_type.loc6_37.2 (%array_type.f81) = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param1 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc10_29: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32.loc10_29: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] -// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param -// CHECK:STDOUT: %.loc10_10: type = splice_block %i32.loc10_10 [template = constants.%i32] { -// CHECK:STDOUT: %int_32.loc10_10: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32.loc10_10: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %N.param: Core.IntLiteral = value_param runtime_param +// CHECK:STDOUT: %.loc6_26.1: type = splice_block %.loc6_26.3 [template = Core.IntLiteral] { +// CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [template = imports.%Core] +// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.8ee [template = constants.%IntLiteral] +// CHECK:STDOUT: %int_literal.make_type: init type = call %IntLiteral.ref() [template = Core.IntLiteral] +// CHECK:STDOUT: %.loc6_26.2: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral] +// CHECK:STDOUT: %.loc6_26.3: type = converted %int_literal.make_type, %.loc6_26.2 [template = Core.IntLiteral] // CHECK:STDOUT: } -// CHECK:STDOUT: %N.loc10_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %a.param: = value_param runtime_param0 -// CHECK:STDOUT: %.loc10_23: type = splice_block %array_type [template = ] { +// CHECK:STDOUT: %N.loc6_6.1: Core.IntLiteral = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc6_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %a.param: @F.%array_type.loc6_37.2 (%array_type.f81) = value_param runtime_param0 +// CHECK:STDOUT: %.loc6_37: type = splice_block %array_type.loc6_37.1 [symbolic = %array_type.loc6_37.2 (constants.%array_type.f81)] { // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] -// CHECK:STDOUT: %N.ref.loc10_22: %i32 = name_ref N, %N.loc10_6.1 [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %impl.elem0: %Convert.type.a9b = impl_witness_access constants.%impl_witness.dd3, element0 [template = constants.%Convert.079] -// CHECK:STDOUT: %Convert.bound.loc10_22.1: = bound_method %N.ref.loc10_22, %impl.elem0 [symbolic = %Convert.bound.loc10_22.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc10_22.1: = specific_function %Convert.bound.loc10_22.1, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc10_22.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc10_22.1: init Core.IntLiteral = call %Convert.specific_fn.loc10_22.1(%N.ref.loc10_22) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc10_22.1: Core.IntLiteral = value_of_initializer %int.convert_checked.loc10_22.1 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc10_22.2: Core.IntLiteral = converted %N.ref.loc10_22, %.loc10_22.1 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %array_type: type = array_type %.loc10_22.2, %C [template = ] +// CHECK:STDOUT: %N.ref.loc6_36: Core.IntLiteral = name_ref N, %N.loc6_6.1 [symbolic = %N.loc6_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %array_type.loc6_37.1: type = array_type %N.ref.loc6_36, %C [symbolic = %array_type.loc6_37.2 (constants.%array_type.f81)] // CHECK:STDOUT: } -// CHECK:STDOUT: %a: = bind_name a, %a.param +// CHECK:STDOUT: %a: @F.%array_type.loc6_37.2 (%array_type.f81) = bind_name a, %a.param // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param1 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } // CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] { -// CHECK:STDOUT: %return.patt: %C = return_slot_pattern -// CHECK:STDOUT: %return.param_patt: %C = out_param_pattern %return.patt, runtime_param0 +// CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern +// CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0 // CHECK:STDOUT: } { -// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] -// CHECK:STDOUT: %return.param: ref %C = out_param runtime_param0 -// CHECK:STDOUT: %return: ref %C = return_slot %return.param +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 +// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -365,59 +397,82 @@ fn G() -> C { // CHECK:STDOUT: complete_type_witness = %complete_type // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @F(%N.loc10_6.1: %i32) { -// CHECK:STDOUT: %N.loc10_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %N.patt.loc10_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %Convert.bound.loc10_22.2: = bound_method %N.loc10_6.2, constants.%Convert.079 [symbolic = %Convert.bound.loc10_22.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc10_22.2: = specific_function %Convert.bound.loc10_22.2, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc10_22.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc10_22.2: init Core.IntLiteral = call %Convert.specific_fn.loc10_22.2(%N.loc10_6.2) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: generic fn @F(%N.loc6_6.1: Core.IntLiteral) { +// CHECK:STDOUT: %N.loc6_6.2: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic = %N.loc6_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %N.patt.loc6_6.2: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc6_6.2 (constants.%N.patt.7d2de8.1)] +// CHECK:STDOUT: %array_type.loc6_37.2: type = array_type %N.loc6_6.2, %C [symbolic = %array_type.loc6_37.2 (constants.%array_type.f81)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%array_type.loc6_37.2 (%array_type.f81) [symbolic = %require_complete (constants.%require_complete.109)] +// CHECK:STDOUT: %Convert.bound.loc6_57.2: = bound_method %N.loc6_6.2, constants.%Convert.925 [symbolic = %Convert.bound.loc6_57.2 (constants.%Convert.bound.2a5)] +// CHECK:STDOUT: %Convert.specific_fn.loc6_57.2: = specific_function %Convert.bound.loc6_57.2, @Convert.2(constants.%int_32) [symbolic = %Convert.specific_fn.loc6_57.2 (constants.%Convert.specific_fn.660)] +// CHECK:STDOUT: %int.convert_checked.loc6_57.2: init %i32 = call %Convert.specific_fn.loc6_57.2(%N.loc6_6.2) [symbolic = %int.convert_checked.loc6_57.2 (constants.%int.convert_checked)] // CHECK:STDOUT: -// CHECK:STDOUT: fn[%N.param_patt: %i32](%a.param_patt: ) -> %i32 { +// CHECK:STDOUT: fn[%N.param_patt: Core.IntLiteral](%a.param_patt: @F.%array_type.loc6_37.2 (%array_type.f81)) -> %i32 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %N.ref.loc10_42: %i32 = name_ref N, %N.loc10_6.1 [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: return %N.ref.loc10_42 +// CHECK:STDOUT: %N.ref.loc6_56: Core.IntLiteral = name_ref N, %N.loc6_6.1 [symbolic = %N.loc6_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %impl.elem0: %Convert.type.cd1 = impl_witness_access constants.%impl_witness.5b0, element0 [template = constants.%Convert.925] +// CHECK:STDOUT: %Convert.bound.loc6_57.1: = bound_method %N.ref.loc6_56, %impl.elem0 [symbolic = %Convert.bound.loc6_57.2 (constants.%Convert.bound.2a5)] +// CHECK:STDOUT: %Convert.specific_fn.loc6_57.1: = specific_function %Convert.bound.loc6_57.1, @Convert.2(constants.%int_32) [symbolic = %Convert.specific_fn.loc6_57.2 (constants.%Convert.specific_fn.660)] +// CHECK:STDOUT: %int.convert_checked.loc6_57.1: init %i32 = call %Convert.specific_fn.loc6_57.1(%N.ref.loc6_56) [symbolic = %int.convert_checked.loc6_57.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc6_57.1: %i32 = value_of_initializer %int.convert_checked.loc6_57.1 [symbolic = %int.convert_checked.loc6_57.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc6_57.2: %i32 = converted %N.ref.loc6_56, %.loc6_57.1 [symbolic = %int.convert_checked.loc6_57.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: return %.loc6_57.2 // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @G() -> %return.param_patt: %C { +// CHECK:STDOUT: fn @G() -> %i32 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %a.var: ref %array_type = var a -// CHECK:STDOUT: %a: ref %array_type = bind_name a, %a.var -// CHECK:STDOUT: %.loc13_21.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_25.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_29.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_30.1: %tuple.type = tuple_literal (%.loc13_21.1, %.loc13_25.1, %.loc13_29.1) +// CHECK:STDOUT: %a.var: ref %array_type.002 = var a +// CHECK:STDOUT: %a: ref %array_type.002 = bind_name a, %a.var +// CHECK:STDOUT: %.loc9_21.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_25.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_29.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_30.1: %tuple.type = tuple_literal (%.loc9_21.1, %.loc9_25.1, %.loc9_29.1) // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0] -// CHECK:STDOUT: %.loc13_30.2: ref %C = array_index %a.var, %int_0 -// CHECK:STDOUT: %.loc13_21.2: init %C = class_init (), %.loc13_30.2 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.3: init %C = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.2: ref %C = array_index %a.var, %int_0 +// CHECK:STDOUT: %.loc9_21.2: init %C = class_init (), %.loc9_30.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.3: init %C = converted %.loc9_21.1, %.loc9_21.2 [template = constants.%C.val] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template = constants.%int_1] -// CHECK:STDOUT: %.loc13_30.4: ref %C = array_index %a.var, %int_1 -// CHECK:STDOUT: %.loc13_25.2: init %C = class_init (), %.loc13_30.4 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.5: init %C = converted %.loc13_25.1, %.loc13_25.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.4: ref %C = array_index %a.var, %int_1 +// CHECK:STDOUT: %.loc9_25.2: init %C = class_init (), %.loc9_30.4 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.5: init %C = converted %.loc9_25.1, %.loc9_25.2 [template = constants.%C.val] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template = constants.%int_2] -// CHECK:STDOUT: %.loc13_30.6: ref %C = array_index %a.var, %int_2 -// CHECK:STDOUT: %.loc13_29.2: init %C = class_init (), %.loc13_30.6 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.7: init %C = converted %.loc13_29.1, %.loc13_29.2 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.8: init %array_type = array_init (%.loc13_30.3, %.loc13_30.5, %.loc13_30.7) to %a.var [template = constants.%array] -// CHECK:STDOUT: %.loc13_31: init %array_type = converted %.loc13_30.1, %.loc13_30.8 [template = constants.%array] -// CHECK:STDOUT: assign %a.var, %.loc13_31 +// CHECK:STDOUT: %.loc9_30.6: ref %C = array_index %a.var, %int_2 +// CHECK:STDOUT: %.loc9_29.2: init %C = class_init (), %.loc9_30.6 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.7: init %C = converted %.loc9_29.1, %.loc9_29.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.8: init %array_type.002 = array_init (%.loc9_30.3, %.loc9_30.5, %.loc9_30.7) to %a.var [template = constants.%array] +// CHECK:STDOUT: %.loc9_31: init %array_type.002 = converted %.loc9_30.1, %.loc9_30.8 [template = constants.%array] +// CHECK:STDOUT: assign %a.var, %.loc9_31 // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F] -// CHECK:STDOUT: %a.ref: ref %array_type = name_ref a, %a -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: %a.ref: ref %array_type.002 = name_ref a, %a +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%int_3.1ba) [template = constants.%F.specific_fn] +// CHECK:STDOUT: %.loc10_12: %array_type.002 = bind_value %a.ref +// CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn(%.loc10_12) +// CHECK:STDOUT: %.loc10_14.1: %i32 = value_of_initializer %F.call +// CHECK:STDOUT: %.loc10_14.2: %i32 = converted %F.call, %.loc10_14.1 +// CHECK:STDOUT: return %.loc10_14.2 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: specific @F(constants.%N.3e4) { -// CHECK:STDOUT: %N.loc10_6.2 => constants.%N.3e4 -// CHECK:STDOUT: %N.patt.loc10_6.2 => constants.%N.3e4 -// CHECK:STDOUT: %Convert.bound.loc10_22.2 => constants.%Convert.bound -// CHECK:STDOUT: %Convert.specific_fn.loc10_22.2 => constants.%Convert.specific_fn -// CHECK:STDOUT: %int.convert_checked.loc10_22.2 => constants.%int.convert_checked +// CHECK:STDOUT: specific @F(constants.%N.f0243b.1) { +// CHECK:STDOUT: %N.loc6_6.2 => constants.%N.f0243b.1 +// CHECK:STDOUT: %N.patt.loc6_6.2 => constants.%N.f0243b.1 +// CHECK:STDOUT: %array_type.loc6_37.2 => constants.%array_type.f81 // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: --- fail_todo_type_and_bound.carbon +// CHECK:STDOUT: specific @F(constants.%int_3.1ba) { +// CHECK:STDOUT: %N.loc6_6.2 => constants.%int_3.1ba +// CHECK:STDOUT: %N.patt.loc6_6.2 => constants.%int_3.1ba +// CHECK:STDOUT: %array_type.loc6_37.2 => constants.%array_type.002 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.dd1 +// CHECK:STDOUT: %Convert.bound.loc6_57.2 => constants.%Convert.bound.0db +// CHECK:STDOUT: %Convert.specific_fn.loc6_57.2 => constants.%Convert.specific_fn.456 +// CHECK:STDOUT: %int.convert_checked.loc6_57.2 => constants.%int_3.25b +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- type_and_bound.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] @@ -425,38 +480,36 @@ fn G() -> C { // CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] -// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 1 [symbolic] -// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 1 [symbolic] -// CHECK:STDOUT: %Convert.type.a9b: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template] -// CHECK:STDOUT: %impl_witness.dd3: = impl_witness (imports.%import_ref.a80), @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] -// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] -// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] -// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] +// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template] +// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template] +// CHECK:STDOUT: %N: Core.IntLiteral = bind_symbolic_name N, 1 [symbolic] +// CHECK:STDOUT: %N.patt: Core.IntLiteral = symbolic_binding_pattern N, 1 [symbolic] +// CHECK:STDOUT: %array_type.24b: type = array_type %N, %T [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %array_type.24b [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template] -// CHECK:STDOUT: %array_type: type = array_type %int_3, %C [template] +// CHECK:STDOUT: %array_type.002: type = array_type %int_3, %C [template] // CHECK:STDOUT: %tuple.type: type = tuple_type (%empty_struct_type, %empty_struct_type, %empty_struct_type) [template] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %C.val: %C = struct_value () [template] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template] -// CHECK:STDOUT: %array: %array_type = tuple_value (%C.val, %C.val, %C.val) [template] +// CHECK:STDOUT: %array: %array_type.002 = tuple_value (%C.val, %C.val, %C.val) [template] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%C, %int_3) [template] +// CHECK:STDOUT: %complete_type.dd1: = complete_type_witness %array_type.002 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { -// CHECK:STDOUT: .Int = %import_ref.187 -// CHECK:STDOUT: .ImplicitAs = %import_ref.a69 +// CHECK:STDOUT: .IntLiteral = %import_ref // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref: %IntLiteral.type = import_ref Core//prelude/types/int_literal, IntLiteral, loaded [template = constants.%IntLiteral] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -469,48 +522,33 @@ fn G() -> C { // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {} // CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { -// CHECK:STDOUT: %T.patt.loc10_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc10_6.2 (constants.%T.patt)] -// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc10_6.1, runtime_param [symbolic = %T.patt.loc10_6.2 (constants.%T.patt)] -// CHECK:STDOUT: %N.patt.loc10_16.1: %i32 = symbolic_binding_pattern N, 1 [symbolic = %N.patt.loc10_16.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc10_16.1, runtime_param [symbolic = %N.patt.loc10_16.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %a.patt: = binding_pattern a -// CHECK:STDOUT: %a.param_patt: = value_param_pattern %a.patt, runtime_param0 -// CHECK:STDOUT: %return.patt: @F.%T.loc10_6.2 (%T) = return_slot_pattern -// CHECK:STDOUT: %return.param_patt: @F.%T.loc10_6.2 (%T) = out_param_pattern %return.patt, runtime_param1 +// CHECK:STDOUT: %T.patt.loc6_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc6_6.1, runtime_param [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %N.patt.loc6_16.1: Core.IntLiteral = symbolic_binding_pattern N, 1 [symbolic = %N.patt.loc6_16.2 (constants.%N.patt)] +// CHECK:STDOUT: %N.param_patt: Core.IntLiteral = value_param_pattern %N.patt.loc6_16.1, runtime_param [symbolic = %N.patt.loc6_16.2 (constants.%N.patt)] +// CHECK:STDOUT: %a.patt: @F.%array_type.loc6_47.2 (%array_type.24b) = binding_pattern a +// CHECK:STDOUT: %a.param_patt: @F.%array_type.loc6_47.2 (%array_type.24b) = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: } { -// CHECK:STDOUT: %T.ref.loc10_39: type = name_ref T, %T.loc10_6.1 [symbolic = %T.loc10_6.2 (constants.%T)] // CHECK:STDOUT: %T.param: type = value_param runtime_param -// CHECK:STDOUT: %T.loc10_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc10_6.2 (constants.%T)] -// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param -// CHECK:STDOUT: %.loc10_20: type = splice_block %i32 [template = constants.%i32] { -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %T.loc6_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: %N.param: Core.IntLiteral = value_param runtime_param +// CHECK:STDOUT: %.loc6_36.1: type = splice_block %.loc6_36.3 [template = Core.IntLiteral] { +// CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [template = imports.%Core] +// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref [template = constants.%IntLiteral] +// CHECK:STDOUT: %int_literal.make_type: init type = call %IntLiteral.ref() [template = Core.IntLiteral] +// CHECK:STDOUT: %.loc6_36.2: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral] +// CHECK:STDOUT: %.loc6_36.3: type = converted %int_literal.make_type, %.loc6_36.2 [template = Core.IntLiteral] // CHECK:STDOUT: } -// CHECK:STDOUT: %N.loc10_16.1: %i32 = bind_symbolic_name N, 1, %N.param [symbolic = %N.loc10_16.2 (constants.%N.3e4)] -// CHECK:STDOUT: %a.param: = value_param runtime_param0 -// CHECK:STDOUT: %.loc10_33: type = splice_block %array_type [template = ] { -// CHECK:STDOUT: %T.ref.loc10_29: type = name_ref T, %T.loc10_6.1 [symbolic = %T.loc10_6.2 (constants.%T)] -// CHECK:STDOUT: %N.ref: %i32 = name_ref N, %N.loc10_16.1 [symbolic = %N.loc10_16.2 (constants.%N.3e4)] -// CHECK:STDOUT: %impl.elem0: %Convert.type.a9b = impl_witness_access constants.%impl_witness.dd3, element0 [template = constants.%Convert.079] -// CHECK:STDOUT: %Convert.bound.loc10_32.1: = bound_method %N.ref, %impl.elem0 [symbolic = %Convert.bound.loc10_32.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc10_32.1: = specific_function %Convert.bound.loc10_32.1, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc10_32.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc10_32.1: init Core.IntLiteral = call %Convert.specific_fn.loc10_32.1(%N.ref) [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc10_32.1: Core.IntLiteral = value_of_initializer %int.convert_checked.loc10_32.1 [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc10_32.2: Core.IntLiteral = converted %N.ref, %.loc10_32.1 [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %array_type: type = array_type %.loc10_32.2, %T [template = ] +// CHECK:STDOUT: %N.loc6_16.1: Core.IntLiteral = bind_symbolic_name N, 1, %N.param [symbolic = %N.loc6_16.2 (constants.%N)] +// CHECK:STDOUT: %a.param: @F.%array_type.loc6_47.2 (%array_type.24b) = value_param runtime_param0 +// CHECK:STDOUT: %.loc6_47: type = splice_block %array_type.loc6_47.1 [symbolic = %array_type.loc6_47.2 (constants.%array_type.24b)] { +// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc6_6.1 [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: %N.ref: Core.IntLiteral = name_ref N, %N.loc6_16.1 [symbolic = %N.loc6_16.2 (constants.%N)] +// CHECK:STDOUT: %array_type.loc6_47.1: type = array_type %N.ref, %T [symbolic = %array_type.loc6_47.2 (constants.%array_type.24b)] // CHECK:STDOUT: } -// CHECK:STDOUT: %a: = bind_name a, %a.param -// CHECK:STDOUT: %return.param: ref @F.%T.loc10_6.2 (%T) = out_param runtime_param1 -// CHECK:STDOUT: %return: ref @F.%T.loc10_6.2 (%T) = return_slot %return.param -// CHECK:STDOUT: } -// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] { -// CHECK:STDOUT: %return.patt: %C = return_slot_pattern -// CHECK:STDOUT: %return.param_patt: %C = out_param_pattern %return.patt, runtime_param0 -// CHECK:STDOUT: } { -// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] -// CHECK:STDOUT: %return.param: ref %C = out_param runtime_param0 -// CHECK:STDOUT: %return: ref %C = return_slot %return.param +// CHECK:STDOUT: %a: @F.%array_type.loc6_47.2 (%array_type.24b) = bind_name a, %a.param // CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {} {} // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { @@ -521,54 +559,70 @@ fn G() -> C { // CHECK:STDOUT: complete_type_witness = %complete_type // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @F(%T.loc10_6.1: type, %N.loc10_16.1: %i32) { -// CHECK:STDOUT: %T.loc10_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc10_6.2 (constants.%T)] -// CHECK:STDOUT: %T.patt.loc10_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc10_6.2 (constants.%T.patt)] -// CHECK:STDOUT: %N.loc10_16.2: %i32 = bind_symbolic_name N, 1 [symbolic = %N.loc10_16.2 (constants.%N.3e4)] -// CHECK:STDOUT: %N.patt.loc10_16.2: %i32 = symbolic_binding_pattern N, 1 [symbolic = %N.patt.loc10_16.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %Convert.bound.loc10_32.2: = bound_method %N.loc10_16.2, constants.%Convert.079 [symbolic = %Convert.bound.loc10_32.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc10_32.2: = specific_function %Convert.bound.loc10_32.2, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc10_32.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc10_32.2: init Core.IntLiteral = call %Convert.specific_fn.loc10_32.2(%N.loc10_16.2) [symbolic = %int.convert_checked.loc10_32.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: generic fn @F(%T.loc6_6.1: type, %N.loc6_16.1: Core.IntLiteral) { +// CHECK:STDOUT: %T.loc6_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc6_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %N.loc6_16.2: Core.IntLiteral = bind_symbolic_name N, 1 [symbolic = %N.loc6_16.2 (constants.%N)] +// CHECK:STDOUT: %N.patt.loc6_16.2: Core.IntLiteral = symbolic_binding_pattern N, 1 [symbolic = %N.patt.loc6_16.2 (constants.%N.patt)] +// CHECK:STDOUT: %array_type.loc6_47.2: type = array_type %N.loc6_16.2, @F.%T.loc6_6.2 (%T) [symbolic = %array_type.loc6_47.2 (constants.%array_type.24b)] // CHECK:STDOUT: -// CHECK:STDOUT: fn[%T.param_patt: type, %N.param_patt: %i32](%a.param_patt: ) -> @F.%T.loc10_6.2 (%T); +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%array_type.loc6_47.2 (%array_type.24b) [symbolic = %require_complete (constants.%require_complete)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%T.param_patt: type, %N.param_patt: Core.IntLiteral](%a.param_patt: @F.%array_type.loc6_47.2 (%array_type.24b)) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @G() -> %return.param_patt: %C { +// CHECK:STDOUT: fn @G() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %a.var: ref %array_type = var a -// CHECK:STDOUT: %a: ref %array_type = bind_name a, %a.var -// CHECK:STDOUT: %.loc13_21.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_25.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_29.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_30.1: %tuple.type = tuple_literal (%.loc13_21.1, %.loc13_25.1, %.loc13_29.1) +// CHECK:STDOUT: %a.var: ref %array_type.002 = var a +// CHECK:STDOUT: %a: ref %array_type.002 = bind_name a, %a.var +// CHECK:STDOUT: %.loc9_21.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_25.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_29.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_30.1: %tuple.type = tuple_literal (%.loc9_21.1, %.loc9_25.1, %.loc9_29.1) // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0] -// CHECK:STDOUT: %.loc13_30.2: ref %C = array_index %a.var, %int_0 -// CHECK:STDOUT: %.loc13_21.2: init %C = class_init (), %.loc13_30.2 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.3: init %C = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.2: ref %C = array_index %a.var, %int_0 +// CHECK:STDOUT: %.loc9_21.2: init %C = class_init (), %.loc9_30.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.3: init %C = converted %.loc9_21.1, %.loc9_21.2 [template = constants.%C.val] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template = constants.%int_1] -// CHECK:STDOUT: %.loc13_30.4: ref %C = array_index %a.var, %int_1 -// CHECK:STDOUT: %.loc13_25.2: init %C = class_init (), %.loc13_30.4 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.5: init %C = converted %.loc13_25.1, %.loc13_25.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.4: ref %C = array_index %a.var, %int_1 +// CHECK:STDOUT: %.loc9_25.2: init %C = class_init (), %.loc9_30.4 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.5: init %C = converted %.loc9_25.1, %.loc9_25.2 [template = constants.%C.val] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template = constants.%int_2] -// CHECK:STDOUT: %.loc13_30.6: ref %C = array_index %a.var, %int_2 -// CHECK:STDOUT: %.loc13_29.2: init %C = class_init (), %.loc13_30.6 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.7: init %C = converted %.loc13_29.1, %.loc13_29.2 [template = constants.%C.val] -// CHECK:STDOUT: %.loc13_30.8: init %array_type = array_init (%.loc13_30.3, %.loc13_30.5, %.loc13_30.7) to %a.var [template = constants.%array] -// CHECK:STDOUT: %.loc13_31: init %array_type = converted %.loc13_30.1, %.loc13_30.8 [template = constants.%array] -// CHECK:STDOUT: assign %a.var, %.loc13_31 +// CHECK:STDOUT: %.loc9_30.6: ref %C = array_index %a.var, %int_2 +// CHECK:STDOUT: %.loc9_29.2: init %C = class_init (), %.loc9_30.6 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.7: init %C = converted %.loc9_29.1, %.loc9_29.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.8: init %array_type.002 = array_init (%.loc9_30.3, %.loc9_30.5, %.loc9_30.7) to %a.var [template = constants.%array] +// CHECK:STDOUT: %.loc9_31: init %array_type.002 = converted %.loc9_30.1, %.loc9_30.8 [template = constants.%array] +// CHECK:STDOUT: assign %a.var, %.loc9_31 // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F] -// CHECK:STDOUT: %a.ref: ref %array_type = name_ref a, %a -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: %a.ref: ref %array_type.002 = name_ref a, %a +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%C, constants.%int_3) [template = constants.%F.specific_fn] +// CHECK:STDOUT: %.loc10: %array_type.002 = bind_value %a.ref +// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn(%.loc10) +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: specific @F(constants.%T, constants.%N.3e4) { -// CHECK:STDOUT: %T.loc10_6.2 => constants.%T -// CHECK:STDOUT: %T.patt.loc10_6.2 => constants.%T -// CHECK:STDOUT: %N.loc10_16.2 => constants.%N.3e4 -// CHECK:STDOUT: %N.patt.loc10_16.2 => constants.%N.3e4 -// CHECK:STDOUT: %Convert.bound.loc10_32.2 => constants.%Convert.bound -// CHECK:STDOUT: %Convert.specific_fn.loc10_32.2 => constants.%Convert.specific_fn -// CHECK:STDOUT: %int.convert_checked.loc10_32.2 => constants.%int.convert_checked +// CHECK:STDOUT: specific @F(constants.%T, constants.%N) { +// CHECK:STDOUT: %T.loc6_6.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc6_6.2 => constants.%T +// CHECK:STDOUT: %N.loc6_16.2 => constants.%N +// CHECK:STDOUT: %N.patt.loc6_16.2 => constants.%N +// CHECK:STDOUT: %array_type.loc6_47.2 => constants.%array_type.24b +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%C, constants.%int_3) { +// CHECK:STDOUT: %T.loc6_6.2 => constants.%C +// CHECK:STDOUT: %T.patt.loc6_6.2 => constants.%C +// CHECK:STDOUT: %N.loc6_16.2 => constants.%int_3 +// CHECK:STDOUT: %N.patt.loc6_16.2 => constants.%int_3 +// CHECK:STDOUT: %array_type.loc6_47.2 => constants.%array_type.002 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.dd1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_bound_mismatch.carbon @@ -748,38 +802,50 @@ fn G() -> C { // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %D: type = class_type @D [template] +// CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [template] +// CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [template] +// CHECK:STDOUT: %N.f0243b.1: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic] +// CHECK:STDOUT: %N.patt.7d2de8.1: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic] +// CHECK:STDOUT: %array_type.f81: type = array_type %N.f0243b.1, %C [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] -// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] -// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] -// CHECK:STDOUT: %Convert.type.a9b: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template] -// CHECK:STDOUT: %impl_witness.dd3: = impl_witness (imports.%import_ref.a80), @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] -// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] -// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] -// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.109: = require_complete_type %array_type.f81 [symbolic] +// CHECK:STDOUT: %Convert.type.cd1: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] +// CHECK:STDOUT: %impl_witness.5b0: = impl_witness (imports.%import_ref.723), @impl.1(%int_32) [template] +// CHECK:STDOUT: %Convert.type.466: type = fn_type @Convert.2, @impl.1(%int_32) [template] +// CHECK:STDOUT: %Convert.925: %Convert.type.466 = struct_value () [template] +// CHECK:STDOUT: %Convert.bound.2a5: = bound_method %N.f0243b.1, %Convert.925 [symbolic] +// CHECK:STDOUT: %Convert.specific_fn.660: = specific_function %Convert.bound.2a5, @Convert.2(%int_32) [symbolic] +// CHECK:STDOUT: %int.convert_checked: init %i32 = call %Convert.specific_fn.660(%N.f0243b.1) [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] -// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template] -// CHECK:STDOUT: %array_type: type = array_type %int_3, %D [template] +// CHECK:STDOUT: %int_3.1ba: Core.IntLiteral = int_value 3 [template] +// CHECK:STDOUT: %array_type.fe4: type = array_type %int_3.1ba, %D [template] // CHECK:STDOUT: %tuple.type: type = tuple_type (%empty_struct_type, %empty_struct_type, %empty_struct_type) [template] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %D.val: %D = struct_value () [template] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template] -// CHECK:STDOUT: %array: %array_type = tuple_value (%D.val, %D.val, %D.val) [template] +// CHECK:STDOUT: %array: %array_type.fe4 = tuple_value (%D.val, %D.val, %D.val) [template] +// CHECK:STDOUT: %array_type.002: type = array_type %int_3.1ba, %C [template] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%int_3.1ba) [template] +// CHECK:STDOUT: %complete_type.dd1: = complete_type_witness %array_type.002 [template] +// CHECK:STDOUT: %Convert.bound.0db: = bound_method %int_3.1ba, %Convert.925 [template] +// CHECK:STDOUT: %Convert.specific_fn.456: = specific_function %Convert.bound.0db, @Convert.2(%int_32) [template] +// CHECK:STDOUT: %int_3.25b: %i32 = int_value 3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .IntLiteral = %import_ref.8ee // CHECK:STDOUT: .Int = %import_ref.187 // CHECK:STDOUT: .ImplicitAs = %import_ref.a69 // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } +// CHECK:STDOUT: %import_ref.8ee: %IntLiteral.type = import_ref Core//prelude/types/int_literal, IntLiteral, loaded [template = constants.%IntLiteral] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -794,44 +860,42 @@ fn G() -> C { // CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {} // CHECK:STDOUT: %D.decl: type = class_decl @D [template = constants.%D] {} {} // CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { -// CHECK:STDOUT: %N.patt.loc10_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc10_6.1, runtime_param [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %a.patt: = binding_pattern a -// CHECK:STDOUT: %a.param_patt: = value_param_pattern %a.patt, runtime_param0 +// CHECK:STDOUT: %N.patt.loc7_6.1: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc7_6.2 (constants.%N.patt.7d2de8.1)] +// CHECK:STDOUT: %N.param_patt: Core.IntLiteral = value_param_pattern %N.patt.loc7_6.1, runtime_param [symbolic = %N.patt.loc7_6.2 (constants.%N.patt.7d2de8.1)] +// CHECK:STDOUT: %a.patt: @F.%array_type.loc7_37.2 (%array_type.f81) = binding_pattern a +// CHECK:STDOUT: %a.param_patt: @F.%array_type.loc7_37.2 (%array_type.f81) = value_param_pattern %a.patt, runtime_param0 // CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern // CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param1 // CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc10_29: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32.loc10_29: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] -// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param -// CHECK:STDOUT: %.loc10_10: type = splice_block %i32.loc10_10 [template = constants.%i32] { -// CHECK:STDOUT: %int_32.loc10_10: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32.loc10_10: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %N.param: Core.IntLiteral = value_param runtime_param +// CHECK:STDOUT: %.loc7_26.1: type = splice_block %.loc7_26.3 [template = Core.IntLiteral] { +// CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core [template = imports.%Core] +// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%import_ref.8ee [template = constants.%IntLiteral] +// CHECK:STDOUT: %int_literal.make_type: init type = call %IntLiteral.ref() [template = Core.IntLiteral] +// CHECK:STDOUT: %.loc7_26.2: type = value_of_initializer %int_literal.make_type [template = Core.IntLiteral] +// CHECK:STDOUT: %.loc7_26.3: type = converted %int_literal.make_type, %.loc7_26.2 [template = Core.IntLiteral] // CHECK:STDOUT: } -// CHECK:STDOUT: %N.loc10_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %a.param: = value_param runtime_param0 -// CHECK:STDOUT: %.loc10_23: type = splice_block %array_type [template = ] { +// CHECK:STDOUT: %N.loc7_6.1: Core.IntLiteral = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc7_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %a.param: @F.%array_type.loc7_37.2 (%array_type.f81) = value_param runtime_param0 +// CHECK:STDOUT: %.loc7_37: type = splice_block %array_type.loc7_37.1 [symbolic = %array_type.loc7_37.2 (constants.%array_type.f81)] { // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] -// CHECK:STDOUT: %N.ref.loc10_22: %i32 = name_ref N, %N.loc10_6.1 [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %impl.elem0: %Convert.type.a9b = impl_witness_access constants.%impl_witness.dd3, element0 [template = constants.%Convert.079] -// CHECK:STDOUT: %Convert.bound.loc10_22.1: = bound_method %N.ref.loc10_22, %impl.elem0 [symbolic = %Convert.bound.loc10_22.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc10_22.1: = specific_function %Convert.bound.loc10_22.1, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc10_22.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc10_22.1: init Core.IntLiteral = call %Convert.specific_fn.loc10_22.1(%N.ref.loc10_22) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc10_22.1: Core.IntLiteral = value_of_initializer %int.convert_checked.loc10_22.1 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc10_22.2: Core.IntLiteral = converted %N.ref.loc10_22, %.loc10_22.1 [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %array_type: type = array_type %.loc10_22.2, %C [template = ] +// CHECK:STDOUT: %N.ref.loc7_36: Core.IntLiteral = name_ref N, %N.loc7_6.1 [symbolic = %N.loc7_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %array_type.loc7_37.1: type = array_type %N.ref.loc7_36, %C [symbolic = %array_type.loc7_37.2 (constants.%array_type.f81)] // CHECK:STDOUT: } -// CHECK:STDOUT: %a: = bind_name a, %a.param +// CHECK:STDOUT: %a: @F.%array_type.loc7_37.2 (%array_type.f81) = bind_name a, %a.param // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param1 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } // CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] { -// CHECK:STDOUT: %return.patt: %C = return_slot_pattern -// CHECK:STDOUT: %return.param_patt: %C = out_param_pattern %return.patt, runtime_param0 +// CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern +// CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0 // CHECK:STDOUT: } { -// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] -// CHECK:STDOUT: %return.param: ref %C = out_param runtime_param0 -// CHECK:STDOUT: %return: ref %C = return_slot %return.param +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 +// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -851,55 +915,235 @@ fn G() -> C { // CHECK:STDOUT: complete_type_witness = %complete_type // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @F(%N.loc10_6.1: %i32) { -// CHECK:STDOUT: %N.loc10_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %N.patt.loc10_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc10_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %Convert.bound.loc10_22.2: = bound_method %N.loc10_6.2, constants.%Convert.079 [symbolic = %Convert.bound.loc10_22.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc10_22.2: = specific_function %Convert.bound.loc10_22.2, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc10_22.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc10_22.2: init Core.IntLiteral = call %Convert.specific_fn.loc10_22.2(%N.loc10_6.2) [symbolic = %int.convert_checked.loc10_22.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: generic fn @F(%N.loc7_6.1: Core.IntLiteral) { +// CHECK:STDOUT: %N.loc7_6.2: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic = %N.loc7_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %N.patt.loc7_6.2: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc7_6.2 (constants.%N.patt.7d2de8.1)] +// CHECK:STDOUT: %array_type.loc7_37.2: type = array_type %N.loc7_6.2, %C [symbolic = %array_type.loc7_37.2 (constants.%array_type.f81)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%array_type.loc7_37.2 (%array_type.f81) [symbolic = %require_complete (constants.%require_complete.109)] +// CHECK:STDOUT: %Convert.bound.loc7_57.2: = bound_method %N.loc7_6.2, constants.%Convert.925 [symbolic = %Convert.bound.loc7_57.2 (constants.%Convert.bound.2a5)] +// CHECK:STDOUT: %Convert.specific_fn.loc7_57.2: = specific_function %Convert.bound.loc7_57.2, @Convert.2(constants.%int_32) [symbolic = %Convert.specific_fn.loc7_57.2 (constants.%Convert.specific_fn.660)] +// CHECK:STDOUT: %int.convert_checked.loc7_57.2: init %i32 = call %Convert.specific_fn.loc7_57.2(%N.loc7_6.2) [symbolic = %int.convert_checked.loc7_57.2 (constants.%int.convert_checked)] // CHECK:STDOUT: -// CHECK:STDOUT: fn[%N.param_patt: %i32](%a.param_patt: ) -> %i32 { +// CHECK:STDOUT: fn[%N.param_patt: Core.IntLiteral](%a.param_patt: @F.%array_type.loc7_37.2 (%array_type.f81)) -> %i32 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %N.ref.loc10_42: %i32 = name_ref N, %N.loc10_6.1 [symbolic = %N.loc10_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: return %N.ref.loc10_42 +// CHECK:STDOUT: %N.ref.loc7_56: Core.IntLiteral = name_ref N, %N.loc7_6.1 [symbolic = %N.loc7_6.2 (constants.%N.f0243b.1)] +// CHECK:STDOUT: %impl.elem0: %Convert.type.cd1 = impl_witness_access constants.%impl_witness.5b0, element0 [template = constants.%Convert.925] +// CHECK:STDOUT: %Convert.bound.loc7_57.1: = bound_method %N.ref.loc7_56, %impl.elem0 [symbolic = %Convert.bound.loc7_57.2 (constants.%Convert.bound.2a5)] +// CHECK:STDOUT: %Convert.specific_fn.loc7_57.1: = specific_function %Convert.bound.loc7_57.1, @Convert.2(constants.%int_32) [symbolic = %Convert.specific_fn.loc7_57.2 (constants.%Convert.specific_fn.660)] +// CHECK:STDOUT: %int.convert_checked.loc7_57.1: init %i32 = call %Convert.specific_fn.loc7_57.1(%N.ref.loc7_56) [symbolic = %int.convert_checked.loc7_57.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc7_57.1: %i32 = value_of_initializer %int.convert_checked.loc7_57.1 [symbolic = %int.convert_checked.loc7_57.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc7_57.2: %i32 = converted %N.ref.loc7_56, %.loc7_57.1 [symbolic = %int.convert_checked.loc7_57.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: return %.loc7_57.2 // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @G() -> %return.param_patt: %C { +// CHECK:STDOUT: fn @G() -> %i32 { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: %a.var: ref %array_type = var a -// CHECK:STDOUT: %a: ref %array_type = bind_name a, %a.var -// CHECK:STDOUT: %.loc13_21.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_25.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_29.1: %empty_struct_type = struct_literal () -// CHECK:STDOUT: %.loc13_30.1: %tuple.type = tuple_literal (%.loc13_21.1, %.loc13_25.1, %.loc13_29.1) +// CHECK:STDOUT: %a.var: ref %array_type.fe4 = var a +// CHECK:STDOUT: %a: ref %array_type.fe4 = bind_name a, %a.var +// CHECK:STDOUT: %.loc11_21.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc11_25.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc11_29.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc11_30.1: %tuple.type = tuple_literal (%.loc11_21.1, %.loc11_25.1, %.loc11_29.1) // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0] -// CHECK:STDOUT: %.loc13_30.2: ref %D = array_index %a.var, %int_0 -// CHECK:STDOUT: %.loc13_21.2: init %D = class_init (), %.loc13_30.2 [template = constants.%D.val] -// CHECK:STDOUT: %.loc13_30.3: init %D = converted %.loc13_21.1, %.loc13_21.2 [template = constants.%D.val] +// CHECK:STDOUT: %.loc11_30.2: ref %D = array_index %a.var, %int_0 +// CHECK:STDOUT: %.loc11_21.2: init %D = class_init (), %.loc11_30.2 [template = constants.%D.val] +// CHECK:STDOUT: %.loc11_30.3: init %D = converted %.loc11_21.1, %.loc11_21.2 [template = constants.%D.val] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template = constants.%int_1] -// CHECK:STDOUT: %.loc13_30.4: ref %D = array_index %a.var, %int_1 -// CHECK:STDOUT: %.loc13_25.2: init %D = class_init (), %.loc13_30.4 [template = constants.%D.val] -// CHECK:STDOUT: %.loc13_30.5: init %D = converted %.loc13_25.1, %.loc13_25.2 [template = constants.%D.val] +// CHECK:STDOUT: %.loc11_30.4: ref %D = array_index %a.var, %int_1 +// CHECK:STDOUT: %.loc11_25.2: init %D = class_init (), %.loc11_30.4 [template = constants.%D.val] +// CHECK:STDOUT: %.loc11_30.5: init %D = converted %.loc11_25.1, %.loc11_25.2 [template = constants.%D.val] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template = constants.%int_2] -// CHECK:STDOUT: %.loc13_30.6: ref %D = array_index %a.var, %int_2 -// CHECK:STDOUT: %.loc13_29.2: init %D = class_init (), %.loc13_30.6 [template = constants.%D.val] -// CHECK:STDOUT: %.loc13_30.7: init %D = converted %.loc13_29.1, %.loc13_29.2 [template = constants.%D.val] -// CHECK:STDOUT: %.loc13_30.8: init %array_type = array_init (%.loc13_30.3, %.loc13_30.5, %.loc13_30.7) to %a.var [template = constants.%array] -// CHECK:STDOUT: %.loc13_31: init %array_type = converted %.loc13_30.1, %.loc13_30.8 [template = constants.%array] -// CHECK:STDOUT: assign %a.var, %.loc13_31 +// CHECK:STDOUT: %.loc11_30.6: ref %D = array_index %a.var, %int_2 +// CHECK:STDOUT: %.loc11_29.2: init %D = class_init (), %.loc11_30.6 [template = constants.%D.val] +// CHECK:STDOUT: %.loc11_30.7: init %D = converted %.loc11_29.1, %.loc11_29.2 [template = constants.%D.val] +// CHECK:STDOUT: %.loc11_30.8: init %array_type.fe4 = array_init (%.loc11_30.3, %.loc11_30.5, %.loc11_30.7) to %a.var [template = constants.%array] +// CHECK:STDOUT: %.loc11_31: init %array_type.fe4 = converted %.loc11_30.1, %.loc11_30.8 [template = constants.%array] +// CHECK:STDOUT: assign %a.var, %.loc11_31 // CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F] -// CHECK:STDOUT: %a.ref: ref %array_type = name_ref a, %a -// CHECK:STDOUT: return to %return +// CHECK:STDOUT: %a.ref: ref %array_type.fe4 = name_ref a, %a +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%int_3.1ba) [template = constants.%F.specific_fn] +// CHECK:STDOUT: %.loc22_12: %array_type.002 = converted %a.ref, [template = ] +// CHECK:STDOUT: %F.call: init %i32 = call %F.specific_fn() +// CHECK:STDOUT: %.loc22_14.1: %i32 = value_of_initializer %F.call +// CHECK:STDOUT: %.loc22_14.2: %i32 = converted %F.call, %.loc22_14.1 +// CHECK:STDOUT: return %.loc22_14.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%N.f0243b.1) { +// CHECK:STDOUT: %N.loc7_6.2 => constants.%N.f0243b.1 +// CHECK:STDOUT: %N.patt.loc7_6.2 => constants.%N.f0243b.1 +// CHECK:STDOUT: %array_type.loc7_37.2 => constants.%array_type.f81 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%int_3.1ba) { +// CHECK:STDOUT: %N.loc7_6.2 => constants.%int_3.1ba +// CHECK:STDOUT: %N.patt.loc7_6.2 => constants.%int_3.1ba +// CHECK:STDOUT: %array_type.loc7_37.2 => constants.%array_type.002 +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.dd1 +// CHECK:STDOUT: %Convert.bound.loc7_57.2 => constants.%Convert.bound.0db +// CHECK:STDOUT: %Convert.specific_fn.loc7_57.2 => constants.%Convert.specific_fn.456 +// CHECK:STDOUT: %int.convert_checked.loc7_57.2 => constants.%int_3.25b +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_bound_type_mismatch.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %C: type = class_type @C [template] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] +// CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] +// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] +// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] +// CHECK:STDOUT: %Convert.type.a9b: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template] +// CHECK:STDOUT: %impl_witness.dd3: = impl_witness (imports.%import_ref.a80), @impl.2(%int_32) [template] +// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] +// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] +// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] +// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] +// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] +// CHECK:STDOUT: %array_type.044: type = array_type %int.convert_checked, %C [symbolic] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.54c: = require_complete_type %array_type.044 [symbolic] +// CHECK:STDOUT: %G.type: type = fn_type @G [template] +// CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template] +// CHECK:STDOUT: %array_type.002: type = array_type %int_3, %C [template] +// CHECK:STDOUT: %tuple.type: type = tuple_type (%empty_struct_type, %empty_struct_type, %empty_struct_type) [template] +// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template] +// CHECK:STDOUT: %C.val: %C = struct_value () [template] +// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template] +// CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template] +// CHECK:STDOUT: %array: %array_type.002 = tuple_value (%C.val, %C.val, %C.val) [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .Int = %import_ref.187 +// CHECK:STDOUT: .ImplicitAs = %import_ref.a69 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/... +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .C = %C.decl +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %C.decl: type = class_decl @C [template = constants.%C] {} {} +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %N.patt.loc6_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc6_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc6_6.1, runtime_param [symbolic = %N.patt.loc6_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %a.patt: @F.%array_type.loc6_23.2 (%array_type.044) = binding_pattern a +// CHECK:STDOUT: %a.param_patt: @F.%array_type.loc6_23.2 (%array_type.044) = value_param_pattern %a.patt, runtime_param0 +// CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern +// CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param1 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %int_32.loc6_29: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32.loc6_29: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param +// CHECK:STDOUT: %.loc6_10: type = splice_block %i32.loc6_10 [template = constants.%i32] { +// CHECK:STDOUT: %int_32.loc6_10: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32.loc6_10: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: %N.loc6_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc6_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %a.param: @F.%array_type.loc6_23.2 (%array_type.044) = value_param runtime_param0 +// CHECK:STDOUT: %.loc6_23: type = splice_block %array_type.loc6_23.1 [symbolic = %array_type.loc6_23.2 (constants.%array_type.044)] { +// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] +// CHECK:STDOUT: %N.ref.loc6_22: %i32 = name_ref N, %N.loc6_6.1 [symbolic = %N.loc6_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %impl.elem0: %Convert.type.a9b = impl_witness_access constants.%impl_witness.dd3, element0 [template = constants.%Convert.079] +// CHECK:STDOUT: %Convert.bound.loc6_22.1: = bound_method %N.ref.loc6_22, %impl.elem0 [symbolic = %Convert.bound.loc6_22.2 (constants.%Convert.bound)] +// CHECK:STDOUT: %Convert.specific_fn.loc6_22.1: = specific_function %Convert.bound.loc6_22.1, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc6_22.2 (constants.%Convert.specific_fn)] +// CHECK:STDOUT: %int.convert_checked.loc6_22.1: init Core.IntLiteral = call %Convert.specific_fn.loc6_22.1(%N.ref.loc6_22) [symbolic = %int.convert_checked.loc6_22.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc6_22.1: Core.IntLiteral = value_of_initializer %int.convert_checked.loc6_22.1 [symbolic = %int.convert_checked.loc6_22.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc6_22.2: Core.IntLiteral = converted %N.ref.loc6_22, %.loc6_22.1 [symbolic = %int.convert_checked.loc6_22.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %array_type.loc6_23.1: type = array_type %.loc6_22.2, %C [symbolic = %array_type.loc6_23.2 (constants.%array_type.044)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %a: @F.%array_type.loc6_23.2 (%array_type.044) = bind_name a, %a.param +// CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param1 +// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param +// CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] { +// CHECK:STDOUT: %return.patt: %i32 = return_slot_pattern +// CHECK:STDOUT: %return.param_patt: %i32 = out_param_pattern %return.patt, runtime_param0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 +// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @C { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.357] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%C +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F(%N.loc6_6.1: %i32) { +// CHECK:STDOUT: %N.loc6_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc6_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %N.patt.loc6_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc6_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %Convert.bound.loc6_22.2: = bound_method %N.loc6_6.2, constants.%Convert.079 [symbolic = %Convert.bound.loc6_22.2 (constants.%Convert.bound)] +// CHECK:STDOUT: %Convert.specific_fn.loc6_22.2: = specific_function %Convert.bound.loc6_22.2, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc6_22.2 (constants.%Convert.specific_fn)] +// CHECK:STDOUT: %int.convert_checked.loc6_22.2: init Core.IntLiteral = call %Convert.specific_fn.loc6_22.2(%N.loc6_6.2) [symbolic = %int.convert_checked.loc6_22.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %array_type.loc6_23.2: type = array_type %int.convert_checked.loc6_22.2, %C [symbolic = %array_type.loc6_23.2 (constants.%array_type.044)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%array_type.loc6_23.2 (%array_type.044) [symbolic = %require_complete (constants.%require_complete.54c)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn[%N.param_patt: %i32](%a.param_patt: @F.%array_type.loc6_23.2 (%array_type.044)) -> %i32 { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %N.ref.loc6_42: %i32 = name_ref N, %N.loc6_6.1 [symbolic = %N.loc6_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: return %N.ref.loc6_42 +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G() -> %i32 { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %a.var: ref %array_type.002 = var a +// CHECK:STDOUT: %a: ref %array_type.002 = bind_name a, %a.var +// CHECK:STDOUT: %.loc9_21.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_25.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_29.1: %empty_struct_type = struct_literal () +// CHECK:STDOUT: %.loc9_30.1: %tuple.type = tuple_literal (%.loc9_21.1, %.loc9_25.1, %.loc9_29.1) +// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template = constants.%int_0] +// CHECK:STDOUT: %.loc9_30.2: ref %C = array_index %a.var, %int_0 +// CHECK:STDOUT: %.loc9_21.2: init %C = class_init (), %.loc9_30.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.3: init %C = converted %.loc9_21.1, %.loc9_21.2 [template = constants.%C.val] +// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template = constants.%int_1] +// CHECK:STDOUT: %.loc9_30.4: ref %C = array_index %a.var, %int_1 +// CHECK:STDOUT: %.loc9_25.2: init %C = class_init (), %.loc9_30.4 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.5: init %C = converted %.loc9_25.1, %.loc9_25.2 [template = constants.%C.val] +// CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template = constants.%int_2] +// CHECK:STDOUT: %.loc9_30.6: ref %C = array_index %a.var, %int_2 +// CHECK:STDOUT: %.loc9_29.2: init %C = class_init (), %.loc9_30.6 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.7: init %C = converted %.loc9_29.1, %.loc9_29.2 [template = constants.%C.val] +// CHECK:STDOUT: %.loc9_30.8: init %array_type.002 = array_init (%.loc9_30.3, %.loc9_30.5, %.loc9_30.7) to %a.var [template = constants.%array] +// CHECK:STDOUT: %.loc9_31: init %array_type.002 = converted %.loc9_30.1, %.loc9_30.8 [template = constants.%array] +// CHECK:STDOUT: assign %a.var, %.loc9_31 +// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F] +// CHECK:STDOUT: %a.ref: ref %array_type.002 = name_ref a, %a +// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%N.3e4) { -// CHECK:STDOUT: %N.loc10_6.2 => constants.%N.3e4 -// CHECK:STDOUT: %N.patt.loc10_6.2 => constants.%N.3e4 -// CHECK:STDOUT: %Convert.bound.loc10_22.2 => constants.%Convert.bound -// CHECK:STDOUT: %Convert.specific_fn.loc10_22.2 => constants.%Convert.specific_fn -// CHECK:STDOUT: %int.convert_checked.loc10_22.2 => constants.%int.convert_checked +// CHECK:STDOUT: %N.loc6_6.2 => constants.%N.3e4 +// CHECK:STDOUT: %N.patt.loc6_6.2 => constants.%N.3e4 +// CHECK:STDOUT: %Convert.bound.loc6_22.2 => constants.%Convert.bound +// CHECK:STDOUT: %Convert.specific_fn.loc6_22.2 => constants.%Convert.specific_fn +// CHECK:STDOUT: %int.convert_checked.loc6_22.2 => constants.%int.convert_checked +// CHECK:STDOUT: %array_type.loc6_23.2 => constants.%array_type.044 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/eval/fail_symbolic.carbon b/toolchain/check/testdata/eval/fail_symbolic.carbon deleted file mode 100644 index 138e0e0f109d..000000000000 --- a/toolchain/check/testdata/eval/fail_symbolic.carbon +++ /dev/null @@ -1,84 +0,0 @@ -// Part of the Carbon Language project, under the Apache License v2.0 with LLVM -// Exceptions. See /LICENSE for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -// AUTOUPDATE -// TIP: To test this file alone, run: -// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/eval/fail_symbolic.carbon -// TIP: To dump output, run: -// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/eval/fail_symbolic.carbon - -// TODO: This should work. -fn G(N:! i32) { - // CHECK:STDERR: fail_symbolic.carbon:[[@LINE+3]]:16: error: semantics TODO: `symbolic array bound` [SemanticsTodo] - // CHECK:STDERR: var k: [i32; N]; - // CHECK:STDERR: ^ - var k: [i32; N]; -} - -// CHECK:STDOUT: --- fail_symbolic.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] -// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] -// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] -// CHECK:STDOUT: %G.type: type = fn_type @G [template] -// CHECK:STDOUT: %G: %G.type = struct_value () [template] -// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] -// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] -// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] -// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { -// CHECK:STDOUT: .Int = %import_ref.187 -// CHECK:STDOUT: .ImplicitAs = %import_ref.a69 -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [template] { -// CHECK:STDOUT: .Core = imports.%Core -// CHECK:STDOUT: .G = %G.decl -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.import = import Core -// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] { -// CHECK:STDOUT: %N.patt.loc12_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc12_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc12_6.1, runtime_param [symbolic = %N.patt.loc12_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: } { -// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param -// CHECK:STDOUT: %.loc12: type = splice_block %i32 [template = constants.%i32] { -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %N.loc12_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc12_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: generic fn @G(%N.loc12_6.1: %i32) { -// CHECK:STDOUT: %N.loc12_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc12_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %N.patt.loc12_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc12_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: -// CHECK:STDOUT: !definition: -// CHECK:STDOUT: %Convert.bound: = bound_method %N.loc12_6.2, constants.%Convert.079 [symbolic = %Convert.bound (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.loc12_6.2) [symbolic = %int.convert_checked (constants.%int.convert_checked)] -// CHECK:STDOUT: -// CHECK:STDOUT: fn(%N.param_patt: %i32) { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: %k.var: ref = var k -// CHECK:STDOUT: %k: ref = bind_name k, %k.var -// CHECK:STDOUT: return -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: specific @G(constants.%N.3e4) { -// CHECK:STDOUT: %N.loc12_6.2 => constants.%N.3e4 -// CHECK:STDOUT: %N.patt.loc12_6.2 => constants.%N.3e4 -// CHECK:STDOUT: } -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/eval/symbolic.carbon b/toolchain/check/testdata/eval/symbolic.carbon index 32426a3ea166..bbaf173c7d90 100644 --- a/toolchain/check/testdata/eval/symbolic.carbon +++ b/toolchain/check/testdata/eval/symbolic.carbon @@ -15,6 +15,10 @@ fn F(T:! type) { var w: [T; 5]; } +fn G(N:! i32) { + var k: [i32; N]; +} + // CHECK:STDOUT: --- symbolic.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { @@ -29,12 +33,27 @@ fn F(T:! type) { // CHECK:STDOUT: %struct_type.a: type = struct_type {.a: %T} [symbolic] // CHECK:STDOUT: %require_complete.96f: = require_complete_type %struct_type.a [symbolic] // CHECK:STDOUT: %int_5: Core.IntLiteral = int_value 5 [template] -// CHECK:STDOUT: %array_type: type = array_type %int_5, %T [symbolic] -// CHECK:STDOUT: %require_complete.43b: = require_complete_type %array_type [symbolic] +// CHECK:STDOUT: %array_type.b78: type = array_type %int_5, %T [symbolic] +// CHECK:STDOUT: %require_complete.43b: = require_complete_type %array_type.b78 [symbolic] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] +// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] +// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] +// CHECK:STDOUT: %G.type: type = fn_type @G [template] +// CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] +// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] +// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] +// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] +// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] +// CHECK:STDOUT: %array_type.352: type = array_type %int.convert_checked, %i32 [symbolic] +// CHECK:STDOUT: %require_complete.70c: = require_complete_type %array_type.352 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .Int = %import_ref.187 +// CHECK:STDOUT: .ImplicitAs = %import_ref.a69 // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } @@ -44,6 +63,7 @@ fn F(T:! type) { // CHECK:STDOUT: package: = namespace [template] { // CHECK:STDOUT: .Core = imports.%Core // CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: .G = %G.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { @@ -53,6 +73,17 @@ fn F(T:! type) { // CHECK:STDOUT: %T.param: type = value_param runtime_param // CHECK:STDOUT: %T.loc12_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc12_6.2 (constants.%T)] // CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] { +// CHECK:STDOUT: %N.patt.loc18_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc18_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc18_6.1, runtime_param [symbolic = %N.patt.loc18_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param +// CHECK:STDOUT: %.loc18: type = splice_block %i32 [template = constants.%i32] { +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: %N.loc18_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc18_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @F(%T.loc12_6.1: type) { @@ -66,8 +97,8 @@ fn F(T:! type) { // CHECK:STDOUT: %require_complete.loc13: = require_complete_type @F.%tuple.type (%tuple.type.e07) [symbolic = %require_complete.loc13 (constants.%require_complete.21d)] // CHECK:STDOUT: %struct_type.a: type = struct_type {.a: @F.%T.loc12_6.2 (%T)} [symbolic = %struct_type.a (constants.%struct_type.a)] // CHECK:STDOUT: %require_complete.loc14: = require_complete_type @F.%struct_type.a (%struct_type.a) [symbolic = %require_complete.loc14 (constants.%require_complete.96f)] -// CHECK:STDOUT: %array_type: type = array_type constants.%int_5, @F.%T.loc12_6.2 (%T) [symbolic = %array_type (constants.%array_type)] -// CHECK:STDOUT: %require_complete.loc15: = require_complete_type @F.%array_type (%array_type) [symbolic = %require_complete.loc15 (constants.%require_complete.43b)] +// CHECK:STDOUT: %array_type: type = array_type constants.%int_5, @F.%T.loc12_6.2 (%T) [symbolic = %array_type (constants.%array_type.b78)] +// CHECK:STDOUT: %require_complete.loc15: = require_complete_type @F.%array_type (%array_type.b78) [symbolic = %require_complete.loc15 (constants.%require_complete.43b)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) { // CHECK:STDOUT: !entry: @@ -75,8 +106,27 @@ fn F(T:! type) { // CHECK:STDOUT: %u: ref @F.%tuple.type (%tuple.type.e07) = bind_name u, %u.var // CHECK:STDOUT: %v.var: ref @F.%struct_type.a (%struct_type.a) = var v // CHECK:STDOUT: %v: ref @F.%struct_type.a (%struct_type.a) = bind_name v, %v.var -// CHECK:STDOUT: %w.var: ref @F.%array_type (%array_type) = var w -// CHECK:STDOUT: %w: ref @F.%array_type (%array_type) = bind_name w, %w.var +// CHECK:STDOUT: %w.var: ref @F.%array_type (%array_type.b78) = var w +// CHECK:STDOUT: %w: ref @F.%array_type (%array_type.b78) = bind_name w, %w.var +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @G(%N.loc18_6.1: %i32) { +// CHECK:STDOUT: %N.loc18_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc18_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %N.patt.loc18_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc18_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Convert.bound: = bound_method %N.loc18_6.2, constants.%Convert.079 [symbolic = %Convert.bound (constants.%Convert.bound)] +// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn (constants.%Convert.specific_fn)] +// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.loc18_6.2) [symbolic = %int.convert_checked (constants.%int.convert_checked)] +// CHECK:STDOUT: %array_type: type = array_type %int.convert_checked, %i32 [symbolic = %array_type (constants.%array_type.352)] +// CHECK:STDOUT: %require_complete: = require_complete_type @G.%array_type (%array_type.352) [symbolic = %require_complete (constants.%require_complete.70c)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%N.param_patt: %i32) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %k.var: ref @G.%array_type (%array_type.352) = var k +// CHECK:STDOUT: %k: ref @G.%array_type (%array_type.352) = bind_name k, %k.var // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: } @@ -86,3 +136,8 @@ fn F(T:! type) { // CHECK:STDOUT: %T.patt.loc12_6.2 => constants.%T // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: specific @G(constants.%N.3e4) { +// CHECK:STDOUT: %N.loc18_6.2 => constants.%N.3e4 +// CHECK:STDOUT: %N.patt.loc18_6.2 => constants.%N.3e4 +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon b/toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon deleted file mode 100644 index 3c0fca96e979..000000000000 --- a/toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon +++ /dev/null @@ -1,96 +0,0 @@ -// Part of the Carbon Language project, under the Apache License v2.0 with LLVM -// Exceptions. See /LICENSE for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -// AUTOUPDATE -// TIP: To test this file alone, run: -// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon -// TIP: To dump output, run: -// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/function/generic/fail_todo_param_in_type.carbon - -// CHECK:STDERR: fail_todo_param_in_type.carbon:[[@LINE+3]]:24: error: semantics TODO: `symbolic array bound` [SemanticsTodo] -// CHECK:STDERR: fn F(N:! i32, a: [i32; N]*); -// CHECK:STDERR: ^ -fn F(N:! i32, a: [i32; N]*); - -// CHECK:STDOUT: --- fail_todo_param_in_type.carbon -// CHECK:STDOUT: -// CHECK:STDOUT: constants { -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] -// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] -// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] -// CHECK:STDOUT: %Convert.type.a9b: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template] -// CHECK:STDOUT: %impl_witness.dd3: = impl_witness (imports.%import_ref.a80), @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] -// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] -// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] -// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] -// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] -// CHECK:STDOUT: %F.type: type = fn_type @F [template] -// CHECK:STDOUT: %F: %F.type = struct_value () [template] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { -// CHECK:STDOUT: .Int = %import_ref.187 -// CHECK:STDOUT: .ImplicitAs = %import_ref.a69 -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [template] { -// CHECK:STDOUT: .Core = imports.%Core -// CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.import = import Core -// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { -// CHECK:STDOUT: %N.patt.loc14_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc14_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc14_6.1, runtime_param [symbolic = %N.patt.loc14_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %a.patt: = binding_pattern a -// CHECK:STDOUT: %a.param_patt: = value_param_pattern %a.patt, runtime_param0 -// CHECK:STDOUT: } { -// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param -// CHECK:STDOUT: %.loc14_10: type = splice_block %i32.loc14_10 [template = constants.%i32] { -// CHECK:STDOUT: %int_32.loc14_10: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32.loc14_10: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %N.loc14_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc14_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %a.param: = value_param runtime_param0 -// CHECK:STDOUT: %.loc14_26: type = splice_block %ptr [template = ] { -// CHECK:STDOUT: %int_32.loc14_19: Core.IntLiteral = int_value 32 [template = constants.%int_32] -// CHECK:STDOUT: %i32.loc14_19: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] -// CHECK:STDOUT: %N.ref: %i32 = name_ref N, %N.loc14_6.1 [symbolic = %N.loc14_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %impl.elem0: %Convert.type.a9b = impl_witness_access constants.%impl_witness.dd3, element0 [template = constants.%Convert.079] -// CHECK:STDOUT: %Convert.bound.loc14_24.1: = bound_method %N.ref, %impl.elem0 [symbolic = %Convert.bound.loc14_24.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc14_24.1: = specific_function %Convert.bound.loc14_24.1, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc14_24.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc14_24.1: init Core.IntLiteral = call %Convert.specific_fn.loc14_24.1(%N.ref) [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc14_24.1: Core.IntLiteral = value_of_initializer %int.convert_checked.loc14_24.1 [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %.loc14_24.2: Core.IntLiteral = converted %N.ref, %.loc14_24.1 [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: %array_type: type = array_type %.loc14_24.2, %i32 [template = ] -// CHECK:STDOUT: %ptr: type = ptr_type [template = ] -// CHECK:STDOUT: } -// CHECK:STDOUT: %a: = bind_name a, %a.param -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: generic fn @F(%N.loc14_6.1: %i32) { -// CHECK:STDOUT: %N.loc14_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc14_6.2 (constants.%N.3e4)] -// CHECK:STDOUT: %N.patt.loc14_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc14_6.2 (constants.%N.patt.52a)] -// CHECK:STDOUT: %Convert.bound.loc14_24.2: = bound_method %N.loc14_6.2, constants.%Convert.079 [symbolic = %Convert.bound.loc14_24.2 (constants.%Convert.bound)] -// CHECK:STDOUT: %Convert.specific_fn.loc14_24.2: = specific_function %Convert.bound.loc14_24.2, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc14_24.2 (constants.%Convert.specific_fn)] -// CHECK:STDOUT: %int.convert_checked.loc14_24.2: init Core.IntLiteral = call %Convert.specific_fn.loc14_24.2(%N.loc14_6.2) [symbolic = %int.convert_checked.loc14_24.2 (constants.%int.convert_checked)] -// CHECK:STDOUT: -// CHECK:STDOUT: fn(%N.param_patt: %i32, %a.param_patt: ); -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: specific @F(constants.%N.3e4) { -// CHECK:STDOUT: %N.loc14_6.2 => constants.%N.3e4 -// CHECK:STDOUT: %N.patt.loc14_6.2 => constants.%N.3e4 -// CHECK:STDOUT: %Convert.bound.loc14_24.2 => constants.%Convert.bound -// CHECK:STDOUT: %Convert.specific_fn.loc14_24.2 => constants.%Convert.specific_fn -// CHECK:STDOUT: %int.convert_checked.loc14_24.2 => constants.%int.convert_checked -// CHECK:STDOUT: } -// CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/generic/param_in_type.carbon b/toolchain/check/testdata/function/generic/param_in_type.carbon new file mode 100644 index 000000000000..c840ab3a21bf --- /dev/null +++ b/toolchain/check/testdata/function/generic/param_in_type.carbon @@ -0,0 +1,99 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// TIP: To test this file alone, run: +// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/function/generic/param_in_type.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/function/generic/param_in_type.carbon + +fn F(N:! i32, a: [i32; N]*); + +// CHECK:STDOUT: --- param_in_type.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] +// CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [template] +// CHECK:STDOUT: %N.3e4: %i32 = bind_symbolic_name N, 0 [symbolic] +// CHECK:STDOUT: %N.patt.52a: %i32 = symbolic_binding_pattern N, 0 [symbolic] +// CHECK:STDOUT: %Convert.type.a9b: type = fn_type @Convert.1, @ImplicitAs(Core.IntLiteral) [template] +// CHECK:STDOUT: %impl_witness.dd3: = impl_witness (imports.%import_ref.a80), @impl.2(%int_32) [template] +// CHECK:STDOUT: %Convert.type.d18: type = fn_type @Convert.3, @impl.2(%int_32) [template] +// CHECK:STDOUT: %Convert.079: %Convert.type.d18 = struct_value () [template] +// CHECK:STDOUT: %Convert.bound: = bound_method %N.3e4, %Convert.079 [symbolic] +// CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.3(%int_32) [symbolic] +// CHECK:STDOUT: %int.convert_checked: init Core.IntLiteral = call %Convert.specific_fn(%N.3e4) [symbolic] +// CHECK:STDOUT: %array_type: type = array_type %int.convert_checked, %i32 [symbolic] +// CHECK:STDOUT: %ptr: type = ptr_type %array_type [symbolic] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: imports { +// CHECK:STDOUT: %Core: = namespace file.%Core.import, [template] { +// CHECK:STDOUT: .Int = %import_ref.187 +// CHECK:STDOUT: .ImplicitAs = %import_ref.a69 +// CHECK:STDOUT: import Core//prelude +// CHECK:STDOUT: import Core//prelude/... +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: file { +// CHECK:STDOUT: package: = namespace [template] { +// CHECK:STDOUT: .Core = imports.%Core +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %N.patt.loc11_6.1: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc11_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %N.param_patt: %i32 = value_param_pattern %N.patt.loc11_6.1, runtime_param [symbolic = %N.patt.loc11_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %a.patt: @F.%ptr.loc11_26.2 (%ptr) = binding_pattern a +// CHECK:STDOUT: %a.param_patt: @F.%ptr.loc11_26.2 (%ptr) = value_param_pattern %a.patt, runtime_param0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %N.param: %i32 = value_param runtime_param +// CHECK:STDOUT: %.loc11_10: type = splice_block %i32.loc11_10 [template = constants.%i32] { +// CHECK:STDOUT: %int_32.loc11_10: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32.loc11_10: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: } +// CHECK:STDOUT: %N.loc11_6.1: %i32 = bind_symbolic_name N, 0, %N.param [symbolic = %N.loc11_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %a.param: @F.%ptr.loc11_26.2 (%ptr) = value_param runtime_param0 +// CHECK:STDOUT: %.loc11_26: type = splice_block %ptr.loc11_26.1 [symbolic = %ptr.loc11_26.2 (constants.%ptr)] { +// CHECK:STDOUT: %int_32.loc11_19: Core.IntLiteral = int_value 32 [template = constants.%int_32] +// CHECK:STDOUT: %i32.loc11_19: type = class_type @Int, @Int(constants.%int_32) [template = constants.%i32] +// CHECK:STDOUT: %N.ref: %i32 = name_ref N, %N.loc11_6.1 [symbolic = %N.loc11_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %impl.elem0: %Convert.type.a9b = impl_witness_access constants.%impl_witness.dd3, element0 [template = constants.%Convert.079] +// CHECK:STDOUT: %Convert.bound.loc11_24.1: = bound_method %N.ref, %impl.elem0 [symbolic = %Convert.bound.loc11_24.2 (constants.%Convert.bound)] +// CHECK:STDOUT: %Convert.specific_fn.loc11_24.1: = specific_function %Convert.bound.loc11_24.1, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc11_24.2 (constants.%Convert.specific_fn)] +// CHECK:STDOUT: %int.convert_checked.loc11_24.1: init Core.IntLiteral = call %Convert.specific_fn.loc11_24.1(%N.ref) [symbolic = %int.convert_checked.loc11_24.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc11_24.1: Core.IntLiteral = value_of_initializer %int.convert_checked.loc11_24.1 [symbolic = %int.convert_checked.loc11_24.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %.loc11_24.2: Core.IntLiteral = converted %N.ref, %.loc11_24.1 [symbolic = %int.convert_checked.loc11_24.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %array_type.loc11_25.1: type = array_type %.loc11_24.2, %i32 [symbolic = %array_type.loc11_25.2 (constants.%array_type)] +// CHECK:STDOUT: %ptr.loc11_26.1: type = ptr_type %array_type [symbolic = %ptr.loc11_26.2 (constants.%ptr)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %a: @F.%ptr.loc11_26.2 (%ptr) = bind_name a, %a.param +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F(%N.loc11_6.1: %i32) { +// CHECK:STDOUT: %N.loc11_6.2: %i32 = bind_symbolic_name N, 0 [symbolic = %N.loc11_6.2 (constants.%N.3e4)] +// CHECK:STDOUT: %N.patt.loc11_6.2: %i32 = symbolic_binding_pattern N, 0 [symbolic = %N.patt.loc11_6.2 (constants.%N.patt.52a)] +// CHECK:STDOUT: %Convert.bound.loc11_24.2: = bound_method %N.loc11_6.2, constants.%Convert.079 [symbolic = %Convert.bound.loc11_24.2 (constants.%Convert.bound)] +// CHECK:STDOUT: %Convert.specific_fn.loc11_24.2: = specific_function %Convert.bound.loc11_24.2, @Convert.3(constants.%int_32) [symbolic = %Convert.specific_fn.loc11_24.2 (constants.%Convert.specific_fn)] +// CHECK:STDOUT: %int.convert_checked.loc11_24.2: init Core.IntLiteral = call %Convert.specific_fn.loc11_24.2(%N.loc11_6.2) [symbolic = %int.convert_checked.loc11_24.2 (constants.%int.convert_checked)] +// CHECK:STDOUT: %array_type.loc11_25.2: type = array_type %int.convert_checked.loc11_24.2, %i32 [symbolic = %array_type.loc11_25.2 (constants.%array_type)] +// CHECK:STDOUT: %ptr.loc11_26.2: type = ptr_type @F.%array_type.loc11_25.2 (%array_type) [symbolic = %ptr.loc11_26.2 (constants.%ptr)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%N.param_patt: %i32, %a.param_patt: @F.%ptr.loc11_26.2 (%ptr)); +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%N.3e4) { +// CHECK:STDOUT: %N.loc11_6.2 => constants.%N.3e4 +// CHECK:STDOUT: %N.patt.loc11_6.2 => constants.%N.3e4 +// CHECK:STDOUT: %Convert.bound.loc11_24.2 => constants.%Convert.bound +// CHECK:STDOUT: %Convert.specific_fn.loc11_24.2 => constants.%Convert.specific_fn +// CHECK:STDOUT: %int.convert_checked.loc11_24.2 => constants.%int.convert_checked +// CHECK:STDOUT: %array_type.loc11_25.2 => constants.%array_type +// CHECK:STDOUT: %ptr.loc11_26.2 => constants.%ptr +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/diagnostics/diagnostic_kind.def b/toolchain/diagnostics/diagnostic_kind.def index 358cc75b0e09..be2bf5657e2b 100644 --- a/toolchain/diagnostics/diagnostic_kind.def +++ b/toolchain/diagnostics/diagnostic_kind.def @@ -300,6 +300,7 @@ CARBON_DIAGNOSTIC_KIND(ArrayBoundNegative) CARBON_DIAGNOSTIC_KIND(ArrayIndexOutOfBounds) CARBON_DIAGNOSTIC_KIND(ArrayInitFromLiteralArgCountMismatch) CARBON_DIAGNOSTIC_KIND(ArrayInitFromExprArgCountMismatch) +CARBON_DIAGNOSTIC_KIND(ArrayInitDependentBound) CARBON_DIAGNOSTIC_KIND(ArrowOperatorOfNonPointer) CARBON_DIAGNOSTIC_KIND(AssignmentToNonAssignable) CARBON_DIAGNOSTIC_KIND(BreakOutsideLoop) diff --git a/toolchain/lower/file_context.cpp b/toolchain/lower/file_context.cpp index 5595b72075f4..f6b409a5d9ff 100644 --- a/toolchain/lower/file_context.cpp +++ b/toolchain/lower/file_context.cpp @@ -452,7 +452,7 @@ static auto BuildTypeForInst(FileContext& context, SemIR::ArrayType inst) -> llvm::Type* { return llvm::ArrayType::get( context.GetType(inst.element_type_id), - context.sem_ir().GetArrayBoundValue(inst.bound_id)); + *context.sem_ir().GetArrayBoundValue(inst.bound_id)); } static auto BuildTypeForInst(FileContext& /*context*/, SemIR::AutoType inst) diff --git a/toolchain/sem_ir/file.h b/toolchain/sem_ir/file.h index 8446737720f9..c58be1a63f4e 100644 --- a/toolchain/sem_ir/file.h +++ b/toolchain/sem_ir/file.h @@ -79,8 +79,12 @@ class File : public Printable { -> void; // Returns array bound value from the bound instruction. - auto GetArrayBoundValue(InstId bound_id) const -> uint64_t { - return ints().Get(insts().GetAs(bound_id).int_id).getZExtValue(); + auto GetArrayBoundValue(InstId bound_id) const -> std::optional { + if (auto bound = insts().TryGetAs( + constant_values().GetConstantInstId(bound_id))) { + return ints().Get(bound->int_id).getZExtValue(); + } + return std::nullopt; } // Gets the pointee type of the given type, which must be a pointer type. diff --git a/toolchain/sem_ir/stringify_type.cpp b/toolchain/sem_ir/stringify_type.cpp index 77afc5a69fbe..4d7ea2ba79f1 100644 --- a/toolchain/sem_ir/stringify_type.cpp +++ b/toolchain/sem_ir/stringify_type.cpp @@ -37,7 +37,6 @@ class StepStack { enum Kind : uint8_t { Inst, FixedString, - ArrayBound, Name, }; @@ -48,8 +47,6 @@ class StepStack { InstId inst_id; // The fixed string to print, when kind is FixedString. const char* fixed_string; - // The array bound to print, when kind is ArrayBound. - InstId bound_id; // The name to print, when kind is Name. NameId name_id; }; @@ -69,9 +66,6 @@ class StepStack { auto PushString(const char* string) -> void { steps_.push_back({.kind = Step::FixedString, .fixed_string = string}); } - auto PushArrayBound(InstId bound_id) -> void { - steps_.push_back({.kind = Step::ArrayBound, .bound_id = bound_id}); - } auto PushNameId(NameId name_id) -> void { steps_.push_back({.kind = Step::Name, .name_id = name_id}); } @@ -167,9 +161,6 @@ auto StringifyTypeExpr(const SemIR::File& sem_ir, InstId outer_inst_id) case StepStack::Step::FixedString: out << step.fixed_string; continue; - case StepStack::Step::ArrayBound: - out << sem_ir.GetArrayBoundValue(step.bound_id); - continue; case StepStack::Step::Name: out << sem_ir.names().GetFormatted(step.name_id); continue; @@ -202,7 +193,7 @@ auto StringifyTypeExpr(const SemIR::File& sem_ir, InstId outer_inst_id) case CARBON_KIND(ArrayType inst): { out << "["; step_stack.PushString("]"); - step_stack.PushArrayBound(inst.bound_id); + step_stack.PushInstId(inst.bound_id); step_stack.PushString("; "); step_stack.PushTypeId(inst.element_type_id); break;