mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Dana Jansens
e62678e682
Proposal #5168 defines when a facet type must be identified or complete, and what it means for an interface and a named constraint to be identified or complete. This updates the toolchain to match the requirements. This implements identification of a facet type to require completed named constraints and to include any interfaces from named constraints into the resulting IdentifiedFacetType. To complete a facet type, each interface in the IdentifiedFacetType, and any interface named though a require declaration from them, must be complete.
280 lines
10 KiB
C++
280 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/base/kind_switch.h"
|
|
#include "toolchain/check/context.h"
|
|
#include "toolchain/check/convert.h"
|
|
#include "toolchain/check/generic.h"
|
|
#include "toolchain/check/handle.h"
|
|
#include "toolchain/check/inst.h"
|
|
#include "toolchain/check/modifiers.h"
|
|
#include "toolchain/check/name_lookup.h"
|
|
#include "toolchain/check/subst.h"
|
|
#include "toolchain/check/type.h"
|
|
#include "toolchain/check/type_completion.h"
|
|
#include "toolchain/diagnostics/diagnostic.h"
|
|
#include "toolchain/parse/node_ids.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
#include "toolchain/sem_ir/named_constraint.h"
|
|
#include "toolchain/sem_ir/type_iterator.h"
|
|
#include "toolchain/sem_ir/typed_insts.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
auto HandleParseNode(Context& context, Parse::RequireIntroducerId node_id)
|
|
-> bool {
|
|
// Require decls are always generic, since everything in an `interface` or
|
|
// `constraint` is generic over `Self`.
|
|
StartGenericDecl(context);
|
|
|
|
// Create an instruction block to hold the instructions created for the type
|
|
// and constraint.
|
|
context.inst_block_stack().Push();
|
|
|
|
// Optional modifiers follow.
|
|
context.decl_introducer_state_stack().Push<Lex::TokenKind::Require>();
|
|
|
|
auto scope_id = context.scope_stack().PeekNameScopeId();
|
|
auto scope_inst_id = context.name_scopes().Get(scope_id).inst_id();
|
|
auto scope_inst = context.insts().Get(scope_inst_id);
|
|
if (!scope_inst.Is<SemIR::InterfaceDecl>() &&
|
|
!scope_inst.Is<SemIR::NamedConstraintDecl>()) {
|
|
CARBON_DIAGNOSTIC(
|
|
RequireInWrongScope, Error,
|
|
"`require` can only be used in an `interface` or `constraint`");
|
|
context.emitter().Emit(node_id, RequireInWrongScope);
|
|
scope_inst_id = SemIR::ErrorInst::InstId;
|
|
}
|
|
|
|
context.node_stack().Push(node_id, scope_inst_id);
|
|
return true;
|
|
}
|
|
|
|
auto HandleParseNode(Context& context, Parse::RequireDefaultSelfImplsId node_id)
|
|
-> bool {
|
|
auto scope_inst_id =
|
|
context.node_stack().Peek<Parse::NodeKind::RequireIntroducer>();
|
|
if (scope_inst_id == SemIR::ErrorInst::InstId) {
|
|
context.node_stack().Push(node_id, SemIR::ErrorInst::TypeInstId);
|
|
return true;
|
|
}
|
|
|
|
auto scope_id = context.scope_stack().PeekNameScopeId();
|
|
auto lookup_result =
|
|
LookupNameInExactScope(context, node_id, SemIR::NameId::SelfType,
|
|
scope_id, context.name_scopes().Get(scope_id),
|
|
/*is_being_declared=*/false);
|
|
CARBON_CHECK(lookup_result.is_found());
|
|
|
|
auto self_inst_id = lookup_result.target_inst_id();
|
|
auto self_type_id = context.insts().Get(self_inst_id).type_id();
|
|
CARBON_CHECK(context.types().Is<SemIR::FacetType>(self_type_id));
|
|
|
|
auto self_facet_as_type = AddTypeInst<SemIR::FacetAccessType>(
|
|
context, node_id,
|
|
{.type_id = SemIR::TypeType::TypeId,
|
|
.facet_value_inst_id = self_inst_id});
|
|
context.node_stack().Push(node_id, self_facet_as_type);
|
|
return true;
|
|
}
|
|
|
|
auto HandleParseNode(Context& context, Parse::RequireTypeImplsId node_id)
|
|
-> bool {
|
|
auto [self_node_id, self_inst_id] = context.node_stack().PopExprWithNodeId();
|
|
|
|
auto introducer = context.decl_introducer_state_stack().innermost();
|
|
if (introducer.modifier_set.HasAnyOf(KeywordModifierSet::Extend)) {
|
|
CARBON_DIAGNOSTIC(RequireImplsExtendWithExplicitSelf, Error,
|
|
"`extend require impls` with explicit type");
|
|
context.emitter().Emit(self_node_id, RequireImplsExtendWithExplicitSelf);
|
|
self_inst_id = SemIR::ErrorInst::InstId;
|
|
}
|
|
|
|
auto self_type = ExprAsType(context, self_node_id, self_inst_id);
|
|
context.node_stack().Push(node_id, self_type.inst_id);
|
|
return true;
|
|
}
|
|
|
|
static auto TypeStructureReferencesSelf(
|
|
Context& context, SemIR::TypeInstId inst_id,
|
|
const SemIR::IdentifiedFacetType& identified_facet_type) -> bool {
|
|
if (inst_id == SemIR::ErrorInst::TypeInstId) {
|
|
// Don't generate more diagnostics.
|
|
return true;
|
|
}
|
|
|
|
auto find_self = [&](SemIR::TypeIterator& type_iter) -> bool {
|
|
while (true) {
|
|
auto step = type_iter.Next();
|
|
if (step.Is<SemIR::TypeIterator::Step::Done>()) {
|
|
break;
|
|
}
|
|
CARBON_KIND_SWITCH(step.any) {
|
|
case CARBON_KIND(SemIR::TypeIterator::Step::Error _): {
|
|
// Don't generate more diagnostics.
|
|
return true;
|
|
}
|
|
case CARBON_KIND(SemIR::TypeIterator::Step::SymbolicBinding bind): {
|
|
if (context.entity_names().Get(bind.entity_name_id).name_id ==
|
|
SemIR::NameId::SelfType) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
{
|
|
SemIR::TypeIterator type_iter(&context.sem_ir());
|
|
type_iter.Add(context.constant_values().GetConstantTypeInstId(inst_id));
|
|
if (find_self(type_iter)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (identified_facet_type.required_interfaces().empty()) {
|
|
return false;
|
|
}
|
|
|
|
for (auto specific_interface : identified_facet_type.required_interfaces()) {
|
|
SemIR::TypeIterator type_iter(&context.sem_ir());
|
|
type_iter.Add(specific_interface);
|
|
if (!find_self(type_iter)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
struct ValidateRequireResult {
|
|
SemIR::FacetType facet_type;
|
|
const SemIR::IdentifiedFacetType* identified;
|
|
};
|
|
|
|
// Returns nullopt if a diagnostic has been emitted and the `require` decl is
|
|
// not valid.
|
|
static auto ValidateRequire(Context& context, SemIR::LocId loc_id,
|
|
SemIR::TypeInstId self_inst_id,
|
|
SemIR::InstId constraint_inst_id,
|
|
SemIR::InstId scope_inst_id)
|
|
-> std::optional<ValidateRequireResult> {
|
|
auto constraint_constant_value_inst_id =
|
|
context.constant_values().GetConstantInstId(constraint_inst_id);
|
|
auto constraint_facet_type = context.insts().TryGetAs<SemIR::FacetType>(
|
|
constraint_constant_value_inst_id);
|
|
if (!constraint_facet_type) {
|
|
if (constraint_constant_value_inst_id != SemIR::ErrorInst::InstId) {
|
|
CARBON_DIAGNOSTIC(
|
|
RequireImplsMissingFacetType, Error,
|
|
"`require` declaration constrained by a non-facet type; "
|
|
"expected an `interface` or `constraint` name after `impls`");
|
|
context.emitter().Emit(constraint_inst_id, RequireImplsMissingFacetType);
|
|
}
|
|
// Can't continue without a constraint to use.
|
|
return std::nullopt;
|
|
}
|
|
|
|
auto identified_facet_type_id =
|
|
RequireIdentifiedFacetType(context, *constraint_facet_type, [&] {
|
|
CARBON_DIAGNOSTIC(
|
|
RequireImplsUnidentifiedFacetType, Error,
|
|
"facet type {0} cannot be identified in `require` declaration",
|
|
InstIdAsType);
|
|
return context.emitter().Build(constraint_inst_id,
|
|
RequireImplsUnidentifiedFacetType,
|
|
constraint_inst_id);
|
|
});
|
|
if (!identified_facet_type_id.has_value()) {
|
|
// The constraint can't be used. A diagnostic was emitted by
|
|
// RequireIdentifiedFacetType().
|
|
return std::nullopt;
|
|
}
|
|
const auto& identified =
|
|
context.identified_facet_types().Get(identified_facet_type_id);
|
|
|
|
if (!TypeStructureReferencesSelf(context, self_inst_id, identified)) {
|
|
CARBON_DIAGNOSTIC(RequireImplsMissingSelf, Error,
|
|
"no `Self` reference found in `require` declaration; "
|
|
"`Self` must appear in the self-type or as a generic "
|
|
"parameter for each `interface` or `constraint`");
|
|
context.emitter().Emit(loc_id, RequireImplsMissingSelf);
|
|
return std::nullopt;
|
|
}
|
|
|
|
if (scope_inst_id == SemIR::ErrorInst::InstId) {
|
|
// `require` is in the wrong scope.
|
|
return std::nullopt;
|
|
}
|
|
if (self_inst_id == SemIR::ErrorInst::InstId ||
|
|
constraint_inst_id == SemIR::ErrorInst::InstId) {
|
|
// Can't build a useful `require` with an error, it couldn't do anything.
|
|
return std::nullopt;
|
|
}
|
|
|
|
return ValidateRequireResult{.facet_type = *constraint_facet_type,
|
|
.identified = &identified};
|
|
}
|
|
|
|
auto HandleParseNode(Context& context, Parse::RequireDeclId node_id) -> bool {
|
|
auto [constraint_node_id, constraint_inst_id] =
|
|
context.node_stack().PopExprWithNodeId();
|
|
auto [self_node_id, self_inst_id] =
|
|
context.node_stack().PopWithNodeId<Parse::NodeCategory::RequireImpls>();
|
|
|
|
auto decl_block_id = context.inst_block_stack().Pop();
|
|
|
|
// Process modifiers.
|
|
auto introducer =
|
|
context.decl_introducer_state_stack().Pop<Lex::TokenKind::Require>();
|
|
LimitModifiersOnDecl(context, introducer, KeywordModifierSet::Extend);
|
|
|
|
auto scope_inst_id =
|
|
context.node_stack().Pop<Parse::NodeKind::RequireIntroducer>();
|
|
|
|
auto validated = ValidateRequire(context, node_id, self_inst_id,
|
|
constraint_inst_id, scope_inst_id);
|
|
if (!validated) {
|
|
DiscardGenericDecl(context);
|
|
return true;
|
|
}
|
|
|
|
auto [constraint_facet_type, identified] = *validated;
|
|
if (identified->required_interfaces().empty()) {
|
|
// A `require T impls type` adds no actual constraints, so nothing to do.
|
|
DiscardGenericDecl(context);
|
|
return true;
|
|
}
|
|
|
|
bool extend = introducer.modifier_set.HasAnyOf(KeywordModifierSet::Extend);
|
|
|
|
auto require_impls_decl =
|
|
SemIR::RequireImplsDecl{// To be filled in after.
|
|
.require_impls_id = SemIR::RequireImplsId::None,
|
|
.decl_block_id = decl_block_id};
|
|
auto decl_id = AddPlaceholderInst(context, node_id, require_impls_decl);
|
|
auto require_impls_id = context.require_impls().Add(
|
|
{.self_id = self_inst_id,
|
|
.facet_type_inst_id =
|
|
context.types().GetAsTypeInstId(constraint_inst_id),
|
|
.facet_type_id = constraint_facet_type.facet_type_id,
|
|
.extend_self = extend,
|
|
.decl_id = decl_id,
|
|
.parent_scope_id = context.scope_stack().PeekNameScopeId(),
|
|
.generic_id = BuildGenericDecl(context, decl_id)});
|
|
|
|
require_impls_decl.require_impls_id = require_impls_id;
|
|
ReplaceInstBeforeConstantUse(context, decl_id, require_impls_decl);
|
|
|
|
context.require_impls_stack().AppendToTop(require_impls_id);
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace Carbon::Check
|