Overloaded operator support. (#3796)

Support is added for all overloaded operator interfaces in the current
design apart from `Assign`, which is going to require some more work to
properly handle, given that primitive assignment currently has a special
implementation for quite a few builtin types.

As we don't have support for generics yet -- in particular, generic
interfaces -- there is no support for `*With` interfaces, but homogenous
interfaces such as `Add` are supported instead.

Factor out building of call expressions so that overloaded operators can
generate calls.

Switch a few places from using specific kinds of NodeId to a general
NodeId. Because overloaded operators and other things like implicit
conversions can result in member access and function calls, those
operations can't require a specific kind of NodeId.

Add import support for associated entities, and fix import support for
interfaces and symbolic bindings. We now import interfaces in two steps,
first importing a forward declaration then a definition, just like we do
for classes. For symbolic bindings, we ensure that each BindSymbolicName
is imported only once, because its ID is used as its symbolic identity.
This is necessary because we (only) support operator interfaces that are
defined in an imported Carbon package for now.

The entire contents of `check/operator.cpp` should probably be
rethought. In particular, doing a lot of name lookups on each operator
is likely to be bad for performance. But this gets us to the point where
overloaded operators are basically working, which seems like a good
place to iterate from.

For now, the tests that the individual operators map to the right
interfaces are mostly generated by a script, but that's just because I'm
expecting a fair bit of churn in how we define the prelude and the
`impl`s -- in particular, when we add support for `AddWith`, we'll need
to update all the tests. The plan is to remove the script once things
settle down.

---------

Co-authored-by: Jon Ross-Perkins <[email protected]>
Co-authored-by: Carbon Infra Bot <[email protected]>

Author: 3 people

.pre-commit-config.yaml

@@ -180,7 +180,7 @@ repos:
             Exceptions. See /LICENSE for license information.
             SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
           - --custom_format
-          - '\.(carbon|proto|ypp)$'
+          - '\.(carbon|proto|ypp)(\.tmpl)?$'
           - ''
           - '// '
           - ''

toolchain/check/BUILD

@@ -55,7 +55,6 @@ cc_library(
         "decl_name_stack.cpp",
         "eval.cpp",
         "import_ref.cpp",
-        "import_ref.h",
         "inst_block_stack.cpp",
         "modifiers.cpp",
         "return.cpp",
@@ -66,6 +65,7 @@ cc_library(
         "decl_name_stack.h",
         "decl_state.h",
         "eval.h",
+        "import_ref.h",
         "inst_block_stack.h",
         "modifiers.h",
         "param_and_arg_refs_stack.h",
@@ -101,12 +101,14 @@ cc_library(
     ]),
     hdrs = ["check.h"],
     deps = [
+        ":call",
         ":context",
         ":function",
         ":impl",
         ":import",
         ":interface",
         ":member_access",
+        ":operator",
         ":pointer_dereference",
         "//common:check",
         "//common:ostream",
@@ -138,6 +140,20 @@ cc_fuzz_test(
     ],
 )
 
+cc_library(
+    name = "call",
+    srcs = ["call.cpp"],
+    hdrs = ["call.h"],
+    deps = [
+        ":context",
+        "//common:check",
+        "//toolchain/sem_ir:file",
+        "//toolchain/sem_ir:ids",
+        "//toolchain/sem_ir:inst",
+        "//toolchain/sem_ir:inst_kind",
+    ],
+)
+
 cc_library(
     name = "function",
     srcs = ["function.cpp"],
@@ -213,6 +229,23 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "operator",
+    srcs = ["operator.cpp"],
+    hdrs = ["operator.h"],
+    deps = [
+        ":call",
+        ":context",
+        ":member_access",
+        "//common:check",
+        "//toolchain/parse:node_kind",
+        "//toolchain/sem_ir:file",
+        "//toolchain/sem_ir:ids",
+        "//toolchain/sem_ir:inst",
+        "//toolchain/sem_ir:inst_kind",
+    ],
+)
+
 cc_library(
     name = "pointer_dereference",
     srcs = ["pointer_dereference.cpp"],

toolchain/check/call.cpp

@@ -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
+
+#include "toolchain/check/call.h"
+
+#include "toolchain/check/context.h"
+#include "toolchain/check/convert.h"
+#include "toolchain/sem_ir/inst.h"
+#include "toolchain/sem_ir/typed_insts.h"
+
+namespace Carbon::Check {
+
+auto PerformCall(Context& context, Parse::NodeId node_id,
+                 SemIR::InstId callee_id, llvm::ArrayRef<SemIR::InstId> arg_ids)
+    -> SemIR::InstId {
+  auto diagnose_not_callable = [&] {
+    auto callee_type_id = context.insts().Get(callee_id).type_id();
+    if (callee_type_id != SemIR::TypeId::Error) {
+      CARBON_DIAGNOSTIC(CallToNonCallable, Error,
+                        "Value of type `{0}` is not callable.", SemIR::TypeId);
+      context.emitter().Emit(node_id, CallToNonCallable, callee_type_id);
+    }
+    return SemIR::InstId::BuiltinError;
+  };
+
+  // For a method call, pick out the `self` value.
+  auto function_callee_id = callee_id;
+  SemIR::InstId self_id = SemIR::InstId::Invalid;
+  if (auto bound_method =
+          context.insts().Get(callee_id).TryAs<SemIR::BoundMethod>()) {
+    self_id = bound_method->object_id;
+    function_callee_id = bound_method->function_id;
+  }
+
+  // Identify the function we're calling.
+  auto function_decl_id = context.constant_values().Get(function_callee_id);
+  if (!function_decl_id.is_constant()) {
+    return diagnose_not_callable();
+  }
+  auto function_decl = context.insts()
+                           .Get(function_decl_id.inst_id())
+                           .TryAs<SemIR::FunctionDecl>();
+  if (!function_decl) {
+    return diagnose_not_callable();
+  }
+  auto function_id = function_decl->function_id;
+  const auto& callable = context.functions().Get(function_id);
+
+  // For functions with an implicit return type, the return type is the empty
+  // tuple type.
+  SemIR::TypeId type_id = callable.return_type_id;
+  if (!type_id.is_valid()) {
+    type_id = context.GetTupleType({});
+  }
+
+  // If there is a return slot, build storage for the result.
+  SemIR::InstId return_storage_id = SemIR::InstId::Invalid;
+  if (callable.return_slot_id.is_valid()) {
+    // Tentatively put storage for a temporary in the function's return slot.
+    // This will be replaced if necessary when we perform initialization.
+    return_storage_id = context.AddInst(
+        {node_id, SemIR::TemporaryStorage{callable.return_type_id}});
+  }
+
+  // Convert the arguments to match the parameters.
+  auto converted_args_id =
+      ConvertCallArgs(context, node_id, self_id, arg_ids, return_storage_id,
+                      function_decl_id.inst_id(),
+                      callable.implicit_param_refs_id, callable.param_refs_id);
+  auto call_inst_id = context.AddInst(
+      {node_id, SemIR::Call{type_id, callee_id, converted_args_id}});
+
+  return call_inst_id;
+}
+
+}  // namespace Carbon::Check

toolchain/check/call.h

@@ -0,0 +1,20 @@
+// 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
+
+#ifndef CARBON_TOOLCHAIN_CHECK_CALL_H_
+#define CARBON_TOOLCHAIN_CHECK_CALL_H_
+
+#include "toolchain/check/context.h"
+#include "toolchain/sem_ir/ids.h"
+
+namespace Carbon::Check {
+
+// Checks and builds SemIR for a call to `callee_id` with arguments `args_id`.
+auto PerformCall(Context& context, Parse::NodeId node_id,
+                 SemIR::InstId callee_id, llvm::ArrayRef<SemIR::InstId> arg_ids)
+    -> SemIR::InstId;
+
+}  // namespace Carbon::Check
+
+#endif  // CARBON_TOOLCHAIN_CHECK_CALL_H_

toolchain/check/eval.cpp

@@ -164,7 +164,7 @@ static auto RebuildAndValidateIfFieldsAreConstant(
   if ((ReplaceFieldWithConstantValue(context, &typed_inst, each_field_id,
                                      &phase) &&
        ...)) {
-    if (!validate_fn(typed_inst)) {
+    if (phase == Phase::UnknownDueToError || !validate_fn(typed_inst)) {
       return SemIR::ConstantId::Error;
     }
     return MakeConstantResult(context, typed_inst, phase);

toolchain/check/handle_call_expr.cpp

@@ -2,9 +2,8 @@
 // Exceptions. See /LICENSE for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "llvm/ADT/ScopeExit.h"
+#include "toolchain/check/call.h"
 #include "toolchain/check/context.h"
-#include "toolchain/check/convert.h"
 #include "toolchain/sem_ir/inst.h"
 
 namespace Carbon::Check {
@@ -27,74 +26,15 @@ auto HandleCallExpr(Context& context, Parse::CallExprId node_id) -> bool {
   // Process the final explicit call argument now, but leave the arguments
   // block on the stack until the end of this function.
   context.param_and_arg_refs_stack().EndNoPop(Parse::NodeKind::CallExprStart);
-  auto discard_args_block = llvm::make_scope_exit(
-      [&] { context.param_and_arg_refs_stack().PopAndDiscard(); });
-
   auto [call_expr_node_id, callee_id] =
       context.node_stack().PopWithNodeId<Parse::NodeKind::CallExprStart>();
 
-  auto diagnose_not_callable = [&, call_expr_node_id = call_expr_node_id,
-                                callee_id = callee_id] {
-    auto callee_type_id = context.insts().Get(callee_id).type_id();
-    if (callee_type_id != SemIR::TypeId::Error) {
-      CARBON_DIAGNOSTIC(CallToNonCallable, Error,
-                        "Value of type `{0}` is not callable.", SemIR::TypeId);
-      context.emitter().Emit(call_expr_node_id, CallToNonCallable,
-                             callee_type_id);
-    }
-    context.node_stack().Push(node_id, SemIR::InstId::BuiltinError);
-    return true;
-  };
-
-  // For a method call, pick out the `self` value.
-  auto function_callee_id = callee_id;
-  SemIR::InstId self_id = SemIR::InstId::Invalid;
-  if (auto bound_method =
-          context.insts().Get(callee_id).TryAs<SemIR::BoundMethod>()) {
-    self_id = bound_method->object_id;
-    function_callee_id = bound_method->function_id;
-  }
-
-  // Identify the function we're calling.
-  auto function_decl_id = context.constant_values().Get(function_callee_id);
-  if (!function_decl_id.is_constant()) {
-    return diagnose_not_callable();
-  }
-  auto function_decl = context.insts()
-                           .Get(function_decl_id.inst_id())
-                           .TryAs<SemIR::FunctionDecl>();
-  if (!function_decl) {
-    return diagnose_not_callable();
-  }
-  auto function_id = function_decl->function_id;
-  const auto& callable = context.functions().Get(function_id);
-
-  // For functions with an implicit return type, the return type is the empty
-  // tuple type.
-  SemIR::TypeId type_id = callable.return_type_id;
-  if (!type_id.is_valid()) {
-    type_id = context.GetTupleType({});
-  }
-
-  // If there is a return slot, build storage for the result.
-  SemIR::InstId return_storage_id = SemIR::InstId::Invalid;
-  if (callable.return_slot_id.is_valid()) {
-    // Tentatively put storage for a temporary in the function's return slot.
-    // This will be replaced if necessary when we perform initialization.
-    return_storage_id = context.AddInst(
-        {call_expr_node_id, SemIR::TemporaryStorage{callable.return_type_id}});
-  }
-
-  // Convert the arguments to match the parameters.
-  auto converted_args_id = ConvertCallArgs(
-      context, call_expr_node_id, self_id,
-      context.param_and_arg_refs_stack().PeekCurrentBlockContents(),
-      return_storage_id, function_decl_id.inst_id(),
-      callable.implicit_param_refs_id, callable.param_refs_id);
-  auto call_inst_id = context.AddInst(
-      {call_expr_node_id, SemIR::Call{type_id, callee_id, converted_args_id}});
+  auto call_id = PerformCall(
+      context, call_expr_node_id, callee_id,
+      context.param_and_arg_refs_stack().PeekCurrentBlockContents());
 
-  context.node_stack().Push(node_id, call_inst_id);
+  context.param_and_arg_refs_stack().PopAndDiscard();
+  context.node_stack().Push(node_id, call_id);
   return true;
 }