mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-04 08:31:04 +01:00
Jon Ross-Perkins
a23f15e901
This is how I'm interpreting discussion:
- Basic elements are getting set to an ID.
- SetName exists to assign a name (which can then be referred to later with an identifier expression) to an ID.
- Expressions are broken down into a series of operations which operate on IDs.
So with something like the last test:
```
fn Main() { return 12 + 34; }
```
This becomes:
```
Function(%0,
{IntegerLiteral(%3, 12),
IntegerLiteral(%2, 34),
BinaryOperator(%1, +, %3, %2),
Return(%1),
})
SetName(`Main`, %0)
```
Note I'm treating blocks as fairly equal to the top of a file now, and basically eliminating boundaries between things. That's because we have discussed also supporting code like:
```
fn Foo() {
fn Bar() {}
Bar();
}
```
Here a declaration of a function is occurring inside a code block, so it felt like eliminating the difference was the best choice.
I know you'd commented on the separation of nodes to individual files before; I still think we're going to have a lot of different types of nodes, and so separating them out into individual files makes them easier to browse.
79 lines
3.1 KiB
C++
79 lines
3.1 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
|
|
|
|
#ifndef CARBON_TOOLCHAIN_SEMANTICS_SEMANTICS_IR_FACTORY_H_
|
|
#define CARBON_TOOLCHAIN_SEMANTICS_SEMANTICS_IR_FACTORY_H_
|
|
|
|
#include "toolchain/parser/parse_tree.h"
|
|
#include "toolchain/semantics/parse_subtree_consumer.h"
|
|
#include "toolchain/semantics/semantics_ir.h"
|
|
|
|
namespace Carbon {
|
|
|
|
// The main semantic analysis entry.
|
|
class SemanticsIRFactory {
|
|
public:
|
|
// Builds the SemanticsIR without doing any substantial semantic analysis.
|
|
static auto Build(const TokenizedBuffer& tokens, const ParseTree& parse_tree)
|
|
-> SemanticsIR;
|
|
|
|
private:
|
|
explicit SemanticsIRFactory(const TokenizedBuffer& tokens,
|
|
const ParseTree& parse_tree)
|
|
: tokens_(&tokens), semantics_(parse_tree) {}
|
|
|
|
void Build();
|
|
|
|
// Requires that a node have no children, to emphasize why the subtree isn't
|
|
// otherwise checked.
|
|
void RequireNodeEmpty(ParseTree::Node node);
|
|
|
|
// Transforms a block subtree, such as a file or CodeBlock, into its semantic
|
|
// nodes.
|
|
auto TransformBlockSubtree(ParseSubtreeConsumer& subtree,
|
|
ParseNodeKind end_kind)
|
|
-> llvm::SmallVector<Semantics::NodeRef, 0>;
|
|
|
|
// Each of these takes a parse tree node and does a transformation based on
|
|
// its type. These functions are per ParseNodeKind.
|
|
auto TransformCodeBlock(ParseTree::Node node)
|
|
-> llvm::SmallVector<Semantics::NodeRef, 0>;
|
|
void TransformDeclaredName(llvm::SmallVector<Semantics::NodeRef, 0>& nodes,
|
|
ParseTree::Node node, int32_t target_id);
|
|
void TransformExpression(llvm::SmallVector<Semantics::NodeRef, 0>& nodes,
|
|
ParseTree::Node node, int32_t target_id);
|
|
// auto TransformExpressionStatement(ParseTree::Node node)
|
|
// -> Semantics::Statement;
|
|
void TransformFunctionDeclaration(
|
|
llvm::SmallVector<Semantics::NodeRef, 0>& nodes, ParseTree::Node node);
|
|
void TransformInfixOperator(llvm::SmallVector<Semantics::NodeRef, 0>& nodes,
|
|
ParseTree::Node node, int32_t target_id);
|
|
// auto TransformParameterList(ParseTree::Node node)
|
|
// -> llvm::SmallVector<Semantics::PatternBinding, 0>
|
|
// auto TransformPatternBinding(ParseTree::Node node)
|
|
// -> Semantics::PatternBinding;
|
|
// auto TransformReturnType(ParseTree::Node node) -> Semantics::Statement;
|
|
void TransformReturnStatement(llvm::SmallVector<Semantics::NodeRef, 0>& nodes,
|
|
ParseTree::Node node);
|
|
|
|
// Returns a unique ID for the SemanticsIR.
|
|
auto next_id() -> int32_t { return id_counter_++; }
|
|
|
|
// Convenience accessor.
|
|
auto parse_tree() -> const ParseTree& { return *semantics_.parse_tree_; }
|
|
|
|
// Tokens for getting data on literals.
|
|
const TokenizedBuffer* tokens_;
|
|
|
|
// The SemanticsIR being constructed.
|
|
SemanticsIR semantics_;
|
|
|
|
// A counter for unique IDs.
|
|
int32_t id_counter_ = 0;
|
|
};
|
|
|
|
} // namespace Carbon
|
|
|
|
#endif // CARBON_TOOLCHAIN_SEMANTICS_SEMANTICS_IR_FACTORY_H_
|