From f7924aa93f174d01e3fc045d5c3168416ad262c1 Mon Sep 17 00:00:00 2001 From: Jon Ross-Perkins Date: Mon, 13 Feb 2023 16:15:04 -0800 Subject: [PATCH] Implement calls in the toolchain. (#2582) This adds tracking of call information plus basic type checking. It adds a builtin for the empty tuple, mainly so that I have the basis for a default function return type. As an aside, it also unifies printing within SemanticsIR, fixing a missing comma after callables. Co-authored-by: Richard Smith --- toolchain/diagnostics/diagnostic_kind.def | 3 + .../semantics/semantics_builtin_kind.def | 15 +- toolchain/semantics/semantics_ir.cpp | 55 ++-- toolchain/semantics/semantics_ir.h | 21 ++ toolchain/semantics/semantics_ir_test.cpp | 1 + toolchain/semantics/semantics_node.h | 23 +- .../semantics/semantics_node_block_stack.cpp | 9 +- .../semantics/semantics_node_block_stack.h | 6 +- toolchain/semantics/semantics_node_kind.def | 1 + .../semantics_parse_tree_handler.cpp | 285 ++++++++++++------ .../semantics/semantics_parse_tree_handler.h | 50 ++- .../testdata/basics/builtin_types.carbon | 20 +- .../semantics/testdata/basics/empty.carbon | 4 + .../testdata/basics/empty_decl.carbon | 4 + .../testdata/basics/fail_name_lookup.carbon | 14 +- .../semantics/testdata/function/basic.carbon | 38 --- .../function/call/fail_param_count.carbon | 156 ++++++++++ .../function/call/fail_param_type.carbon | 74 +++++ .../function/call/more_param_ir.carbon | 113 +++++++ .../testdata/function/call/params_one.carbon | 77 +++++ .../function/call/params_one_comma.carbon | 89 ++++++ .../testdata/function/call/params_two.carbon | 87 ++++++ .../function/call/params_two_comma.carbon | 103 +++++++ .../testdata/function/call/params_zero.carbon | 59 ++++ .../fail_param_name_conflict.carbon | 59 ++++ .../testdata/function/definition/order.carbon | 60 ++++ .../params_one.carbon} | 18 +- .../params_one_comma.carbon} | 18 +- .../params_two.carbon} | 34 ++- .../params_two_comma.carbon} | 34 ++- .../params_zero.carbon} | 20 +- .../definition/same_param_name.carbon | 70 +++++ .../testdata/operators/binary_op.carbon | 24 +- .../operators/fail_type_mismatch.carbon | 24 +- .../operators/fail_type_mismatch_once.carbon | 26 +- .../semantics/testdata/return/literal.carbon | 22 +- .../semantics/testdata/return/trivial.carbon | 16 +- toolchain/semantics/testdata/var/decl.carbon | 22 +- .../testdata/var/decl_with_init.carbon | 24 +- .../testdata/var/fail_duplicate_decl.carbon | 28 +- .../var/fail_init_type_mismatch.carbon | 24 +- .../testdata/var/fail_init_with_self.carbon | 24 +- .../var/fail_lookup_outside_scope.carbon | 32 +- .../semantics/testdata/var/global_decl.carbon | 10 +- .../testdata/var/global_decl_with_init.carbon | 12 +- .../testdata/var/global_lookup.carbon | 16 +- .../var/global_lookup_in_scope.carbon | 28 +- .../semantics/testdata/var/lookup.carbon | 24 +- 48 files changed, 1578 insertions(+), 398 deletions(-) delete mode 100644 toolchain/semantics/testdata/function/basic.carbon create mode 100644 toolchain/semantics/testdata/function/call/fail_param_count.carbon create mode 100644 toolchain/semantics/testdata/function/call/fail_param_type.carbon create mode 100644 toolchain/semantics/testdata/function/call/more_param_ir.carbon create mode 100644 toolchain/semantics/testdata/function/call/params_one.carbon create mode 100644 toolchain/semantics/testdata/function/call/params_one_comma.carbon create mode 100644 toolchain/semantics/testdata/function/call/params_two.carbon create mode 100644 toolchain/semantics/testdata/function/call/params_two_comma.carbon create mode 100644 toolchain/semantics/testdata/function/call/params_zero.carbon create mode 100644 toolchain/semantics/testdata/function/definition/fail_param_name_conflict.carbon create mode 100644 toolchain/semantics/testdata/function/definition/order.carbon rename toolchain/semantics/testdata/function/{params_two.carbon => definition/params_one.carbon} (78%) rename toolchain/semantics/testdata/function/{params_two_comma.carbon => definition/params_one_comma.carbon} (78%) rename toolchain/semantics/testdata/function/{order.carbon => definition/params_two.carbon} (67%) rename toolchain/semantics/testdata/function/{params_one_comma.carbon => definition/params_two_comma.carbon} (63%) rename toolchain/semantics/testdata/function/{params_one.carbon => definition/params_zero.carbon} (74%) create mode 100644 toolchain/semantics/testdata/function/definition/same_param_name.carbon diff --git a/toolchain/diagnostics/diagnostic_kind.def b/toolchain/diagnostics/diagnostic_kind.def index 56d6caece9c2..62ed56ff2946 100644 --- a/toolchain/diagnostics/diagnostic_kind.def +++ b/toolchain/diagnostics/diagnostic_kind.def @@ -99,6 +99,9 @@ CARBON_DIAGNOSTIC_KIND(TypeMismatch) CARBON_DIAGNOSTIC_KIND(NameNotFound) CARBON_DIAGNOSTIC_KIND(NameRedefined) CARBON_DIAGNOSTIC_KIND(PreviousDefinition) +CARBON_DIAGNOSTIC_KIND(NoMatchingCall) +CARBON_DIAGNOSTIC_KIND(CallArgCountMismatch) +CARBON_DIAGNOSTIC_KIND(CallArgTypeMismatch) // ============================================================================ // Other diagnostics diff --git a/toolchain/semantics/semantics_builtin_kind.def b/toolchain/semantics/semantics_builtin_kind.def index c5d8a7f17d5e..a1b7c595b511 100644 --- a/toolchain/semantics/semantics_builtin_kind.def +++ b/toolchain/semantics/semantics_builtin_kind.def @@ -45,18 +45,27 @@ CARBON_SEMANTICS_BUILTIN_KIND(TypeType, TypeType) // This has a deliberately self-referential type. CARBON_SEMANTICS_BUILTIN_KIND(InvalidType, InvalidType) +// ----------------------------------------------------------------------------- +// TODO: Below types are all placeholders. While the above may last, the below +// are expected to need to change in order to better reflect Carbon's design. +// Keeping distinct placeholders can help find usages for later fixes. +// ----------------------------------------------------------------------------- + // The type of integer values and integer literals, currently always i32. -// Long-term we may not want it this way, but for now this is the approach. CARBON_SEMANTICS_BUILTIN_KIND(IntegerType, TypeType) // The type of floating point values and real literals, currently always f64. -// Long-term we may not want it this way, but for now this is the approach. CARBON_SEMANTICS_BUILTIN_KIND(FloatingPointType, TypeType) // The type of string values and String literals. -// Long-term we may not want it this way, but for now this is the approach. CARBON_SEMANTICS_BUILTIN_KIND(StringType, TypeType) +// The canonical empty tuple type, or `() as type`. +CARBON_SEMANTICS_BUILTIN_KIND(EmptyTupleType, TypeType) + +// The canonical empty tuple, or `()`. +CARBON_SEMANTICS_BUILTIN_KIND(EmptyTuple, EmptyTupleType) + // Keep invalid last, so that we can use values as array indices without needing // an invalid entry. CARBON_SEMANTICS_BUILTIN_KIND_NAME(Invalid) diff --git a/toolchain/semantics/semantics_ir.cpp b/toolchain/semantics/semantics_ir.cpp index 12b2037edb6e..55c83f3d8840 100644 --- a/toolchain/semantics/semantics_ir.cpp +++ b/toolchain/semantics/semantics_ir.cpp @@ -58,45 +58,28 @@ auto SemanticsIR::MakeFromParseTree(const SemanticsIR& builtin_ir, return semantics; } -auto SemanticsIR::Print(llvm::raw_ostream& out) const -> void { - constexpr int Indent = 2; +static constexpr int Indent = 2; +template +static auto PrintList(llvm::raw_ostream& out, llvm::StringLiteral name, + const llvm::SmallVector& list) { + out << name << ": [\n"; + for (const auto& element : list) { + out.indent(Indent); + out << element << ",\n"; + } + out << "]\n"; +} + +auto SemanticsIR::Print(llvm::raw_ostream& out) const -> void { out << "cross_reference_irs_size: " << cross_reference_irs_.size() << "\n"; - out << "callables: [\n"; - for (auto callable : callables_) { - out.indent(Indent); - out << callable << "\n"; - } - out << "]\n"; - - out << "integer_literals: [\n"; - for (const auto& integer_literal : integer_literals_) { - out.indent(Indent); - out << integer_literal << ",\n"; - } - out << "]\n"; - - out << "real_literals: [\n"; - for (const auto& real_literal : real_literals_) { - out.indent(Indent); - out << real_literal << ",\n"; - } - out << "]\n"; - - out << "strings: [\n"; - for (const auto& string : strings_) { - out.indent(Indent); - out << string << ",\n"; - } - out << "]\n"; - - out << "nodes: [\n"; - for (const auto& node : nodes_) { - out.indent(Indent); - out << node << ",\n"; - } - out << "]\n"; + PrintList(out, "calls", calls_); + PrintList(out, "callables", callables_); + PrintList(out, "integer_literals", integer_literals_); + PrintList(out, "real_literals", real_literals_); + PrintList(out, "strings", strings_); + PrintList(out, "nodes", nodes_); out << "node_blocks: [\n"; for (const auto& node_block : node_blocks_) { diff --git a/toolchain/semantics/semantics_ir.h b/toolchain/semantics/semantics_ir.h index 7c2cb898d819..20c25931c302 100644 --- a/toolchain/semantics/semantics_ir.h +++ b/toolchain/semantics/semantics_ir.h @@ -16,6 +16,18 @@ class SemanticsIRForTest; namespace Carbon { +// A call. +struct SemanticsCall { + auto Print(llvm::raw_ostream& out) const -> void { + out << "{arg_ir: " << arg_ir_id << ", arg_refs: " << arg_refs_id << "}"; + } + + // The full IR for arguments. + SemanticsNodeBlockId arg_ir_id; + // A block containing a single reference node per argument. + SemanticsNodeBlockId arg_refs_id; +}; + // A callable object. struct SemanticsCallable { auto Print(llvm::raw_ostream& out) const -> void { @@ -81,6 +93,12 @@ class SemanticsIR { return GetNode(node_id).type(); } + auto AddCall(SemanticsCall call) -> SemanticsCallId { + SemanticsCallId id(calls_.size()); + calls_.push_back(call); + return id; + } + auto AddCallable(SemanticsCallable callable) -> SemanticsCallableId { SemanticsCallableId id(callables_.size()); callables_.push_back(callable); @@ -150,6 +168,9 @@ class SemanticsIR { bool has_errors_ = false; + // Storage for call objects. + llvm::SmallVector calls_; + // Storage for callable objects. llvm::SmallVector callables_; diff --git a/toolchain/semantics/semantics_ir_test.cpp b/toolchain/semantics/semantics_ir_test.cpp index 7ff341d1ff69..9fb8970a3dbf 100644 --- a/toolchain/semantics/semantics_ir_test.cpp +++ b/toolchain/semantics/semantics_ir_test.cpp @@ -49,6 +49,7 @@ TEST(SemanticsIRTest, YAML) { Yaml::Value::FromText(print_output), ElementsAre(Yaml::Mapping(ElementsAre( Pair("cross_reference_irs_size", "1"), + Pair("calls", Yaml::Sequence(IsEmpty())), Pair("callables", Yaml::Sequence(IsEmpty())), Pair("integer_literals", Yaml::Sequence(ElementsAre("0"))), Pair("real_literals", Yaml::Sequence(IsEmpty())), diff --git a/toolchain/semantics/semantics_node.h b/toolchain/semantics/semantics_node.h index 8172ab34a98c..b452da766130 100644 --- a/toolchain/semantics/semantics_node.h +++ b/toolchain/semantics/semantics_node.h @@ -43,11 +43,21 @@ constexpr SemanticsNodeId SemanticsNodeId::Invalid = SemanticsNodeId(SemanticsBuiltinKind::Name.AsInt()); #include "toolchain/semantics/semantics_builtin_kind.def" +// The ID of a call. +struct SemanticsCallId : public IndexBase { + using IndexBase::IndexBase; + auto Print(llvm::raw_ostream& out) const -> void { + out << "call"; + IndexBase::Print(out); + } +}; + // The ID of a callable, such as a function. struct SemanticsCallableId : public IndexBase { using IndexBase::IndexBase; auto Print(llvm::raw_ostream& out) const -> void { - out << "callable" << index; + out << "callable"; + IndexBase::Print(out); } }; @@ -162,6 +172,17 @@ class SemanticsNode { return SemanticsBuiltinKind::FromInt(arg0_); } + static auto MakeCall(ParseTree::Node parse_node, SemanticsNodeId type, + SemanticsCallId call_id, SemanticsCallableId callable_id) + -> SemanticsNode { + return SemanticsNode(parse_node, SemanticsNodeKind::Call, type, + call_id.index, callable_id.index); + } + auto GetAsCall() const -> std::pair { + CARBON_CHECK(kind_ == SemanticsNodeKind::Call); + return {SemanticsCallId(arg0_), SemanticsCallableId(arg1_)}; + } + static auto MakeCodeBlock(ParseTree::Node parse_node, SemanticsNodeBlockId node_block) -> SemanticsNode { return SemanticsNode(parse_node, SemanticsNodeKind::CodeBlock, diff --git a/toolchain/semantics/semantics_node_block_stack.cpp b/toolchain/semantics/semantics_node_block_stack.cpp index 065cea06c4c1..769425a0b6b2 100644 --- a/toolchain/semantics/semantics_node_block_stack.cpp +++ b/toolchain/semantics/semantics_node_block_stack.cpp @@ -10,19 +10,20 @@ namespace Carbon { auto SemanticsNodeBlockStack::Push() -> void { - CARBON_VLOG() << "NodeBlock Push " << stack_.size() << "\n"; + CARBON_VLOG() << name_ << " Push " << stack_.size() << "\n"; CARBON_CHECK(stack_.size() < (1 << 20)) << "Excessive stack size: likely infinite loop"; stack_.push_back(SemanticsNodeBlockId::Invalid); } auto SemanticsNodeBlockStack::PeekForAdd() -> SemanticsNodeBlockId { + CARBON_CHECK(!stack_.empty()); auto& back = stack_.back(); if (!back.is_valid()) { SemanticsNodeBlockId block_id(node_blocks_->size()); node_blocks_->resize(block_id.index + 1); back = block_id; - CARBON_VLOG() << "NodeBlock Add " << stack_.size() - 1 << ": " << back + CARBON_VLOG() << name_ << " Add " << stack_.size() - 1 << ": " << back << "\n"; } return back; @@ -30,7 +31,7 @@ auto SemanticsNodeBlockStack::PeekForAdd() -> SemanticsNodeBlockId { auto SemanticsNodeBlockStack::Pop() -> SemanticsNodeBlockId { auto back = stack_.pop_back_val(); - CARBON_VLOG() << "NodeBlock Pop " << stack_.size() << ": " << back << "\n"; + CARBON_VLOG() << name_ << " Pop " << stack_.size() << ": " << back << "\n"; if (!back.is_valid()) { return SemanticsNodeBlockId::Empty; } @@ -39,7 +40,7 @@ auto SemanticsNodeBlockStack::Pop() -> SemanticsNodeBlockId { auto SemanticsNodeBlockStack::PrintForStackDump(llvm::raw_ostream& output) const -> void { - output << "SemanticsNodeBlockStack:\n"; + output << name_ << ":\n"; for (int i = 0; i < static_cast(stack_.size()); ++i) { output << "\t" << i << ".\t" << stack_[i] << "\n"; } diff --git a/toolchain/semantics/semantics_node_block_stack.h b/toolchain/semantics/semantics_node_block_stack.h index 47faca91c580..14425ee907ad 100644 --- a/toolchain/semantics/semantics_node_block_stack.h +++ b/toolchain/semantics/semantics_node_block_stack.h @@ -19,9 +19,10 @@ namespace Carbon { class SemanticsNodeBlockStack { public: explicit SemanticsNodeBlockStack( + llvm::StringLiteral name, llvm::SmallVector>& node_blocks, llvm::raw_ostream* vlog_stream) - : node_blocks_(&node_blocks), vlog_stream_(vlog_stream) {} + : name_(name), node_blocks_(&node_blocks), vlog_stream_(vlog_stream) {} // Pushes a new node block. It will be invalid unless PeekForAdd is called in // order to support lazy allocation. @@ -45,6 +46,9 @@ class SemanticsNodeBlockStack { auto size() const -> size_t { return stack_.size(); } private: + // A name for debugging. + llvm::StringLiteral name_; + // The underlying node block storage on SemanticsIR. Always non-null. llvm::SmallVector>* const node_blocks_; diff --git a/toolchain/semantics/semantics_node_kind.def b/toolchain/semantics/semantics_node_kind.def index 3806eda4ec28..829782e81d3c 100644 --- a/toolchain/semantics/semantics_node_kind.def +++ b/toolchain/semantics/semantics_node_kind.def @@ -22,6 +22,7 @@ CARBON_SEMANTICS_NODE_KIND(Assign) CARBON_SEMANTICS_NODE_KIND(BinaryOperatorAdd) CARBON_SEMANTICS_NODE_KIND(BindName) CARBON_SEMANTICS_NODE_KIND(Builtin) +CARBON_SEMANTICS_NODE_KIND(Call) CARBON_SEMANTICS_NODE_KIND(CodeBlock) CARBON_SEMANTICS_NODE_KIND(FunctionDeclaration) CARBON_SEMANTICS_NODE_KIND(FunctionDefinition) diff --git a/toolchain/semantics/semantics_parse_tree_handler.cpp b/toolchain/semantics/semantics_parse_tree_handler.cpp index e68f0cb3d28a..ba293ca24a83 100644 --- a/toolchain/semantics/semantics_parse_tree_handler.cpp +++ b/toolchain/semantics/semantics_parse_tree_handler.cpp @@ -15,6 +15,7 @@ #include "toolchain/semantics/semantics_builtin_kind.h" #include "toolchain/semantics/semantics_ir.h" #include "toolchain/semantics/semantics_node.h" +#include "toolchain/semantics/semantics_node_block_stack.h" namespace Carbon { @@ -71,7 +72,7 @@ auto SemanticsParseTreeHandler::Build() -> void { CARBON_CHECK(name_lookup_.empty()) << name_lookup_.size(); CARBON_CHECK(scope_stack_.empty()) << scope_stack_.size(); CARBON_CHECK(node_block_stack_.empty()) << node_block_stack_.size(); - CARBON_CHECK(params_stack_.empty()) << params_stack_.size(); + CARBON_CHECK(params_or_args_stack_.empty()) << params_or_args_stack_.size(); } auto SemanticsParseTreeHandler::AddNode(SemanticsNode node) -> SemanticsNodeId { @@ -130,6 +131,21 @@ auto SemanticsParseTreeHandler::PopScope() -> void { } } +auto SemanticsParseTreeHandler::CanTypeConvert(SemanticsNodeId from_type, + SemanticsNodeId to_type) + -> SemanticsNodeId { + // TODO: This should attempt implicit conversions, but there's not enough + // implemented to do that right now. + if (from_type == SemanticsNodeId::BuiltinInvalidType || + to_type == SemanticsNodeId::BuiltinInvalidType) { + return SemanticsNodeId::BuiltinInvalidType; + } + if (from_type == to_type) { + return from_type; + } + return SemanticsNodeId::Invalid; +} + auto SemanticsParseTreeHandler::TryTypeConversion(ParseTree::Node parse_node, SemanticsNodeId lhs_id, SemanticsNodeId rhs_id, @@ -137,20 +153,137 @@ auto SemanticsParseTreeHandler::TryTypeConversion(ParseTree::Node parse_node, -> SemanticsNodeId { auto lhs_type = semantics_->GetType(lhs_id); auto rhs_type = semantics_->GetType(rhs_id); - // TODO: This should attempt a type conversion, but there's not enough - // implemented to do that right now. - if (lhs_type != rhs_type) { - if (lhs_type != SemanticsNodeId::BuiltinInvalidType && - rhs_type != SemanticsNodeId::BuiltinInvalidType) { - // TODO: This is a poor diagnostic, and should be expanded. - CARBON_DIAGNOSTIC(TypeMismatch, Error, - "Type mismatch: lhs is {0}, rhs is {1}", - SemanticsNodeId, SemanticsNodeId); - emitter_->Emit(parse_node, TypeMismatch, lhs_type, rhs_type); - } - return SemanticsNodeId::BuiltinInvalidType; + // TODO: CanTypeConvert can be assumed to handle rhs conversions, and we'll + // either want to call it twice or refactor it to be aware of lhs conversions. + auto type = CanTypeConvert(rhs_type, lhs_type); + if (type.is_valid()) { + return type; } - return lhs_type; + // TODO: This should use type names instead of nodes. + CARBON_DIAGNOSTIC(TypeMismatch, Error, + "Type mismatch: lhs is {0}, rhs is {1}", SemanticsNodeId, + SemanticsNodeId); + emitter_->Emit(parse_node, TypeMismatch, lhs_type, rhs_type); + return SemanticsNodeId::BuiltinInvalidType; +} + +auto SemanticsParseTreeHandler::TryTypeConversionOnArgs( + ParseTree::Node arg_parse_node, SemanticsNodeBlockId /*arg_ir_id*/, + SemanticsNodeBlockId arg_refs_id, ParseTree::Node param_parse_node, + SemanticsNodeBlockId param_refs_id) -> bool { + CARBON_DIAGNOSTIC(NoMatchingCall, Error, "No matching callable was found."); + + // If both arguments and parameters are empty, return quickly. Otherwise, + // we'll fetch both so that errors are consistent. + if (arg_refs_id == SemanticsNodeBlockId::Empty && + param_refs_id == SemanticsNodeBlockId::Empty) { + return true; + } + + auto arg_refs = semantics_->GetNodeBlock(arg_refs_id); + auto param_refs = semantics_->GetNodeBlock(param_refs_id); + + // If sizes mismatch, fail early. + if (arg_refs.size() != param_refs.size()) { + CARBON_DIAGNOSTIC(CallArgCountMismatch, Note, + "Received {0} argument(s), but require {1} argument(s).", + int, int); + emitter_->Build(arg_parse_node, NoMatchingCall) + .Note(param_parse_node, CallArgCountMismatch, arg_refs.size(), + param_refs.size()) + .Emit(); + return false; + } + + // Check type conversions per-element. + // TODO: arg_ir_id is passed so that implicit conversions can be inserted. + // It's currently not supported, but will be needed. + for (size_t i = 0; i < arg_refs.size(); ++i) { + const auto& arg_ref = arg_refs[i]; + auto arg_ref_type = semantics_->GetType(arg_ref); + const auto& param_ref = param_refs[i]; + auto param_ref_type = semantics_->GetType(param_ref); + + auto result_type = CanTypeConvert(arg_ref_type, param_ref_type); + if (!result_type.is_valid()) { + // TODO: This should use type names instead of nodes. + CARBON_DIAGNOSTIC( + CallArgTypeMismatch, Note, + "Type mismatch: cannot convert argument {0} from {1} to {2}.", size_t, + SemanticsNodeId, SemanticsNodeId); + emitter_->Build(arg_parse_node, NoMatchingCall) + .Note(param_parse_node, CallArgTypeMismatch, i, arg_ref_type, + param_ref_type) + .Emit(); + return false; + } + } + + return true; +} + +auto SemanticsParseTreeHandler::ParamOrArgStart() -> void { + params_or_args_stack_.Push(); + node_block_stack_.Push(); +} + +auto SemanticsParseTreeHandler::ParamOrArgComma(ParseTree::Node parse_node) + -> bool { + node_stack_.Push(parse_node); + + // Copy the last node added to the IR block into the params block. + if (!ParamOrArgSave()) { + emitter_->Emit( + parse_node, SemanticsTodo, + "Should have a param before comma, will need error recovery"); + return false; + } + + return true; +} + +auto SemanticsParseTreeHandler::ParamOrArgEnd( + ParseNodeKind start_kind, ParseNodeKind comma_kind, + std::function on_start) + -> bool { + // If there's a node in the IR block that has yet to be added to the params + // block, add it now. + ParamOrArgSave(); + + while (true) { + auto parse_kind = parse_tree_->node_kind(node_stack_.PeekParseNode()); + if (parse_kind == start_kind) { + return on_start(node_block_stack_.Pop(), params_or_args_stack_.Pop()); + } else if (parse_kind == comma_kind) { + node_stack_.PopAndDiscardSoloParseNode(comma_kind); + } else { + node_stack_.PopAndIgnore(); + } + } +} + +auto SemanticsParseTreeHandler::ParamOrArgSave() -> bool { + // Copy the last node added to the IR block into the params block. + auto ir_id = node_block_stack_.Peek(); + if (!ir_id.is_valid()) { + return false; + } + + // We get params before ir because it may add a node block, which can + // invalidate the ir reference. + auto& params = semantics_->GetNodeBlock(params_or_args_stack_.PeekForAdd()); + + auto& ir = semantics_->GetNodeBlock(ir_id); + CARBON_CHECK(!ir.empty()) + << "Should only have a valid ID if a node was added"; + auto& param = ir.back(); + + if (!params.empty() && param == params.back()) { + // The param was already added after a comma. + return false; + } + params.push_back(ir.back()); + return true; } auto SemanticsParseTreeHandler::HandleAddress(ParseTree::Node parse_node) @@ -173,20 +306,53 @@ auto SemanticsParseTreeHandler::HandleBreakStatementStart( auto SemanticsParseTreeHandler::HandleCallExpression(ParseTree::Node parse_node) -> bool { - emitter_->Emit(parse_node, SemanticsTodo, "HandleCallExpression"); - return false; + auto on_start = [&](SemanticsNodeBlockId ir_id, + SemanticsNodeBlockId refs_id) -> bool { + // TODO: Convert to call expression. + auto [call_expr_parse_node, name_id] = node_stack_.PopForParseNodeAndNodeId( + ParseNodeKind::CallExpressionStart); + auto name_node = semantics_->GetNode(name_id); + if (name_node.kind() != SemanticsNodeKind::FunctionDeclaration) { + // TODO: Work on error. + emitter_->Emit(parse_node, SemanticsTodo, "Not a callable name"); + node_stack_.Push(parse_node, name_id); + return true; + } + + auto callable_id = name_node.GetAsFunctionDeclaration(); + auto callable = semantics_->callables_[callable_id.index]; + + if (!TryTypeConversionOnArgs(call_expr_parse_node, ir_id, refs_id, + name_node.parse_node(), + callable.param_refs_id)) { + node_stack_.Push(parse_node, SemanticsNodeId::BuiltinInvalidType); + return true; + } + + auto call_id = semantics_->AddCall({ir_id, refs_id}); + // TODO: Propagate return types from callable. + auto call_node_id = AddNode(SemanticsNode::MakeCall( + call_expr_parse_node, SemanticsNodeId::BuiltinEmptyTuple, call_id, + callable_id)); + + node_stack_.Push(parse_node, call_node_id); + return true; + }; + return ParamOrArgEnd(ParseNodeKind::CallExpressionStart, + ParseNodeKind::CallExpressionComma, on_start); } auto SemanticsParseTreeHandler::HandleCallExpressionComma( ParseTree::Node parse_node) -> bool { - emitter_->Emit(parse_node, SemanticsTodo, "HandleCallExpressionComma"); - return false; + return ParamOrArgComma(parse_node); } auto SemanticsParseTreeHandler::HandleCallExpressionStart( ParseTree::Node parse_node) -> bool { - emitter_->Emit(parse_node, SemanticsTodo, "HandleCallExpressionStart"); - return false; + auto name_id = node_stack_.PopForNodeId(ParseNodeKind::NameReference); + node_stack_.Push(parse_node, name_id); + ParamOrArgStart(); + return true; } auto SemanticsParseTreeHandler::HandleCodeBlock(ParseTree::Node parse_node) @@ -531,83 +697,30 @@ auto SemanticsParseTreeHandler::HandlePackageLibrary(ParseTree::Node parse_node) return false; } -auto SemanticsParseTreeHandler::SaveParam() -> bool { - // Copy the last node added to the IR block into the params block. - auto ir_id = node_block_stack_.Peek(); - if (!ir_id.is_valid()) { - return false; - } - auto& ir = semantics_->GetNodeBlock(ir_id); - CARBON_CHECK(!ir.empty()) - << "Should only have a valid ID if a node was added"; - auto& param = ir.back(); - auto& params = semantics_->GetNodeBlock(params_stack_.PeekForAdd()); - if (!params.empty() && param == params.back()) { - // The param was already added after a comma. - return false; - } - params.push_back(ir.back()); - return true; -} - auto SemanticsParseTreeHandler::HandleParameterList(ParseTree::Node parse_node) -> bool { - // If there's a node in the IR block that has yet to be added to the params - // block, add it now. - SaveParam(); - - while (true) { - switch (auto parse_kind = - parse_tree_->node_kind(node_stack_.PeekParseNode())) { - case ParseNodeKind::ParameterListStart: - node_stack_.PopAndDiscardSoloParseNode( - ParseNodeKind::ParameterListStart); - finished_params_stack_.push_back( - {node_block_stack_.Pop(), params_stack_.Pop()}); - node_stack_.Push(parse_node); - return true; - - case ParseNodeKind::ParameterListComma: - node_stack_.PopAndDiscardSoloParseNode( - ParseNodeKind::ParameterListComma); - break; - - case ParseNodeKind::PatternBinding: - node_stack_.PopAndDiscardId(ParseNodeKind::PatternBinding); - break; - - default: - // This should only occur for invalid parse trees. - emitter_->Emit(parse_node, SemanticsTodo, "Need error recovery"); - return false; - } - } - - llvm_unreachable("loop always exits"); + auto on_start = [&](SemanticsNodeBlockId ir_id, + SemanticsNodeBlockId refs_id) -> bool { + PopScope(); + node_stack_.PopAndDiscardSoloParseNode(ParseNodeKind::ParameterListStart); + finished_params_stack_.push_back({ir_id, refs_id}); + node_stack_.Push(parse_node); + return true; + }; + return ParamOrArgEnd(ParseNodeKind::ParameterListStart, + ParseNodeKind::ParameterListComma, on_start); } auto SemanticsParseTreeHandler::HandleParameterListComma( ParseTree::Node parse_node) -> bool { - node_stack_.Push(parse_node); - - // Copy the last node added to the IR block into the params block. - if (!SaveParam()) { - emitter_->Emit( - parse_node, SemanticsTodo, - "Should have a param before comma, will need error recovery"); - return false; - } - - return true; + return ParamOrArgComma(parse_node); } auto SemanticsParseTreeHandler::HandleParameterListStart( ParseTree::Node parse_node) -> bool { + PushScope(); node_stack_.Push(parse_node); - - params_stack_.Push(); - node_block_stack_.Push(); - + ParamOrArgStart(); return true; } diff --git a/toolchain/semantics/semantics_parse_tree_handler.h b/toolchain/semantics/semantics_parse_tree_handler.h index e84ba74bf9ad..b3989098f627 100644 --- a/toolchain/semantics/semantics_parse_tree_handler.h +++ b/toolchain/semantics/semantics_parse_tree_handler.h @@ -30,8 +30,10 @@ class SemanticsParseTreeHandler { semantics_(&semantics), vlog_stream_(vlog_stream), node_stack_(parse_tree, vlog_stream), - node_block_stack_(semantics.node_blocks_, vlog_stream), - params_stack_(semantics.node_blocks_, vlog_stream) {} + node_block_stack_("node_block_stack_", semantics.node_blocks_, + vlog_stream), + params_or_args_stack_("params_or_args_stack_", semantics.node_blocks_, + vlog_stream) {} // Outputs the ParseTree information into SemanticsIR. auto Build() -> void; @@ -94,16 +96,43 @@ class SemanticsParseTreeHandler { // Pops the top scope from scope_stack_, cleaning up names from name_lookup_. auto PopScope() -> void; - // Attempts a type conversion between arguments of the two arguments with - // provided types, returning the result type. The result type will be invalid - // for errors; this handles printing diagnostics. + // Attempts a type conversion between two types. Returns: + // - The result type if valid. + // - BuiltinInvalidType if either lhs_id or rhs_id is BuiltinInvalidType. + // - Invalid if no conversion is supported. + // + // The caller might choose to print a diagnostic if Invalid is returned, + // whereas BuiltinInvalidType means there was a previous error that may be + // related and another diagnostic is undesirable. + auto CanTypeConvert(SemanticsNodeId from_type, SemanticsNodeId to_type) + -> SemanticsNodeId; + + // Attempts a type conversion between two arguments, returning the result + // type. The result type will be BuiltinInvalidType for errors; this handles + // printing diagnostics. auto TryTypeConversion(ParseTree::Node parse_node, SemanticsNodeId lhs_id, SemanticsNodeId rhs_id, bool can_convert_lhs) -> SemanticsNodeId; + // Attempts a type conversion between arguments and parameters. Returns true + // on success. arg_parse_node and param_parse_node are only used for + // diagnostic locations. + auto TryTypeConversionOnArgs(ParseTree::Node arg_parse_node, + SemanticsNodeBlockId arg_ir_id, + SemanticsNodeBlockId arg_refs_id, + ParseTree::Node param_parse_node, + SemanticsNodeBlockId param_refs_id) -> bool; + + auto ParamOrArgStart() -> void; + auto ParamOrArgComma(ParseTree::Node parse_node) -> bool; + auto ParamOrArgEnd( + ParseNodeKind start_kind, ParseNodeKind comma_kind, + std::function on_start) + -> bool; + // Saves a parameter from the top block in node_stack_ to the top block in - // params_stack_. Returns false if nothing is copied. - auto SaveParam() -> bool; + // params_or_args_stack_. Returns false if nothing is copied. + auto ParamOrArgSave() -> bool; // Parse node handlers. Returns false for unrecoverable errors. #define CARBON_PARSE_NODE_KIND(Name) \ @@ -133,8 +162,11 @@ class SemanticsParseTreeHandler { // The stack of node blocks being used for general IR generation. SemanticsNodeBlockStack node_block_stack_; - // The stack of node blocks being used for parameters. - SemanticsNodeBlockStack params_stack_; + // The stack of node blocks being used for per-element tracking of nodes in + // parameter and argument node blocks. Versus node_block_stack_, an element + // will have 1 or more nodes in blocks in node_block_stack_, but only ever 1 + // node in blocks here. + SemanticsNodeBlockStack params_or_args_stack_; llvm::SmallVector> finished_params_stack_; diff --git a/toolchain/semantics/testdata/basics/builtin_types.carbon b/toolchain/semantics/testdata/basics/builtin_types.carbon index a17dde11272b..042c9d863565 100644 --- a/toolchain/semantics/testdata/basics/builtin_types.carbon +++ b/toolchain/semantics/testdata/basics/builtin_types.carbon @@ -5,6 +5,8 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ @@ -25,25 +27,25 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node5, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: VarStorage, type: node3}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node3}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node11, type: node3}, // CHECK:STDOUT: {kind: RealLiteral, arg0: real0, type: node3}, -// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node11, type: node3}, +// CHECK:STDOUT: {kind: Assign, arg0: node11, arg1: node13, type: node3}, // CHECK:STDOUT: {kind: VarStorage, type: node4}, -// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node13, type: node4}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node15, type: node4}, // CHECK:STDOUT: {kind: StringLiteral, arg0: str3, type: node4}, -// CHECK:STDOUT: {kind: Assign, arg0: node13, arg1: node15, type: node4}, +// CHECK:STDOUT: {kind: Assign, arg0: node15, arg1: node17, type: node4}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: node9, @@ -54,6 +56,8 @@ // CHECK:STDOUT: node14, // CHECK:STDOUT: node15, // CHECK:STDOUT: node16, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: node18, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/basics/empty.carbon b/toolchain/semantics/testdata/basics/empty.carbon index fc47af87220e..2e733e6a8d79 100644 --- a/toolchain/semantics/testdata/basics/empty.carbon +++ b/toolchain/semantics/testdata/basics/empty.carbon @@ -5,6 +5,8 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ @@ -19,6 +21,8 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ diff --git a/toolchain/semantics/testdata/basics/empty_decl.carbon b/toolchain/semantics/testdata/basics/empty_decl.carbon index 5d0a882e8ca8..aa7226d175bc 100644 --- a/toolchain/semantics/testdata/basics/empty_decl.carbon +++ b/toolchain/semantics/testdata/basics/empty_decl.carbon @@ -5,6 +5,8 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ @@ -19,6 +21,8 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ diff --git a/toolchain/semantics/testdata/basics/fail_name_lookup.carbon b/toolchain/semantics/testdata/basics/fail_name_lookup.carbon index b1af8f6fb9d8..d128345ddd1a 100644 --- a/toolchain/semantics/testdata/basics/fail_name_lookup.carbon +++ b/toolchain/semantics/testdata/basics/fail_name_lookup.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{not} %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -21,17 +23,19 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block0}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/function/basic.carbon b/toolchain/semantics/testdata/function/basic.carbon deleted file mode 100644 index 8570d9fbaa69..000000000000 --- a/toolchain/semantics/testdata/function/basic.carbon +++ /dev/null @@ -1,38 +0,0 @@ -// Part of the Carbon Language project, under the Apache License v2.0 with LLVM -// Exceptions. See /LICENSE for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -// AUTOUPDATE -// RUN: %{carbon-run-semantics} -// CHECK:STDOUT: cross_reference_irs_size: 1 -// CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} -// CHECK:STDOUT: ] -// CHECK:STDOUT: integer_literals: [ -// CHECK:STDOUT: ] -// CHECK:STDOUT: real_literals: [ -// CHECK:STDOUT: ] -// CHECK:STDOUT: strings: [ -// CHECK:STDOUT: Foo, -// CHECK:STDOUT: ] -// CHECK:STDOUT: nodes: [ -// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, -// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, -// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, -// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, -// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, -// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block0}, -// CHECK:STDOUT: ] -// CHECK:STDOUT: node_blocks: [ -// CHECK:STDOUT: [ -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node7, -// CHECK:STDOUT: ], -// CHECK:STDOUT: ] - -fn Foo() {} diff --git a/toolchain/semantics/testdata/function/call/fail_param_count.carbon b/toolchain/semantics/testdata/function/call/fail_param_count.carbon new file mode 100644 index 000000000000..11b3ea1dcd96 --- /dev/null +++ b/toolchain/semantics/testdata/function/call/fail_param_count.carbon @@ -0,0 +1,156 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{not} %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: {param_ir: block2, param_refs: block3}, +// CHECK:STDOUT: {param_ir: block4, param_refs: block5}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 0, +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 0, +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 0, +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: Run0, +// CHECK:STDOUT: a, +// CHECK:STDOUT: Run1, +// CHECK:STDOUT: b, +// CHECK:STDOUT: Run2, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block0}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node10, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node12}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node12, arg1: block0}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node15, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str3, arg1: node17, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable2}, +// CHECK:STDOUT: {kind: BindName, arg0: str4, arg1: node19}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node19, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable3}, +// CHECK:STDOUT: {kind: BindName, arg0: str5, arg1: node22}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int2, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int3, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int4, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int5, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node22, arg1: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: node19, +// CHECK:STDOUT: node20, +// CHECK:STDOUT: node21, +// CHECK:STDOUT: node22, +// CHECK:STDOUT: node23, +// CHECK:STDOUT: node30, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node11, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node15, +// CHECK:STDOUT: node16, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: node18, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node16, +// CHECK:STDOUT: node18, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node24, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node24, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node25, +// CHECK:STDOUT: node26, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node25, +// CHECK:STDOUT: node26, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node27, +// CHECK:STDOUT: node28, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node27, +// CHECK:STDOUT: node28, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node29, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node29, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Run0() {} +fn Run1(a: i32) {} +fn Run2(a: i32, b: i32) {} + +fn Main() { + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE+2]]:7: No matching callable was found. + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE-6]]:1: Received 1 argument(s), but require 0 argument(s). + Run0(1); + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE+2]]:7: No matching callable was found. + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE-9]]:1: Received 2 argument(s), but require 0 argument(s). + Run0(0, 1); + + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE+2]]:7: No matching callable was found. + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE-12]]:1: Received 0 argument(s), but require 1 argument(s). + Run1(); + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE+2]]:7: No matching callable was found. + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE-15]]:1: Received 2 argument(s), but require 1 argument(s). + Run1(0, 1); + + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE+2]]:7: No matching callable was found. + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE-18]]:1: Received 0 argument(s), but require 2 argument(s). + Run2(); + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE+2]]:7: No matching callable was found. + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_count.carbon:[[@LINE-21]]:1: Received 1 argument(s), but require 2 argument(s). + Run2(0); +} diff --git a/toolchain/semantics/testdata/function/call/fail_param_type.carbon b/toolchain/semantics/testdata/function/call/fail_param_type.carbon new file mode 100644 index 000000000000..34a3ae929b3b --- /dev/null +++ b/toolchain/semantics/testdata/function/call/fail_param_type.carbon @@ -0,0 +1,74 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{not} %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: {mantissa: 10, exponent: -1, is_decimal: 1}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: Run, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node9, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node12}, +// CHECK:STDOUT: {kind: RealLiteral, arg0: real0, type: node3}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node12, arg1: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node14, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node14, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Run(a: i32) {} + +fn Main() { + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_type.carbon:[[@LINE+2]]:6: No matching callable was found. + // CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/call/fail_param_type.carbon:[[@LINE-4]]:1: Type mismatch: cannot convert argument 0 from node3 to node2. + Run(1.0); +} diff --git a/toolchain/semantics/testdata/function/call/more_param_ir.carbon b/toolchain/semantics/testdata/function/call/more_param_ir.carbon new file mode 100644 index 000000000000..e42e68481f7d --- /dev/null +++ b/toolchain/semantics/testdata/function/call/more_param_ir.carbon @@ -0,0 +1,113 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: {arg_ir: block4, arg_refs: block5}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 2, +// CHECK:STDOUT: 3, +// CHECK:STDOUT: 4, +// CHECK:STDOUT: 5, +// CHECK:STDOUT: 6, +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: b, +// CHECK:STDOUT: c, +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node11, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str3, arg1: node13}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node13, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str4, arg1: node16}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, +// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node18, arg1: node19, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int2, type: node2}, +// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node20, arg1: node21, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int3, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int4, type: node2}, +// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node23, arg1: node24, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int5, type: node2}, +// CHECK:STDOUT: {kind: Call, arg0: call0, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node16, arg1: block6}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: node16, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: node28, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node18, +// CHECK:STDOUT: node19, +// CHECK:STDOUT: node20, +// CHECK:STDOUT: node21, +// CHECK:STDOUT: node22, +// CHECK:STDOUT: node23, +// CHECK:STDOUT: node24, +// CHECK:STDOUT: node25, +// CHECK:STDOUT: node26, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node22, +// CHECK:STDOUT: node25, +// CHECK:STDOUT: node26, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node27, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo(a: i32, b: i32, c: i32) {} + +fn Main() { + // Generates multiple IR instructions for the first two parameters. + Foo(1 + 2 + 3, 4 + 5, 6); +} diff --git a/toolchain/semantics/testdata/function/call/params_one.carbon b/toolchain/semantics/testdata/function/call/params_one.carbon new file mode 100644 index 000000000000..f5f91cd2c955 --- /dev/null +++ b/toolchain/semantics/testdata/function/call/params_one.carbon @@ -0,0 +1,77 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: {arg_ir: block4, arg_refs: block5}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: 1, +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node9, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node12}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, +// CHECK:STDOUT: {kind: Call, arg0: call0, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node12, arg1: block6}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node16, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node14, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node14, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node15, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo(a: i32) {} + +fn Main() { + Foo(1); +} diff --git a/toolchain/semantics/testdata/function/call/params_one_comma.carbon b/toolchain/semantics/testdata/function/call/params_one_comma.carbon new file mode 100644 index 000000000000..0029b90ff012 --- /dev/null +++ b/toolchain/semantics/testdata/function/call/params_one_comma.carbon @@ -0,0 +1,89 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: {arg_ir: block4, arg_refs: block5}, +// CHECK:STDOUT: {arg_ir: block7, arg_refs: block8}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 1, +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node9, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node12}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, +// CHECK:STDOUT: {kind: Call, arg0: call0, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, +// CHECK:STDOUT: {kind: Call, arg0: call1, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node12, arg1: block6}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node18, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node14, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node14, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node15, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node16, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node16, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo(a: i32,) {} + +fn Main() { + Foo(1); + Foo(1,); +} diff --git a/toolchain/semantics/testdata/function/call/params_two.carbon b/toolchain/semantics/testdata/function/call/params_two.carbon new file mode 100644 index 000000000000..ec5083df1463 --- /dev/null +++ b/toolchain/semantics/testdata/function/call/params_two.carbon @@ -0,0 +1,87 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: {arg_ir: block4, arg_refs: block5}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 2, +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: b, +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node11}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node11, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str3, arg1: node14}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, +// CHECK:STDOUT: {kind: Call, arg0: call0, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node14, arg1: block6}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: node19, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node16, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node16, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node18, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo(a: i32, b: i32) {} + +fn Main() { + Foo(1, 2); +} diff --git a/toolchain/semantics/testdata/function/call/params_two_comma.carbon b/toolchain/semantics/testdata/function/call/params_two_comma.carbon new file mode 100644 index 000000000000..5cbf1743ac7a --- /dev/null +++ b/toolchain/semantics/testdata/function/call/params_two_comma.carbon @@ -0,0 +1,103 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: {arg_ir: block4, arg_refs: block5}, +// CHECK:STDOUT: {arg_ir: block7, arg_refs: block8}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 2, +// CHECK:STDOUT: 1, +// CHECK:STDOUT: 2, +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: b, +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node11}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node11, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str3, arg1: node14}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, +// CHECK:STDOUT: {kind: Call, arg0: call0, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int2, type: node2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int3, type: node2}, +// CHECK:STDOUT: {kind: Call, arg0: call1, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node14, arg1: block6}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: node22, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node16, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node16, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node18, +// CHECK:STDOUT: node21, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node19, +// CHECK:STDOUT: node20, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node19, +// CHECK:STDOUT: node20, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo(a: i32, b: i32,) {} + +fn Main() { + Foo(1, 2); + Foo(1, 2,); +} diff --git a/toolchain/semantics/testdata/function/call/params_zero.carbon b/toolchain/semantics/testdata/function/call/params_zero.carbon new file mode 100644 index 000000000000..3e5bb14df208 --- /dev/null +++ b/toolchain/semantics/testdata/function/call/params_zero.carbon @@ -0,0 +1,59 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: {arg_ir: block0, arg_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Main, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node10}, +// CHECK:STDOUT: {kind: Call, arg0: call0, arg1: callable0, type: node6}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node10, arg1: block2}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node12, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo() {} + +fn Main() { + Foo(); +} diff --git a/toolchain/semantics/testdata/function/definition/fail_param_name_conflict.carbon b/toolchain/semantics/testdata/function/definition/fail_param_name_conflict.carbon new file mode 100644 index 000000000000..e1181da7d0c7 --- /dev/null +++ b/toolchain/semantics/testdata/function/definition/fail_param_name_conflict.carbon @@ -0,0 +1,59 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{not} %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: Bar, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node11}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node11, arg1: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +// CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/definition/fail_param_name_conflict.carbon:[[@LINE+2]]:16: Redefining a in the same scope. +// CHECK:STDERR: {{.*}}/toolchain/semantics/testdata/function/definition/fail_param_name_conflict.carbon:[[@LINE+1]]:8: Previous definition is here. +fn Bar(a: i32, a: i32) {} diff --git a/toolchain/semantics/testdata/function/definition/order.carbon b/toolchain/semantics/testdata/function/definition/order.carbon new file mode 100644 index 000000000000..6dc6f29e0556 --- /dev/null +++ b/toolchain/semantics/testdata/function/definition/order.carbon @@ -0,0 +1,60 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Bar, +// CHECK:STDOUT: Baz, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node10}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node10, arg1: block0}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable2}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node13}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node13, arg1: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo() {} +fn Bar() {} +fn Baz() {} diff --git a/toolchain/semantics/testdata/function/params_two.carbon b/toolchain/semantics/testdata/function/definition/params_one.carbon similarity index 78% rename from toolchain/semantics/testdata/function/params_two.carbon rename to toolchain/semantics/testdata/function/definition/params_one.carbon index 3634b1aace19..7f8924ef8d9c 100644 --- a/toolchain/semantics/testdata/function/params_two.carbon +++ b/toolchain/semantics/testdata/function/definition/params_one.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block1, param_refs: block2} +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -14,7 +16,6 @@ // CHECK:STDOUT: ] // CHECK:STDOUT: strings: [ // CHECK:STDOUT: a, -// CHECK:STDOUT: b, // CHECK:STDOUT: Foo, // CHECK:STDOUT: ] // CHECK:STDOUT: nodes: [ @@ -23,25 +24,22 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, -// CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node9}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9}, // CHECK:STDOUT: {kind: FunctionDefinition, arg0: node9, arg1: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node6, // CHECK:STDOUT: node8, // CHECK:STDOUT: ], // CHECK:STDOUT: [ @@ -51,4 +49,4 @@ // CHECK:STDOUT: ], // CHECK:STDOUT: ] -fn Foo(a: i32, b: i32) {} +fn Foo(a: i32) {} diff --git a/toolchain/semantics/testdata/function/params_two_comma.carbon b/toolchain/semantics/testdata/function/definition/params_one_comma.carbon similarity index 78% rename from toolchain/semantics/testdata/function/params_two_comma.carbon rename to toolchain/semantics/testdata/function/definition/params_one_comma.carbon index c5c55ad890e7..9f37fbdce19a 100644 --- a/toolchain/semantics/testdata/function/params_two_comma.carbon +++ b/toolchain/semantics/testdata/function/definition/params_one_comma.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block1, param_refs: block2} +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -14,7 +16,6 @@ // CHECK:STDOUT: ] // CHECK:STDOUT: strings: [ // CHECK:STDOUT: a, -// CHECK:STDOUT: b, // CHECK:STDOUT: Foo, // CHECK:STDOUT: ] // CHECK:STDOUT: nodes: [ @@ -23,25 +24,22 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, -// CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node9}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9}, // CHECK:STDOUT: {kind: FunctionDefinition, arg0: node9, arg1: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node6, // CHECK:STDOUT: node8, // CHECK:STDOUT: ], // CHECK:STDOUT: [ @@ -51,4 +49,4 @@ // CHECK:STDOUT: ], // CHECK:STDOUT: ] -fn Foo(a: i32, b: i32,) {} +fn Foo(a: i32,) {} diff --git a/toolchain/semantics/testdata/function/order.carbon b/toolchain/semantics/testdata/function/definition/params_two.carbon similarity index 67% rename from toolchain/semantics/testdata/function/order.carbon rename to toolchain/semantics/testdata/function/definition/params_two.carbon index a4ff56d73a37..be37d39d5813 100644 --- a/toolchain/semantics/testdata/function/order.carbon +++ b/toolchain/semantics/testdata/function/definition/params_two.carbon @@ -5,19 +5,19 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] // CHECK:STDOUT: real_literals: [ // CHECK:STDOUT: ] // CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: b, // CHECK:STDOUT: Foo, -// CHECK:STDOUT: Bar, -// CHECK:STDOUT: Baz, // CHECK:STDOUT: ] // CHECK:STDOUT: nodes: [ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, @@ -25,13 +25,13 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block0}, -// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node8}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node8, arg1: block0}, -// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable2}, // CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node11}, // CHECK:STDOUT: {kind: FunctionDefinition, arg0: node11, arg1: block0}, // CHECK:STDOUT: ] @@ -39,18 +39,20 @@ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node11, // CHECK:STDOUT: node12, // CHECK:STDOUT: node13, // CHECK:STDOUT: ], // CHECK:STDOUT: ] -fn Foo() {} -fn Bar() {} -fn Baz() {} +fn Foo(a: i32, b: i32) {} diff --git a/toolchain/semantics/testdata/function/params_one_comma.carbon b/toolchain/semantics/testdata/function/definition/params_two_comma.carbon similarity index 63% rename from toolchain/semantics/testdata/function/params_one_comma.carbon rename to toolchain/semantics/testdata/function/definition/params_two_comma.carbon index 1cf1174c3daf..3515aa5ffa1c 100644 --- a/toolchain/semantics/testdata/function/params_one_comma.carbon +++ b/toolchain/semantics/testdata/function/definition/params_two_comma.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block1, param_refs: block2} +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -14,6 +16,7 @@ // CHECK:STDOUT: ] // CHECK:STDOUT: strings: [ // CHECK:STDOUT: a, +// CHECK:STDOUT: b, // CHECK:STDOUT: Foo, // CHECK:STDOUT: ] // CHECK:STDOUT: nodes: [ @@ -22,27 +25,34 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block0}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node11}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node11, arg1: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ -// CHECK:STDOUT: node6, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, // CHECK:STDOUT: ], // CHECK:STDOUT: ] -fn Foo(a: i32,) {} +fn Foo(a: i32, b: i32,) {} diff --git a/toolchain/semantics/testdata/function/params_one.carbon b/toolchain/semantics/testdata/function/definition/params_zero.carbon similarity index 74% rename from toolchain/semantics/testdata/function/params_one.carbon rename to toolchain/semantics/testdata/function/definition/params_zero.carbon index ac724c98f903..4ee21729d3ce 100644 --- a/toolchain/semantics/testdata/function/params_one.carbon +++ b/toolchain/semantics/testdata/function/definition/params_zero.carbon @@ -5,15 +5,16 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block1, param_refs: block2} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] // CHECK:STDOUT: real_literals: [ // CHECK:STDOUT: ] // CHECK:STDOUT: strings: [ -// CHECK:STDOUT: a, // CHECK:STDOUT: Foo, // CHECK:STDOUT: ] // CHECK:STDOUT: nodes: [ @@ -22,27 +23,20 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, -// CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ -// CHECK:STDOUT: node6, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: node9, // CHECK:STDOUT: ], // CHECK:STDOUT: ] -fn Foo(a: i32) {} +fn Foo() {} diff --git a/toolchain/semantics/testdata/function/definition/same_param_name.carbon b/toolchain/semantics/testdata/function/definition/same_param_name.carbon new file mode 100644 index 000000000000..51c6570199ee --- /dev/null +++ b/toolchain/semantics/testdata/function/definition/same_param_name.carbon @@ -0,0 +1,70 @@ +// Part of the Carbon Language project, under the Apache License v2.0 with LLVM +// Exceptions. See /LICENSE for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +// AUTOUPDATE +// RUN: %{carbon-run-semantics} +// CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: callables: [ +// CHECK:STDOUT: {param_ir: block1, param_refs: block2}, +// CHECK:STDOUT: {param_ir: block4, param_refs: block5}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: integer_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: real_literals: [ +// CHECK:STDOUT: ] +// CHECK:STDOUT: strings: [ +// CHECK:STDOUT: a, +// CHECK:STDOUT: Foo, +// CHECK:STDOUT: Bar, +// CHECK:STDOUT: ] +// CHECK:STDOUT: nodes: [ +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node0, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node9, arg1: block0}, +// CHECK:STDOUT: {kind: VarStorage, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node12, type: node2}, +// CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable1}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node14}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node14, arg1: block0}, +// CHECK:STDOUT: ] +// CHECK:STDOUT: node_blocks: [ +// CHECK:STDOUT: [ +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node8, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: node16, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: ] + +fn Foo(a: i32) {} +fn Bar(a: i32) {} diff --git a/toolchain/semantics/testdata/operators/binary_op.carbon b/toolchain/semantics/testdata/operators/binary_op.carbon index 84265d66ae3d..c510c5c51a71 100644 --- a/toolchain/semantics/testdata/operators/binary_op.carbon +++ b/toolchain/semantics/testdata/operators/binary_op.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 12, @@ -23,27 +25,29 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, -// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node7, arg1: node8, type: node2}, -// CHECK:STDOUT: {kind: ReturnExpression, arg0: node9, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node9, arg1: node10, type: node2}, +// CHECK:STDOUT: {kind: ReturnExpression, arg0: node11, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node11, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/operators/fail_type_mismatch.carbon b/toolchain/semantics/testdata/operators/fail_type_mismatch.carbon index 17bb11da4586..617d5a8362a8 100644 --- a/toolchain/semantics/testdata/operators/fail_type_mismatch.carbon +++ b/toolchain/semantics/testdata/operators/fail_type_mismatch.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{not} %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 12, @@ -23,27 +25,29 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, // CHECK:STDOUT: {kind: RealLiteral, arg0: real0, type: node3}, -// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node7, arg1: node8, type: node1}, -// CHECK:STDOUT: {kind: ReturnExpression, arg0: node9, type: node1}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node9, arg1: node10, type: node1}, +// CHECK:STDOUT: {kind: ReturnExpression, arg0: node11, type: node1}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node11, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/operators/fail_type_mismatch_once.carbon b/toolchain/semantics/testdata/operators/fail_type_mismatch_once.carbon index 88dd48777b68..15deed323a8b 100644 --- a/toolchain/semantics/testdata/operators/fail_type_mismatch_once.carbon +++ b/toolchain/semantics/testdata/operators/fail_type_mismatch_once.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{not} %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 12, @@ -24,31 +26,33 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, // CHECK:STDOUT: {kind: RealLiteral, arg0: real0, type: node3}, -// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node7, arg1: node8, type: node1}, -// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, // CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node9, arg1: node10, type: node1}, -// CHECK:STDOUT: {kind: ReturnExpression, arg0: node11, type: node1}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, +// CHECK:STDOUT: {kind: BinaryOperatorAdd, arg0: node11, arg1: node12, type: node1}, +// CHECK:STDOUT: {kind: ReturnExpression, arg0: node13, type: node1}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node13, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, // CHECK:STDOUT: node11, // CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/return/literal.carbon b/toolchain/semantics/testdata/return/literal.carbon index a45416c3d7a3..71e77b4d1584 100644 --- a/toolchain/semantics/testdata/return/literal.carbon +++ b/toolchain/semantics/testdata/return/literal.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 0, @@ -22,23 +24,25 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: ReturnExpression, arg0: node7, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: ReturnExpression, arg0: node9, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node9, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/return/trivial.carbon b/toolchain/semantics/testdata/return/trivial.carbon index 8a4664d06201..6f12061e2141 100644 --- a/toolchain/semantics/testdata/return/trivial.carbon +++ b/toolchain/semantics/testdata/return/trivial.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -21,21 +23,23 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: Return}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, +// CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node10, // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node7, +// CHECK:STDOUT: node9, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/decl.carbon b/toolchain/semantics/testdata/var/decl.carbon index 91f362e60471..8cdba32ffc43 100644 --- a/toolchain/semantics/testdata/var/decl.carbon +++ b/toolchain/semantics/testdata/var/decl.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -22,23 +24,25 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node9, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/decl_with_init.carbon b/toolchain/semantics/testdata/var/decl_with_init.carbon index 22da5b0a4f80..f49e5e895ec2 100644 --- a/toolchain/semantics/testdata/var/decl_with_init.carbon +++ b/toolchain/semantics/testdata/var/decl_with_init.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 0, @@ -23,27 +25,29 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node11, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node11, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/fail_duplicate_decl.carbon b/toolchain/semantics/testdata/var/fail_duplicate_decl.carbon index b58d57cfcbfd..d8db652310b7 100644 --- a/toolchain/semantics/testdata/var/fail_duplicate_decl.carbon +++ b/toolchain/semantics/testdata/var/fail_duplicate_decl.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{not} %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 0, @@ -24,35 +26,37 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node11, type: node2}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node11, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node13, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int1, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node13, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node15, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node15, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node17, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, // CHECK:STDOUT: node11, // CHECK:STDOUT: node12, // CHECK:STDOUT: node13, // CHECK:STDOUT: node14, +// CHECK:STDOUT: node15, +// CHECK:STDOUT: node16, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/fail_init_type_mismatch.carbon b/toolchain/semantics/testdata/var/fail_init_type_mismatch.carbon index 9f5999e1985a..2ff6b45864b2 100644 --- a/toolchain/semantics/testdata/var/fail_init_type_mismatch.carbon +++ b/toolchain/semantics/testdata/var/fail_init_type_mismatch.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{not} %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -23,27 +25,29 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: RealLiteral, arg0: real0, type: node3}, -// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node1}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node11, type: node1}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node11, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/fail_init_with_self.carbon b/toolchain/semantics/testdata/var/fail_init_with_self.carbon index 409de39a9698..b2b50f58d3ad 100644 --- a/toolchain/semantics/testdata/var/fail_init_with_self.carbon +++ b/toolchain/semantics/testdata/var/fail_init_with_self.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{not} %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -22,25 +24,27 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node1, type: node1}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node10, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/fail_lookup_outside_scope.carbon b/toolchain/semantics/testdata/var/fail_lookup_outside_scope.carbon index 6bda0c0c3419..700233513b07 100644 --- a/toolchain/semantics/testdata/var/fail_lookup_outside_scope.carbon +++ b/toolchain/semantics/testdata/var/fail_lookup_outside_scope.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{not} %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: ] @@ -23,29 +25,31 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node10, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node10, arg1: node1, type: node1}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node12, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node12, arg1: node1, type: node1}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node9, -// CHECK:STDOUT: node10, -// CHECK:STDOUT: node11, -// CHECK:STDOUT: node12, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/global_decl.carbon b/toolchain/semantics/testdata/var/global_decl.carbon index 379772577f5d..3bb3d0feb97e 100644 --- a/toolchain/semantics/testdata/var/global_decl.carbon +++ b/toolchain/semantics/testdata/var/global_decl.carbon @@ -5,6 +5,8 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ @@ -20,15 +22,17 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, +// CHECK:STDOUT: node7, +// CHECK:STDOUT: node8, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/global_decl_with_init.carbon b/toolchain/semantics/testdata/var/global_decl_with_init.carbon index 998dd0c0c7d6..83795d415c31 100644 --- a/toolchain/semantics/testdata/var/global_decl_with_init.carbon +++ b/toolchain/semantics/testdata/var/global_decl_with_init.carbon @@ -5,6 +5,8 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ @@ -21,19 +23,21 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node5, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node9, +// CHECK:STDOUT: node10, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/global_lookup.carbon b/toolchain/semantics/testdata/var/global_lookup.carbon index 67fe77ac6e0f..92eb1917bba4 100644 --- a/toolchain/semantics/testdata/var/global_lookup.carbon +++ b/toolchain/semantics/testdata/var/global_lookup.carbon @@ -5,6 +5,8 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ @@ -22,25 +24,27 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node5, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node11, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node11, arg1: node7, type: node2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, // CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, +// CHECK:STDOUT: node13, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/global_lookup_in_scope.carbon b/toolchain/semantics/testdata/var/global_lookup_in_scope.carbon index 1d9f80231149..93ca1d5dd021 100644 --- a/toolchain/semantics/testdata/var/global_lookup_in_scope.carbon +++ b/toolchain/semantics/testdata/var/global_lookup_in_scope.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 0, @@ -24,33 +26,35 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node5, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node11}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node11, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node11, arg1: node5, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node9, arg1: block2}, +// CHECK:STDOUT: {kind: BindName, arg0: str2, arg1: node13, type: node2}, +// CHECK:STDOUT: {kind: Assign, arg0: node13, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node11, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, -// CHECK:STDOUT: node14, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node11, // CHECK:STDOUT: node12, +// CHECK:STDOUT: node16, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node13, +// CHECK:STDOUT: node14, +// CHECK:STDOUT: node15, // CHECK:STDOUT: ], // CHECK:STDOUT: ] diff --git a/toolchain/semantics/testdata/var/lookup.carbon b/toolchain/semantics/testdata/var/lookup.carbon index 398d5854e227..0d0104b27149 100644 --- a/toolchain/semantics/testdata/var/lookup.carbon +++ b/toolchain/semantics/testdata/var/lookup.carbon @@ -5,8 +5,10 @@ // AUTOUPDATE // RUN: %{carbon-run-semantics} // CHECK:STDOUT: cross_reference_irs_size: 1 +// CHECK:STDOUT: calls: [ +// CHECK:STDOUT: ] // CHECK:STDOUT: callables: [ -// CHECK:STDOUT: {param_ir: block0, param_refs: block0} +// CHECK:STDOUT: {param_ir: block0, param_refs: block0}, // CHECK:STDOUT: ] // CHECK:STDOUT: integer_literals: [ // CHECK:STDOUT: 0, @@ -23,27 +25,29 @@ // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node2, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node3, type: node0}, // CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node4, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node5, type: node0}, +// CHECK:STDOUT: {kind: CrossReference, arg0: ir0, arg1: node6, type: node5}, // CHECK:STDOUT: {kind: FunctionDeclaration, arg0: callable0}, -// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node5}, +// CHECK:STDOUT: {kind: BindName, arg0: str0, arg1: node7}, // CHECK:STDOUT: {kind: VarStorage, type: node2}, -// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node7, type: node2}, +// CHECK:STDOUT: {kind: BindName, arg0: str1, arg1: node9, type: node2}, // CHECK:STDOUT: {kind: IntegerLiteral, arg0: int0, type: node2}, -// CHECK:STDOUT: {kind: Assign, arg0: node7, arg1: node9, type: node2}, -// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node5, arg1: block2}, +// CHECK:STDOUT: {kind: Assign, arg0: node9, arg1: node11, type: node2}, +// CHECK:STDOUT: {kind: FunctionDefinition, arg0: node7, arg1: block2}, // CHECK:STDOUT: ] // CHECK:STDOUT: node_blocks: [ // CHECK:STDOUT: [ // CHECK:STDOUT: ], // CHECK:STDOUT: [ -// CHECK:STDOUT: node5, -// CHECK:STDOUT: node6, -// CHECK:STDOUT: node11, -// CHECK:STDOUT: ], -// CHECK:STDOUT: [ // CHECK:STDOUT: node7, // CHECK:STDOUT: node8, +// CHECK:STDOUT: node13, +// CHECK:STDOUT: ], +// CHECK:STDOUT: [ // CHECK:STDOUT: node9, // CHECK:STDOUT: node10, +// CHECK:STDOUT: node11, +// CHECK:STDOUT: node12, // CHECK:STDOUT: ], // CHECK:STDOUT: ]