Split statement-specific parts of semantics_handle.cpp into separate files. (#2949)

`semantics_handle.cpp` is a little on the large side, and is going to grow as we add new nodes. Some of the statement-specific parts have already been split into their own files. Split out the remaining such parts.
2026-10-04 22:02:52 +01:00 · 2023-06-27 09:26:59 -07:00
parent adcb5fb0b5
commit 288ad9f8e5
4 changed files with 148 additions and 128 deletions
@@ -0,0 +1,83 @@
+// 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
+
+#include "toolchain/semantics/semantics_context.h"
+#include "toolchain/semantics/semantics_node.h"
+
+namespace Carbon {
+
+auto SemanticsHandleExpressionStatement(SemanticsContext& context,
+                                        ParseTree::Node /*parse_node*/)
+    -> bool {
+  // Pop the expression without investigating its contents.
+  // TODO: This will probably eventually need to do some "do not discard"
+  // analysis.
+  context.node_stack().PopAndDiscardId();
+  return true;
+}
+
+auto SemanticsHandleReturnStatement(SemanticsContext& context,
+                                    ParseTree::Node parse_node) -> bool {
+  CARBON_CHECK(!context.return_scope_stack().empty());
+  const auto& fn_node =
+      context.semantics_ir().GetNode(context.return_scope_stack().back());
+  const auto callable =
+      context.semantics_ir().GetFunction(fn_node.GetAsFunctionDeclaration());
+
+  if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) ==
+      ParseNodeKind::ReturnStatementStart) {
+    context.node_stack().PopAndDiscardSoloParseNode(
+        ParseNodeKind::ReturnStatementStart);
+
+    if (callable.return_type_id.is_valid()) {
+      // TODO: Add a note pointing at the return type's parse node.
+      CARBON_DIAGNOSTIC(ReturnStatementMissingExpression, Error,
+                        "Must return a {0}.", std::string);
+      context.emitter()
+          .Build(parse_node, ReturnStatementMissingExpression,
+                 context.semantics_ir().StringifyType(callable.return_type_id))
+          .Emit();
+    }
+
+    context.AddNode(SemanticsNode::Return::Make(parse_node));
+  } else {
+    auto arg = context.node_stack().Pop<SemanticsNodeId>();
+    context.node_stack().PopAndDiscardSoloParseNode(
+        ParseNodeKind::ReturnStatementStart);
+
+    if (!callable.return_type_id.is_valid()) {
+      CARBON_DIAGNOSTIC(
+          ReturnStatementDisallowExpression, Error,
+          "No return expression should be provided in this context.");
+      CARBON_DIAGNOSTIC(ReturnStatementImplicitNote, Note,
+                        "There was no return type provided.");
+      context.emitter()
+          .Build(parse_node, ReturnStatementDisallowExpression)
+          .Note(fn_node.parse_node(), ReturnStatementImplicitNote)
+          .Emit();
+    } else {
+      arg =
+          context.ImplicitAsRequired(parse_node, arg, callable.return_type_id);
+    }
+
+    context.AddNode(SemanticsNode::ReturnExpression::Make(
+        parse_node, context.semantics_ir().GetNode(arg).type_id(), arg));
+  }
+
+  // Switch to a new, unreachable, empty node block. This typically won't
+  // contain any semantics IR, but it can do if there are statements following
+  // the `return` statement.
+  context.node_block_stack().Pop();
+  context.node_block_stack().PushUnreachable();
+  return true;
+}
+
+auto SemanticsHandleReturnStatementStart(SemanticsContext& context,
+                                         ParseTree::Node parse_node) -> bool {
+  // No action, just a bracketing node.
+  context.node_stack().Push(parse_node);
+  return true;
+}
+
+}  // namespace Carbon