mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-05 22:02:55 +01:00
Dana Jansens
0cf2448505
When forming an IdentifiedFacetType, we collect interfaces named by require decls in named constraints that the facet type refers to. These interfaces come with a specific, but the require decl is inside an named constraint which may be generic. So we need the specific being applied to the containing named constraint to also be applied to the require decl and its target interfaces. This uncovered that the facet type in require decls was not being imported correctly, as it was not being attached to the require decl's generic. This is fixed by making import of RequireImplsDecl multiphase, so that the decl instruction exists before we resolve the facet type within it. And by pointing the generic importing machinery to the RequireImplsDecl, and from there to the RequireImpls structure to get the generic id. Then `ImplStore::GetOrAddLookupBucket` can use an IdentifiedFacetType to correctly get the interface being impl'd, both in the local and the imported named constraint case. Which allows us to correctly diagnose redeclarations in the impl file of an impl of an interface through a named constraint. And to correctly _not_ diagnose them when the specific in the generic named constraint differs from other decls.
303 lines
11 KiB
C++
303 lines
11 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;
|
|
SemIR::TypeId facet_type_type_id;
|
|
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_id =
|
|
context.constant_values().Get(constraint_inst_id);
|
|
auto constraint_type_id =
|
|
SemIR::TypeId::ForTypeConstant(constraint_constant_value_id);
|
|
auto constraint_facet_type =
|
|
context.types().TryGetAs<SemIR::FacetType>(constraint_type_id);
|
|
if (!constraint_facet_type) {
|
|
if (constraint_constant_value_id != SemIR::ErrorInst::ConstantId) {
|
|
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, SemIR::LocId(constraint_inst_id), *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,
|
|
.facet_type_type_id = constraint_type_id,
|
|
.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, constraint_type_id, 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);
|
|
|
|
// We look for a complete type after BuildGenericDecl, so that the resulting
|
|
// RequireCompleteType instruction is part of the enclosing interface or named
|
|
// constraint generic definition. Then requiring enclosing entity to be
|
|
// complete will resolve that definition (via ResolveSpecificDefinition()) and
|
|
// also construct a specific for the `constraint_inst_id`, finding any
|
|
// monomorphization errors that result.
|
|
if (extend) {
|
|
if (!RequireCompleteType(
|
|
context, constraint_type_id, SemIR::LocId(constraint_inst_id), [&] {
|
|
CARBON_DIAGNOSTIC(RequireImplsIncompleteFacetType, Error,
|
|
"`extend require` of incomplete facet type {0}",
|
|
InstIdAsType);
|
|
return context.emitter().Build(constraint_inst_id,
|
|
RequireImplsIncompleteFacetType,
|
|
constraint_inst_id);
|
|
})) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
context.require_impls_stack().AppendToTop(require_impls_id);
|
|
return true;
|
|
}
|
|
|
|
} // namespace Carbon::Check
|