mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-15 18:38:13 +00:00
Richard Smith
947c1eb527
As described in proposal #4682, make `array(T, N)` be syntactic sugar for the type `Core.Array` defined in the standard library. This provides a home for impls that are specific to `Core.Array`. Assisted-by: Gemini and Claude via Antigravity
258 lines
10 KiB
C++
258 lines
10 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/literal.h"
|
|
|
|
#include "toolchain/check/call.h"
|
|
#include "toolchain/check/context.h"
|
|
#include "toolchain/check/convert.h"
|
|
#include "toolchain/check/diagnostic_helpers.h"
|
|
#include "toolchain/check/name_lookup.h"
|
|
#include "toolchain/check/type.h"
|
|
#include "toolchain/check/type_completion.h"
|
|
#include "toolchain/diagnostics/diagnostic.h"
|
|
#include "toolchain/lex/token_info.h"
|
|
#include "toolchain/parse/node_ids.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
// Adds a TypeLiteral instruction to represent a syntactic type literal.
|
|
static auto MakeTypeLiteral(Context& context, SemIR::LocId loc_id,
|
|
SemIR::InstId value_id) -> SemIR::TypeInstId {
|
|
auto type_inst_id = ExprAsType(context, loc_id, value_id).inst_id;
|
|
return AddTypeInst<SemIR::TypeLiteral>(
|
|
context, loc_id,
|
|
{.type_id = SemIR::TypeType::TypeId, .value_id = type_inst_id});
|
|
}
|
|
|
|
auto MakeTypeTypeLiteral(Context& context, Parse::NodeId node_id)
|
|
-> SemIR::TypeInstId {
|
|
return MakeTypeLiteral(context, node_id, SemIR::TypeType::TypeInstId);
|
|
}
|
|
|
|
auto MakeBoolTypeLiteral(Context& context, Parse::NodeId node_id)
|
|
-> SemIR::TypeInstId {
|
|
auto desugared_loc_id = SemIR::LocId(node_id).AsDesugared();
|
|
auto inst_id =
|
|
LookupNameInCore(context, desugared_loc_id, CoreIdentifier::Bool);
|
|
return MakeTypeLiteral(context, node_id, inst_id);
|
|
}
|
|
|
|
auto MakeBoolLiteral(Context& context, SemIR::LocId loc_id,
|
|
SemIR::BoolValue value) -> SemIR::InstId {
|
|
return AddInst<SemIR::BoolLiteral>(
|
|
context, loc_id,
|
|
{.type_id = GetSingletonType(context, SemIR::BoolType::TypeInstId),
|
|
.value = value});
|
|
}
|
|
|
|
auto MakeIntLiteral(Context& context, Parse::NodeId node_id, IntId int_id)
|
|
-> SemIR::InstId {
|
|
return AddInst<SemIR::IntValue>(
|
|
context, node_id,
|
|
{.type_id = GetSingletonType(context, SemIR::IntLiteralType::TypeInstId),
|
|
.int_id = int_id});
|
|
}
|
|
|
|
// Returns an instruction with the given constant integer value.
|
|
static auto GetOrAddIntValue(Context& context, SemIR::LocId loc_id,
|
|
IntId int_id) -> SemIR::InstId {
|
|
return GetOrAddInst<SemIR::IntValue>(
|
|
context, loc_id,
|
|
{.type_id = GetSingletonType(context, SemIR::IntLiteralType::TypeInstId),
|
|
.int_id = int_id});
|
|
}
|
|
|
|
auto MakeCharTypeLiteral(Context& context, Parse::NodeId node_id)
|
|
-> SemIR::TypeInstId {
|
|
auto inst_id = LookupNameInCore(context, node_id, CoreIdentifier::Char);
|
|
return MakeTypeLiteral(context, node_id, inst_id);
|
|
}
|
|
|
|
// Returns an instruction representing the type `iN` or `uN`.
|
|
static auto GetOrAddIntTypeInst(Context& context, SemIR::LocId loc_id,
|
|
SemIR::IntKind int_kind, IntId size_id)
|
|
-> SemIR::InstId {
|
|
auto width_id = GetOrAddIntValue(context, loc_id, size_id);
|
|
auto fn_inst_id = LookupNameInCore(context, loc_id,
|
|
int_kind == SemIR::IntKind::Signed
|
|
? CoreIdentifier::Int
|
|
: CoreIdentifier::UInt);
|
|
return PerformCall(context, loc_id, fn_inst_id, {width_id});
|
|
}
|
|
|
|
auto MakeIntTypeLiteral(Context& context, Parse::NodeId node_id,
|
|
SemIR::IntKind int_kind, IntId size_id)
|
|
-> SemIR::TypeInstId {
|
|
auto desugared_loc_id = SemIR::LocId(node_id).AsDesugared();
|
|
auto type_inst_id =
|
|
GetOrAddIntTypeInst(context, desugared_loc_id, int_kind, size_id);
|
|
return MakeTypeLiteral(context, node_id, type_inst_id);
|
|
}
|
|
|
|
auto MakeIntType(Context& context, Parse::NodeId node_id,
|
|
SemIR::IntKind int_kind, IntId size_id) -> SemIR::TypeId {
|
|
auto desugared_loc_id = SemIR::LocId(node_id).AsDesugared();
|
|
auto type_inst_id =
|
|
GetOrAddIntTypeInst(context, desugared_loc_id, int_kind, size_id);
|
|
return ExprAsType(context, node_id, type_inst_id).type_id;
|
|
}
|
|
|
|
auto MakeFloatTypeLiteral(Context& context, Parse::NodeId node_id,
|
|
IntId size_id) -> SemIR::TypeInstId {
|
|
auto desugared_loc_id = SemIR::LocId(node_id).AsDesugared();
|
|
auto width_id = GetOrAddIntValue(context, desugared_loc_id, size_id);
|
|
auto fn_inst_id =
|
|
LookupNameInCore(context, desugared_loc_id, CoreIdentifier::Float);
|
|
auto call_id = PerformCall(context, desugared_loc_id, fn_inst_id, {width_id});
|
|
return MakeTypeLiteral(context, node_id, call_id);
|
|
}
|
|
|
|
namespace {
|
|
// The extracted representation of the type `Core.String`.
|
|
struct StringRepr {
|
|
SemIR::TypeId ptr_field_type_id;
|
|
SemIR::TypeId size_field_type_id;
|
|
SemIR::TypeStore::IntTypeInfo size_field_type_info;
|
|
};
|
|
} // namespace
|
|
|
|
// Extracts information about the representation of the `Core.String` type
|
|
// necessary for building a string literal.
|
|
static auto GetStringLiteralRepr(Context& context, SemIR::LocId loc_id,
|
|
SemIR::TypeId type_id)
|
|
-> std::optional<StringRepr> {
|
|
// The object representation should be a struct type.
|
|
auto object_repr_id = context.types().GetObjectRepr(type_id);
|
|
auto struct_repr =
|
|
context.types().TryGetAs<SemIR::StructType>(object_repr_id);
|
|
if (!struct_repr) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
// The struct should have two fields.
|
|
auto fields = context.struct_type_fields().Get(struct_repr->fields_id);
|
|
if (fields.size() != 2) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
// The first field should be a pointer to 8-bit integers.
|
|
auto ptr_type =
|
|
context.insts().TryGetAs<SemIR::PointerType>(fields[0].type_inst_id);
|
|
if (!ptr_type) {
|
|
return std::nullopt;
|
|
}
|
|
auto pointee_type_id =
|
|
context.types().GetTypeIdForTypeInstId(ptr_type->pointee_id);
|
|
if (!TryToCompleteType(context, pointee_type_id, loc_id)) {
|
|
return std::nullopt;
|
|
}
|
|
auto elem_type_info = context.types().TryGetIntTypeInfo(pointee_type_id);
|
|
if (!elem_type_info || context.ints().Get(elem_type_info->bit_width) != 8) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
// The second field should be an integer type.
|
|
auto size_field_type_id =
|
|
context.types().GetTypeIdForTypeInstId(fields[1].type_inst_id);
|
|
auto size_type_info = context.types().TryGetIntTypeInfo(size_field_type_id);
|
|
if (!size_type_info) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
return StringRepr{.ptr_field_type_id = context.types().GetTypeIdForTypeInstId(
|
|
fields[0].type_inst_id),
|
|
.size_field_type_id = size_field_type_id,
|
|
.size_field_type_info = *size_type_info};
|
|
}
|
|
|
|
auto MakeStringLiteral(Context& context, Parse::StringLiteralId node_id,
|
|
StringLiteralValueId value_id) -> SemIR::InstId {
|
|
auto str_type = MakeStringType(context, SemIR::LocId(node_id).AsDesugared());
|
|
if (!RequireCompleteType(
|
|
context, str_type.type_id, node_id, [&](auto& builder) {
|
|
CARBON_DIAGNOSTIC(StringLiteralTypeIncomplete, Context,
|
|
"type {0} is incomplete", InstIdAsType);
|
|
builder.Context(node_id, StringLiteralTypeIncomplete,
|
|
str_type.inst_id);
|
|
})) {
|
|
return SemIR::ErrorInst::InstId;
|
|
}
|
|
|
|
auto repr = GetStringLiteralRepr(context, node_id, str_type.type_id);
|
|
if (!repr) {
|
|
if (str_type.type_id != SemIR::ErrorInst::TypeId) {
|
|
CARBON_DIAGNOSTIC(StringLiteralTypeUnexpected, Error,
|
|
"unexpected representation for type {0}", InstIdAsType);
|
|
context.emitter().Emit(node_id, StringLiteralTypeUnexpected,
|
|
str_type.inst_id);
|
|
}
|
|
return SemIR::ErrorInst::InstId;
|
|
}
|
|
|
|
// The pointer field is a `StringLiteral` object.
|
|
// TODO: Perhaps `StringLiteral` should instead produce a durable reference,
|
|
// and we should take its address here?
|
|
auto ptr_value_id = AddInst<SemIR::StringLiteral>(
|
|
context, node_id,
|
|
{.type_id = repr->ptr_field_type_id, .string_literal_id = value_id});
|
|
|
|
// The size field is an integer literal.
|
|
auto size = context.string_literal_values().Get(value_id).size();
|
|
if (repr->size_field_type_info.bit_width.has_value()) {
|
|
// Check that the size value fits in the size field.
|
|
auto width = context.ints()
|
|
.Get(repr->size_field_type_info.bit_width)
|
|
.getLimitedValue();
|
|
if (repr->size_field_type_info.is_signed ? !llvm::isIntN(width, size)
|
|
: !llvm::isUIntN(width, size)) {
|
|
CARBON_DIAGNOSTIC(StringLiteralTooLong, Error,
|
|
"string literal is too long");
|
|
context.emitter().Emit(node_id, StringLiteralTooLong);
|
|
return SemIR::ErrorInst::InstId;
|
|
}
|
|
}
|
|
auto size_value_id =
|
|
AddInst<SemIR::IntValue>(context, node_id,
|
|
{.type_id = repr->size_field_type_id,
|
|
.int_id = context.ints().Add(size)});
|
|
|
|
// Build the representation struct.
|
|
auto elements_id = context.inst_blocks().Add({ptr_value_id, size_value_id});
|
|
return AddInst<SemIR::StructValue>(
|
|
context, node_id,
|
|
{.type_id = str_type.type_id, .elements_id = elements_id});
|
|
}
|
|
|
|
// Returns an instruction with the value `str`.
|
|
static auto GetOrAddStringTypeInst(Context& context, SemIR::LocId loc_id)
|
|
-> SemIR::InstId {
|
|
return LookupNameInCore(context, loc_id, CoreIdentifier::String);
|
|
}
|
|
|
|
auto MakeStringTypeLiteral(Context& context, Parse::StringTypeLiteralId node_id)
|
|
-> SemIR::TypeInstId {
|
|
auto inst_id = GetOrAddStringTypeInst(context, node_id);
|
|
return MakeTypeLiteral(context, node_id, inst_id);
|
|
}
|
|
|
|
auto MakeStringType(Context& context, SemIR::LocId loc_id) -> TypeExpr {
|
|
auto type_inst_id = GetOrAddStringTypeInst(context, loc_id);
|
|
return ExprAsType(context, loc_id, type_inst_id);
|
|
}
|
|
|
|
auto MakeArrayType(Context& context, SemIR::LocId loc_id,
|
|
SemIR::InstId element_type_inst_id, SemIR::InstId bound_id)
|
|
-> TypeExpr {
|
|
auto desugared_loc_id = context.insts().GetLocIdForDesugaring(loc_id);
|
|
auto fn_inst_id =
|
|
LookupNameInCore(context, desugared_loc_id, CoreIdentifier::Array);
|
|
auto call_id = PerformCall(context, loc_id, fn_inst_id,
|
|
{element_type_inst_id, bound_id});
|
|
return ExprAsType(context, loc_id, call_id);
|
|
}
|
|
|
|
} // namespace Carbon::Check
|