tree-sitter 0.0.1 → 0.1.0

data/ext/tree-sitter/tree-sitter/src/compiler/rules/metadata.h

@@ -2,8 +2,7 @@
 #define COMPILER_RULES_METADATA_H_
 
 #include <string>
-#include <map>
-#include "compiler/rule.h"
+#include <memory>
 
 namespace tree_sitter {
 namespace rules {
@@ -14,8 +13,17 @@ enum Associativity {
   AssociativityRight,
 };
 
+struct Alias {
+  std::string value = "";
+  bool is_named = false;
+  bool operator==(const Alias &) const;
+  bool operator!=(const Alias &) const;
+  bool operator<(const Alias &) const;
+};
+
 struct MetadataParams {
   int precedence;
+  int dynamic_precedence;
   Associativity associativity;
   bool has_precedence;
   bool has_associativity;
@@ -23,26 +31,49 @@ struct MetadataParams {
   bool is_string;
   bool is_active;
   bool is_main_token;
+  Alias alias;
 
-  MetadataParams();
-  bool operator==(const MetadataParams &) const;
-};
+  inline MetadataParams() :
+    precedence{0}, dynamic_precedence{0}, associativity{AssociativityNone},
+    has_precedence{false}, has_associativity{false}, is_token{false}, is_string{false},
+    is_active{false}, is_main_token{false} {}
 
-class Metadata : public Rule {
- public:
-  Metadata(rule_ptr rule, MetadataParams);
-  static rule_ptr build(rule_ptr rule, MetadataParams);
-  static rule_ptr main_token(rule_ptr rule);
-  static rule_ptr separator(rule_ptr rule);
+  inline bool operator==(const MetadataParams &other) const {
+    return (
+      precedence == other.precedence &&
+      associativity == other.associativity &&
+      has_precedence == other.has_precedence &&
+      has_associativity == other.has_associativity &&
+      dynamic_precedence == other.dynamic_precedence &&
+      is_token == other.is_token &&
+      is_string == other.is_string &&
+      is_active == other.is_active &&
+      is_main_token == other.is_main_token &&
+      alias == other.alias
+    );
+  }
+};
 
-  bool operator==(const Rule &other) const;
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
+struct Rule;
 
-  const rule_ptr rule;
+struct Metadata {
+  std::shared_ptr<Rule> rule;
   MetadataParams params;
+
+  Metadata(const Rule &rule, MetadataParams params);
+
+  static Metadata merge(Rule &&rule, MetadataParams params);
+  static Metadata token(Rule &&rule);
+  static Metadata active_prec(int precedence, Rule &&rule);
+  static Metadata prec(int precedence, Rule &&rule);
+  static Metadata prec_left(int precedence, Rule &&rule);
+  static Metadata prec_right(int precedence, Rule &&rule);
+  static Metadata prec_dynamic(int precedence, Rule &&rule);
+  static Metadata separator(Rule &&rule);
+  static Metadata main_token(Rule &&rule);
+  static Metadata alias(std::string &&value, bool is_named, Rule &&rule);
+
+  bool operator==(const Metadata &other) const;
 };
 
 }  // namespace rules

data/ext/tree-sitter/tree-sitter/src/compiler/rules/named_symbol.h

@@ -2,25 +2,19 @@
 #define COMPILER_RULES_NAMED_SYMBOL_H_
 
 #include <string>
-#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-class NamedSymbol : public Rule {
- public:
-  explicit NamedSymbol(const std::string &name);
+struct NamedSymbol {
+  std::string value;
 
-  bool operator==(const Rule &other) const;
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
-
-  std::string name;
+  inline bool operator==(const NamedSymbol &other) const {
+    return value == other.value;
+  }
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-#endif  // COMPILER_RULES_NAMED_SYMBOL_H_
+#endif  // COMPILER_RULES_NAMED_SYMBOL_H_

data/ext/tree-sitter/tree-sitter/src/compiler/rules/pattern.h

@@ -2,25 +2,19 @@
 #define COMPILER_RULES_PATTERN_H_
 
 #include <string>
-#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-class Pattern : public Rule {
- public:
-  explicit Pattern(const std::string &string);
+struct Pattern {
+  std::string value;
 
-  bool operator==(const Rule &other) const;
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
-
-  const std::string value;
+  inline bool operator==(const Pattern &other) const {
+    return value == other.value;
+  }
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-#endif  // COMPILER_RULES_PATTERN_H_
+#endif  // COMPILER_RULES_PATTERN_H_

data/ext/tree-sitter/tree-sitter/src/compiler/rules/repeat.cc

@@ -1,43 +1,14 @@
 #include "compiler/rules/repeat.h"
-#include <memory>
-#include <string>
-#include "compiler/rules/visitor.h"
+#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-using std::make_shared;
-using std::string;
+Repeat::Repeat(const Rule &rule) :
+  rule(std::make_shared<Rule>(rule)) {}
 
-Repeat::Repeat(const rule_ptr content) : content(content) {}
-
-rule_ptr Repeat::build(const rule_ptr &rule) {
-  auto inner_repeat = rule->as<Repeat>();
-  if (inner_repeat)
-    return rule;
-  else
-    return make_shared<Repeat>(rule);
-}
-
-bool Repeat::operator==(const Rule &rule) const {
-  auto other = rule.as<Repeat>();
-  return other && (*other->content == *content);
-}
-
-size_t Repeat::hash_code() const {
-  return content->hash_code();
-}
-
-rule_ptr Repeat::copy() const {
-  return make_shared<Repeat>(*this);
-}
-
-string Repeat::to_string() const {
-  return string("(repeat ") + content->to_string() + ")";
-}
-
-void Repeat::accept(Visitor *visitor) const {
-  visitor->visit(this);
+bool Repeat::operator==(const Repeat &other) const {
+  return rule->operator==(*other.rule);
 }
 
 }  // namespace rules

data/ext/tree-sitter/tree-sitter/src/compiler/rules/repeat.h

@@ -1,27 +1,21 @@
 #ifndef COMPILER_RULES_REPEAT_H_
 #define COMPILER_RULES_REPEAT_H_
 
-#include <string>
-#include "compiler/rule.h"
+#include <memory>
 
 namespace tree_sitter {
 namespace rules {
 
-class Repeat : public Rule {
- public:
-  explicit Repeat(rule_ptr content);
-  static rule_ptr build(const rule_ptr &rule);
+struct Rule;
 
-  bool operator==(const Rule &other) const;
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
+struct Repeat {
+  std::shared_ptr<Rule> rule;
 
-  const rule_ptr content;
+  explicit Repeat(const Rule &rule);
+  bool operator==(const Repeat &other) const;
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-#endif  // COMPILER_RULES_REPEAT_H_
+#endif  // COMPILER_RULES_REPEAT_H_

data/ext/tree-sitter/tree-sitter/src/compiler/rules/seq.cc

@@ -1,56 +1,15 @@
 #include "compiler/rules/seq.h"
-#include <string>
-#include "compiler/rules/visitor.h"
-#include "compiler/rules/blank.h"
-#include "compiler/rules/metadata.h"
+#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-using std::make_shared;
-using std::string;
-using std::vector;
+Seq::Seq(const Rule &left, const Rule &right) :
+  left(std::make_shared<Rule>(left)),
+  right(std::make_shared<Rule>(right)) {}
 
-Seq::Seq(rule_ptr left, rule_ptr right) : left(left), right(right) {}
-
-rule_ptr Seq::build(const std::vector<rule_ptr> &rules) {
-  rule_ptr result = make_shared<Blank>();
-  for (auto &rule : rules) {
-    auto blank = rule->as<Blank>();
-    if (blank)
-      continue;
-
-    auto metadata = rule->as<Metadata>();
-    if (metadata && metadata->rule->as<Blank>())
-      continue;
-
-    if (result->as<Blank>())
-      result = rule;
-    else
-      result = make_shared<Seq>(result, rule);
-  }
-  return result;
-}
-
-bool Seq::operator==(const Rule &rule) const {
-  const Seq *other = rule.as<Seq>();
-  return other && (*other->left == *left) && (*other->right == *right);
-}
-
-size_t Seq::hash_code() const {
-  return left->hash_code() ^ right->hash_code();
-}
-
-rule_ptr Seq::copy() const {
-  return std::make_shared<Seq>(*this);
-}
-
-string Seq::to_string() const {
-  return string("(seq ") + left->to_string() + " " + right->to_string() + ")";
-}
-
-void Seq::accept(Visitor *visitor) const {
-  visitor->visit(this);
+bool Seq::operator==(const Seq &other) const {
+  return left->operator==(*other.left) && right->operator==(*other.right);
 }
 
 }  // namespace rules

data/ext/tree-sitter/tree-sitter/src/compiler/rules/seq.h

@@ -1,29 +1,23 @@
 #ifndef COMPILER_RULES_SEQ_H_
 #define COMPILER_RULES_SEQ_H_
 
-#include <string>
+#include <memory>
 #include <vector>
-#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-class Seq : public Rule {
- public:
-  Seq(rule_ptr left, rule_ptr right);
-  static rule_ptr build(const std::vector<rule_ptr> &rules);
+struct Rule;
 
-  bool operator==(const Rule &other) const;
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
+struct Seq {
+  std::shared_ptr<Rule> left;
+  std::shared_ptr<Rule> right;
 
-  const rule_ptr left;
-  const rule_ptr right;
+  Seq(const Rule &left, const Rule &right);
+  bool operator==(const Seq &other) const;
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-#endif  // COMPILER_RULES_SEQ_H_
+#endif  // COMPILER_RULES_SEQ_H_

data/ext/tree-sitter/tree-sitter/src/compiler/rules/string.h

@@ -2,25 +2,19 @@
 #define COMPILER_RULES_STRING_H_
 
 #include <string>
-#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-class String : public Rule {
- public:
-  explicit String(std::string value);
+struct String {
+  std::string value;
 
-  bool operator==(const Rule &other) const;
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
-
-  const std::string value;
+  inline bool operator==(const String &other) const {
+    return value == other.value;
+  }
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-#endif  // COMPILER_RULES_STRING_H_
+#endif  // COMPILER_RULES_STRING_H_

data/ext/tree-sitter/tree-sitter/src/compiler/rules/symbol.h

@@ -1,55 +1,76 @@
 #ifndef COMPILER_RULES_SYMBOL_H_
 #define COMPILER_RULES_SYMBOL_H_
 
-#include <string>
-#include "compiler/rule.h"
-
 namespace tree_sitter {
 namespace rules {
 
-class Symbol : public Rule {
- public:
-  typedef int Index;
-
-  typedef enum {
+struct Symbol {
+  using Index = int;
+  enum Type {
     External,
     Terminal,
     NonTerminal,
-  } Type;
-
-  Symbol(Index index, Type type);
+  };
 
-  bool operator==(const Symbol &other) const;
-  bool operator==(const Rule &other) const;
+  inline bool operator==(const Symbol &other) const {
+    return index == other.index && type == other.type;
+  }
 
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
+  inline bool operator!=(const Symbol &other) const {
+    return !operator==(other);
+  }
 
-  bool operator<(const Symbol &other) const;
-  static bool is_built_in(Index);
-  bool is_built_in() const;
-  bool is_token() const;
-  bool is_external() const;
-  bool is_non_terminal() const;
+  inline bool operator<(const Symbol &other) const {
+    if (type < other.type) return true;
+    if (type > other.type) return false;
+    return index < other.index;
+  }
 
   Index index;
   Type type;
-};
 
-}  // namespace rules
-}  // namespace tree_sitter
+  static Symbol terminal(Index index) {
+    return Symbol{index, Type::Terminal};
+  }
+
+  static Symbol external(Index index) {
+    return Symbol{index, Type::External};
+  }
 
-namespace std {
+  static Symbol non_terminal(Index index) {
+    return Symbol{index, Type::NonTerminal};
+  }
+
+  bool is_non_terminal() const {
+    return type == Type::NonTerminal;
+  }
+
+  bool is_terminal() const {
+    return type == Type::Terminal;
+  }
+
+  bool is_external() const {
+    return type == Type::External;
+  }
 
-template <>
-struct hash<tree_sitter::rules::Symbol> {
-  size_t operator()(const tree_sitter::rules::Symbol &rule) const {
-    return rule.hash_code();
+  bool is_built_in() const {
+    return index < 0;
   }
 };
 
-}  // std
+inline Symbol END_OF_INPUT() {
+  return Symbol{-1, Symbol::Terminal};
+}
+
+inline Symbol START() {
+  return Symbol{-2, Symbol::NonTerminal};
+}
+
+inline Symbol NONE() {
+  return Symbol{-3, Symbol::Type(-1)};
+}
+
+}  // namespace rules
+}  // namespace tree_sitter
 
 #endif  // COMPILER_RULES_SYMBOL_H_