mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Jon Ross-Perkins
d9c62b106d
Following up on discussion from #3948, doing a general rename of "enclosing scope" to "parent scope" (and "enclosing scopes" to "ancestor scopes"). The intent is to improve understandability and collide less with C++ terminology for "enclosing scope". Note this changes most uses of "enclosing", but leaves behind a few like "enclosing function" and "enclosing block". Note this does create some "parent class" mentions for "adapt" and "var" (the class they're within), which is maybe unfortunate, but we'd probably say "base class" if we meant inheritance so perhaps that's okay. Along the same lines, these are the only `parent_class` uses I see now, and we do have a few `base_class`.
219 lines
9.6 KiB
C++
219 lines
9.6 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/context.h"
|
|
#include "toolchain/check/convert.h"
|
|
#include "toolchain/check/return.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
#include "toolchain/sem_ir/inst.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id,
|
|
bool is_generic) -> bool {
|
|
auto [type_node, parsed_type_id] = context.node_stack().PopExprWithNodeId();
|
|
auto cast_type_id = ExprAsType(context, type_node, parsed_type_id);
|
|
|
|
// TODO: Handle `_` bindings.
|
|
|
|
// Every other kind of pattern binding has a name.
|
|
auto [name_node, name_id] = context.node_stack().PopNameWithNodeId();
|
|
|
|
// Determine whether we're handling an associated constant. These share the
|
|
// syntax for a compile-time binding, but don't behave like other compile-time
|
|
// bindings.
|
|
// TODO: Consider using a different parse node kind to make this easier.
|
|
bool is_associated_constant = false;
|
|
if (is_generic) {
|
|
auto inst_id = context.scope_stack().PeekInstId();
|
|
is_associated_constant =
|
|
inst_id.is_valid() && context.insts().Is<SemIR::InterfaceDecl>(inst_id);
|
|
}
|
|
|
|
// Create the appropriate kind of binding for this pattern.
|
|
auto make_bind_name = [&](SemIR::TypeId type_id,
|
|
SemIR::InstId value_id) -> SemIR::LocIdAndInst {
|
|
// TODO: Eventually the name will need to support associations with other
|
|
// scopes, but right now we don't support qualified names here.
|
|
auto bind_name_id = context.bind_names().Add(
|
|
{.name_id = name_id,
|
|
.parent_scope_id = context.scope_stack().PeekNameScopeId(),
|
|
// TODO: Don't allocate a compile-time binding index for an associated
|
|
// constant declaration.
|
|
.bind_index = is_generic && !is_associated_constant
|
|
? context.scope_stack().AddCompileTimeBinding()
|
|
: SemIR::CompileTimeBindIndex::Invalid});
|
|
if (is_generic) {
|
|
// TODO: Create a `BindTemplateName` instead inside a `template` pattern.
|
|
return SemIR::LocIdAndInst(
|
|
name_node, SemIR::BindSymbolicName{.type_id = type_id,
|
|
.bind_name_id = bind_name_id,
|
|
.value_id = value_id});
|
|
} else {
|
|
return SemIR::LocIdAndInst(name_node,
|
|
SemIR::BindName{.type_id = type_id,
|
|
.bind_name_id = bind_name_id,
|
|
.value_id = value_id});
|
|
}
|
|
};
|
|
|
|
// A `self` binding can only appear in an implicit parameter list.
|
|
if (name_id == SemIR::NameId::SelfValue &&
|
|
!context.node_stack().PeekIs<Parse::NodeKind::ImplicitParamListStart>()) {
|
|
CARBON_DIAGNOSTIC(
|
|
SelfOutsideImplicitParamList, Error,
|
|
"`self` can only be declared in an implicit parameter list.");
|
|
context.emitter().Emit(node_id, SelfOutsideImplicitParamList);
|
|
}
|
|
|
|
// Allocate an instruction of the appropriate kind, linked to the name for
|
|
// error locations.
|
|
// TODO: The node stack is a fragile way of getting context information.
|
|
// Get this information from somewhere else.
|
|
switch (auto context_node_kind = context.node_stack().PeekNodeKind()) {
|
|
case Parse::NodeKind::ReturnedModifier:
|
|
case Parse::NodeKind::VariableIntroducer: {
|
|
if (is_generic) {
|
|
CARBON_DIAGNOSTIC(
|
|
CompileTimeBindingInVarDecl, Error,
|
|
"`var` declaration cannot declare a compile-time binding.");
|
|
context.emitter().Emit(type_node, CompileTimeBindingInVarDecl);
|
|
}
|
|
auto binding_id =
|
|
is_generic
|
|
? Parse::NodeId::Invalid
|
|
: context.parse_tree().As<Parse::BindingPatternId>(node_id);
|
|
|
|
// A `var` declaration at class scope introduces a field.
|
|
auto parent_class_decl = context.GetCurrentScopeAs<SemIR::ClassDecl>();
|
|
cast_type_id = context.AsCompleteType(cast_type_id, [&] {
|
|
CARBON_DIAGNOSTIC(IncompleteTypeInVarDecl, Error,
|
|
"{0} has incomplete type `{1}`.", llvm::StringLiteral,
|
|
SemIR::TypeId);
|
|
return context.emitter().Build(type_node, IncompleteTypeInVarDecl,
|
|
parent_class_decl
|
|
? llvm::StringLiteral("Field")
|
|
: llvm::StringLiteral("Variable"),
|
|
cast_type_id);
|
|
});
|
|
if (parent_class_decl) {
|
|
CARBON_CHECK(context_node_kind == Parse::NodeKind::VariableIntroducer)
|
|
<< "`returned var` at class scope";
|
|
auto& class_info = context.classes().Get(parent_class_decl->class_id);
|
|
auto field_type_id = context.GetUnboundElementType(
|
|
class_info.self_type_id, cast_type_id);
|
|
auto field_id = context.AddInst<SemIR::FieldDecl>(
|
|
binding_id,
|
|
{.type_id = field_type_id,
|
|
.name_id = name_id,
|
|
.index = SemIR::ElementIndex(context.args_type_info_stack()
|
|
.PeekCurrentBlockContents()
|
|
.size())});
|
|
|
|
// Add a corresponding field to the object representation of the class.
|
|
context.args_type_info_stack().AddInstId(
|
|
context.AddInstInNoBlock<SemIR::StructTypeField>(
|
|
binding_id,
|
|
{.name_id = name_id, .field_type_id = cast_type_id}));
|
|
context.node_stack().Push(node_id, field_id);
|
|
break;
|
|
}
|
|
|
|
SemIR::InstId value_id = SemIR::InstId::Invalid;
|
|
if (context_node_kind == Parse::NodeKind::ReturnedModifier) {
|
|
// TODO: Should we check this for the `var` as a whole, rather than for
|
|
// the name binding?
|
|
value_id =
|
|
CheckReturnedVar(context, context.node_stack().PeekNodeId(),
|
|
name_node, name_id, type_node, cast_type_id);
|
|
} else {
|
|
value_id = context.AddInst<SemIR::VarStorage>(
|
|
name_node, {.type_id = cast_type_id, .name_id = name_id});
|
|
}
|
|
auto bind_id = context.AddInst(make_bind_name(cast_type_id, value_id));
|
|
context.node_stack().Push(node_id, bind_id);
|
|
|
|
if (context_node_kind == Parse::NodeKind::ReturnedModifier) {
|
|
RegisterReturnedVar(context, bind_id);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case Parse::NodeKind::ImplicitParamListStart:
|
|
case Parse::NodeKind::TuplePatternStart: {
|
|
// Parameters can have incomplete types in a function declaration, but not
|
|
// in a function definition. We don't know which kind we have here.
|
|
// TODO: A tuple pattern can appear in other places than function
|
|
// parameters.
|
|
auto param_id = context.AddInst<SemIR::Param>(
|
|
name_node, {.type_id = cast_type_id, .name_id = name_id});
|
|
auto bind_id = context.AddInst(make_bind_name(cast_type_id, param_id));
|
|
// TODO: Bindings should come into scope immediately in other contexts
|
|
// too.
|
|
context.AddNameToLookup(name_id, bind_id);
|
|
context.node_stack().Push(node_id, bind_id);
|
|
break;
|
|
}
|
|
|
|
case Parse::NodeKind::LetIntroducer:
|
|
cast_type_id = context.AsCompleteType(cast_type_id, [&] {
|
|
CARBON_DIAGNOSTIC(IncompleteTypeInLetDecl, Error,
|
|
"`let` binding has incomplete type `{0}`.",
|
|
SemIR::TypeId);
|
|
return context.emitter().Build(type_node, IncompleteTypeInLetDecl,
|
|
cast_type_id);
|
|
});
|
|
// Create the instruction, but don't add it to a block until after we've
|
|
// formed its initializer.
|
|
// TODO: For general pattern parsing, we'll need to create a block to hold
|
|
// the `let` pattern before we see the initializer.
|
|
context.node_stack().Push(
|
|
node_id, context.AddPlaceholderInstInNoBlock(
|
|
make_bind_name(cast_type_id, SemIR::InstId::Invalid)));
|
|
break;
|
|
|
|
default:
|
|
CARBON_FATAL() << "Found a pattern binding in unexpected context "
|
|
<< context_node_kind;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
auto HandleBindingPattern(Context& context, Parse::BindingPatternId node_id)
|
|
-> bool {
|
|
return HandleAnyBindingPattern(context, node_id, /*is_generic=*/false);
|
|
}
|
|
|
|
auto HandleCompileTimeBindingPattern(Context& context,
|
|
Parse::CompileTimeBindingPatternId node_id)
|
|
-> bool {
|
|
return HandleAnyBindingPattern(context, node_id, /*is_generic=*/true);
|
|
}
|
|
|
|
auto HandleAddr(Context& context, Parse::AddrId node_id) -> bool {
|
|
auto self_param_id = context.node_stack().PopPattern();
|
|
if (auto self_param =
|
|
context.insts().TryGetAs<SemIR::AnyBindName>(self_param_id);
|
|
self_param &&
|
|
context.bind_names().Get(self_param->bind_name_id).name_id ==
|
|
SemIR::NameId::SelfValue) {
|
|
// TODO: The type of an `addr_pattern` should probably be the non-pointer
|
|
// type, because that's the type that the pattern matches.
|
|
context.AddInstAndPush<SemIR::AddrPattern>(
|
|
node_id, {.type_id = self_param->type_id, .inner_id = self_param_id});
|
|
} else {
|
|
CARBON_DIAGNOSTIC(AddrOnNonSelfParam, Error,
|
|
"`addr` can only be applied to a `self` parameter.");
|
|
context.emitter().Emit(TokenOnly(node_id), AddrOnNonSelfParam);
|
|
context.node_stack().Push(node_id, self_param_id);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
auto HandleTemplate(Context& context, Parse::TemplateId node_id) -> bool {
|
|
return context.TODO(node_id, "HandleTemplate");
|
|
}
|
|
|
|
} // namespace Carbon::Check
|