diff --git a/toolchain/check/generic.cpp b/toolchain/check/generic.cpp index b778026948e9..f64e0f2db1c0 100644 --- a/toolchain/check/generic.cpp +++ b/toolchain/check/generic.cpp @@ -412,9 +412,6 @@ auto StartGenericDefinition(Context& context, SemIR::GenericId generic_id) auto DiscardGenericDecl(Context& context) -> void { // Unattach any types and constant values we might have created in the // generic. - // TODO: We should re-evaluate the contents of the eval block in a synthesized - // specific to form these values, in order to propagate the values of local - // `let :!` bindings. for (auto inst_id : context.generic_region_stack().PeekDependentInsts()) { // Note that `Get` returns an instruction with an unattached type. context.sem_ir().insts().Set(inst_id, context.insts().Get(inst_id)); diff --git a/toolchain/check/handle_binding_pattern.cpp b/toolchain/check/handle_binding_pattern.cpp index f21c5cab87f8..4f4630e5eba6 100644 --- a/toolchain/check/handle_binding_pattern.cpp +++ b/toolchain/check/handle_binding_pattern.cpp @@ -28,6 +28,78 @@ auto HandleParseNode(Context& context, Parse::UnderscoreNameId node_id) return true; } +// Returns the `InstKind` corresponding to the pattern's `NodeKind`. +static auto GetPatternInstKind(Parse::NodeKind node_kind, bool is_ref) + -> SemIR::InstKind { + switch (node_kind) { + case Parse::NodeKind::CompileTimeBindingPattern: + return SemIR::InstKind::SymbolicBindingPattern; + case Parse::NodeKind::LetBindingPattern: + return is_ref ? SemIR::InstKind::RefBindingPattern + : SemIR::InstKind::ValueBindingPattern; + case Parse::NodeKind::VarBindingPattern: + return SemIR::InstKind::RefBindingPattern; + default: + CARBON_FATAL("Unexpected node kind: {0}", node_kind); + } +} + +// Returns true if a parameter is valid in the given `introducer_kind`. +static auto IsValidParamForIntroducer(Context& context, Parse::NodeId node_id, + SemIR::NameId name_id, + Lex::TokenKind introducer_kind, + bool is_generic) -> bool { + switch (introducer_kind) { + case Lex::TokenKind::Fn: { + if (context.full_pattern_stack().CurrentKind() == + FullPatternStack::Kind::ImplicitParamList && + !(is_generic || name_id == SemIR::NameId::SelfValue)) { + CARBON_DIAGNOSTIC( + ImplictParamMustBeConstant, Error, + "implicit parameters of functions must be constant or `self`"); + context.emitter().Emit(node_id, ImplictParamMustBeConstant); + return false; + } + // Parameters can have incomplete types in a function declaration, but not + // in a function definition. We don't know which kind we have here, so + // don't validate it. + return true; + } + case Lex::TokenKind::Choice: + if (context.scope_stack().PeekInstId().has_value()) { + // We are building a pattern for a choice alternative, not the + // choice type itself. + + // Implicit param lists are prevented during parse. + CARBON_CHECK(context.full_pattern_stack().CurrentKind() != + FullPatternStack::Kind::ImplicitParamList, + "choice alternative with implicit parameters"); + // Don't fall through to the `Class` logic for choice alternatives. + return true; + } + [[fallthrough]]; + case Lex::TokenKind::Class: + case Lex::TokenKind::Impl: + case Lex::TokenKind::Interface: { + if (name_id == SemIR::NameId::SelfValue) { + CARBON_DIAGNOSTIC(SelfParameterNotAllowed, Error, + "`self` parameter only allowed on functions"); + context.emitter().Emit(node_id, SelfParameterNotAllowed); + return false; + } + if (!is_generic) { + CARBON_DIAGNOSTIC(GenericParamMustBeConstant, Error, + "parameters of generic types must be constant"); + context.emitter().Emit(node_id, GenericParamMustBeConstant); + return false; + } + return true; + } + default: + return true; + } +} + // TODO: make this function shorter by factoring pieces out. static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id, Parse::NodeKind node_kind) -> bool { @@ -52,24 +124,7 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id, context.node_stack() .PopAndDiscardSoloNodeIdIf(); - SemIR::InstKind pattern_inst_kind; - switch (node_kind) { - case Parse::NodeKind::CompileTimeBindingPattern: - pattern_inst_kind = SemIR::InstKind::SymbolicBindingPattern; - break; - case Parse::NodeKind::LetBindingPattern: - if (is_ref) { - pattern_inst_kind = SemIR::InstKind::RefBindingPattern; - } else { - pattern_inst_kind = SemIR::InstKind::ValueBindingPattern; - } - break; - case Parse::NodeKind::VarBindingPattern: - pattern_inst_kind = SemIR::InstKind::RefBindingPattern; - break; - default: - CARBON_FATAL("Unexpected node kind: {0}", node_kind); - } + SemIR::InstKind pattern_inst_kind = GetPatternInstKind(node_kind, is_ref); auto [name_node, name_id] = context.node_stack().PopNameWithNodeId(); @@ -112,88 +167,51 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id, context.emitter().Emit(node_id, SelfOutsideImplicitParamList); } + if (node_kind == Parse::NodeKind::CompileTimeBindingPattern && + introducer.kind == Lex::TokenKind::Let) { + // TODO: We should re-evaluate the contents of the eval block in a + // synthesized specific to form these values, in order to propagate the + // values. + return context.TODO(node_id, + "local `let :!` bindings are currently unsupported"); + } + // Allocate an instruction of the appropriate kind, linked to the name for // error locations. switch (context.full_pattern_stack().CurrentKind()) { case FullPatternStack::Kind::ImplicitParamList: case FullPatternStack::Kind::ExplicitParamList: { - // Parameters can have incomplete types in a function declaration, but not - // in a function definition. We don't know which kind we have here. - bool had_error = false; - switch (introducer.kind) { - case Lex::TokenKind::Fn: { - if (context.full_pattern_stack().CurrentKind() == - FullPatternStack::Kind::ImplicitParamList && - !(is_generic || name_id == SemIR::NameId::SelfValue)) { - CARBON_DIAGNOSTIC( - ImplictParamMustBeConstant, Error, - "implicit parameters of functions must be constant or `self`"); - context.emitter().Emit(node_id, ImplictParamMustBeConstant); - had_error = true; - } - break; - } - case Lex::TokenKind::Choice: - if (context.scope_stack().PeekInstId().has_value()) { - // We are building a pattern for a choice alternative, not the - // choice type itself. - - // Implicit param lists are prevented during parse. - CARBON_CHECK(context.full_pattern_stack().CurrentKind() != - FullPatternStack::Kind::ImplicitParamList, - "choice alternative with implicit parameters"); - // Don't fall through to the `Class` logic for choice alternatives. - break; - } - [[fallthrough]]; - case Lex::TokenKind::Class: - case Lex::TokenKind::Impl: - case Lex::TokenKind::Interface: { - if (name_id == SemIR::NameId::SelfValue) { - CARBON_DIAGNOSTIC(SelfParameterNotAllowed, Error, - "`self` parameter only allowed on functions"); - context.emitter().Emit(node_id, SelfParameterNotAllowed); - had_error = true; - } else if (!is_generic) { - CARBON_DIAGNOSTIC(GenericParamMustBeConstant, Error, - "parameters of generic types must be constant"); - context.emitter().Emit(node_id, GenericParamMustBeConstant); - had_error = true; - } - break; - } - default: - break; - } - auto result_inst_id = SemIR::InstId::None; - if (had_error) { + if (!IsValidParamForIntroducer(context, node_id, name_id, introducer.kind, + is_generic)) { if (name_id != SemIR::NameId::Underscore) { AddNameToLookup(context, name_id, SemIR::ErrorInst::InstId); } // Replace the parameter with `ErrorInst` so that we don't try // constructing a generic based on it. - result_inst_id = SemIR::ErrorInst::InstId; - } else { - result_inst_id = make_binding_pattern(); + context.node_stack().Push(node_id, SemIR::ErrorInst::InstId); + break; + } - // A binding pattern in a function signature is a `Call` parameter - // unless it's nested inside a `var` pattern (because then the - // enclosing `var` pattern is), or it's a compile-time binding pattern - // (because then it's not passed to the `Call` inst). - if (node_kind == Parse::NodeKind::LetBindingPattern) { - if (is_ref) { - result_inst_id = AddPatternInst( - context, node_id, - {.type_id = context.insts().Get(result_inst_id).type_id(), - .subpattern_id = result_inst_id, - .index = SemIR::CallParamIndex::None}); - } else { - result_inst_id = AddPatternInst( - context, node_id, - {.type_id = context.insts().Get(result_inst_id).type_id(), - .subpattern_id = result_inst_id, - .index = SemIR::CallParamIndex::None}); - } + auto result_inst_id = make_binding_pattern(); + + // A binding pattern in a function signature is a `Call` parameter + // unless it's nested inside a `var` pattern (because then the + // enclosing `var` pattern is), or it's a compile-time binding pattern + // (because then it's not passed to the `Call` inst). + if (node_kind == Parse::NodeKind::LetBindingPattern) { + auto type_id = context.insts().GetAttachedType(result_inst_id); + if (is_ref) { + result_inst_id = AddPatternInst( + context, node_id, + {.type_id = type_id, + .subpattern_id = result_inst_id, + .index = SemIR::CallParamIndex::None}); + } else { + result_inst_id = AddPatternInst( + context, node_id, + {.type_id = type_id, + .subpattern_id = result_inst_id, + .index = SemIR::CallParamIndex::None}); } } context.node_stack().Push(node_id, result_inst_id); diff --git a/toolchain/check/testdata/deduce/value_with_type_through_access.carbon b/toolchain/check/testdata/deduce/value_with_type_through_access.carbon index b3a4cc0272f1..224aba25681b 100644 --- a/toolchain/check/testdata/deduce/value_with_type_through_access.carbon +++ b/toolchain/check/testdata/deduce/value_with_type_through_access.carbon @@ -69,11 +69,21 @@ fn F[T:! Class](x: HoldsType(T), a: T.t) {} class C {} -fn G() { - let c:! Class = {.t = C} as Class; +fn G(c:! Class) { F({} as HoldsType(c), {}); } +fn H() { + // CHECK:STDERR: fail_todo_class_access.carbon:[[@LINE+7]]:3: error: argument for generic parameter is not a compile-time constant [CompTimeArgumentNotConstant] + // CHECK:STDERR: G({.t = C}); + // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: fail_todo_class_access.carbon:[[@LINE-8]]:6: note: initializing generic parameter `c` declared here [InitializingGenericParam] + // CHECK:STDERR: fn G(c:! Class) { + // CHECK:STDERR: ^ + // CHECK:STDERR: + G({.t = C}); +} + // --- fail_todo_array_index.carbon library "[[@TEST_NAME]]"; @@ -542,21 +552,12 @@ fn G() { // CHECK:STDOUT: %F: %F.type = struct_value () [concrete] // CHECK:STDOUT: %require_complete.52328d.1: = require_complete_type %HoldsType.68ad07.1 [symbolic] // CHECK:STDOUT: %C: type = class_type @C [concrete] +// CHECK:STDOUT: %c: %Class = symbolic_binding c, 0 [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [concrete] // CHECK:STDOUT: %G: %G.type = struct_value () [concrete] -// CHECK:STDOUT: %c: %Class = symbolic_binding c, 0 [symbolic] -// CHECK:STDOUT: %struct: %struct_type.t = struct_value (%C) [concrete] -// CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] -// CHECK:STDOUT: %Copy.Op.type: type = fn_type @Copy.Op [concrete] -// CHECK:STDOUT: %Copy.impl_witness.de9: = impl_witness imports.%Copy.impl_witness_table.40f [concrete] -// CHECK:STDOUT: %Copy.facet: %Copy.type = facet_value type, (%Copy.impl_witness.de9) [concrete] -// CHECK:STDOUT: %.98f: type = fn_type_with_self_type %Copy.Op.type, %Copy.facet [concrete] -// CHECK:STDOUT: %type.as.Copy.impl.Op.type: type = fn_type @type.as.Copy.impl.Op [concrete] -// CHECK:STDOUT: %type.as.Copy.impl.Op: %type.as.Copy.impl.Op.type = struct_value () [concrete] -// CHECK:STDOUT: %type.as.Copy.impl.Op.bound: = bound_method %C, %type.as.Copy.impl.Op [concrete] -// CHECK:STDOUT: %Class.val: %Class = struct_value (%C) [concrete] // CHECK:STDOUT: %empty_struct: %empty_struct_type = struct_value () [concrete] // CHECK:STDOUT: %HoldsType.68ad07.2: type = class_type @HoldsType, @HoldsType(%c) [symbolic] +// CHECK:STDOUT: %require_complete.52328d.2: = require_complete_type %HoldsType.68ad07.2 [symbolic] // CHECK:STDOUT: %HoldsType.val: %HoldsType.68ad07.2 = struct_value () [symbolic] // CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] // CHECK:STDOUT: %Destroy.Op.type: type = fn_type @Destroy.Op [concrete] @@ -568,9 +569,22 @@ fn G() { // CHECK:STDOUT: %Destroy.impl_witness.4dc: = impl_witness imports.%Destroy.impl_witness_table, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.16e) [symbolic] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.c84: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.16e) [symbolic] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.eb8: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.c84 = struct_value () [symbolic] +// CHECK:STDOUT: %.eeb: require_specific_def_type = require_specific_def @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.16e) [symbolic] // CHECK:STDOUT: %Destroy.facet.b08: %Destroy.type = facet_value %HoldsType.68ad07.2, (%Destroy.impl_witness.4dc) [symbolic] // CHECK:STDOUT: %.bcb: type = fn_type_with_self_type %Destroy.Op.type, %Destroy.facet.b08 [symbolic] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.358: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.eb8, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value.16e) [symbolic] +// CHECK:STDOUT: %H.type: type = fn_type @H [concrete] +// CHECK:STDOUT: %H: %H.type = struct_value () [concrete] +// CHECK:STDOUT: %struct: %struct_type.t = struct_value (%C) [concrete] +// CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] +// CHECK:STDOUT: %Copy.Op.type: type = fn_type @Copy.Op [concrete] +// CHECK:STDOUT: %Copy.impl_witness.de9: = impl_witness imports.%Copy.impl_witness_table.40f [concrete] +// CHECK:STDOUT: %Copy.facet: %Copy.type = facet_value type, (%Copy.impl_witness.de9) [concrete] +// CHECK:STDOUT: %.98f: type = fn_type_with_self_type %Copy.Op.type, %Copy.facet [concrete] +// CHECK:STDOUT: %type.as.Copy.impl.Op.type: type = fn_type @type.as.Copy.impl.Op [concrete] +// CHECK:STDOUT: %type.as.Copy.impl.Op: %type.as.Copy.impl.Op.type = struct_value () [concrete] +// CHECK:STDOUT: %type.as.Copy.impl.Op.bound: = bound_method %C, %type.as.Copy.impl.Op [concrete] +// CHECK:STDOUT: %Class.val: %Class = struct_value (%C) [concrete] // CHECK:STDOUT: %facet_value.d3d: %type_where = facet_value %Class, () [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.33d: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.d3d) [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.45a: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.33d = struct_value () [concrete] @@ -579,17 +593,17 @@ fn G() { // CHECK:STDOUT: // CHECK:STDOUT: imports { // CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .Copy = %Core.Copy // CHECK:STDOUT: .Destroy = %Core.Destroy +// CHECK:STDOUT: .Copy = %Core.Copy // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } -// CHECK:STDOUT: %Core.Copy: type = import_ref Core//prelude/parts/copy, Copy, loaded [concrete = constants.%Copy.type] -// CHECK:STDOUT: %Core.import_ref.f97: %type.as.Copy.impl.Op.type = import_ref Core//prelude/parts/copy, loc{{\d+_\d+}}, loaded [concrete = constants.%type.as.Copy.impl.Op] -// CHECK:STDOUT: %Copy.impl_witness_table.40f = impl_witness_table (%Core.import_ref.f97), @type.as.Copy.impl [concrete] // CHECK:STDOUT: %Core.Destroy: type = import_ref Core//prelude/parts/destroy, Destroy, loaded [concrete = constants.%Destroy.type] // CHECK:STDOUT: %Core.import_ref.de0: @DestroyT.binding.as_type.as.Destroy.impl.%DestroyT.binding.as_type.as.Destroy.impl.Op.type (%DestroyT.binding.as_type.as.Destroy.impl.Op.type.0bf) = import_ref Core//prelude/parts/destroy, loc{{\d+_\d+}}, loaded [symbolic = @DestroyT.binding.as_type.as.Destroy.impl.%DestroyT.binding.as_type.as.Destroy.impl.Op (constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.97a)] // CHECK:STDOUT: %Destroy.impl_witness_table = impl_witness_table (%Core.import_ref.de0), @DestroyT.binding.as_type.as.Destroy.impl [concrete] +// CHECK:STDOUT: %Core.Copy: type = import_ref Core//prelude/parts/copy, Copy, loaded [concrete = constants.%Copy.type] +// CHECK:STDOUT: %Core.import_ref.f97: %type.as.Copy.impl.Op.type = import_ref Core//prelude/parts/copy, loc{{\d+_\d+}}, loaded [concrete = constants.%type.as.Copy.impl.Op] +// CHECK:STDOUT: %Copy.impl_witness_table.40f = impl_witness_table (%Core.import_ref.f97), @type.as.Copy.impl [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -600,6 +614,7 @@ fn G() { // CHECK:STDOUT: .F = %F.decl // CHECK:STDOUT: .C = %C.decl // CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: .H = %H.decl // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %Class.decl: type = class_decl @Class [concrete = constants.%Class] {} {} @@ -641,7 +656,16 @@ fn G() { // CHECK:STDOUT: %a: = value_binding a, %a.param // CHECK:STDOUT: } // CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} -// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [concrete = constants.%G] {} {} +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [concrete = constants.%G] { +// CHECK:STDOUT: %c.patt: %pattern_type.761 = symbolic_binding_pattern c, 0 [concrete] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %.loc25: type = splice_block %Class.ref [concrete = constants.%Class] { +// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] +// CHECK:STDOUT: %Class.ref: type = name_ref Class, file.%Class.decl [concrete = constants.%Class] +// CHECK:STDOUT: } +// CHECK:STDOUT: %c.loc25_6.2: %Class = symbolic_binding c, 0 [symbolic = %c.loc25_6.1 (constants.%c)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %H.decl: %H.type = fn_decl @H [concrete = constants.%H] {} {} // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @Class { @@ -691,48 +715,62 @@ fn G() { // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @G() { +// CHECK:STDOUT: generic fn @G(%c.loc25_6.2: %Class) { +// CHECK:STDOUT: %c.loc25_6.1: %Class = symbolic_binding c, 0 [symbolic = %c.loc25_6.1 (constants.%c)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %HoldsType.loc26_22.2: type = class_type @HoldsType, @HoldsType(%c.loc25_6.1) [symbolic = %HoldsType.loc26_22.2 (constants.%HoldsType.68ad07.2)] +// CHECK:STDOUT: %require_complete: = require_complete_type %HoldsType.loc26_22.2 [symbolic = %require_complete (constants.%require_complete.52328d.2)] +// CHECK:STDOUT: %HoldsType.val: @G.%HoldsType.loc26_22.2 (%HoldsType.68ad07.2) = struct_value () [symbolic = %HoldsType.val (constants.%HoldsType.val)] +// CHECK:STDOUT: %facet_value: %type_where = facet_value %HoldsType.loc26_22.2, () [symbolic = %facet_value (constants.%facet_value.16e)] +// CHECK:STDOUT: %.loc26_6.5: require_specific_def_type = require_specific_def @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [symbolic = %.loc26_6.5 (constants.%.eeb)] +// CHECK:STDOUT: %Destroy.impl_witness: = impl_witness imports.%Destroy.impl_witness_table, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [symbolic = %Destroy.impl_witness (constants.%Destroy.impl_witness.4dc)] +// CHECK:STDOUT: %Destroy.facet: %Destroy.type = facet_value %HoldsType.loc26_22.2, (%Destroy.impl_witness) [symbolic = %Destroy.facet (constants.%Destroy.facet.b08)] +// CHECK:STDOUT: %.loc26_6.6: type = fn_type_with_self_type constants.%Destroy.Op.type, %Destroy.facet [symbolic = %.loc26_6.6 (constants.%.bcb)] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [symbolic = %DestroyT.binding.as_type.as.Destroy.impl.Op.type (constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.type.c84)] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op: @G.%DestroyT.binding.as_type.as.Destroy.impl.Op.type (%DestroyT.binding.as_type.as.Destroy.impl.Op.type.c84) = struct_value () [symbolic = %DestroyT.binding.as_type.as.Destroy.impl.Op (constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.eb8)] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value) [symbolic = %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn (constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.358)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] +// CHECK:STDOUT: %.loc26_6.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %HoldsType.ref: %HoldsType.type = name_ref HoldsType, file.%HoldsType.decl [concrete = constants.%HoldsType.generic] +// CHECK:STDOUT: %c.ref: %Class = name_ref c, %c.loc25_6.2 [symbolic = %c.loc25_6.1 (constants.%c)] +// CHECK:STDOUT: %HoldsType.loc26_22.1: type = class_type @HoldsType, @HoldsType(constants.%c) [symbolic = %HoldsType.loc26_22.2 (constants.%HoldsType.68ad07.2)] +// CHECK:STDOUT: %.loc26_6.2: ref @G.%HoldsType.loc26_22.2 (%HoldsType.68ad07.2) = temporary_storage +// CHECK:STDOUT: %.loc26_6.3: init @G.%HoldsType.loc26_22.2 (%HoldsType.68ad07.2) = class_init (), %.loc26_6.2 [symbolic = %HoldsType.val (constants.%HoldsType.val)] +// CHECK:STDOUT: %.loc26_6.4: ref @G.%HoldsType.loc26_22.2 (%HoldsType.68ad07.2) = temporary %.loc26_6.2, %.loc26_6.3 +// CHECK:STDOUT: %.loc26_8: ref @G.%HoldsType.loc26_22.2 (%HoldsType.68ad07.2) = converted %.loc26_6.1, %.loc26_6.4 +// CHECK:STDOUT: %.loc26_26: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] +// CHECK:STDOUT: %impl.elem0: @G.%.loc26_6.6 (%.bcb) = impl_witness_access constants.%Destroy.impl_witness.4dc, element0 [symbolic = %DestroyT.binding.as_type.as.Destroy.impl.Op (constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.eb8)] +// CHECK:STDOUT: %bound_method.loc26_6.1: = bound_method %.loc26_6.4, %impl.elem0 +// CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.16e) [symbolic = %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn (constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.358)] +// CHECK:STDOUT: %bound_method.loc26_6.2: = bound_method %.loc26_6.4, %specific_fn +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc26_6.2(%.loc26_6.4) +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @H() { // CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %c.patt: %pattern_type.761 = symbolic_binding_pattern c, 0 [concrete] -// CHECK:STDOUT: } +// CHECK:STDOUT: %G.ref: %G.type = name_ref G, file.%G.decl [concrete = constants.%G] // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [concrete = constants.%C] -// CHECK:STDOUT: %.loc26_26.1: %struct_type.t = struct_literal (%C.ref) [concrete = constants.%struct] -// CHECK:STDOUT: %Class.ref.loc26_31: type = name_ref Class, file.%Class.decl [concrete = constants.%Class] -// CHECK:STDOUT: %impl.elem0.loc26: %.98f = impl_witness_access constants.%Copy.impl_witness.de9, element0 [concrete = constants.%type.as.Copy.impl.Op] -// CHECK:STDOUT: %bound_method.loc26_25: = bound_method %C.ref, %impl.elem0.loc26 [concrete = constants.%type.as.Copy.impl.Op.bound] -// CHECK:STDOUT: %type.as.Copy.impl.Op.call: init type = call %bound_method.loc26_25(%C.ref) [concrete = constants.%C] -// CHECK:STDOUT: %.loc26_26.2: ref %Class = temporary_storage -// CHECK:STDOUT: %.loc26_26.3: ref type = class_element_access %.loc26_26.2, element0 -// CHECK:STDOUT: %.loc26_26.4: init type = initialize_from %type.as.Copy.impl.Op.call to %.loc26_26.3 [concrete = constants.%C] -// CHECK:STDOUT: %.loc26_26.5: init %Class = class_init (%.loc26_26.4), %.loc26_26.2 [concrete = constants.%Class.val] -// CHECK:STDOUT: %.loc26_26.6: ref %Class = temporary %.loc26_26.2, %.loc26_26.5 -// CHECK:STDOUT: %.loc26_28.1: ref %Class = converted %.loc26_26.1, %.loc26_26.6 -// CHECK:STDOUT: %.loc26_11: type = splice_block %Class.ref.loc26_11 [concrete = constants.%Class] { -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %Class.ref.loc26_11: type = name_ref Class, file.%Class.decl [concrete = constants.%Class] -// CHECK:STDOUT: } -// CHECK:STDOUT: %.loc26_28.2: %Class = acquire_value %.loc26_28.1 -// CHECK:STDOUT: %c: %Class = symbolic_binding c, 0, %.loc26_28.2 [symbolic = constants.%c] -// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] -// CHECK:STDOUT: %.loc27_6.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %HoldsType.ref: %HoldsType.type = name_ref HoldsType, file.%HoldsType.decl [concrete = constants.%HoldsType.generic] -// CHECK:STDOUT: %c.ref: %Class = name_ref c, %c [symbolic = constants.%c] -// CHECK:STDOUT: %HoldsType: type = class_type @HoldsType, @HoldsType(constants.%c) [symbolic = constants.%HoldsType.68ad07.2] -// CHECK:STDOUT: %.loc27_6.2: ref %HoldsType.68ad07.2 = temporary_storage -// CHECK:STDOUT: %.loc27_6.3: init %HoldsType.68ad07.2 = class_init (), %.loc27_6.2 [symbolic = constants.%HoldsType.val] -// CHECK:STDOUT: %.loc27_6.4: ref %HoldsType.68ad07.2 = temporary %.loc27_6.2, %.loc27_6.3 -// CHECK:STDOUT: %.loc27_8: ref %HoldsType.68ad07.2 = converted %.loc27_6.1, %.loc27_6.4 -// CHECK:STDOUT: %.loc27_26: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %impl.elem0.loc27: %.bcb = impl_witness_access constants.%Destroy.impl_witness.4dc, element0 [symbolic = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.eb8] -// CHECK:STDOUT: %bound_method.loc27_6.1: = bound_method %.loc27_6.4, %impl.elem0.loc27 -// CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0.loc27, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.16e) [symbolic = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.358] -// CHECK:STDOUT: %bound_method.loc27_6.2: = bound_method %.loc27_6.4, %specific_fn -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc27: init %empty_tuple.type = call %bound_method.loc27_6.2(%.loc27_6.4) -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc26_26.6, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.45a +// CHECK:STDOUT: %.loc37_12.1: %struct_type.t = struct_literal (%C.ref) [concrete = constants.%struct] +// CHECK:STDOUT: %impl.elem0: %.98f = impl_witness_access constants.%Copy.impl_witness.de9, element0 [concrete = constants.%type.as.Copy.impl.Op] +// CHECK:STDOUT: %bound_method.loc37_11: = bound_method %C.ref, %impl.elem0 [concrete = constants.%type.as.Copy.impl.Op.bound] +// CHECK:STDOUT: %type.as.Copy.impl.Op.call: init type = call %bound_method.loc37_11(%C.ref) [concrete = constants.%C] +// CHECK:STDOUT: %.loc37_12.2: ref %Class = temporary_storage +// CHECK:STDOUT: %.loc37_12.3: ref type = class_element_access %.loc37_12.2, element0 +// CHECK:STDOUT: %.loc37_12.4: init type = initialize_from %type.as.Copy.impl.Op.call to %.loc37_12.3 [concrete = constants.%C] +// CHECK:STDOUT: %.loc37_12.5: init %Class = class_init (%.loc37_12.4), %.loc37_12.2 [concrete = constants.%Class.val] +// CHECK:STDOUT: %.loc37_12.6: ref %Class = temporary %.loc37_12.2, %.loc37_12.5 +// CHECK:STDOUT: %.loc37_13.1: ref %Class = converted %.loc37_12.1, %.loc37_12.6 +// CHECK:STDOUT: %.loc37_13.2: %Class = acquire_value %.loc37_13.1 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc37_12.6, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.45a // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.45a, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.d3d) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.70f] -// CHECK:STDOUT: %bound_method.loc26_26: = bound_method %.loc26_26.6, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc26: init %empty_tuple.type = call %bound_method.loc26_26(%.loc26_26.6) +// CHECK:STDOUT: %bound_method.loc37_12: = bound_method %.loc37_12.6, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc37_12(%.loc37_12.6) // CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: @@ -749,6 +787,10 @@ fn G() { // CHECK:STDOUT: %.loc21_38.1 => constants.%.302 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: specific @G(constants.%c) { +// CHECK:STDOUT: %c.loc25_6.1 => constants.%c +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: specific @HoldsType(constants.%c) { // CHECK:STDOUT: %T.loc8_17.1 => constants.%c // CHECK:STDOUT: diff --git a/toolchain/check/testdata/facet/fail_convert_type_erased_type_to_facet.carbon b/toolchain/check/testdata/facet/fail_convert_type_erased_type_to_facet.carbon index e04e65b017ad..06e489c959ef 100644 --- a/toolchain/check/testdata/facet/fail_convert_type_erased_type_to_facet.carbon +++ b/toolchain/check/testdata/facet/fail_convert_type_erased_type_to_facet.carbon @@ -20,14 +20,11 @@ impl Goat as Animal {} fn WalkAnimal(a:! Animal) {} fn F() { - let x:! type = Goat; - // CHECK:STDERR: fail_convert_type_erased_type_to_facet.carbon:[[@LINE+7]]:3: error: cannot convert type `x` into type implementing `Animal` [ConversionFailureTypeToFacet] - // CHECK:STDERR: WalkAnimal(x); - // CHECK:STDERR: ^~~~~~~~~~~~~ - // CHECK:STDERR: fail_convert_type_erased_type_to_facet.carbon:[[@LINE-7]]:15: note: initializing generic parameter `a` declared here [InitializingGenericParam] - // CHECK:STDERR: fn WalkAnimal(a:! Animal) {} - // CHECK:STDERR: ^ + // CHECK:STDERR: fail_convert_type_erased_type_to_facet.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let x:! type = Goat; + // CHECK:STDERR: ^~~~~~~~ // CHECK:STDERR: + let x:! type = Goat; WalkAnimal(x); } @@ -39,53 +36,7 @@ fn F() { // CHECK:STDOUT: %Goat: type = class_type @Goat [concrete] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [concrete] -// CHECK:STDOUT: %Animal.impl_witness: = impl_witness file.%Animal.impl_witness_table [concrete] -// CHECK:STDOUT: %type: type = facet_type [concrete] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self] // CHECK:STDOUT: %a: %Animal.type = symbolic_binding a, 0 [symbolic] -// CHECK:STDOUT: %pattern_type.3c3: type = pattern_type %Animal.type [concrete] -// CHECK:STDOUT: %WalkAnimal.type: type = fn_type @WalkAnimal [concrete] -// CHECK:STDOUT: %WalkAnimal: %WalkAnimal.type = struct_value () [concrete] -// CHECK:STDOUT: %F.type: type = fn_type @F [concrete] -// CHECK:STDOUT: %F: %F.type = struct_value () [concrete] -// CHECK:STDOUT: %x: type = symbolic_binding x, 0 [symbolic] -// CHECK:STDOUT: %pattern_type.98f: type = pattern_type type [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [concrete] { -// CHECK:STDOUT: .Core = imports.%Core -// CHECK:STDOUT: .Animal = %Animal.decl -// CHECK:STDOUT: .Goat = %Goat.decl -// CHECK:STDOUT: .WalkAnimal = %WalkAnimal.decl -// CHECK:STDOUT: .F = %F.decl -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.import = import Core -// CHECK:STDOUT: %Animal.decl: type = interface_decl @Animal [concrete = constants.%Animal.type] {} {} -// CHECK:STDOUT: %Goat.decl: type = class_decl @Goat [concrete = constants.%Goat] {} {} -// CHECK:STDOUT: impl_decl @Goat.as.Animal.impl [concrete] {} { -// CHECK:STDOUT: %Goat.ref: type = name_ref Goat, file.%Goat.decl [concrete = constants.%Goat] -// CHECK:STDOUT: %Animal.ref: type = name_ref Animal, file.%Animal.decl [concrete = constants.%Animal.type] -// CHECK:STDOUT: } -// CHECK:STDOUT: %Animal.impl_witness_table = impl_witness_table (), @Goat.as.Animal.impl [concrete] -// CHECK:STDOUT: %Animal.impl_witness: = impl_witness %Animal.impl_witness_table [concrete = constants.%Animal.impl_witness] -// CHECK:STDOUT: %WalkAnimal.decl: %WalkAnimal.type = fn_decl @WalkAnimal [concrete = constants.%WalkAnimal] { -// CHECK:STDOUT: %a.patt: %pattern_type.3c3 = symbolic_binding_pattern a, 0 [concrete] -// CHECK:STDOUT: } { -// CHECK:STDOUT: %.loc20: type = splice_block %Animal.ref [concrete = constants.%Animal.type] { -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %Animal.ref: type = name_ref Animal, file.%Animal.decl [concrete = constants.%Animal.type] -// CHECK:STDOUT: } -// CHECK:STDOUT: %a.loc20_15.2: %Animal.type = symbolic_binding a, 0 [symbolic = %a.loc20_15.1 (constants.%a)] -// CHECK:STDOUT: } -// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [concrete = constants.%F] {} {} // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: interface @Animal { @@ -98,9 +49,9 @@ fn F() { // CHECK:STDOUT: !requires: // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: impl @Goat.as.Animal.impl: %Goat.ref as %Animal.ref { +// CHECK:STDOUT: impl @: .inst{{[0-9A-F]+}}.loc18_6 as .inst{{[0-9A-F]+}}.loc18_14 { // CHECK:STDOUT: !members: -// CHECK:STDOUT: witness = file.%Animal.impl_witness +// CHECK:STDOUT: witness = .inst{{[0-9A-F]+}}.loc18_21 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @Goat { @@ -111,8 +62,8 @@ fn F() { // CHECK:STDOUT: .Self = constants.%Goat // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: generic fn @WalkAnimal(%a.loc20_15.2: %Animal.type) { -// CHECK:STDOUT: %a.loc20_15.1: %Animal.type = symbolic_binding a, 0 [symbolic = %a.loc20_15.1 (constants.%a)] +// CHECK:STDOUT: generic fn @WalkAnimal(.inst{{[0-9A-F]+}}.loc20_15: %Animal.type) { +// CHECK:STDOUT: %a: %Animal.type = symbolic_binding a, 0 [symbolic = %a (constants.%a)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: @@ -122,20 +73,9 @@ fn F() { // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %x.patt: %pattern_type.98f = symbolic_binding_pattern x, 0 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %Goat.ref: type = name_ref Goat, file.%Goat.decl [concrete = constants.%Goat] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %x: type = symbolic_binding x, 0, %Goat.ref [symbolic = constants.%x] -// CHECK:STDOUT: %WalkAnimal.ref: %WalkAnimal.type = name_ref WalkAnimal, file.%WalkAnimal.decl [concrete = constants.%WalkAnimal] -// CHECK:STDOUT: %x.ref: type = name_ref x, %x [symbolic = constants.%x] -// CHECK:STDOUT: return -// CHECK:STDOUT: } +// CHECK:STDOUT: fn @F(); // CHECK:STDOUT: // CHECK:STDOUT: specific @WalkAnimal(constants.%a) { -// CHECK:STDOUT: %a.loc20_15.1 => constants.%a +// CHECK:STDOUT: %a => constants.%a // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon b/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon index 7f38723a656a..3f287b9c314c 100644 --- a/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon +++ b/toolchain/check/testdata/facet/fail_deduction_uses_runtime_type_conversion.carbon @@ -26,15 +26,14 @@ impl RuntimeConvertFrom as Core.ImplicitAs(RuntimeConvertTo) { fn F[T:! (type, )](A:! T.0, x: HoldsType(T)) {} -fn G(holds_to: HoldsType((RuntimeConvertTo, ))) { - let from:! RuntimeConvertFrom = {} as RuntimeConvertFrom; +fn G(holds_to: HoldsType((RuntimeConvertTo, )), from:! RuntimeConvertFrom) { // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE+10]]:3: error: compile-time value requires runtime conversion, constructing value of type `RuntimeConvertTo` [RuntimeConversionDuringCompTimeDeduction] // CHECK:STDERR: F(from, holds_to); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE-7]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] + // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE-6]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] // CHECK:STDERR: fn F[T:! (type, )](A:! T.0, x: HoldsType(T)) {} // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE-10]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] + // CHECK:STDERR: fail_deduction_uses_runtime_type_conversion.carbon:[[@LINE-9]]:1: note: while deducing parameters of generic declared here [DeductionGenericHere] // CHECK:STDERR: fn F[T:! (type, )](A:! T.0, x: HoldsType(T)) {} // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // CHECK:STDERR: @@ -81,22 +80,17 @@ fn G(holds_to: HoldsType((RuntimeConvertTo, ))) { // CHECK:STDOUT: %tuple.c68: %tuple.type = tuple_value (%RuntimeConvertTo) [concrete] // CHECK:STDOUT: %HoldsType.066: type = class_type @HoldsType, @HoldsType(%tuple.c68) [concrete] // CHECK:STDOUT: %pattern_type.a13: type = pattern_type %HoldsType.066 [concrete] +// CHECK:STDOUT: %from: %RuntimeConvertFrom = symbolic_binding from, 0 [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [concrete] // CHECK:STDOUT: %G: %G.type = struct_value () [concrete] -// CHECK:STDOUT: %from: %RuntimeConvertFrom = symbolic_binding from, 0 [symbolic] -// CHECK:STDOUT: %RuntimeConvertFrom.val: %RuntimeConvertFrom = struct_value () [concrete] // CHECK:STDOUT: %.838: type = fn_type_with_self_type %ImplicitAs.Convert.type.50a, %ImplicitAs.facet [concrete] // CHECK:STDOUT: %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.bound: = bound_method %from, %RuntimeConvertFrom.as.ImplicitAs.impl.Convert [symbolic] // CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] // CHECK:STDOUT: %type_where: type = facet_type > [concrete] -// CHECK:STDOUT: %facet_value.d7d: %type_where = facet_value %RuntimeConvertTo, () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.a33: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.d7d) [concrete] +// CHECK:STDOUT: %facet_value: %type_where = facet_value %RuntimeConvertTo, () [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.a33: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [concrete] // CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.fef: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.a33 = struct_value () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.109: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.fef, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value.d7d) [concrete] -// CHECK:STDOUT: %facet_value.631: %type_where = facet_value %RuntimeConvertFrom, () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.6c1: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.631) [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.a23: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.6c1 = struct_value () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.692: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.a23, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value.631) [concrete] +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.fef, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value) [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -171,6 +165,7 @@ fn G(holds_to: HoldsType((RuntimeConvertTo, ))) { // CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [concrete = constants.%G] { // CHECK:STDOUT: %holds_to.patt: %pattern_type.a13 = value_binding_pattern holds_to [concrete] // CHECK:STDOUT: %holds_to.param_patt: %pattern_type.a13 = value_param_pattern %holds_to.patt, call_param0 [concrete] +// CHECK:STDOUT: %from.patt: %pattern_type.f64 = symbolic_binding_pattern from, 0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %holds_to.param: %HoldsType.066 = value_param call_param0 // CHECK:STDOUT: %.loc29_46.1: type = splice_block %HoldsType [concrete = constants.%HoldsType.066] { @@ -182,6 +177,11 @@ fn G(holds_to: HoldsType((RuntimeConvertTo, ))) { // CHECK:STDOUT: %HoldsType: type = class_type @HoldsType, @HoldsType(constants.%tuple.c68) [concrete = constants.%HoldsType.066] // CHECK:STDOUT: } // CHECK:STDOUT: %holds_to: %HoldsType.066 = value_binding holds_to, %holds_to.param +// CHECK:STDOUT: %.loc29_56: type = splice_block %RuntimeConvertFrom.ref [concrete = constants.%RuntimeConvertFrom] { +// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] +// CHECK:STDOUT: %RuntimeConvertFrom.ref: type = name_ref RuntimeConvertFrom, file.%RuntimeConvertFrom.decl [concrete = constants.%RuntimeConvertFrom] +// CHECK:STDOUT: } +// CHECK:STDOUT: %from.loc29_49.2: %RuntimeConvertFrom = symbolic_binding from, 0 [symbolic = %from.loc29_49.1 (constants.%from)] // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: @@ -261,44 +261,32 @@ fn G(holds_to: HoldsType((RuntimeConvertTo, ))) { // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @G(%holds_to.param: %HoldsType.066) { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %from.patt: %pattern_type.f64 = symbolic_binding_pattern from, 0 [concrete] +// CHECK:STDOUT: generic fn @G(%from.loc29_49.2: %RuntimeConvertFrom) { +// CHECK:STDOUT: %from.loc29_49.1: %RuntimeConvertFrom = symbolic_binding from, 0 [symbolic = %from.loc29_49.1 (constants.%from)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.bound: = bound_method %from.loc29_49.1, constants.%RuntimeConvertFrom.as.ImplicitAs.impl.Convert [symbolic = %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.bound (constants.%RuntimeConvertFrom.as.ImplicitAs.impl.Convert.bound)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%holds_to.param: %HoldsType.066) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] +// CHECK:STDOUT: %from.ref: %RuntimeConvertFrom = name_ref from, %from.loc29_49.2 [symbolic = %from.loc29_49.1 (constants.%from)] +// CHECK:STDOUT: %holds_to.ref: %HoldsType.066 = name_ref holds_to, %holds_to +// CHECK:STDOUT: %impl.elem0: %.838 = impl_witness_access constants.%ImplicitAs.impl_witness, element0 [concrete = constants.%RuntimeConvertFrom.as.ImplicitAs.impl.Convert] +// CHECK:STDOUT: %bound_method.loc40_19.1: = bound_method constants.%from, %impl.elem0 [symbolic = %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.bound (constants.%RuntimeConvertFrom.as.ImplicitAs.impl.Convert.bound)] +// CHECK:STDOUT: %.loc40_19.1: ref %RuntimeConvertTo = temporary_storage +// CHECK:STDOUT: %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.call: init %RuntimeConvertTo = call %bound_method.loc40_19.1(constants.%from) to %.loc40_19.1 +// CHECK:STDOUT: %.loc40_19.2: init %RuntimeConvertTo = converted constants.%from, %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.call +// CHECK:STDOUT: %.loc40_19.3: ref %RuntimeConvertTo = temporary %.loc40_19.1, %.loc40_19.2 +// CHECK:STDOUT: %.loc40_19.4: %RuntimeConvertTo = acquire_value %.loc40_19.3 +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%tuple.c68, ) [concrete = ] +// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn(%holds_to.ref) +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %.loc40_19.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.fef +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.fef, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn] +// CHECK:STDOUT: %bound_method.loc40_19.2: = bound_method %.loc40_19.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc40_19.2(%.loc40_19.3) +// CHECK:STDOUT: return // CHECK:STDOUT: } -// CHECK:STDOUT: %.loc30_36.1: %empty_struct_type = struct_literal () [concrete = constants.%empty_struct] -// CHECK:STDOUT: %RuntimeConvertFrom.ref.loc30_41: type = name_ref RuntimeConvertFrom, file.%RuntimeConvertFrom.decl [concrete = constants.%RuntimeConvertFrom] -// CHECK:STDOUT: %.loc30_36.2: ref %RuntimeConvertFrom = temporary_storage -// CHECK:STDOUT: %.loc30_36.3: init %RuntimeConvertFrom = class_init (), %.loc30_36.2 [concrete = constants.%RuntimeConvertFrom.val] -// CHECK:STDOUT: %.loc30_36.4: ref %RuntimeConvertFrom = temporary %.loc30_36.2, %.loc30_36.3 -// CHECK:STDOUT: %.loc30_38.1: ref %RuntimeConvertFrom = converted %.loc30_36.1, %.loc30_36.4 -// CHECK:STDOUT: %.loc30_14: type = splice_block %RuntimeConvertFrom.ref.loc30_14 [concrete = constants.%RuntimeConvertFrom] { -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %RuntimeConvertFrom.ref.loc30_14: type = name_ref RuntimeConvertFrom, file.%RuntimeConvertFrom.decl [concrete = constants.%RuntimeConvertFrom] -// CHECK:STDOUT: } -// CHECK:STDOUT: %.loc30_38.2: %RuntimeConvertFrom = acquire_value %.loc30_38.1 -// CHECK:STDOUT: %from: %RuntimeConvertFrom = symbolic_binding from, 0, %.loc30_38.2 [symbolic = constants.%from] -// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [concrete = constants.%F] -// CHECK:STDOUT: %from.ref: %RuntimeConvertFrom = name_ref from, %from [symbolic = constants.%from] -// CHECK:STDOUT: %holds_to.ref: %HoldsType.066 = name_ref holds_to, %holds_to -// CHECK:STDOUT: %impl.elem0: %.838 = impl_witness_access constants.%ImplicitAs.impl_witness, element0 [concrete = constants.%RuntimeConvertFrom.as.ImplicitAs.impl.Convert] -// CHECK:STDOUT: %bound_method.loc41_19.1: = bound_method constants.%from, %impl.elem0 [symbolic = constants.%RuntimeConvertFrom.as.ImplicitAs.impl.Convert.bound] -// CHECK:STDOUT: %.loc41_19.1: ref %RuntimeConvertTo = temporary_storage -// CHECK:STDOUT: %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.call: init %RuntimeConvertTo = call %bound_method.loc41_19.1(constants.%from) to %.loc41_19.1 -// CHECK:STDOUT: %.loc41_19.2: init %RuntimeConvertTo = converted constants.%from, %RuntimeConvertFrom.as.ImplicitAs.impl.Convert.call -// CHECK:STDOUT: %.loc41_19.3: ref %RuntimeConvertTo = temporary %.loc41_19.1, %.loc41_19.2 -// CHECK:STDOUT: %.loc41_19.4: %RuntimeConvertTo = acquire_value %.loc41_19.3 -// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%tuple.c68, ) [concrete = ] -// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn(%holds_to.ref) -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc41: = bound_method %.loc41_19.3, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.fef -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.fef, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.d7d) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.109] -// CHECK:STDOUT: %bound_method.loc41_19.2: = bound_method %.loc41_19.3, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc41: init %empty_tuple.type = call %bound_method.loc41_19.2(%.loc41_19.3) -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc30: = bound_method %.loc30_36.4, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a23 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a23, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.631) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.692] -// CHECK:STDOUT: %bound_method.loc30: = bound_method %.loc30_36.4, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc30: init %empty_tuple.type = call %bound_method.loc30(%.loc30_36.4) -// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @HoldsType(constants.%T) { @@ -322,6 +310,10 @@ fn G(holds_to: HoldsType((RuntimeConvertTo, ))) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: specific @G(constants.%from) { +// CHECK:STDOUT: %from.loc29_49.1 => constants.%from +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: specific @F(constants.%tuple.c68, ) { // CHECK:STDOUT: %T.loc27_6.1 => constants.%tuple.c68 // CHECK:STDOUT: %tuple.elem0.loc27_25.1 => constants.%RuntimeConvertTo diff --git a/toolchain/check/testdata/facet/named_constant.carbon b/toolchain/check/testdata/facet/named_constant.carbon index 1eb101b0d3b5..7b60be9aa886 100644 --- a/toolchain/check/testdata/facet/named_constant.carbon +++ b/toolchain/check/testdata/facet/named_constant.carbon @@ -19,19 +19,16 @@ interface I { } fn Test() { + // CHECK:STDERR: fail_todo_named_constant_in_rewrite.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = (); fn F(T:! I where .X = Constant) {} fn G(T:! I where .X = Constant) { // TODO: The facet type T in G should match the facet type T in F. - // CHECK:STDERR: fail_todo_named_constant_in_rewrite.carbon:[[@LINE+7]]:5: error: cannot deduce value for generic parameter `Constant` [DeductionIncomplete] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_todo_named_constant_in_rewrite.carbon:[[@LINE-7]]:3: note: while deducing parameters of generic declared here [DeductionGenericHere] - // CHECK:STDERR: fn F(T:! I where .X = Constant) {} - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: F(T); } } @@ -45,6 +42,10 @@ interface I { } fn Test() { + // CHECK:STDERR: fail_todo_named_constant_two_levels_in_rewrite.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant2:! type = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant2:! type = (); let Constant:! type = (Constant2, ); @@ -52,13 +53,6 @@ fn Test() { fn G(T:! I where .X = Constant) { // TODO: The facet type T in G should match the facet type T in F. - // CHECK:STDERR: fail_todo_named_constant_two_levels_in_rewrite.carbon:[[@LINE+7]]:5: error: cannot deduce value for generic parameter `Constant2` [DeductionIncomplete] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_todo_named_constant_two_levels_in_rewrite.carbon:[[@LINE-7]]:3: note: while deducing parameters of generic declared here [DeductionGenericHere] - // CHECK:STDERR: fn F(T:! I where .X = Constant) {} - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: F(T); } } @@ -72,19 +66,16 @@ interface I { } fn Test() { + // CHECK:STDERR: fail_todo_named_constant_in_rewrite_callee.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = (); fn F(T:! I where .X = Constant) {} fn G(T:! I where .X = ()) { // TODO: The facet type T in G should match the facet type T in F. - // CHECK:STDERR: fail_todo_named_constant_in_rewrite_callee.carbon:[[@LINE+7]]:5: error: cannot deduce value for generic parameter `Constant` [DeductionIncomplete] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_todo_named_constant_in_rewrite_callee.carbon:[[@LINE-7]]:3: note: while deducing parameters of generic declared here [DeductionGenericHere] - // CHECK:STDERR: fn F(T:! I where .X = Constant) {} - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: F(T); } } @@ -98,19 +89,16 @@ interface I { } fn Test() { + // CHECK:STDERR: fail_todo_named_constant_in_rewrite_caller.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = (); fn F(T:! I where .X = ()) {} fn G(T:! I where .X = Constant) { // TODO: The facet type T in G should match the facet type T in F. - // CHECK:STDERR: fail_todo_named_constant_in_rewrite_caller.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = Constant` into type implementing `I where .(I.X) = ()` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_todo_named_constant_in_rewrite_caller.carbon:[[@LINE-7]]:8: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = ()) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } @@ -124,20 +112,16 @@ interface I { } fn Test() { + // CHECK:STDERR: fail_todo_named_constant_in_nested_facet_type.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = (); // TODO: The .Self reference in each .X should be different, there should be // no cycle here. - // CHECK:STDERR: fail_todo_named_constant_in_nested_facet_type.carbon:[[@LINE+4]]:12: error: found cycle in facet type constraint for `.(I.X)` [FacetTypeConstraintCycle] - // CHECK:STDERR: fn F(T:! I where .X = (I where .X = Constant)) {} - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fn F(T:! I where .X = (I where .X = Constant)) {} - // CHECK:STDERR: fail_todo_named_constant_in_nested_facet_type.carbon:[[@LINE+4]]:12: error: found cycle in facet type constraint for `.(I.X)` [FacetTypeConstraintCycle] - // CHECK:STDERR: fn G(T:! I where .X = (I where .X = Constant)) { - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fn G(T:! I where .X = (I where .X = Constant)) { // TODO: The facet type T in G should match the facet type T in F. F(T); @@ -153,16 +137,16 @@ interface I { } fn Test() { + // CHECK:STDERR: fail_todo_named_constant_in_nested_facet_type_caller.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = (); fn F(T:! I where .X = (I where .X = ())) {} // TODO: The .Self reference in each .X should be different, there should be // no cycle here. - // CHECK:STDERR: fail_todo_named_constant_in_nested_facet_type_caller.carbon:[[@LINE+4]]:12: error: found cycle in facet type constraint for `.(I.X)` [FacetTypeConstraintCycle] - // CHECK:STDERR: fn G(T:! I where .X = (I where .X = Constant)) { - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fn G(T:! I where .X = (I where .X = Constant)) { // TODO: The facet type T in G should match the facet type T in F. F(T); @@ -178,14 +162,14 @@ interface I { } fn Test() { + // CHECK:STDERR: fail_named_constant_in_nested_facet_type_callee.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = (); // TODO: The .Self reference in each .X should be different, there should be // no cycle here. - // CHECK:STDERR: fail_named_constant_in_nested_facet_type_callee.carbon:[[@LINE+4]]:12: error: found cycle in facet type constraint for `.(I.X)` [FacetTypeConstraintCycle] - // CHECK:STDERR: fn F(T:! I where .X = (I where .X = Constant)) {} - // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fn F(T:! I where .X = (I where .X = Constant)) {} fn G(T:! I where .X = (I where .X = ())) { diff --git a/toolchain/check/testdata/facet/tuple_and_struct_type_value.carbon b/toolchain/check/testdata/facet/tuple_and_struct_type_value.carbon index 730f74a50cce..0f1440a73ddb 100644 --- a/toolchain/check/testdata/facet/tuple_and_struct_type_value.carbon +++ b/toolchain/check/testdata/facet/tuple_and_struct_type_value.carbon @@ -21,23 +21,27 @@ constraint N {} fn InterfaceParam(U:! Z) {} fn ConstraintParam(U:! N) {} -fn F() { - let T:! (type, ) = ({}, ); +fn F(T:! (type, ), U:! type, Empty:! ()) { // Passes a symbolic binding of type TupleType. InterfaceParam(T); ConstraintParam(T); - // Converts from a TupleLiteral with a symbolic type to a symbolic `type`. - let U:! type = (T.0, ); // Passes a symbolic `type`. InterfaceParam(U); ConstraintParam(U); - let Empty:! () = (); InterfaceParam(Empty); ConstraintParam(Empty); } +fn G(T:! (type, )) { + F(T, (T.0, ), ()); +} + +fn H() { + G(({}, )); +} + // --- struct_value_to_facet_value.carbon library "[[@TEST_NAME]]"; @@ -49,13 +53,16 @@ constraint N {} fn InterfaceParam(U:! Z) {} fn ConstraintParam(U:! N) {} -fn F() { - let T:! {} = {}; +fn F(T:! {}) { // Passes a symbolic binding of type StructType. InterfaceParam(T); ConstraintParam(T); } +fn G() { + F({}); +} + // --- fail_struct_value_with_field_to_facet_value.carbon library "[[@TEST_NAME]]"; @@ -67,15 +74,14 @@ constraint N {} fn InterfaceParam(U:! Z) {} fn ConstraintParam(U:! N) {} -fn F() { - let T:! {.a: type} = {.a = ()}; +fn F(T:! {.a: type}) { // CHECK:STDERR: fail_struct_value_with_field_to_facet_value.carbon:[[@LINE+10]]:3: error: cannot implicitly convert non-type value of type `{.a: type}` into type implementing `Z` [ConversionFailureNonTypeToFacet] // CHECK:STDERR: InterfaceParam(T); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_struct_value_with_field_to_facet_value.carbon:[[@LINE+7]]:3: note: type `{.a: type}` does not implement interface `Core.ImplicitAs(Z)` [MissingImplInMemberAccessNote] // CHECK:STDERR: InterfaceParam(T); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_struct_value_with_field_to_facet_value.carbon:[[@LINE-11]]:19: note: initializing generic parameter `U` declared here [InitializingGenericParam] + // CHECK:STDERR: fail_struct_value_with_field_to_facet_value.carbon:[[@LINE-10]]:19: note: initializing generic parameter `U` declared here [InitializingGenericParam] // CHECK:STDERR: fn InterfaceParam(U:! Z) {} // CHECK:STDERR: ^ // CHECK:STDERR: @@ -86,9 +92,13 @@ fn F() { // CHECK:STDERR: fail_struct_value_with_field_to_facet_value.carbon:[[@LINE+7]]:3: note: type `{.a: type}` does not implement interface `Core.ImplicitAs(N)` [MissingImplInMemberAccessNote] // CHECK:STDERR: ConstraintParam(T); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ - // CHECK:STDERR: fail_struct_value_with_field_to_facet_value.carbon:[[@LINE-21]]:20: note: initializing generic parameter `U` declared here [InitializingGenericParam] + // CHECK:STDERR: fail_struct_value_with_field_to_facet_value.carbon:[[@LINE-20]]:20: note: initializing generic parameter `U` declared here [InitializingGenericParam] // CHECK:STDERR: fn ConstraintParam(U:! N) {} // CHECK:STDERR: ^ // CHECK:STDERR: ConstraintParam(T); } + +fn G() { + F({.a = ()}); +} diff --git a/toolchain/check/testdata/facet/validate_rewrite_constraints.carbon b/toolchain/check/testdata/facet/validate_rewrite_constraints.carbon index ca340f950be4..03fe5813a30e 100644 --- a/toolchain/check/testdata/facet/validate_rewrite_constraints.carbon +++ b/toolchain/check/testdata/facet/validate_rewrite_constraints.carbon @@ -942,16 +942,13 @@ fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} // `.X` within becomes self-referential and makes a cycle. fn G1() { + // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = I where .X = .Y; + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = I where .X = .Y; fn G(T:! I where .X = (I where .Y = (Constant, ))) { - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = I where .(I.Y) = (Constant,)` into type implementing `I where .(I.X) = I where .(I.Y) = (I where .(I.X) = .(I.Y),)` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE-16]]:6: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } @@ -960,13 +957,6 @@ fn G2() { let Constant:! type = (I where .X = .Y, ); fn G(T:! I where .X = (I where .Y = Constant)) { - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = I where .(I.Y) = Constant` into type implementing `I where .(I.X) = I where .(I.Y) = (I where .(I.X) = .(I.Y),)` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE-31]]:6: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } @@ -975,13 +965,6 @@ fn G3() { let Constant:! type = I where .Y = (I where .X = .Y, ); fn G(T:! I where .X = Constant) { - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = Constant` into type implementing `I where .(I.X) = I where .(I.Y) = (I where .(I.X) = .(I.Y),)` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE-46]]:6: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } @@ -991,13 +974,6 @@ fn G4() { let Constant:! type = Constant2; fn G(T:! I where .X = (I where .Y = Constant)) { - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = I where .(I.Y) = Constant` into type implementing `I where .(I.X) = I where .(I.Y) = (I where .(I.X) = .(I.Y),)` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE-62]]:6: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } @@ -1007,13 +983,6 @@ fn G5() { let Constant:! type = (Constant2, ); fn G(T:! I where .X = (I where .Y = Constant)) { - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = I where .(I.Y) = Constant` into type implementing `I where .(I.X) = I where .(I.Y) = (I where .(I.X) = .(I.Y),)` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE-78]]:6: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } @@ -1023,18 +992,11 @@ fn G6() { let Constant:! type = I where .Y = Constant2; fn G(T:! I where .X = Constant) { - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = Constant` into type implementing `I where .(I.X) = I where .(I.Y) = (I where .(I.X) = .(I.Y),)` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_nested_facet_type_from_constant.carbon:[[@LINE-94]]:6: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } -// ---fail_nested_facet_type_from_constant_differs.carbon +// --- fail_nested_facet_type_from_constant_differs.carbon library "[[@TEST_NAME]]"; interface I { @@ -1045,16 +1007,13 @@ interface I { fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} fn G1() { + // CHECK:STDERR: fail_nested_facet_type_from_constant_differs.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Constant:! type = I where .X = () and .Y = (); + // CHECK:STDERR: ^~~~~~~~~~~~~~~ + // CHECK:STDERR: let Constant:! type = I where .X = () and .Y = (); fn G(T:! I where .X = (I where .Y = (Constant, ))) { - // CHECK:STDERR: fail_nested_facet_type_from_constant_differs.carbon:[[@LINE+7]]:5: error: cannot convert type `T` that implements `I where .(I.X) = I where .(I.Y) = (Constant,)` into type implementing `I where .(I.X) = I where .(I.Y) = (I where .(I.X) = .(I.Y),)` [ConversionFailureFacetToFacet] - // CHECK:STDERR: F(T); - // CHECK:STDERR: ^~~~ - // CHECK:STDERR: fail_nested_facet_type_from_constant_differs.carbon:[[@LINE-9]]:6: note: initializing generic parameter `T` declared here [InitializingGenericParam] - // CHECK:STDERR: fn F(T:! I where .X = (I where .Y = (I where .X = .Y, ))) {} - // CHECK:STDERR: ^ - // CHECK:STDERR: F(T); } } diff --git a/toolchain/check/testdata/for/actual.carbon b/toolchain/check/testdata/for/actual.carbon index 9d0f52b496ad..21d51db5a03c 100644 --- a/toolchain/check/testdata/for/actual.carbon +++ b/toolchain/check/testdata/for/actual.carbon @@ -45,8 +45,7 @@ fn Range(end: i32) -> IntRange(32) { import library "lib"; -fn Read() { - let y:! Core.IntLiteral() = 43; +fn Read(y:! Core.IntLiteral()) { var x: IntRange(32) = Range(y); } @@ -839,16 +838,15 @@ fn Read() { // CHECK:STDOUT: --- trivial.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { -// CHECK:STDOUT: %Read.type: type = fn_type @Read [concrete] -// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] -// CHECK:STDOUT: %Read: %Read.type = struct_value () [concrete] // CHECK:STDOUT: %type: type = facet_type [concrete] // CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] // CHECK:STDOUT: %IntLiteral.type: type = fn_type @IntLiteral [concrete] // CHECK:STDOUT: %IntLiteral: %IntLiteral.type = struct_value () [concrete] // CHECK:STDOUT: %y: Core.IntLiteral = symbolic_binding y, 0 [symbolic] // CHECK:STDOUT: %pattern_type.dc0: type = pattern_type Core.IntLiteral [concrete] -// CHECK:STDOUT: %int_43: Core.IntLiteral = int_value 43 [concrete] +// CHECK:STDOUT: %Read.type: type = fn_type @Read [concrete] +// CHECK:STDOUT: %Read: %Read.type = struct_value () [concrete] // CHECK:STDOUT: %IntRange.type: type = generic_class_type @IntRange [concrete] // CHECK:STDOUT: %IntRange.generic: %IntRange.type = struct_value () [concrete] // CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] @@ -942,7 +940,19 @@ fn Read() { // CHECK:STDOUT: } // CHECK:STDOUT: %Core.import = import Core // CHECK:STDOUT: %default.import = import -// CHECK:STDOUT: %Read.decl: %Read.type = fn_decl @Read [concrete = constants.%Read] {} {} +// CHECK:STDOUT: %Read.decl: %Read.type = fn_decl @Read [concrete = constants.%Read] { +// CHECK:STDOUT: %y.patt: %pattern_type.dc0 = symbolic_binding_pattern y, 0 [concrete] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %.loc4_29.1: type = splice_block %.loc4_29.3 [concrete = Core.IntLiteral] { +// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] +// CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core.ece [concrete = imports.%Core.ece] +// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%Core.IntLiteral [concrete = constants.%IntLiteral] +// CHECK:STDOUT: %IntLiteral.call: init type = call %IntLiteral.ref() [concrete = Core.IntLiteral] +// CHECK:STDOUT: %.loc4_29.2: type = value_of_initializer %IntLiteral.call [concrete = Core.IntLiteral] +// CHECK:STDOUT: %.loc4_29.3: type = converted %IntLiteral.call, %.loc4_29.2 [concrete = Core.IntLiteral] +// CHECK:STDOUT: } +// CHECK:STDOUT: %y.loc4_9.2: Core.IntLiteral = symbolic_binding y, 0 [symbolic = %y.loc4_9.1 (constants.%y)] +// CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic class @IntRange(imports.%Main.import_ref.6b552a.2: Core.IntLiteral) [from "lib.carbon"] { @@ -970,49 +980,45 @@ fn Read() { // CHECK:STDOUT: } // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: fn @Read() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %y.patt: %pattern_type.dc0 = symbolic_binding_pattern y, 0 [concrete] +// CHECK:STDOUT: generic fn @Read(%y.loc4_9.2: Core.IntLiteral) { +// CHECK:STDOUT: %y.loc4_9.1: Core.IntLiteral = symbolic_binding y, 0 [symbolic = %y.loc4_9.1 (constants.%y)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %y.loc4_9.1, constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.8ce [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.bound (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound)] +// CHECK:STDOUT: %bound_method.loc5_31.3: = bound_method %y.loc4_9.1, constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn [symbolic = %bound_method.loc5_31.3 (constants.%bound_method)] +// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc5_31.2: init %i32 = call %bound_method.loc5_31.3(%y.loc4_9.1) [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc5_31.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: name_binding_decl { +// CHECK:STDOUT: %x.patt: %pattern_type.d16 = ref_binding_pattern x [concrete] +// CHECK:STDOUT: %x.var_patt: %pattern_type.d16 = var_pattern %x.patt [concrete] +// CHECK:STDOUT: } +// CHECK:STDOUT: %x.var: ref %IntRange.365 = var %x.var_patt +// CHECK:STDOUT: %Range.ref: %Range.type = name_ref Range, imports.%Main.Range [concrete = constants.%Range] +// CHECK:STDOUT: %y.ref: Core.IntLiteral = name_ref y, %y.loc4_9.2 [symbolic = %y.loc4_9.1 (constants.%y)] +// CHECK:STDOUT: %.loc5_3: ref %IntRange.365 = splice_block %x.var {} +// CHECK:STDOUT: %impl.elem0: %.181 = impl_witness_access constants.%ImplicitAs.impl_witness.e97, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.8ce] +// CHECK:STDOUT: %bound_method.loc5_31.1: = bound_method %y.ref, %impl.elem0 [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.bound (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound)] +// CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] +// CHECK:STDOUT: %bound_method.loc5_31.2: = bound_method %y.ref, %specific_fn [symbolic = %bound_method.loc5_31.3 (constants.%bound_method)] +// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc5_31.1: init %i32 = call %bound_method.loc5_31.2(%y.ref) [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc5_31.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] +// CHECK:STDOUT: %.loc5_31.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc5_31.1 [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc5_31.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] +// CHECK:STDOUT: %.loc5_31.2: %i32 = converted %y.ref, %.loc5_31.1 [symbolic = %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc5_31.2 (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call)] +// CHECK:STDOUT: %Range.call: init %IntRange.365 = call %Range.ref(%.loc5_31.2) to %.loc5_3 +// CHECK:STDOUT: assign %x.var, %Range.call +// CHECK:STDOUT: %.loc5_21: type = splice_block %IntRange [concrete = constants.%IntRange.365] { +// CHECK:STDOUT: %IntRange.ref: %IntRange.type = name_ref IntRange, imports.%Main.IntRange [concrete = constants.%IntRange.generic] +// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %IntRange: type = class_type @IntRange, @IntRange(constants.%int_32) [concrete = constants.%IntRange.365] +// CHECK:STDOUT: } +// CHECK:STDOUT: %x: ref %IntRange.365 = ref_binding x, %x.var +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %x.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a04 +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a04, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn] +// CHECK:STDOUT: %bound_method.loc5_3: = bound_method %x.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn +// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc5_3(%x.var) +// CHECK:STDOUT: return // CHECK:STDOUT: } -// CHECK:STDOUT: %int_43: Core.IntLiteral = int_value 43 [concrete = constants.%int_43] -// CHECK:STDOUT: %.loc5_27.1: type = splice_block %.loc5_27.3 [concrete = Core.IntLiteral] { -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %Core.ref: = name_ref Core, imports.%Core.ece [concrete = imports.%Core.ece] -// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%Core.IntLiteral [concrete = constants.%IntLiteral] -// CHECK:STDOUT: %IntLiteral.call: init type = call %IntLiteral.ref() [concrete = Core.IntLiteral] -// CHECK:STDOUT: %.loc5_27.2: type = value_of_initializer %IntLiteral.call [concrete = Core.IntLiteral] -// CHECK:STDOUT: %.loc5_27.3: type = converted %IntLiteral.call, %.loc5_27.2 [concrete = Core.IntLiteral] -// CHECK:STDOUT: } -// CHECK:STDOUT: %y: Core.IntLiteral = symbolic_binding y, 0, %int_43 [symbolic = constants.%y] -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %x.patt: %pattern_type.d16 = ref_binding_pattern x [concrete] -// CHECK:STDOUT: %x.var_patt: %pattern_type.d16 = var_pattern %x.patt [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %x.var: ref %IntRange.365 = var %x.var_patt -// CHECK:STDOUT: %Range.ref: %Range.type = name_ref Range, imports.%Main.Range [concrete = constants.%Range] -// CHECK:STDOUT: %y.ref: Core.IntLiteral = name_ref y, %y [symbolic = constants.%y] -// CHECK:STDOUT: %.loc6_3: ref %IntRange.365 = splice_block %x.var {} -// CHECK:STDOUT: %impl.elem0: %.181 = impl_witness_access constants.%ImplicitAs.impl_witness.e97, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.8ce] -// CHECK:STDOUT: %bound_method.loc6_31.1: = bound_method %y.ref, %impl.elem0 [symbolic = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound] -// CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc6_31.2: = bound_method %y.ref, %specific_fn [symbolic = constants.%bound_method] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc6_31.2(%y.ref) [symbolic = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call] -// CHECK:STDOUT: %.loc6_31.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [symbolic = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call] -// CHECK:STDOUT: %.loc6_31.2: %i32 = converted %y.ref, %.loc6_31.1 [symbolic = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.call] -// CHECK:STDOUT: %Range.call: init %IntRange.365 = call %Range.ref(%.loc6_31.2) to %.loc6_3 -// CHECK:STDOUT: assign %x.var, %Range.call -// CHECK:STDOUT: %.loc6_21: type = splice_block %IntRange [concrete = constants.%IntRange.365] { -// CHECK:STDOUT: %IntRange.ref: %IntRange.type = name_ref IntRange, imports.%Main.IntRange [concrete = constants.%IntRange.generic] -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %IntRange: type = class_type @IntRange, @IntRange(constants.%int_32) [concrete = constants.%IntRange.365] -// CHECK:STDOUT: } -// CHECK:STDOUT: %x: ref %IntRange.365 = ref_binding x, %x.var -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound: = bound_method %x.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a04 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a04, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn] -// CHECK:STDOUT: %bound_method.loc6_3: = bound_method %x.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc6_3(%x.var) -// CHECK:STDOUT: return // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: generic fn @IntRange.Make(imports.%Main.import_ref.6b552a.1: Core.IntLiteral) [from "lib.carbon"] { @@ -1038,6 +1044,10 @@ fn Read() { // CHECK:STDOUT: // CHECK:STDOUT: fn @Range [from "lib.carbon"]; // CHECK:STDOUT: +// CHECK:STDOUT: specific @Read(constants.%y) { +// CHECK:STDOUT: %y.loc4_9.1 => constants.%y +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: specific @IntRange(constants.%N) { // CHECK:STDOUT: %N => constants.%N // CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/compile_time_bindings.carbon b/toolchain/check/testdata/let/compile_time_bindings.carbon index c8aa5bc4b01e..5c9f57c5cafc 100644 --- a/toolchain/check/testdata/let/compile_time_bindings.carbon +++ b/toolchain/check/testdata/let/compile_time_bindings.carbon @@ -60,10 +60,14 @@ class C { var c1: ((), ()) = c; var d1: ((), (), ()) = d; } - // CHECK:STDERR: fail_multiple_lets.carbon:[[@LINE+4]]:7: error: semantics TODO: ``let` compile time binding outside function or interface` [SemanticsTodo] + // CHECK:STDERR: fail_multiple_lets.carbon:[[@LINE+8]]:7: error: semantics TODO: ``let` compile time binding outside function or interface` [SemanticsTodo] // CHECK:STDERR: let d:! ((), (), ()) = ((), (), ()); // CHECK:STDERR: ^~~~~~~~~~~~~~~~ // CHECK:STDERR: + // CHECK:STDERR: fail_multiple_lets.carbon:[[@LINE-11]]:9: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let c:! ((), ()) = ((), ()); + // CHECK:STDERR: ^~~~~~~~~~~~ + // CHECK:STDERR: let d:! ((), (), ()) = ((), (), ()); } @@ -84,21 +88,29 @@ class C { let x:! (); } -// --- use_in_function.carbon +// --- fail_todo_use_in_function.carbon library "[[@TEST_NAME]]"; fn F() -> i32 { + // CHECK:STDERR: fail_todo_use_in_function.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Zero:! i32 = 0; + // CHECK:STDERR: ^~~~~~~~~~ + // CHECK:STDERR: let Zero:! i32 = 0; return Zero; } -// --- use_in_block.carbon +// --- fail_todo_use_in_block.carbon library "[[@TEST_NAME]]"; fn F() -> i32 { if (true) { + // CHECK:STDERR: fail_todo_use_in_block.carbon:[[@LINE+4]]:9: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let Zero:! i32 = 0; + // CHECK:STDERR: ^~~~~~~~~~ + // CHECK:STDERR: let Zero:! i32 = 0; return Zero; } @@ -319,50 +331,7 @@ impl i32 as Empty { // CHECK:STDOUT: %tuple.7e4: %tuple.type.2d5 = tuple_value (%empty_tuple, %empty_tuple, %empty_tuple) [concrete] // CHECK:STDOUT: %pattern_type.8c1: type = pattern_type %tuple.type.2d5 [concrete] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [concrete] -// CHECK:STDOUT: %complete_type.357: = complete_type_witness %empty_struct_type [concrete] -// CHECK:STDOUT: %tuple.type.bcd: type = tuple_type (%empty_tuple.type, %empty_tuple.type) [concrete] -// CHECK:STDOUT: %tuple.d8f: %tuple.type.bcd = tuple_value (%empty_tuple, %empty_tuple) [concrete] -// CHECK:STDOUT: %c: %tuple.type.bcd = symbolic_binding c, 1 [symbolic] -// CHECK:STDOUT: %pattern_type.5b8: type = pattern_type %tuple.type.bcd [concrete] -// CHECK:STDOUT: %tuple.elem0.4ff: %empty_tuple.type = tuple_access %b, element0 [symbolic] -// CHECK:STDOUT: %tuple.elem0.f56: %empty_tuple.type = tuple_access %c, element0 [symbolic] -// CHECK:STDOUT: %tuple.elem1: %empty_tuple.type = tuple_access %c, element1 [symbolic] -// CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] -// CHECK:STDOUT: %type_where: type = facet_type > [concrete] -// CHECK:STDOUT: %facet_value.c7f: %type_where = facet_value %tuple.type.2d5, () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.353: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.c7f) [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.17f: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.353 = struct_value () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.3e9: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.17f, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value.c7f) [concrete] -// CHECK:STDOUT: %facet_value.dcc: %type_where = facet_value %tuple.type.bcd, () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.a2a: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.dcc) [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.7d9: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.a2a = struct_value () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1f1: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.7d9, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value.dcc) [concrete] -// CHECK:STDOUT: %facet_value.132: %type_where = facet_value %tuple.type.9fb, () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.5e9: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.132) [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.baa: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.5e9 = struct_value () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.12a: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.baa, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value.132) [concrete] -// CHECK:STDOUT: %facet_value.ff9: %type_where = facet_value %empty_tuple.type, () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.fb5: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value.ff9) [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.144: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.fb5 = struct_value () [concrete] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.41b: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.144, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value.ff9) [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .Destroy = %Core.Destroy -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.Destroy: type = import_ref Core//prelude/parts/destroy, Destroy, loaded [concrete = constants.%Destroy.type] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [concrete] { -// CHECK:STDOUT: .Core = imports.%Core -// CHECK:STDOUT: .C = %C.decl -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.import = import Core -// CHECK:STDOUT: %C.decl: type = class_decl @C [concrete = constants.%C] {} {} +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { @@ -382,7 +351,7 @@ impl i32 as Empty { // CHECK:STDOUT: %b.patt: %pattern_type.559 = symbolic_binding_pattern b, 0 [concrete] // CHECK:STDOUT: } { // CHECK:STDOUT: %.loc10_16.1: type = splice_block %.loc10_16.4 [concrete = constants.%tuple.type.9fb] { -// CHECK:STDOUT: %.Self.2: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] +// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] // CHECK:STDOUT: %.loc10_14: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] // CHECK:STDOUT: %.loc10_16.2: %tuple.type.9fb = tuple_literal (%.loc10_14) [concrete = constants.%tuple.f41] // CHECK:STDOUT: %.loc10_16.3: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] @@ -393,31 +362,31 @@ impl i32 as Empty { // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %d.patt: %pattern_type.8c1 = value_binding_pattern d [concrete] // CHECK:STDOUT: } -// CHECK:STDOUT: %.loc22_28: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_32: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_36: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_37.1: %tuple.type.2d5 = tuple_literal (%.loc22_28, %.loc22_32, %.loc22_36) [concrete = constants.%tuple.7e4] -// CHECK:STDOUT: %.loc22_22.1: type = splice_block %.loc22_22.6 [concrete = constants.%tuple.type.2d5] { +// CHECK:STDOUT: %.loc26_28: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_32: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_36: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_37.1: %tuple.type.2d5 = tuple_literal (%.loc26_28, %.loc26_32, %.loc26_36) [concrete = constants.%tuple.7e4] +// CHECK:STDOUT: %.loc26_22.1: type = splice_block %.loc26_22.6 [concrete = constants.%tuple.type.2d5] { // CHECK:STDOUT: %.Self.1: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %.loc22_13: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_17: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_21: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_22.2: %tuple.type.2d5 = tuple_literal (%.loc22_13, %.loc22_17, %.loc22_21) [concrete = constants.%tuple.7e4] -// CHECK:STDOUT: %.loc22_22.3: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc22_22.4: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc22_22.5: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc22_22.6: type = converted %.loc22_22.2, constants.%tuple.type.2d5 [concrete = constants.%tuple.type.2d5] +// CHECK:STDOUT: %.loc26_13: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_17: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_21: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_22.2: %tuple.type.2d5 = tuple_literal (%.loc26_13, %.loc26_17, %.loc26_21) [concrete = constants.%tuple.7e4] +// CHECK:STDOUT: %.loc26_22.3: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] +// CHECK:STDOUT: %.loc26_22.4: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] +// CHECK:STDOUT: %.loc26_22.5: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] +// CHECK:STDOUT: %.loc26_22.6: type = converted %.loc26_22.2, constants.%tuple.type.2d5 [concrete = constants.%tuple.type.2d5] // CHECK:STDOUT: } -// CHECK:STDOUT: %empty_tuple.loc22_28: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_37.2: %empty_tuple.type = converted %.loc22_28, %empty_tuple.loc22_28 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %empty_tuple.loc22_32: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_37.3: %empty_tuple.type = converted %.loc22_32, %empty_tuple.loc22_32 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %empty_tuple.loc22_36: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc22_37.4: %empty_tuple.type = converted %.loc22_36, %empty_tuple.loc22_36 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %tuple: %tuple.type.2d5 = tuple_value (%.loc22_37.2, %.loc22_37.3, %.loc22_37.4) [concrete = constants.%tuple.7e4] -// CHECK:STDOUT: %.loc22_37.5: %tuple.type.2d5 = converted %.loc22_37.1, %tuple [concrete = constants.%tuple.7e4] -// CHECK:STDOUT: %d: %tuple.type.2d5 = value_binding d, %.loc22_37.5 -// CHECK:STDOUT: %complete_type: = complete_type_witness constants.%empty_struct_type [concrete = constants.%complete_type.357] +// CHECK:STDOUT: %empty_tuple.loc26_28: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_37.2: %empty_tuple.type = converted %.loc26_28, %empty_tuple.loc26_28 [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %empty_tuple.loc26_32: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_37.3: %empty_tuple.type = converted %.loc26_32, %empty_tuple.loc26_32 [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %empty_tuple.loc26_36: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %.loc26_37.4: %empty_tuple.type = converted %.loc26_36, %empty_tuple.loc26_36 [concrete = constants.%empty_tuple] +// CHECK:STDOUT: %tuple: %tuple.type.2d5 = tuple_value (%.loc26_37.2, %.loc26_37.3, %.loc26_37.4) [concrete = constants.%tuple.7e4] +// CHECK:STDOUT: %.loc26_37.5: %tuple.type.2d5 = converted %.loc26_37.1, %tuple [concrete = constants.%tuple.7e4] +// CHECK:STDOUT: %d: %tuple.type.2d5 = value_binding d, %.loc26_37.5 +// CHECK:STDOUT: %complete_type: = complete_type_witness constants.%empty_struct_type [concrete = constants.%complete_type] // CHECK:STDOUT: complete_type_witness = %complete_type // CHECK:STDOUT: // CHECK:STDOUT: !members: @@ -430,146 +399,7 @@ impl i32 as Empty { // CHECK:STDOUT: generic fn @C.F(%b.loc10_8.2: %tuple.type.9fb) { // CHECK:STDOUT: %b.loc10_8.1: %tuple.type.9fb = symbolic_binding b, 0 [symbolic = %b.loc10_8.1 (constants.%b)] // CHECK:STDOUT: -// CHECK:STDOUT: !definition: -// CHECK:STDOUT: %c.loc11_9.2: %tuple.type.bcd = symbolic_binding c, 1 [symbolic = %c.loc11_9.2 (constants.%c)] -// CHECK:STDOUT: %tuple.elem0.loc14_21.3: %empty_tuple.type = tuple_access %b.loc10_8.1, element0 [symbolic = %tuple.elem0.loc14_21.3 (constants.%tuple.elem0.4ff)] -// CHECK:STDOUT: %tuple.elem0.loc15_24.3: %empty_tuple.type = tuple_access %c.loc11_9.2, element0 [symbolic = %tuple.elem0.loc15_24.3 (constants.%tuple.elem0.f56)] -// CHECK:STDOUT: %tuple.elem1.loc15_24.3: %empty_tuple.type = tuple_access %c.loc11_9.2, element1 [symbolic = %tuple.elem1.loc15_24.3 (constants.%tuple.elem1)] -// CHECK:STDOUT: -// CHECK:STDOUT: fn() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %c.patt: %pattern_type.5b8 = symbolic_binding_pattern c, 1 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %.loc11_26: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc11_30: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc11_31.1: %tuple.type.bcd = tuple_literal (%.loc11_26, %.loc11_30) [concrete = constants.%tuple.d8f] -// CHECK:STDOUT: %.loc11_20.1: type = splice_block %.loc11_20.5 [concrete = constants.%tuple.type.bcd] { -// CHECK:STDOUT: %.Self.1: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %.loc11_15: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc11_19: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc11_20.2: %tuple.type.bcd = tuple_literal (%.loc11_15, %.loc11_19) [concrete = constants.%tuple.d8f] -// CHECK:STDOUT: %.loc11_20.3: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc11_20.4: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc11_20.5: type = converted %.loc11_20.2, constants.%tuple.type.bcd [concrete = constants.%tuple.type.bcd] -// CHECK:STDOUT: } -// CHECK:STDOUT: %empty_tuple.loc11_26: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc11_31.2: %empty_tuple.type = converted %.loc11_26, %empty_tuple.loc11_26 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %empty_tuple.loc11_30: %empty_tuple.type = tuple_value () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc11_31.3: %empty_tuple.type = converted %.loc11_30, %empty_tuple.loc11_30 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %tuple: %tuple.type.bcd = tuple_value (%.loc11_31.2, %.loc11_31.3) [concrete = constants.%tuple.d8f] -// CHECK:STDOUT: %.loc11_31.4: %tuple.type.bcd = converted %.loc11_31.1, %tuple [concrete = constants.%tuple.d8f] -// CHECK:STDOUT: %c.loc11_9.1: %tuple.type.bcd = symbolic_binding c, 1, %.loc11_31.4 [symbolic = %c.loc11_9.2 (constants.%c)] -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %a1.patt: %pattern_type.cb1 = ref_binding_pattern a1 [concrete] -// CHECK:STDOUT: %a1.var_patt: %pattern_type.cb1 = var_pattern %a1.patt [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %a1.var: ref %empty_tuple.type = var %a1.var_patt -// CHECK:STDOUT: %a.ref: %empty_tuple.type = name_ref a, @C.%a -// CHECK:STDOUT: %.loc13_18: init %empty_tuple.type = tuple_init () to %a1.var [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc13_5: init %empty_tuple.type = converted %a.ref, %.loc13_18 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: assign %a1.var, %.loc13_5 -// CHECK:STDOUT: %.loc13_14.1: type = splice_block %.loc13_14.3 [concrete = constants.%empty_tuple.type] { -// CHECK:STDOUT: %.loc13_14.2: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc13_14.3: type = converted %.loc13_14.2, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: } -// CHECK:STDOUT: %a1: ref %empty_tuple.type = ref_binding a1, %a1.var -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %b1.patt: %pattern_type.559 = ref_binding_pattern b1 [concrete] -// CHECK:STDOUT: %b1.var_patt: %pattern_type.559 = var_pattern %b1.patt [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %b1.var: ref %tuple.type.9fb = var %b1.var_patt -// CHECK:STDOUT: %b.ref: %tuple.type.9fb = name_ref b, %b.loc10_8.2 [symbolic = %b.loc10_8.1 (constants.%b)] -// CHECK:STDOUT: %tuple.elem0.loc14_21.1: %empty_tuple.type = tuple_access %b.ref, element0 [symbolic = %tuple.elem0.loc14_21.3 (constants.%tuple.elem0.4ff)] -// CHECK:STDOUT: %tuple.elem0.loc14_21.2: ref %empty_tuple.type = tuple_access %b1.var, element0 -// CHECK:STDOUT: %.loc14_21.1: init %empty_tuple.type = tuple_init () to %tuple.elem0.loc14_21.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc14_21.2: init %empty_tuple.type = converted %tuple.elem0.loc14_21.1, %.loc14_21.1 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc14_21.3: init %tuple.type.9fb = tuple_init (%.loc14_21.2) to %b1.var [concrete = constants.%tuple.f41] -// CHECK:STDOUT: %.loc14_5: init %tuple.type.9fb = converted %b.ref, %.loc14_21.3 [concrete = constants.%tuple.f41] -// CHECK:STDOUT: assign %b1.var, %.loc14_5 -// CHECK:STDOUT: %.loc14_17.1: type = splice_block %.loc14_17.4 [concrete = constants.%tuple.type.9fb] { -// CHECK:STDOUT: %.loc14_15: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc14_17.2: %tuple.type.9fb = tuple_literal (%.loc14_15) [concrete = constants.%tuple.f41] -// CHECK:STDOUT: %.loc14_17.3: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc14_17.4: type = converted %.loc14_17.2, constants.%tuple.type.9fb [concrete = constants.%tuple.type.9fb] -// CHECK:STDOUT: } -// CHECK:STDOUT: %b1: ref %tuple.type.9fb = ref_binding b1, %b1.var -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %c1.patt: %pattern_type.5b8 = ref_binding_pattern c1 [concrete] -// CHECK:STDOUT: %c1.var_patt: %pattern_type.5b8 = var_pattern %c1.patt [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %c1.var: ref %tuple.type.bcd = var %c1.var_patt -// CHECK:STDOUT: %c.ref: %tuple.type.bcd = name_ref c, %c.loc11_9.1 [symbolic = %c.loc11_9.2 (constants.%c)] -// CHECK:STDOUT: %tuple.elem0.loc15_24.1: %empty_tuple.type = tuple_access %c.ref, element0 [symbolic = %tuple.elem0.loc15_24.3 (constants.%tuple.elem0.f56)] -// CHECK:STDOUT: %tuple.elem0.loc15_24.2: ref %empty_tuple.type = tuple_access %c1.var, element0 -// CHECK:STDOUT: %.loc15_24.1: init %empty_tuple.type = tuple_init () to %tuple.elem0.loc15_24.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc15_24.2: init %empty_tuple.type = converted %tuple.elem0.loc15_24.1, %.loc15_24.1 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %tuple.elem1.loc15_24.1: %empty_tuple.type = tuple_access %c.ref, element1 [symbolic = %tuple.elem1.loc15_24.3 (constants.%tuple.elem1)] -// CHECK:STDOUT: %tuple.elem1.loc15_24.2: ref %empty_tuple.type = tuple_access %c1.var, element1 -// CHECK:STDOUT: %.loc15_24.3: init %empty_tuple.type = tuple_init () to %tuple.elem1.loc15_24.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc15_24.4: init %empty_tuple.type = converted %tuple.elem1.loc15_24.1, %.loc15_24.3 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc15_24.5: init %tuple.type.bcd = tuple_init (%.loc15_24.2, %.loc15_24.4) to %c1.var [concrete = constants.%tuple.d8f] -// CHECK:STDOUT: %.loc15_5: init %tuple.type.bcd = converted %c.ref, %.loc15_24.5 [concrete = constants.%tuple.d8f] -// CHECK:STDOUT: assign %c1.var, %.loc15_5 -// CHECK:STDOUT: %.loc15_20.1: type = splice_block %.loc15_20.5 [concrete = constants.%tuple.type.bcd] { -// CHECK:STDOUT: %.loc15_15: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc15_19: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc15_20.2: %tuple.type.bcd = tuple_literal (%.loc15_15, %.loc15_19) [concrete = constants.%tuple.d8f] -// CHECK:STDOUT: %.loc15_20.3: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc15_20.4: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc15_20.5: type = converted %.loc15_20.2, constants.%tuple.type.bcd [concrete = constants.%tuple.type.bcd] -// CHECK:STDOUT: } -// CHECK:STDOUT: %c1: ref %tuple.type.bcd = ref_binding c1, %c1.var -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %d1.patt: %pattern_type.8c1 = ref_binding_pattern d1 [concrete] -// CHECK:STDOUT: %d1.var_patt: %pattern_type.8c1 = var_pattern %d1.patt [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %d1.var: ref %tuple.type.2d5 = var %d1.var_patt -// CHECK:STDOUT: %d.ref: %tuple.type.2d5 = name_ref d, @C.%d -// CHECK:STDOUT: %tuple.elem0.loc16_28.1: %empty_tuple.type = tuple_access %d.ref, element0 -// CHECK:STDOUT: %tuple.elem0.loc16_28.2: ref %empty_tuple.type = tuple_access %d1.var, element0 -// CHECK:STDOUT: %.loc16_28.1: init %empty_tuple.type = tuple_init () to %tuple.elem0.loc16_28.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc16_28.2: init %empty_tuple.type = converted %tuple.elem0.loc16_28.1, %.loc16_28.1 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %tuple.elem1.loc16_28.1: %empty_tuple.type = tuple_access %d.ref, element1 -// CHECK:STDOUT: %tuple.elem1.loc16_28.2: ref %empty_tuple.type = tuple_access %d1.var, element1 -// CHECK:STDOUT: %.loc16_28.3: init %empty_tuple.type = tuple_init () to %tuple.elem1.loc16_28.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc16_28.4: init %empty_tuple.type = converted %tuple.elem1.loc16_28.1, %.loc16_28.3 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %tuple.elem2.loc16_28.1: %empty_tuple.type = tuple_access %d.ref, element2 -// CHECK:STDOUT: %tuple.elem2.loc16_28.2: ref %empty_tuple.type = tuple_access %d1.var, element2 -// CHECK:STDOUT: %.loc16_28.5: init %empty_tuple.type = tuple_init () to %tuple.elem2.loc16_28.2 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc16_28.6: init %empty_tuple.type = converted %tuple.elem2.loc16_28.1, %.loc16_28.5 [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc16_28.7: init %tuple.type.2d5 = tuple_init (%.loc16_28.2, %.loc16_28.4, %.loc16_28.6) to %d1.var [concrete = constants.%tuple.7e4] -// CHECK:STDOUT: %.loc16_5: init %tuple.type.2d5 = converted %d.ref, %.loc16_28.7 [concrete = constants.%tuple.7e4] -// CHECK:STDOUT: assign %d1.var, %.loc16_5 -// CHECK:STDOUT: %.loc16_24.1: type = splice_block %.loc16_24.6 [concrete = constants.%tuple.type.2d5] { -// CHECK:STDOUT: %.loc16_15: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc16_19: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc16_23: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple] -// CHECK:STDOUT: %.loc16_24.2: %tuple.type.2d5 = tuple_literal (%.loc16_15, %.loc16_19, %.loc16_23) [concrete = constants.%tuple.7e4] -// CHECK:STDOUT: %.loc16_24.3: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc16_24.4: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc16_24.5: type = converted constants.%empty_tuple, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type] -// CHECK:STDOUT: %.loc16_24.6: type = converted %.loc16_24.2, constants.%tuple.type.2d5 [concrete = constants.%tuple.type.2d5] -// CHECK:STDOUT: } -// CHECK:STDOUT: %d1: ref %tuple.type.2d5 = ref_binding d1, %d1.var -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc16: = bound_method %d1.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.17f -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.17f, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.c7f) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.3e9] -// CHECK:STDOUT: %bound_method.loc16: = bound_method %d1.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc16: init %empty_tuple.type = call %bound_method.loc16(%d1.var) -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc15: = bound_method %c1.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.7d9 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.7d9, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.dcc) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.1f1] -// CHECK:STDOUT: %bound_method.loc15: = bound_method %c1.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.2 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc15: init %empty_tuple.type = call %bound_method.loc15(%c1.var) -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc14: = bound_method %b1.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.baa -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.3: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.baa, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.132) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.12a] -// CHECK:STDOUT: %bound_method.loc14: = bound_method %b1.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.3 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc14: init %empty_tuple.type = call %bound_method.loc14(%b1.var) -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.bound.loc13: = bound_method %a1.var, constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.144 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.4: = specific_function constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.144, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value.ff9) [concrete = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.41b] -// CHECK:STDOUT: %bound_method.loc13: = bound_method %a1.var, %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn.4 -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call.loc13: init %empty_tuple.type = call %bound_method.loc13(%a1.var) -// CHECK:STDOUT: return -// CHECK:STDOUT: } +// CHECK:STDOUT: fn(); // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @C.F(constants.%b) { @@ -635,238 +465,23 @@ impl i32 as Empty { // CHECK:STDOUT: return %.loc5_26 to %return // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: --- use_in_function.carbon +// CHECK:STDOUT: --- fail_todo_use_in_function.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %Int.type: type = generic_class_type @Int [concrete] -// CHECK:STDOUT: %Int.generic: %Int.type = struct_value () [concrete] -// CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] -// CHECK:STDOUT: %F.type: type = fn_type @F [concrete] -// CHECK:STDOUT: %F: %F.type = struct_value () [concrete] -// CHECK:STDOUT: %type: type = facet_type [concrete] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self] -// CHECK:STDOUT: %Zero: %i32 = symbolic_binding Zero, 0 [symbolic] -// CHECK:STDOUT: %int_0.5c6: Core.IntLiteral = int_value 0 [concrete] -// CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] -// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] -// CHECK:STDOUT: %ImplicitAs.type.d14: type = facet_type <@ImplicitAs, @ImplicitAs(%i32)> [concrete] -// CHECK:STDOUT: %ImplicitAs.Convert.type.1b6: type = fn_type @ImplicitAs.Convert, @ImplicitAs(%i32) [concrete] -// CHECK:STDOUT: %To: Core.IntLiteral = symbolic_binding To, 0 [symbolic] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.412: type = fn_type @Core.IntLiteral.as.ImplicitAs.impl.Convert, @Core.IntLiteral.as.ImplicitAs.impl(%To) [symbolic] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.740: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.412 = struct_value () [symbolic] -// CHECK:STDOUT: %ImplicitAs.impl_witness.ec0: = impl_witness imports.%ImplicitAs.impl_witness_table.99e, @Core.IntLiteral.as.ImplicitAs.impl(%int_32) [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.84b: type = fn_type @Core.IntLiteral.as.ImplicitAs.impl.Convert, @Core.IntLiteral.as.ImplicitAs.impl(%int_32) [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.84b = struct_value () [concrete] -// CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.d14 = facet_value Core.IntLiteral, (%ImplicitAs.impl_witness.ec0) [concrete] -// CHECK:STDOUT: %.d28: type = fn_type_with_self_type %ImplicitAs.Convert.type.1b6, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.bound: = bound_method %int_0.5c6, %Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0 [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0, @Core.IntLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.6f8: = bound_method %int_0.5c6, %Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] -// CHECK:STDOUT: %int_0.6a9: %i32 = int_value 0 [concrete] -// CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] -// CHECK:STDOUT: %Copy.Op.type: type = fn_type @Copy.Op [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.type.413: type = fn_type @Int.as.Copy.impl.Op, @Int.as.Copy.impl(%N) [symbolic] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.2d6: %Int.as.Copy.impl.Op.type.413 = struct_value () [symbolic] -// CHECK:STDOUT: %Copy.impl_witness.09c: = impl_witness imports.%Copy.impl_witness_table.e1c, @Int.as.Copy.impl(%int_32) [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.type.60b: type = fn_type @Int.as.Copy.impl.Op, @Int.as.Copy.impl(%int_32) [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.c85: %Int.as.Copy.impl.Op.type.60b = struct_value () [concrete] -// CHECK:STDOUT: %Copy.facet: %Copy.type = facet_value %i32, (%Copy.impl_witness.09c) [concrete] -// CHECK:STDOUT: %.fe5: type = fn_type_with_self_type %Copy.Op.type, %Copy.facet [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.bound: = bound_method %Zero, %Int.as.Copy.impl.Op.c85 [symbolic] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.specific_fn: = specific_function %Int.as.Copy.impl.Op.c85, @Int.as.Copy.impl.Op(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1da: = bound_method %Zero, %Int.as.Copy.impl.Op.specific_fn [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .Int = %Core.Int -// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs -// CHECK:STDOUT: .Copy = %Core.Copy -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.Int: %Int.type = import_ref Core//prelude/parts/int, Int, loaded [concrete = constants.%Int.generic] -// CHECK:STDOUT: %Core.ImplicitAs: %ImplicitAs.type.cc7 = import_ref Core//prelude/parts/as, ImplicitAs, loaded [concrete = constants.%ImplicitAs.generic] -// CHECK:STDOUT: %Core.import_ref.3e1: @Core.IntLiteral.as.ImplicitAs.impl.%Core.IntLiteral.as.ImplicitAs.impl.Convert.type (%Core.IntLiteral.as.ImplicitAs.impl.Convert.type.412) = import_ref Core//prelude/parts/int, loc{{\d+_\d+}}, loaded [symbolic = @Core.IntLiteral.as.ImplicitAs.impl.%Core.IntLiteral.as.ImplicitAs.impl.Convert (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.740)] -// CHECK:STDOUT: %ImplicitAs.impl_witness_table.99e = impl_witness_table (%Core.import_ref.3e1), @Core.IntLiteral.as.ImplicitAs.impl [concrete] -// CHECK:STDOUT: %Core.Copy: type = import_ref Core//prelude/parts/copy, Copy, loaded [concrete = constants.%Copy.type] -// CHECK:STDOUT: %Core.import_ref.edf: @Int.as.Copy.impl.%Int.as.Copy.impl.Op.type (%Int.as.Copy.impl.Op.type.413) = import_ref Core//prelude/parts/int, loc{{\d+_\d+}}, loaded [symbolic = @Int.as.Copy.impl.%Int.as.Copy.impl.Op (constants.%Int.as.Copy.impl.Op.2d6)] -// CHECK:STDOUT: %Copy.impl_witness_table.e1c = impl_witness_table (%Core.import_ref.edf), @Int.as.Copy.impl [concrete] -// CHECK:STDOUT: } +// CHECK:STDOUT: fn @F() -> %i32; // CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [concrete] { -// 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 [concrete = constants.%F] { -// CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] -// CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param0 [concrete] -// CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc4: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc4: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %return.param: ref %i32 = out_param call_param0 -// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() -> %i32 { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %Zero.patt: %pattern_type.7ce = symbolic_binding_pattern Zero, 0 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %.loc5_14: type = splice_block %i32.loc5 [concrete = constants.%i32] { -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %int_32.loc5: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc5: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %impl.elem0.loc5: %.d28 = impl_witness_access constants.%ImplicitAs.impl_witness.ec0, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0] -// CHECK:STDOUT: %bound_method.loc5_20.1: = bound_method %int_0, %impl.elem0.loc5 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound] -// CHECK:STDOUT: %specific_fn.loc5: = specific_function %impl.elem0.loc5, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc5_20.2: = bound_method %int_0, %specific_fn.loc5 [concrete = constants.%bound_method.6f8] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call: init %i32 = call %bound_method.loc5_20.2(%int_0) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc5_20.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc5_20.2: %i32 = converted %int_0, %.loc5_20.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %Zero: %i32 = symbolic_binding Zero, 0, %.loc5_20.2 [symbolic = constants.%Zero] -// CHECK:STDOUT: %Zero.ref: %i32 = name_ref Zero, %Zero [symbolic = constants.%Zero] -// CHECK:STDOUT: %impl.elem0.loc6: %.fe5 = impl_witness_access constants.%Copy.impl_witness.09c, element0 [concrete = constants.%Int.as.Copy.impl.Op.c85] -// CHECK:STDOUT: %bound_method.loc6_10.1: = bound_method %Zero.ref, %impl.elem0.loc6 [symbolic = constants.%Int.as.Copy.impl.Op.bound] -// CHECK:STDOUT: %specific_fn.loc6: = specific_function %impl.elem0.loc6, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] -// CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %Zero.ref, %specific_fn.loc6 [symbolic = constants.%bound_method.1da] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_10.2(%Zero.ref) [symbolic = constants.%Zero] -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: --- use_in_block.carbon +// CHECK:STDOUT: --- fail_todo_use_in_block.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %Int.type: type = generic_class_type @Int [concrete] -// CHECK:STDOUT: %Int.generic: %Int.type = struct_value () [concrete] -// CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] -// CHECK:STDOUT: %F.type: type = fn_type @F [concrete] -// CHECK:STDOUT: %F: %F.type = struct_value () [concrete] -// CHECK:STDOUT: %true: bool = bool_literal true [concrete] -// CHECK:STDOUT: %type: type = facet_type [concrete] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self] -// CHECK:STDOUT: %Zero: %i32 = symbolic_binding Zero, 0 [symbolic] -// CHECK:STDOUT: %int_0.5c6: Core.IntLiteral = int_value 0 [concrete] -// CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] -// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] -// CHECK:STDOUT: %ImplicitAs.type.d14: type = facet_type <@ImplicitAs, @ImplicitAs(%i32)> [concrete] -// CHECK:STDOUT: %ImplicitAs.Convert.type.1b6: type = fn_type @ImplicitAs.Convert, @ImplicitAs(%i32) [concrete] -// CHECK:STDOUT: %To: Core.IntLiteral = symbolic_binding To, 0 [symbolic] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.412: type = fn_type @Core.IntLiteral.as.ImplicitAs.impl.Convert, @Core.IntLiteral.as.ImplicitAs.impl(%To) [symbolic] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.740: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.412 = struct_value () [symbolic] -// CHECK:STDOUT: %ImplicitAs.impl_witness.ec0: = impl_witness imports.%ImplicitAs.impl_witness_table.99e, @Core.IntLiteral.as.ImplicitAs.impl(%int_32) [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.84b: type = fn_type @Core.IntLiteral.as.ImplicitAs.impl.Convert, @Core.IntLiteral.as.ImplicitAs.impl(%int_32) [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0: %Core.IntLiteral.as.ImplicitAs.impl.Convert.type.84b = struct_value () [concrete] -// CHECK:STDOUT: %ImplicitAs.facet: %ImplicitAs.type.d14 = facet_value Core.IntLiteral, (%ImplicitAs.impl_witness.ec0) [concrete] -// CHECK:STDOUT: %.d28: type = fn_type_with_self_type %ImplicitAs.Convert.type.1b6, %ImplicitAs.facet [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.4b5: = bound_method %int_0.5c6, %Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0 [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn: = specific_function %Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0, @Core.IntLiteral.as.ImplicitAs.impl.Convert(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.6f8: = bound_method %int_0.5c6, %Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] -// CHECK:STDOUT: %int_0.6a9: %i32 = int_value 0 [concrete] -// CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] -// CHECK:STDOUT: %Copy.Op.type: type = fn_type @Copy.Op [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.type.413: type = fn_type @Int.as.Copy.impl.Op, @Int.as.Copy.impl(%N) [symbolic] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.2d6: %Int.as.Copy.impl.Op.type.413 = struct_value () [symbolic] -// CHECK:STDOUT: %Copy.impl_witness.09c: = impl_witness imports.%Copy.impl_witness_table.e1c, @Int.as.Copy.impl(%int_32) [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.type.60b: type = fn_type @Int.as.Copy.impl.Op, @Int.as.Copy.impl(%int_32) [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.c85: %Int.as.Copy.impl.Op.type.60b = struct_value () [concrete] -// CHECK:STDOUT: %Copy.facet: %Copy.type = facet_value %i32, (%Copy.impl_witness.09c) [concrete] -// CHECK:STDOUT: %.fe5: type = fn_type_with_self_type %Copy.Op.type, %Copy.facet [concrete] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.bound: = bound_method %Zero, %Int.as.Copy.impl.Op.c85 [symbolic] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.specific_fn: = specific_function %Int.as.Copy.impl.Op.c85, @Int.as.Copy.impl.Op(%int_32) [concrete] -// CHECK:STDOUT: %bound_method.1da: = bound_method %Zero, %Int.as.Copy.impl.Op.specific_fn [symbolic] -// CHECK:STDOUT: %int_1.5b8: Core.IntLiteral = int_value 1 [concrete] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.3d4: = bound_method %int_1.5b8, %Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0 [concrete] -// CHECK:STDOUT: %bound_method.d3a: = bound_method %int_1.5b8, %Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn [concrete] -// CHECK:STDOUT: %int_1.5d2: %i32 = int_value 1 [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .Int = %Core.Int -// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs -// CHECK:STDOUT: .Copy = %Core.Copy -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.Int: %Int.type = import_ref Core//prelude/parts/int, Int, loaded [concrete = constants.%Int.generic] -// CHECK:STDOUT: %Core.ImplicitAs: %ImplicitAs.type.cc7 = import_ref Core//prelude/parts/as, ImplicitAs, loaded [concrete = constants.%ImplicitAs.generic] -// CHECK:STDOUT: %Core.import_ref.3e1: @Core.IntLiteral.as.ImplicitAs.impl.%Core.IntLiteral.as.ImplicitAs.impl.Convert.type (%Core.IntLiteral.as.ImplicitAs.impl.Convert.type.412) = import_ref Core//prelude/parts/int, loc{{\d+_\d+}}, loaded [symbolic = @Core.IntLiteral.as.ImplicitAs.impl.%Core.IntLiteral.as.ImplicitAs.impl.Convert (constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.740)] -// CHECK:STDOUT: %ImplicitAs.impl_witness_table.99e = impl_witness_table (%Core.import_ref.3e1), @Core.IntLiteral.as.ImplicitAs.impl [concrete] -// CHECK:STDOUT: %Core.Copy: type = import_ref Core//prelude/parts/copy, Copy, loaded [concrete = constants.%Copy.type] -// CHECK:STDOUT: %Core.import_ref.edf: @Int.as.Copy.impl.%Int.as.Copy.impl.Op.type (%Int.as.Copy.impl.Op.type.413) = import_ref Core//prelude/parts/int, loc{{\d+_\d+}}, loaded [symbolic = @Int.as.Copy.impl.%Int.as.Copy.impl.Op (constants.%Int.as.Copy.impl.Op.2d6)] -// CHECK:STDOUT: %Copy.impl_witness_table.e1c = impl_witness_table (%Core.import_ref.edf), @Int.as.Copy.impl [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [concrete] { -// 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 [concrete = constants.%F] { -// CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] -// CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param0 [concrete] -// CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc4: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc4: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %return.param: ref %i32 = out_param call_param0 -// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() -> %i32 { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: %true: bool = bool_literal true [concrete = constants.%true] -// CHECK:STDOUT: if %true br !if.then else br !if.else -// CHECK:STDOUT: -// CHECK:STDOUT: !if.then: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %Zero.patt: %pattern_type.7ce = symbolic_binding_pattern Zero, 0 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0.5c6] -// CHECK:STDOUT: %.loc6_16: type = splice_block %i32.loc6 [concrete = constants.%i32] { -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %int_32.loc6: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc6: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %impl.elem0.loc6: %.d28 = impl_witness_access constants.%ImplicitAs.impl_witness.ec0, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0] -// CHECK:STDOUT: %bound_method.loc6_22.1: = bound_method %int_0, %impl.elem0.loc6 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.4b5] -// CHECK:STDOUT: %specific_fn.loc6: = specific_function %impl.elem0.loc6, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc6_22.2: = bound_method %int_0, %specific_fn.loc6 [concrete = constants.%bound_method.6f8] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6: init %i32 = call %bound_method.loc6_22.2(%int_0) [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc6_22.1: %i32 = value_of_initializer %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc6 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %.loc6_22.2: %i32 = converted %int_0, %.loc6_22.1 [concrete = constants.%int_0.6a9] -// CHECK:STDOUT: %Zero: %i32 = symbolic_binding Zero, 0, %.loc6_22.2 [symbolic = constants.%Zero] -// CHECK:STDOUT: %Zero.ref: %i32 = name_ref Zero, %Zero [symbolic = constants.%Zero] -// CHECK:STDOUT: %impl.elem0.loc7: %.fe5 = impl_witness_access constants.%Copy.impl_witness.09c, element0 [concrete = constants.%Int.as.Copy.impl.Op.c85] -// CHECK:STDOUT: %bound_method.loc7_12.1: = bound_method %Zero.ref, %impl.elem0.loc7 [symbolic = constants.%Int.as.Copy.impl.Op.bound] -// CHECK:STDOUT: %specific_fn.loc7: = specific_function %impl.elem0.loc7, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] -// CHECK:STDOUT: %bound_method.loc7_12.2: = bound_method %Zero.ref, %specific_fn.loc7 [symbolic = constants.%bound_method.1da] -// CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc7_12.2(%Zero.ref) [symbolic = constants.%Zero] -// CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return -// CHECK:STDOUT: -// CHECK:STDOUT: !if.else: -// CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [concrete = constants.%int_1.5b8] -// CHECK:STDOUT: %impl.elem0.loc9: %.d28 = impl_witness_access constants.%ImplicitAs.impl_witness.ec0, element0 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.6f0] -// CHECK:STDOUT: %bound_method.loc9_11.1: = bound_method %int_1, %impl.elem0.loc9 [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.bound.3d4] -// CHECK:STDOUT: %specific_fn.loc9: = specific_function %impl.elem0.loc9, @Core.IntLiteral.as.ImplicitAs.impl.Convert(constants.%int_32) [concrete = constants.%Core.IntLiteral.as.ImplicitAs.impl.Convert.specific_fn] -// CHECK:STDOUT: %bound_method.loc9_11.2: = bound_method %int_1, %specific_fn.loc9 [concrete = constants.%bound_method.d3a] -// CHECK:STDOUT: %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc9: init %i32 = call %bound_method.loc9_11.2(%int_1) [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: %.loc9: init %i32 = converted %int_1, %Core.IntLiteral.as.ImplicitAs.impl.Convert.call.loc9 [concrete = constants.%int_1.5d2] -// CHECK:STDOUT: return %.loc9 to %return -// CHECK:STDOUT: } +// CHECK:STDOUT: fn @F() -> %i32; // CHECK:STDOUT: // CHECK:STDOUT: --- return_in_interface.carbon // CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/fail_generic.carbon b/toolchain/check/testdata/let/fail_generic.carbon index 9a723be0fcb1..b25372b8a0c3 100644 --- a/toolchain/check/testdata/let/fail_generic.carbon +++ b/toolchain/check/testdata/let/fail_generic.carbon @@ -14,22 +14,12 @@ // TODO: Should this be valid? fn F(a: i32) -> i32 { + // CHECK:STDERR: fail_generic.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let T:! type = i32; + // CHECK:STDERR: ^~~~~~~~ + // CHECK:STDERR: let T:! type = i32; - // CHECK:STDERR: fail_generic.carbon:[[@LINE+7]]:14: error: cannot implicitly convert expression of type `Core.IntLiteral` to `T` [ConversionFailure] - // CHECK:STDERR: let x: T = 5; - // CHECK:STDERR: ^ - // CHECK:STDERR: fail_generic.carbon:[[@LINE+4]]:14: note: type `Core.IntLiteral` does not implement interface `Core.ImplicitAs(T)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: let x: T = 5; - // CHECK:STDERR: ^ - // CHECK:STDERR: let x: T = 5; - // CHECK:STDERR: fail_generic.carbon:[[@LINE+7]]:3: error: cannot implicitly convert expression of type `T` to `i32` [ConversionFailure] - // CHECK:STDERR: return x; - // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: fail_generic.carbon:[[@LINE+4]]:3: note: type `T` does not implement interface `Core.ImplicitAs(i32)` [MissingImplInMemberAccessNote] - // CHECK:STDERR: return x; - // CHECK:STDERR: ^~~~~~~~~ - // CHECK:STDERR: return x; } @@ -37,90 +27,8 @@ fn F(a: i32) -> i32 { // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %Int.type: type = generic_class_type @Int [concrete] -// CHECK:STDOUT: %Int.generic: %Int.type = struct_value () [concrete] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] -// CHECK:STDOUT: %F.type: type = fn_type @F [concrete] -// CHECK:STDOUT: %F: %F.type = struct_value () [concrete] -// CHECK:STDOUT: %type: type = facet_type [concrete] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self] -// CHECK:STDOUT: %T: type = symbolic_binding T, 0 [symbolic] -// CHECK:STDOUT: %pattern_type.98f: type = pattern_type type [concrete] -// CHECK:STDOUT: %pattern_type.51d1c4.1: type = pattern_type %T [symbolic] -// CHECK:STDOUT: %int_5: Core.IntLiteral = int_value 5 [concrete] -// CHECK:STDOUT: %ImplicitAs.type.cc7: type = generic_interface_type @ImplicitAs [concrete] -// CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.cc7 = struct_value () [concrete] -// CHECK:STDOUT: %Dest: type = symbolic_binding Dest, 0 [symbolic] -// CHECK:STDOUT: %ImplicitAs.assoc_type.ff3a0a.1: type = assoc_entity_type @ImplicitAs, @ImplicitAs(%Dest) [symbolic] -// CHECK:STDOUT: %ImplicitAs.Convert.type.6d3439.1: type = fn_type @ImplicitAs.Convert, @ImplicitAs(%Dest) [symbolic] -// CHECK:STDOUT: %ImplicitAs.Convert.50ff02.1: %ImplicitAs.Convert.type.6d3439.1 = struct_value () [symbolic] -// CHECK:STDOUT: %ImplicitAs.type.985f4d.2: type = facet_type <@ImplicitAs, @ImplicitAs(%T)> [symbolic] -// CHECK:STDOUT: %ImplicitAs.assoc_type.ff3a0a.2: type = assoc_entity_type @ImplicitAs, @ImplicitAs(%T) [symbolic] -// CHECK:STDOUT: %assoc0.d89b5b.2: %ImplicitAs.assoc_type.ff3a0a.2 = assoc_entity element0, imports.%Core.import_ref.d3c [symbolic] -// CHECK:STDOUT: %assoc0.df2: %ImplicitAs.assoc_type.ff3a0a.1 = assoc_entity element0, imports.%Core.import_ref.a08 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .Int = %Core.Int -// CHECK:STDOUT: .ImplicitAs = %Core.ImplicitAs -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.Int: %Int.type = import_ref Core//prelude/parts/int, Int, loaded [concrete = constants.%Int.generic] -// CHECK:STDOUT: %Core.ImplicitAs: %ImplicitAs.type.cc7 = import_ref Core//prelude/parts/as, ImplicitAs, loaded [concrete = constants.%ImplicitAs.generic] -// CHECK:STDOUT: %Core.import_ref.c18: @ImplicitAs.%ImplicitAs.assoc_type (%ImplicitAs.assoc_type.ff3a0a.1) = import_ref Core//prelude/parts/as, loc{{\d+_\d+}}, loaded [symbolic = @ImplicitAs.%assoc0 (constants.%assoc0.df2)] -// CHECK:STDOUT: %Core.import_ref.d3c: @ImplicitAs.%ImplicitAs.Convert.type (%ImplicitAs.Convert.type.6d3439.1) = import_ref Core//prelude/parts/as, loc{{\d+_\d+}}, loaded [symbolic = @ImplicitAs.%ImplicitAs.Convert (constants.%ImplicitAs.Convert.50ff02.1)] -// CHECK:STDOUT: %Core.import_ref.a08 = import_ref Core//prelude/parts/as, loc{{\d+_\d+}}, unloaded -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [concrete] { -// 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 [concrete = constants.%F] { -// CHECK:STDOUT: %a.patt: %pattern_type.7ce = value_binding_pattern a [concrete] -// CHECK:STDOUT: %a.param_patt: %pattern_type.7ce = value_param_pattern %a.patt, call_param0 [concrete] -// CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] -// CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param1 [concrete] -// CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc16_17: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc16_17: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %a.param: %i32 = value_param call_param0 -// CHECK:STDOUT: %.loc16: type = splice_block %i32.loc16_9 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc16_9: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc16_9: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %a: %i32 = value_binding a, %a.param -// CHECK:STDOUT: %return.param: ref %i32 = out_param call_param1 -// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F(%a.param: %i32) -> %i32 { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %T.patt: %pattern_type.98f = symbolic_binding_pattern T, 0 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %int_32.loc17: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc17: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %T: type = symbolic_binding T, 0, %i32.loc17 [symbolic = constants.%T] -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %x.patt: %pattern_type.51d1c4.1 = value_binding_pattern x [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %int_5: Core.IntLiteral = int_value 5 [concrete = constants.%int_5] -// CHECK:STDOUT: %T.ref: type = name_ref T, %T [symbolic = constants.%T] -// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(constants.%T)> [symbolic = constants.%ImplicitAs.type.985f4d.2] -// CHECK:STDOUT: %.loc25_14.1: %ImplicitAs.assoc_type.ff3a0a.2 = specific_constant imports.%Core.import_ref.c18, @ImplicitAs(constants.%T) [symbolic = constants.%assoc0.d89b5b.2] -// CHECK:STDOUT: %Convert.ref: %ImplicitAs.assoc_type.ff3a0a.2 = name_ref Convert, %.loc25_14.1 [symbolic = constants.%assoc0.d89b5b.2] -// CHECK:STDOUT: %.loc25_14.2: %T = converted %int_5, [concrete = ] -// CHECK:STDOUT: %x: %T = value_binding x, [concrete = ] -// CHECK:STDOUT: %x.ref: %T = name_ref x, %x [concrete = ] -// CHECK:STDOUT: %.loc33: %i32 = converted %x.ref, [concrete = ] -// CHECK:STDOUT: return to %return -// CHECK:STDOUT: } +// CHECK:STDOUT: fn @F(%a.param: %i32) -> %i32; // CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/generic.carbon b/toolchain/check/testdata/let/generic.carbon index 15e6723e3467..cecc85cdc5dc 100644 --- a/toolchain/check/testdata/let/generic.carbon +++ b/toolchain/check/testdata/let/generic.carbon @@ -12,99 +12,45 @@ // TIP: To dump output, run: // TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/let/generic.carbon +// --- fail_todo_type.carbon +library "[[@TEST_NAME]]"; + fn F() { + // CHECK:STDERR: fail_todo_type.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let T:! type = i32; + // CHECK:STDERR: ^~~~~~~~ + // CHECK:STDERR: let T:! type = i32; var p: T*; let a: T = *p; } -// CHECK:STDOUT: --- generic.carbon +// --- fail_todo_assignment.carbon +library "[[@TEST_NAME]]"; + +fn F(a: i32) -> i32 { + // CHECK:STDERR: fail_todo_assignment.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let T:! type = i32; + // CHECK:STDERR: ^~~~~~~~ + // CHECK:STDERR: + let T:! type = i32; + let x: T = 5; + return x; +} + +// CHECK:STDOUT: --- fail_todo_type.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F(); +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_todo_assignment.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { -// CHECK:STDOUT: %F.type: type = fn_type @F [concrete] -// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete] -// CHECK:STDOUT: %F: %F.type = struct_value () [concrete] -// CHECK:STDOUT: %type: type = facet_type [concrete] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self] -// CHECK:STDOUT: %T: type = symbolic_binding T, 0 [symbolic] -// CHECK:STDOUT: %pattern_type.98f: type = pattern_type type [concrete] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %Int.type: type = generic_class_type @Int [concrete] -// CHECK:STDOUT: %Int.generic: %Int.type = struct_value () [concrete] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] -// CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic] -// CHECK:STDOUT: %pattern_type.4f4: type = pattern_type %ptr [symbolic] -// CHECK:STDOUT: %pattern_type.51d: type = pattern_type %T [symbolic] -// CHECK:STDOUT: %Destroy.type: type = facet_type <@Destroy> [concrete] -// CHECK:STDOUT: %Destroy.Op.type: type = fn_type @Destroy.Op [concrete] -// CHECK:STDOUT: %type_where: type = facet_type > [concrete] -// CHECK:STDOUT: %DestroyT: %type_where = symbolic_binding DestroyT, 0 [symbolic] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.0bf: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%DestroyT) [symbolic] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.97a: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.0bf = struct_value () [symbolic] -// CHECK:STDOUT: %facet_value: %type_where = facet_value %ptr, () [symbolic] -// CHECK:STDOUT: %Destroy.impl_witness.318: = impl_witness imports.%Destroy.impl_witness_table, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [symbolic] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.eba: type = fn_type @DestroyT.binding.as_type.as.Destroy.impl.Op, @DestroyT.binding.as_type.as.Destroy.impl(%facet_value) [symbolic] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.a14: %DestroyT.binding.as_type.as.Destroy.impl.Op.type.eba = struct_value () [symbolic] -// CHECK:STDOUT: %Destroy.facet: %Destroy.type = facet_value %ptr, (%Destroy.impl_witness.318) [symbolic] -// CHECK:STDOUT: %.005: type = fn_type_with_self_type %Destroy.Op.type, %Destroy.facet [symbolic] -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn: = specific_function %DestroyT.binding.as_type.as.Destroy.impl.Op.a14, @DestroyT.binding.as_type.as.Destroy.impl.Op(%facet_value) [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .Int = %Core.Int -// CHECK:STDOUT: .Destroy = %Core.Destroy -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.Int: %Int.type = import_ref Core//prelude/parts/int, Int, loaded [concrete = constants.%Int.generic] -// CHECK:STDOUT: %Core.Destroy: type = import_ref Core//prelude/parts/destroy, Destroy, loaded [concrete = constants.%Destroy.type] -// CHECK:STDOUT: %Core.import_ref.de0: @DestroyT.binding.as_type.as.Destroy.impl.%DestroyT.binding.as_type.as.Destroy.impl.Op.type (%DestroyT.binding.as_type.as.Destroy.impl.Op.type.0bf) = import_ref Core//prelude/parts/destroy, loc{{\d+_\d+}}, loaded [symbolic = @DestroyT.binding.as_type.as.Destroy.impl.%DestroyT.binding.as_type.as.Destroy.impl.Op (constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.97a)] -// CHECK:STDOUT: %Destroy.impl_witness_table = impl_witness_table (%Core.import_ref.de0), @DestroyT.binding.as_type.as.Destroy.impl [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [concrete] { -// 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 [concrete = constants.%F] {} {} -// CHECK:STDOUT: } -// CHECK:STDOUT: -// CHECK:STDOUT: fn @F() { -// CHECK:STDOUT: !entry: -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %T.patt: %pattern_type.98f = symbolic_binding_pattern T, 0 [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self] -// CHECK:STDOUT: %T: type = symbolic_binding T, 0, %i32 [symbolic = constants.%T] -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %p.patt: %pattern_type.4f4 = ref_binding_pattern p [concrete] -// CHECK:STDOUT: %p.var_patt: %pattern_type.4f4 = var_pattern %p.patt [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %p.var: ref %ptr = var %p.var_patt -// CHECK:STDOUT: %.loc17: type = splice_block %ptr [symbolic = constants.%ptr] { -// CHECK:STDOUT: %T.ref.loc17: type = name_ref T, %T [symbolic = constants.%T] -// CHECK:STDOUT: %ptr: type = ptr_type %T.ref.loc17 [symbolic = constants.%ptr] -// CHECK:STDOUT: } -// CHECK:STDOUT: %p: ref %ptr = ref_binding p, %p.var -// CHECK:STDOUT: name_binding_decl { -// CHECK:STDOUT: %a.patt: %pattern_type.51d = value_binding_pattern a [concrete] -// CHECK:STDOUT: } -// CHECK:STDOUT: %p.ref: ref %ptr = name_ref p, %p -// CHECK:STDOUT: %.loc18_15: %ptr = acquire_value %p.ref -// CHECK:STDOUT: %.loc18_14.1: ref %T = deref %.loc18_15 -// CHECK:STDOUT: %T.ref.loc18: type = name_ref T, %T [symbolic = constants.%T] -// CHECK:STDOUT: %.loc18_14.2: %T = acquire_value %.loc18_14.1 -// CHECK:STDOUT: %a: %T = value_binding a, %.loc18_14.2 -// CHECK:STDOUT: %impl.elem0: %.005 = impl_witness_access constants.%Destroy.impl_witness.318, element0 [symbolic = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.a14] -// CHECK:STDOUT: %bound_method.loc17_3.1: = bound_method %p.var, %impl.elem0 -// CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @DestroyT.binding.as_type.as.Destroy.impl.Op(constants.%facet_value) [symbolic = constants.%DestroyT.binding.as_type.as.Destroy.impl.Op.specific_fn] -// CHECK:STDOUT: %bound_method.loc17_3.2: = bound_method %p.var, %specific_fn -// CHECK:STDOUT: %DestroyT.binding.as_type.as.Destroy.impl.Op.call: init %empty_tuple.type = call %bound_method.loc17_3.2(%p.var) -// CHECK:STDOUT: return -// CHECK:STDOUT: } +// CHECK:STDOUT: fn @F(%a.param: %i32) -> %i32; // CHECK:STDOUT: diff --git a/toolchain/check/testdata/let/local.carbon b/toolchain/check/testdata/let/local.carbon index d5c8d50bef07..aebd1ca60a50 100644 --- a/toolchain/check/testdata/let/local.carbon +++ b/toolchain/check/testdata/let/local.carbon @@ -3,8 +3,6 @@ // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // // INCLUDE-FILE: toolchain/testing/testdata/min_prelude/int.carbon -// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only". -// EXTRA-ARGS: --dump-sem-ir-ranges=if-present // // AUTOUPDATE // TIP: To test this file alone, run: @@ -12,22 +10,41 @@ // TIP: To dump output, run: // TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/let/local.carbon +// --- local.carbon +library "[[@TEST_NAME]]"; + fn F(a: i32) -> i32 { + //@dump-sem-ir-begin let b: i32 = a; return b; + //@dump-sem-ir-end +} + +// --- fail_todo_symbolic.carbon +library "[[@TEST_NAME]]"; + +class C {} + +fn F(c: C) {} + +fn CallF() { + //@dump-sem-ir-begin + // CHECK:STDERR: fail_todo_symbolic.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let c:! C = {}; + // CHECK:STDERR: ^~~~~ + // CHECK:STDERR: + let c:! C = {}; + F(c); + //@dump-sem-ir-end } // CHECK:STDOUT: --- local.carbon // CHECK:STDOUT: // CHECK:STDOUT: constants { // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [concrete] -// CHECK:STDOUT: %Int.type: type = generic_class_type @Int [concrete] -// CHECK:STDOUT: %Int.generic: %Int.type = struct_value () [concrete] // CHECK:STDOUT: %N: Core.IntLiteral = symbolic_binding N, 0 [symbolic] // CHECK:STDOUT: %i32: type = class_type @Int, @Int(%int_32) [concrete] // CHECK:STDOUT: %pattern_type.7ce: type = pattern_type %i32 [concrete] -// CHECK:STDOUT: %F.type: type = fn_type @F [concrete] -// CHECK:STDOUT: %F: %F.type = struct_value () [concrete] // CHECK:STDOUT: %Copy.type: type = facet_type <@Copy> [concrete] // CHECK:STDOUT: %Copy.Op.type: type = fn_type @Copy.Op [concrete] // CHECK:STDOUT: %Int.as.Copy.impl.Op.type.413: type = fn_type @Int.as.Copy.impl.Op, @Int.as.Copy.impl(%N) [symbolic] @@ -41,60 +58,34 @@ fn F(a: i32) -> i32 { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { -// CHECK:STDOUT: %Core: = namespace file.%Core.import, [concrete] { -// CHECK:STDOUT: .Int = %Core.Int -// CHECK:STDOUT: .Copy = %Core.Copy -// CHECK:STDOUT: import Core//prelude -// CHECK:STDOUT: import Core//prelude/... -// CHECK:STDOUT: } -// CHECK:STDOUT: %Core.Int: %Int.type = import_ref Core//prelude/parts/int, Int, loaded [concrete = constants.%Int.generic] -// CHECK:STDOUT: %Core.Copy: type = import_ref Core//prelude/parts/copy, Copy, loaded [concrete = constants.%Copy.type] // CHECK:STDOUT: %Core.import_ref.edf: @Int.as.Copy.impl.%Int.as.Copy.impl.Op.type (%Int.as.Copy.impl.Op.type.413) = import_ref Core//prelude/parts/int, loc{{\d+_\d+}}, loaded [symbolic = @Int.as.Copy.impl.%Int.as.Copy.impl.Op (constants.%Int.as.Copy.impl.Op.2d6)] // CHECK:STDOUT: %Copy.impl_witness_table.e1c = impl_witness_table (%Core.import_ref.edf), @Int.as.Copy.impl [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: -// CHECK:STDOUT: file { -// CHECK:STDOUT: package: = namespace [concrete] { -// 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 [concrete = constants.%F] { -// CHECK:STDOUT: %a.patt: %pattern_type.7ce = value_binding_pattern a [concrete] -// CHECK:STDOUT: %a.param_patt: %pattern_type.7ce = value_param_pattern %a.patt, call_param0 [concrete] -// CHECK:STDOUT: %return.patt: %pattern_type.7ce = return_slot_pattern [concrete] -// CHECK:STDOUT: %return.param_patt: %pattern_type.7ce = out_param_pattern %return.patt, call_param1 [concrete] -// CHECK:STDOUT: } { -// CHECK:STDOUT: %int_32.loc15_17: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc15_17: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: %a.param: %i32 = value_param call_param0 -// CHECK:STDOUT: %.loc15: type = splice_block %i32.loc15_9 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc15_9: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc15_9: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] -// CHECK:STDOUT: } -// CHECK:STDOUT: %a: %i32 = value_binding a, %a.param -// CHECK:STDOUT: %return.param: ref %i32 = out_param call_param1 -// CHECK:STDOUT: %return: ref %i32 = return_slot %return.param -// CHECK:STDOUT: } -// CHECK:STDOUT: } -// CHECK:STDOUT: // CHECK:STDOUT: fn @F(%a.param: %i32) -> %i32 { // CHECK:STDOUT: !entry: // CHECK:STDOUT: name_binding_decl { // CHECK:STDOUT: %b.patt: %pattern_type.7ce = value_binding_pattern b [concrete] // CHECK:STDOUT: } // CHECK:STDOUT: %a.ref: %i32 = name_ref a, %a -// CHECK:STDOUT: %.loc16: type = splice_block %i32.loc16 [concrete = constants.%i32] { -// CHECK:STDOUT: %int_32.loc16: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] -// CHECK:STDOUT: %i32.loc16: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] +// CHECK:STDOUT: %.loc5: type = splice_block %i32.loc5 [concrete = constants.%i32] { +// CHECK:STDOUT: %int_32.loc5: Core.IntLiteral = int_value 32 [concrete = constants.%int_32] +// CHECK:STDOUT: %i32.loc5: type = class_type @Int, @Int(constants.%int_32) [concrete = constants.%i32] // CHECK:STDOUT: } // CHECK:STDOUT: %b: %i32 = value_binding b, %a.ref // CHECK:STDOUT: %b.ref: %i32 = name_ref b, %b // CHECK:STDOUT: %impl.elem0: %.fe5 = impl_witness_access constants.%Copy.impl_witness.09c, element0 [concrete = constants.%Int.as.Copy.impl.Op.c85] -// CHECK:STDOUT: %bound_method.loc17_10.1: = bound_method %b.ref, %impl.elem0 +// CHECK:STDOUT: %bound_method.loc6_10.1: = bound_method %b.ref, %impl.elem0 // CHECK:STDOUT: %specific_fn: = specific_function %impl.elem0, @Int.as.Copy.impl.Op(constants.%int_32) [concrete = constants.%Int.as.Copy.impl.Op.specific_fn] -// CHECK:STDOUT: %bound_method.loc17_10.2: = bound_method %b.ref, %specific_fn -// CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc17_10.2(%b.ref) +// CHECK:STDOUT: %bound_method.loc6_10.2: = bound_method %b.ref, %specific_fn +// CHECK:STDOUT: %Int.as.Copy.impl.Op.call: init %i32 = call %bound_method.loc6_10.2(%b.ref) // CHECK:STDOUT: return %Int.as.Copy.impl.Op.call to %return // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: --- fail_todo_symbolic.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @CallF(); +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/where_expr/equal_rewrite.carbon b/toolchain/check/testdata/where_expr/equal_rewrite.carbon index edb0ffcb5645..aa6a42529cd4 100644 --- a/toolchain/check/testdata/where_expr/equal_rewrite.carbon +++ b/toolchain/check/testdata/where_expr/equal_rewrite.carbon @@ -162,17 +162,19 @@ interface I { // CHECK:STDERR: fn RewriteTypeMismatch(X:! I where .Member = 2); -// --- todo_let.carbon +// --- fail_todo_let.carbon library "[[@TEST_NAME]]"; interface A {} class D {} impl D as A {} -// TODO: This should be a compile-time binding, once that is supported at file scope. -let B: type where .Self impls A = D; fn F() { + // CHECK:STDERR: fail_todo_let.carbon:[[@LINE+4]]:7: error: semantics TODO: `local `let :!` bindings are currently unsupported` [SemanticsTodo] + // CHECK:STDERR: let E:! type where .Self impls A = D; + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // CHECK:STDERR: let E:! type where .Self impls A = D; } diff --git a/toolchain/driver/testdata/fail_flush_errors.carbon b/toolchain/driver/testdata/fail_flush_errors.carbon index f1b6b675aff4..ab5575312db7 100644 --- a/toolchain/driver/testdata/fail_flush_errors.carbon +++ b/toolchain/driver/testdata/fail_flush_errors.carbon @@ -37,7 +37,7 @@ fn F() { undeclared2; // Add the name into the string table via a declaration rather than an expression. - if (true) { let undeclared3:! () = (); } + if (true) { let undeclared3: () = (); } // CHECK:STDERR: fail_flush_errors.carbon:[[@LINE+4]]:3: error: name `undeclared3` not found [NameNotFound] // CHECK:STDERR: undeclared3; // CHECK:STDERR: ^~~~~~~~~~~ diff --git a/toolchain/lower/function_context.cpp b/toolchain/lower/function_context.cpp index 55be878599a5..1ee3469b222b 100644 --- a/toolchain/lower/function_context.cpp +++ b/toolchain/lower/function_context.cpp @@ -115,7 +115,7 @@ static auto LowerInstHelper(FunctionContext& context, SemIR::InstId inst_id, // in `requires`-style overloads. // NOLINTNEXTLINE(readability-function-size): The define confuses lint. auto FunctionContext::LowerInst(SemIR::InstId inst_id) -> void { - // Skip over constants. `FileContext::GetGlobal` lowers them as needed. + // Skip over constants. `FileContext::GetConstant` lowers them as needed. if (sem_ir().constant_values().Get(inst_id).is_constant()) { return; } diff --git a/toolchain/lower/testdata/let/local.carbon b/toolchain/lower/testdata/let/local.carbon index 09c6f6a943ca..deec574cec7b 100644 --- a/toolchain/lower/testdata/let/local.carbon +++ b/toolchain/lower/testdata/let/local.carbon @@ -10,12 +10,29 @@ // TIP: To dump output, run: // TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/lower/testdata/let/local.carbon +// --- local.carbon +library "[[@TEST_NAME]]"; + fn Run() -> i32 { let n: i32 = 1; let m: i32 = n; return m; } +// --- symbolic.carbon +library "[[@TEST_NAME]]"; + +class C {} + +fn F(c: C) {} + +fn CallF() { + // TODO: Uncomment this once symbolic locals work in check. It's disabled so + // that we still test lowering of non-symbolic locals. + // let c:! C = {}; + // F(c); +} + // CHECK:STDOUT: ; ModuleID = 'local.carbon' // CHECK:STDOUT: source_filename = "local.carbon" // CHECK:STDOUT: @@ -34,8 +51,43 @@ fn Run() -> i32 { // CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3} // CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) // CHECK:STDOUT: !3 = !DIFile(filename: "local.carbon", directory: "") -// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "Run", linkageName: "main", scope: null, file: !3, line: 13, type: !5, spFlags: DISPFlagDefinition, unit: !2) +// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "Run", linkageName: "main", scope: null, file: !3, line: 3, type: !5, spFlags: DISPFlagDefinition, unit: !2) // CHECK:STDOUT: !5 = !DISubroutineType(types: !6) // CHECK:STDOUT: !6 = !{!7} // CHECK:STDOUT: !7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed) -// CHECK:STDOUT: !8 = !DILocation(line: 16, column: 3, scope: !4) +// CHECK:STDOUT: !8 = !DILocation(line: 6, column: 3, scope: !4) +// CHECK:STDOUT: ; ModuleID = 'symbolic.carbon' +// CHECK:STDOUT: source_filename = "symbolic.carbon" +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: nounwind +// CHECK:STDOUT: define void @_CF.Main(ptr %c) #0 !dbg !4 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: ret void, !dbg !10 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: ; Function Attrs: nounwind +// CHECK:STDOUT: define void @_CCallF.Main() #0 !dbg !11 { +// CHECK:STDOUT: entry: +// CHECK:STDOUT: ret void, !dbg !14 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: attributes #0 = { nounwind } +// CHECK:STDOUT: +// CHECK:STDOUT: !llvm.module.flags = !{!0, !1} +// CHECK:STDOUT: !llvm.dbg.cu = !{!2} +// CHECK:STDOUT: +// CHECK:STDOUT: !0 = !{i32 7, !"Dwarf Version", i32 5} +// CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3} +// CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +// CHECK:STDOUT: !3 = !DIFile(filename: "symbolic.carbon", directory: "") +// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "_CF.Main", scope: null, file: !3, line: 5, type: !5, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !8) +// CHECK:STDOUT: !5 = !DISubroutineType(types: !6) +// CHECK:STDOUT: !6 = !{null, !7} +// CHECK:STDOUT: !7 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: null, size: 8) +// CHECK:STDOUT: !8 = !{!9} +// CHECK:STDOUT: !9 = !DILocalVariable(arg: 1, scope: !4, type: !7) +// CHECK:STDOUT: !10 = !DILocation(line: 5, column: 1, scope: !4) +// CHECK:STDOUT: !11 = distinct !DISubprogram(name: "CallF", linkageName: "_CCallF.Main", scope: null, file: !3, line: 7, type: !12, spFlags: DISPFlagDefinition, unit: !2) +// CHECK:STDOUT: !12 = !DISubroutineType(types: !13) +// CHECK:STDOUT: !13 = !{null} +// CHECK:STDOUT: !14 = !DILocation(line: 7, column: 1, scope: !11)