mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-16 22:08:11 +00:00
I was running into some difficult merges in #2940, so I'm wanting to finish splitting this last file to minimize the chance of future issues.
125 lines
5.0 KiB
C++
125 lines
5.0 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/semantics/semantics_context.h"
|
|
#include "toolchain/semantics/semantics_node.h"
|
|
|
|
namespace Carbon {
|
|
|
|
auto SemanticsHandleMemberAccessExpression(SemanticsContext& context,
|
|
ParseTree::Node parse_node) -> bool {
|
|
auto name_id =
|
|
context.node_stack().Pop<SemanticsStringId>(ParseNodeKind::Name);
|
|
|
|
auto base_id = context.node_stack().Pop<SemanticsNodeId>();
|
|
auto base = context.semantics_ir().GetNode(base_id);
|
|
if (base.kind() == SemanticsNodeKind::Namespace) {
|
|
// For a namespace, just resolve the name.
|
|
auto node_id =
|
|
context.LookupName(parse_node, name_id, base.GetAsNamespace(),
|
|
/*print_diagnostics=*/true);
|
|
context.node_stack().Push(parse_node, node_id);
|
|
return true;
|
|
}
|
|
|
|
auto base_type = context.semantics_ir().GetNode(
|
|
context.semantics_ir().GetType(base.type_id()));
|
|
|
|
switch (base_type.kind()) {
|
|
case SemanticsNodeKind::StructType: {
|
|
auto refs =
|
|
context.semantics_ir().GetNodeBlock(base_type.GetAsStructType());
|
|
// TODO: Do we need to optimize this with a lookup table for O(1)?
|
|
for (int i = 0; i < static_cast<int>(refs.size()); ++i) {
|
|
auto ref = context.semantics_ir().GetNode(refs[i]);
|
|
if (name_id == ref.GetAsStructTypeField()) {
|
|
context.AddNodeAndPush(
|
|
parse_node,
|
|
SemanticsNode::StructMemberAccess::Make(
|
|
parse_node, ref.type_id(), base_id, SemanticsMemberIndex(i)));
|
|
return true;
|
|
}
|
|
}
|
|
CARBON_DIAGNOSTIC(QualifiedExpressionNameNotFound, Error,
|
|
"Type `{0}` does not have a member `{1}`.", std::string,
|
|
llvm::StringRef);
|
|
context.emitter().Emit(
|
|
parse_node, QualifiedExpressionNameNotFound,
|
|
context.semantics_ir().StringifyType(base.type_id()),
|
|
context.semantics_ir().GetString(name_id));
|
|
break;
|
|
}
|
|
default: {
|
|
CARBON_DIAGNOSTIC(QualifiedExpressionUnsupported, Error,
|
|
"Type `{0}` does not support qualified expressions.",
|
|
std::string);
|
|
context.emitter().Emit(
|
|
parse_node, QualifiedExpressionUnsupported,
|
|
context.semantics_ir().StringifyType(base.type_id()));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Should only be reached on error.
|
|
context.node_stack().Push(parse_node, SemanticsNodeId::BuiltinError);
|
|
return true;
|
|
}
|
|
|
|
auto SemanticsHandleName(SemanticsContext& context, ParseTree::Node parse_node)
|
|
-> bool {
|
|
auto name_str = context.parse_tree().GetNodeText(parse_node);
|
|
auto name_id = context.semantics_ir().AddString(name_str);
|
|
// The parent is responsible for binding the name.
|
|
context.node_stack().Push(parse_node, name_id);
|
|
return true;
|
|
}
|
|
|
|
auto SemanticsHandleNameExpression(SemanticsContext& context,
|
|
ParseTree::Node parse_node) -> bool {
|
|
auto name_str = context.parse_tree().GetNodeText(parse_node);
|
|
auto name_id = context.semantics_ir().AddString(name_str);
|
|
context.node_stack().Push(
|
|
parse_node,
|
|
context.LookupName(parse_node, name_id, SemanticsNameScopeId::Invalid,
|
|
/*print_diagnostics=*/true));
|
|
return true;
|
|
}
|
|
|
|
auto SemanticsHandleQualifiedDeclaration(SemanticsContext& context,
|
|
ParseTree::Node parse_node) -> bool {
|
|
// The first two qualifiers in a chain will be a QualifiedDeclaration with two
|
|
// Identifier or expression children. Later qualifiers will have a
|
|
// QualifiedDeclaration as the first child, and an Identifier or expression as
|
|
// the second child.
|
|
auto [parse_node2, node_or_name_id2] =
|
|
context.node_stack().PopWithParseNode<SemanticsNodeId>();
|
|
if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) !=
|
|
ParseNodeKind::QualifiedDeclaration) {
|
|
// First QualifiedDeclaration in a chain.
|
|
auto [parse_node1, node_or_name_id1] =
|
|
context.node_stack().PopWithParseNode<SemanticsNodeId>();
|
|
context.ApplyDeclarationNameQualifier(parse_node1, node_or_name_id1);
|
|
// Add the QualifiedDeclaration so that it can be used for bracketing.
|
|
context.node_stack().Push(parse_node);
|
|
} else {
|
|
// Nothing to do: the QualifiedDeclaration remains as a bracketing node for
|
|
// later QualifiedDeclarations.
|
|
}
|
|
context.ApplyDeclarationNameQualifier(parse_node2, node_or_name_id2);
|
|
|
|
return true;
|
|
}
|
|
|
|
auto SemanticsHandleSelfTypeNameExpression(SemanticsContext& context,
|
|
ParseTree::Node parse_node) -> bool {
|
|
return context.TODO(parse_node, "HandleSelfTypeNameExpression");
|
|
}
|
|
|
|
auto SemanticsHandleSelfValueName(SemanticsContext& context,
|
|
ParseTree::Node parse_node) -> bool {
|
|
return context.TODO(parse_node, "HandleSelfValueName");
|
|
}
|
|
|
|
} // namespace Carbon
|