mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Richard Smith
f0e940ddfd
For now, a builtin function is defined by specifying a string literal initializer in a function declaration: ```carbon fn MyBuiltin(a: i32) -> i32 = "builtin.name"; ``` End-to-end support is included for a sample `"int.add"` builtin performing integer addition, covering constant evaluation and code generation. The implementation here needs substantial refactoring before we'll be ready to start adding more builtins. That refactoring work will be coming next. This change is aiming to checkpoint some incremental progress.
101 lines
3.7 KiB
C++
101 lines
3.7 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/parse/context.h"
|
|
|
|
namespace Carbon::Parse {
|
|
|
|
auto HandleFunctionIntroducer(Context& context) -> void {
|
|
auto state = context.PopState();
|
|
context.PushState(state, State::FunctionAfterParams);
|
|
context.PushState(State::DeclNameAndParamsAsRequired, state.token);
|
|
}
|
|
|
|
auto HandleFunctionAfterParams(Context& context) -> void {
|
|
auto state = context.PopState();
|
|
|
|
// Regardless of whether there's a return type, we'll finish the signature.
|
|
context.PushState(state, State::FunctionSignatureFinish);
|
|
|
|
// If there is a return type, parse the expression before adding the return
|
|
// type node.
|
|
if (context.PositionIs(Lex::TokenKind::MinusGreater)) {
|
|
context.PushState(State::FunctionReturnTypeFinish);
|
|
context.ConsumeAndDiscard();
|
|
context.PushStateForExpr(PrecedenceGroup::ForType());
|
|
}
|
|
}
|
|
|
|
auto HandleFunctionReturnTypeFinish(Context& context) -> void {
|
|
auto state = context.PopState();
|
|
|
|
context.AddNode(NodeKind::ReturnType, state.token, state.subtree_start,
|
|
state.has_error);
|
|
}
|
|
|
|
auto HandleFunctionSignatureFinish(Context& context) -> void {
|
|
auto state = context.PopState();
|
|
|
|
switch (context.PositionKind()) {
|
|
case Lex::TokenKind::Semi: {
|
|
context.AddNode(NodeKind::FunctionDecl, context.Consume(),
|
|
state.subtree_start, state.has_error);
|
|
break;
|
|
}
|
|
case Lex::TokenKind::OpenCurlyBrace: {
|
|
context.AddNode(NodeKind::FunctionDefinitionStart, context.Consume(),
|
|
state.subtree_start, state.has_error);
|
|
// Any error is recorded on the FunctionDefinitionStart.
|
|
state.has_error = false;
|
|
context.PushState(state, State::FunctionDefinitionFinish);
|
|
context.PushState(State::StatementScopeLoop);
|
|
break;
|
|
}
|
|
case Lex::TokenKind::Equal: {
|
|
context.AddNode(NodeKind::BuiltinFunctionDefinitionStart,
|
|
context.Consume(), state.subtree_start, state.has_error);
|
|
if (!context.ConsumeAndAddLeafNodeIf(Lex::TokenKind::StringLiteral,
|
|
NodeKind::BuiltinName)) {
|
|
CARBON_DIAGNOSTIC(ExpectedBuiltinName, Error,
|
|
"Expected builtin function name after `=`.");
|
|
context.emitter().Emit(*context.position(), ExpectedBuiltinName);
|
|
state.has_error = true;
|
|
}
|
|
auto semi = context.ConsumeIf(Lex::TokenKind::Semi);
|
|
if (!semi && !state.has_error) {
|
|
context.EmitExpectedDeclSemi(context.tokens().GetKind(state.token));
|
|
state.has_error = true;
|
|
}
|
|
if (state.has_error) {
|
|
context.RecoverFromDeclError(state, NodeKind::BuiltinFunctionDefinition,
|
|
/*skip_past_likely_end=*/true);
|
|
} else {
|
|
context.AddNode(NodeKind::BuiltinFunctionDefinition, *semi,
|
|
state.subtree_start, state.has_error);
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
if (!state.has_error) {
|
|
context.EmitExpectedDeclSemiOrDefinition(Lex::TokenKind::Fn);
|
|
}
|
|
// Only need to skip if we've not already found a new line.
|
|
bool skip_past_likely_end =
|
|
context.tokens().GetLine(*context.position()) ==
|
|
context.tokens().GetLine(state.token);
|
|
context.RecoverFromDeclError(state, NodeKind::FunctionDecl,
|
|
skip_past_likely_end);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
auto HandleFunctionDefinitionFinish(Context& context) -> void {
|
|
auto state = context.PopState();
|
|
context.AddNode(NodeKind::FunctionDefinition, context.Consume(),
|
|
state.subtree_start, state.has_error);
|
|
}
|
|
|
|
} // namespace Carbon::Parse
|