Adding some shape to toolchain semantic analysis

.clang-tidy

@@ -8,7 +8,7 @@
 # - performance-unnecessary-value-param is disabled because it duplicate
 #   modernize-pass-by-value.
 Checks:
-  -*, bugprone-*, -bugprone-easily-swappable-parameters,
+  -*, bugprone-*, -bugprone-branch-clone, -bugprone-easily-swappable-parameters,
   -bugprone-narrowing-conversions, google-*, -google-readability-todo,
   misc-definitions-in-headers, misc-misplaced-const, misc-redundant-expression,
   misc-static-assert, misc-unconventional-assign-operator,

toolchain/parser/parse_tree.cpp

@@ -37,6 +37,7 @@ auto ParseTree::postorder() const -> llvm::iterator_range<PostorderIterator> {
 
 auto ParseTree::postorder(Node n) const
     -> llvm::iterator_range<PostorderIterator> {
+  CHECK(n.is_valid());
   // The postorder ends after this node, the root, and begins at the start of
   // its subtree.
   int end_index = n.index_ + 1;
@@ -47,6 +48,7 @@ auto ParseTree::postorder(Node n) const
 
 auto ParseTree::children(Node n) const
     -> llvm::iterator_range<SiblingIterator> {
+  CHECK(n.is_valid());
   int end_index = n.index_ - node_impls_[n.index_].subtree_size;
   return {SiblingIterator(*this, Node(n.index_ - 1)),
           SiblingIterator(*this, Node(end_index))};
@@ -59,18 +61,22 @@ auto ParseTree::roots() const -> llvm::iterator_range<SiblingIterator> {
 }
 
 auto ParseTree::node_has_error(Node n) const -> bool {
+  CHECK(n.is_valid());
   return node_impls_[n.index_].has_error;
 }
 
 auto ParseTree::node_kind(Node n) const -> ParseNodeKind {
+  CHECK(n.is_valid());
   return node_impls_[n.index_].kind;
 }
 
 auto ParseTree::node_token(Node n) const -> TokenizedBuffer::Token {
+  CHECK(n.is_valid());
   return node_impls_[n.index_].token;
 }
 
 auto ParseTree::GetNodeText(Node n) const -> llvm::StringRef {
+  CHECK(n.is_valid());
   return tokens_->GetTokenText(node_impls_[n.index_].token);
 }
 

toolchain/parser/parse_tree.h

@@ -144,6 +144,9 @@ class ParseTree {
   class Parser;
   friend Parser;
 
+  // Allow the location translator access for tokens_.
+  friend class ParseTreeNodeLocationTranslator;
+
   // The in-memory representation of data used for a particular node in the
   // tree.
   struct NodeImpl {
@@ -259,6 +262,10 @@ class ParseTree::Node {
   // Prints the node index.
   auto Print(llvm::raw_ostream& output) const -> void;
 
+  // Returns true if the node is valid; in other words, it was not default
+  // initialized.
+  auto is_valid() -> bool { return index_ != -1; }
+
  private:
   friend ParseTree;
   friend Parser;
@@ -270,7 +277,7 @@ class ParseTree::Node {
   explicit Node(int index) : index_(index) {}
 
   // The index of this node's implementation in the postorder sequence.
-  int32_t index_;
+  int32_t index_ = -1;
 };
 
 // A random-access iterator to the depth-first postorder sequence of parse nodes

toolchain/semantics/BUILD

@@ -5,19 +5,45 @@
 package(default_visibility = ["//visibility:public"])
 
 cc_library(
-    name = "semantics",
-    srcs = ["semantics.cpp"],
-    hdrs = ["semantics.h"],
+    name = "function",
+    hdrs = ["function.h"],
     deps = ["//toolchain/parser:parse_tree"],
 )
 
+cc_library(
+    name = "semantics_ir",
+    srcs = ["semantics_ir.cpp"],
+    hdrs = ["semantics_ir.h"],
+    deps = [
+        ":function",
+        "//common:check",
+        "//toolchain/lexer:tokenized_buffer",
+        "//toolchain/parser:parse_tree",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
+cc_library(
+    name = "semantics_ir_factory",
+    srcs = ["semantics_ir_factory.cpp"],
+    hdrs = ["semantics_ir_factory.h"],
+    deps = [
+        ":semantics_ir",
+        "//common:check",
+        "//toolchain/lexer:tokenized_buffer",
+        "//toolchain/parser:parse_node_kind",
+        "//toolchain/parser:parse_tree",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
 cc_test(
-    name = "semantics_test",
+    name = "semantics_ir_factory_test",
     size = "small",
-    srcs = ["semantics_test.cpp"],
+    srcs = ["semantics_ir_factory_test.cpp"],
     deps = [
-        ":semantics",
-        "//toolchain/diagnostics:diagnostic_emitter",
+        ":semantics_ir_factory",
+        "//toolchain/diagnostics:mocks",
         "//toolchain/lexer:tokenized_buffer",
         "//toolchain/parser:parse_tree",
         "//toolchain/source:source_buffer",

toolchain/semantics/function.h

@@ -0,0 +1,31 @@
+// 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 TOOLCHAIN_SEMANTICS_FUNCTION_H_
+#define TOOLCHAIN_SEMANTICS_FUNCTION_H_
+
+#include "toolchain/parser/parse_tree.h"
+
+namespace Carbon::Semantics {
+
+// Semantic information for a function.
+class Function {
+ public:
+  Function(ParseTree::Node decl_node, ParseTree::Node name_node)
+      : decl_node_(decl_node), name_node_(name_node) {}
+
+  auto decl_node() const -> ParseTree::Node { return decl_node_; }
+  auto name_node() const -> ParseTree::Node { return name_node_; }
+
+ private:
+  // The FunctionDeclaration node.
+  ParseTree::Node decl_node_;
+
+  // The function's DeclaredName node.
+  ParseTree::Node name_node_;
+};
+
+}  // namespace Carbon::Semantics
+
+#endif  // TOOLCHAIN_SEMANTICS_FUNCTION_H_

toolchain/semantics/semantics_ir.cpp

@@ -0,0 +1,28 @@
+// 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_ir.h"
+
+#include "common/check.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "toolchain/lexer/tokenized_buffer.h"
+
+namespace Carbon {
+
+void SemanticsIR::Block::Add(llvm::StringRef name, Token named_entity) {
+  ordering_.push_back(named_entity);
+  name_lookup_.insert({name, named_entity});
+}
+
+auto SemanticsIR::AddFunction(Block& block, ParseTree::Node decl_node,
+                              ParseTree::Node name_node)
+    -> Semantics::Function& {
+  int32_t index = functions_.size();
+  functions_.push_back(Semantics::Function(decl_node, name_node));
+  block.Add(parse_tree_->GetNodeText(name_node),
+            Token(Token::Kind::Function, index));
+  return functions_[index];
+}
+
+}  // namespace Carbon

toolchain/semantics/semantics_ir.h

@@ -0,0 +1,78 @@
+// 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 TOOLCHAIN_SEMANTICS_SEMANTICS_IR_H_
+#define TOOLCHAIN_SEMANTICS_SEMANTICS_IR_H_
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "toolchain/parser/parse_tree.h"
+#include "toolchain/semantics/function.h"
+
+namespace Carbon {
+
+// Provides semantic analysis on a ParseTree.
+class SemanticsIR {
+ public:
+  // Provides a link back to an entity in a name scope.
+  class Token {
+   public:
+    Token() : Token(Kind::Invalid, -1) {}
+
+   private:
+    friend class SemanticsIR;
+
+    // The kind of token. These correspond to the lists on SemanticsIR which
+    // will be indexed into.
+    enum class Kind {
+      Invalid,
+      Function,
+    };
+
+    Token(Kind kind, int32_t index) : kind_(kind), index_(index) {
+      // TODO: kind_ and index_ are currently unused, this suppresses the
+      // warning.
+      kind_ = kind;
+      index_ = index;
+    }
+
+    Kind kind_;
+
+    // The index of the named entity within its list.
+    int32_t index_;
+  };
+
+  struct Block {
+   public:
+    void Add(llvm::StringRef name, Token named_entity);
+
+   private:
+    llvm::SmallVector<Token> ordering_;
+    llvm::StringMap<Token> name_lookup_;
+  };
+
+ private:
+  friend class SemanticsIRFactory;
+
+  explicit SemanticsIR(const ParseTree& parse_tree)
+      : parse_tree_(&parse_tree) {}
+
+  // Creates a function, adds it to the enclosing scope, and returns a reference
+  // for further mutations. On a name collision, it will not be added to the
+  // scope, but will still be returned.
+  auto AddFunction(Block& block, ParseTree::Node decl_node,
+                   ParseTree::Node name_node) -> Semantics::Function&;
+
+  // Indexed by Token::Function.
+  llvm::SmallVector<Semantics::Function, 0> functions_;
+
+  // The file-level block.
+  Block root_block_;
+
+  const ParseTree* parse_tree_;
+};
+
+}  // namespace Carbon
+
+#endif  // TOOLCHAIN_SEMANTICS_SEMANTICS_IR_H_

toolchain/semantics/semantics_ir_factory.cpp

@@ -0,0 +1,58 @@
+// 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_ir_factory.h"
+
+#include "common/check.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "toolchain/lexer/tokenized_buffer.h"
+#include "toolchain/parser/parse_node_kind.h"
+
+namespace Carbon {
+
+auto SemanticsIRFactory::Build(const ParseTree& parse_tree) -> SemanticsIR {
+  SemanticsIRFactory builder(parse_tree);
+  builder.ProcessRoots();
+  return builder.semantics_;
+}
+
+void SemanticsIRFactory::ProcessRoots() {
+  for (ParseTree::Node node : semantics_.parse_tree_->roots()) {
+    switch (semantics_.parse_tree_->node_kind(node)) {
+      case ParseNodeKind::FunctionDeclaration():
+        ProcessFunctionNode(semantics_.root_block_, node);
+        break;
+      case ParseNodeKind::FileEnd():
+        // No action needed.
+        break;
+      default:
+        FATAL() << "Unhandled node kind: "
+                << semantics_.parse_tree_->node_kind(node).name();
+    }
+  }
+}
+
+void SemanticsIRFactory::ProcessFunctionNode(SemanticsIR::Block& block,
+                                             ParseTree::Node decl_node) {
+  llvm::Optional<Semantics::Function> fn;
+  for (ParseTree::Node node : semantics_.parse_tree_->children(decl_node)) {
+    switch (semantics_.parse_tree_->node_kind(node)) {
+      case ParseNodeKind::DeclaredName():
+        fn = semantics_.AddFunction(block, decl_node, node);
+        break;
+      case ParseNodeKind::ParameterList():
+        // TODO: Maybe something like Semantics::AddVariable passed to
+        // Function::AddParameter.
+        break;
+      case ParseNodeKind::CodeBlock():
+        // TODO: Should accumulate the definition into the code block.
+        break;
+      default:
+        FATAL() << "Unhandled node kind: "
+                << semantics_.parse_tree_->node_kind(node).name();
+    }
+  }
+}
+
+}  // namespace Carbon