mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-02 13:06:00 +01:00
Jon Ross-PerkinsandRichard Smith
5bb318cae6
Trying to conform with #4009. Changes SemIR::LocIdAndInst construction to root out struct init cases with AddInst and related functions. I'm using templating of AddInst functions in order to avoid `AddInst(loc_id, InstName{...})` and instead have `AddInst<InstName>(loc_id, {...})` with I think similar readability results. There are a couple cases where inst construction is templated and so designated initializers couldn't be used, so this may be better for those in particular due to the extra type enforcement. This probably doesn't clean up every last case, but I was trying to get the bulk at once without bleeding over into less related changes. --------- Co-authored-by: Richard Smith <richard@metafoo.co.uk>
104 lines
4.4 KiB
C++
104 lines
4.4 KiB
C++
// 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/check/function.h"
|
|
#include "toolchain/sem_ir/inst.h"
|
|
#include "toolchain/sem_ir/typed_insts.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
// Performs a call where the callee is the name of a generic class, such as
|
|
// `Vector(i32)`.
|
|
static auto PerformCallToGenericClass(Context& context, Parse::NodeId node_id,
|
|
SemIR::ClassId class_id,
|
|
llvm::ArrayRef<SemIR::InstId> arg_ids)
|
|
-> SemIR::InstId {
|
|
auto& class_info = context.classes().Get(class_id);
|
|
|
|
// Convert the arguments to match the parameters.
|
|
auto converted_args_id = ConvertCallArgs(
|
|
context, node_id, /*self_id=*/SemIR::InstId::Invalid, arg_ids,
|
|
/*return_storage_id=*/SemIR::InstId::Invalid, class_info.decl_id,
|
|
class_info.implicit_param_refs_id, class_info.param_refs_id);
|
|
return context.AddInst<SemIR::ClassType>(node_id,
|
|
{.type_id = SemIR::TypeId::TypeType,
|
|
.class_id = class_id,
|
|
.args_id = converted_args_id});
|
|
}
|
|
|
|
auto PerformCall(Context& context, Parse::NodeId node_id,
|
|
SemIR::InstId callee_id, llvm::ArrayRef<SemIR::InstId> arg_ids)
|
|
-> SemIR::InstId {
|
|
// Identify the function we're calling.
|
|
auto callee_function = GetCalleeFunction(context.sem_ir(), callee_id);
|
|
if (!callee_function.function_id.is_valid()) {
|
|
if (auto generic_class = context.types().TryGetAs<SemIR::GenericClassType>(
|
|
context.insts().Get(callee_id).type_id())) {
|
|
return PerformCallToGenericClass(context, node_id,
|
|
generic_class->class_id, arg_ids);
|
|
}
|
|
if (!callee_function.is_error) {
|
|
CARBON_DIAGNOSTIC(CallToNonCallable, Error,
|
|
"Value of type `{0}` is not callable.", SemIR::TypeId);
|
|
context.emitter().Emit(node_id, CallToNonCallable,
|
|
context.insts().Get(callee_id).type_id());
|
|
}
|
|
return SemIR::InstId::BuiltinError;
|
|
}
|
|
auto& callable = context.functions().Get(callee_function.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;
|
|
{
|
|
DiagnosticAnnotationScope annotate_diagnostics(
|
|
&context.emitter(), [&](auto& builder) {
|
|
CARBON_DIAGNOSTIC(IncompleteReturnTypeHere, Note,
|
|
"Return type declared here.");
|
|
builder.Note(callable.return_storage_id, IncompleteReturnTypeHere);
|
|
});
|
|
CheckFunctionReturnType(context, callee_id, callable);
|
|
}
|
|
switch (callable.return_slot) {
|
|
case SemIR::Function::ReturnSlot::Present:
|
|
// 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<SemIR::TemporaryStorage>(
|
|
node_id, {.type_id = callable.return_type_id});
|
|
break;
|
|
case SemIR::Function::ReturnSlot::Absent:
|
|
break;
|
|
case SemIR::Function::ReturnSlot::Error:
|
|
// Don't form an initializing expression with an incomplete type.
|
|
type_id = SemIR::TypeId::Error;
|
|
break;
|
|
case SemIR::Function::ReturnSlot::NotComputed:
|
|
CARBON_FATAL() << "Missing return slot category in call to " << callable;
|
|
}
|
|
|
|
// Convert the arguments to match the parameters.
|
|
auto converted_args_id =
|
|
ConvertCallArgs(context, node_id, callee_function.self_id, arg_ids,
|
|
return_storage_id, callable.decl_id,
|
|
callable.implicit_param_refs_id, callable.param_refs_id);
|
|
auto call_inst_id =
|
|
context.AddInst<SemIR::Call>(node_id, {.type_id = type_id,
|
|
.callee_id = callee_id,
|
|
.args_id = converted_args_id});
|
|
|
|
return call_inst_id;
|
|
}
|
|
|
|
} // namespace Carbon::Check
|