tree-sitter 0.0.1 → 0.1.0

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

@@ -1,25 +1,16 @@
 #ifndef COMPILER_RULES_BLANK_H_
 #define COMPILER_RULES_BLANK_H_
 
-#include <string>
-#include "compiler/rule.h"
-
 namespace tree_sitter {
 namespace rules {
 
-class Blank : public Rule {
- public:
-  Blank();
-  static rule_ptr build();
-
-  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 Blank {
+  inline bool operator==(const Blank &other) const {
+    return true;
+  }
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-#endif  // COMPILER_RULES_BLANK_H_
+#endif  // COMPILER_RULES_BLANK_H_

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

@@ -1,59 +1,48 @@
 #include "compiler/rules/character_set.h"
-#include <string>
-#include <utility>
-#include <vector>
-#include "compiler/rules/visitor.h"
-#include "compiler/util/hash_combine.h"
 
-namespace tree_sitter {
-namespace rules {
-
-using std::string;
 using std::set;
 using std::vector;
-using util::hash_combine;
+
+namespace tree_sitter {
+namespace rules {
 
 static void add_range(set<uint32_t> *characters, uint32_t min, uint32_t max) {
-  for (uint32_t c = min; c <= max; c++)
+  for (uint32_t c = min; c <= max; c++) {
     characters->insert(c);
+  }
 }
 
 static void remove_range(set<uint32_t> *characters, uint32_t min, uint32_t max) {
-  for (uint32_t c = min; c <= max; c++)
+  for (uint32_t c = min; c <= max; c++) {
     characters->erase(c);
+  }
 }
 
-static set<uint32_t> remove_chars(set<uint32_t> *left,
-                                  const set<uint32_t> &right) {
+static set<uint32_t> remove_chars(set<uint32_t> *left, const set<uint32_t> &right) {
   set<uint32_t> result;
   for (uint32_t c : right) {
-    if (left->erase(c))
+    if (left->erase(c)) {
       result.insert(c);
+    }
   }
   return result;
 }
 
 static set<uint32_t> add_chars(set<uint32_t> *left, const set<uint32_t> &right) {
   set<uint32_t> result;
-  for (uint32_t c : right)
-    if (left->insert(c).second)
+  for (uint32_t c : right) {
+    if (left->insert(c).second) {
       result.insert(c);
+    }
+  }
   return result;
 }
 
-static vector<CharacterRange> consolidate_ranges(const set<uint32_t> &chars) {
+static vector<CharacterRange> consolidate_ranges(const set<uint32_t> &characters) {
   vector<CharacterRange> result;
-  for (uint32_t c : chars) {
-    size_t size = result.size();
-    if (size >= 2 && result[size - 2].max == (c - 2)) {
-      result.pop_back();
+  for (uint32_t c : characters) {
+    if (!result.empty() && result.back().max == c - 1) {
       result.back().max = c;
-    } else if (size >= 1) {
-      CharacterRange &last = result.back();
-      if (last.min < last.max && last.max == (c - 1))
-        last.max = c;
-      else
-        result.push_back(CharacterRange(c));
     } else {
       result.push_back(CharacterRange(c));
     }
@@ -61,61 +50,28 @@ static vector<CharacterRange> consolidate_ranges(const set<uint32_t> &chars) {
   return result;
 }
 
-CharacterSet::CharacterSet()
-    : includes_all(false), included_chars({}), excluded_chars({}) {}
+CharacterSet::CharacterSet() : includes_all(false) {}
 
-bool CharacterSet::operator==(const Rule &rule) const {
-  const CharacterSet *other = rule.as<CharacterSet>();
-  return other && (includes_all == other->includes_all) &&
-         (included_chars == other->included_chars) &&
-         (excluded_chars == other->excluded_chars);
-}
-
-bool CharacterSet::operator<(const CharacterSet &other) const {
-  if (!includes_all && other.includes_all)
-    return true;
-  if (includes_all && !other.includes_all)
-    return false;
-  if (included_chars < other.included_chars)
-    return true;
-  if (other.included_chars < included_chars)
-    return false;
-  return excluded_chars < other.excluded_chars;
-}
-
-size_t CharacterSet::hash_code() const {
-  size_t result = 0;
-  hash_combine(&result, includes_all);
-  hash_combine(&result, included_chars.size());
-  for (uint32_t c : included_chars)
-    hash_combine(&result, c);
-  hash_combine(&result, excluded_chars.size());
-  for (uint32_t c : excluded_chars)
-    hash_combine(&result, c);
-  return result;
-}
+CharacterSet::CharacterSet(const set<uint32_t> &chars) : included_chars(chars), includes_all(false) {}
 
-rule_ptr CharacterSet::copy() const {
-  return std::make_shared<CharacterSet>(*this);
+bool CharacterSet::operator==(const CharacterSet &other) const {
+  return includes_all == other.includes_all &&
+         included_chars == other.included_chars &&
+         excluded_chars == other.excluded_chars;
 }
 
-string CharacterSet::to_string() const {
-  string result("(char");
-  if (includes_all)
-    result += " include_all";
-  if (!included_chars.empty()) {
-    result += " (include";
-    for (auto r : included_ranges())
-      result += string(" ") + r.to_string();
-    result += ")";
-  }
-  if (!excluded_chars.empty()) {
-    result += " (exclude";
-    for (auto r : excluded_ranges())
-      result += string(" ") + r.to_string();
-    result += ")";
+bool CharacterSet::operator<(const CharacterSet &other) const {
+  if (!includes_all && other.includes_all) return true;
+  if (includes_all && !other.includes_all) return false;
+  if (includes_all) {
+    if (excluded_chars.size() > other.excluded_chars.size()) return true;
+    if (excluded_chars.size() < other.excluded_chars.size()) return false;
+    return excluded_chars < other.excluded_chars;
+  } else {
+    if (included_chars.size() < other.included_chars.size()) return true;
+    if (included_chars.size() > other.included_chars.size()) return false;
+    return included_chars < other.included_chars;
   }
-  return result + ")";
 }
 
 CharacterSet &CharacterSet::include_all() {
@@ -168,8 +124,7 @@ void CharacterSet::add_set(const CharacterSet &other) {
           excluded_chars.insert(c);
       included_chars.clear();
     } else {
-      for (uint32_t c : other.included_chars)
-        included_chars.insert(c);
+      included_chars.insert(other.included_chars.begin(), other.included_chars.end());
     }
   }
 }
@@ -212,9 +167,5 @@ vector<CharacterRange> CharacterSet::excluded_ranges() const {
   return consolidate_ranges(excluded_chars);
 }
 
-void CharacterSet::accept(Visitor *visitor) const {
-  visitor->visit(this);
-}
-
 }  // namespace rules
 }  // namespace tree_sitter

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

@@ -1,20 +1,28 @@
 #ifndef COMPILER_RULES_CHARACTER_SET_H_
 #define COMPILER_RULES_CHARACTER_SET_H_
 
-#include <stdint.h>
-#include <set>
-#include <string>
-#include <utility>
 #include <vector>
-#include "compiler/rule.h"
-#include "compiler/rules/character_range.h"
+#include <set>
+#include <cstdint>
 
 namespace tree_sitter {
 namespace rules {
 
-class CharacterSet : public Rule {
- public:
+struct CharacterRange {
+  uint32_t min;
+  uint32_t max;
+
+  inline explicit CharacterRange(uint32_t value) : min{value}, max{value} {}
+  inline CharacterRange(uint32_t min, uint32_t max) : min{min}, max{max} {}
+
+  inline bool operator==(const CharacterRange &other) const {
+    return min == other.min && max == other.max;
+  }
+};
+
+struct CharacterSet {
   CharacterSet();
+  CharacterSet(const std::set<uint32_t> &);
 
   CharacterSet &include_all();
   CharacterSet &include(uint32_t c);
@@ -22,12 +30,8 @@ class CharacterSet : public Rule {
   CharacterSet &exclude(uint32_t c);
   CharacterSet &exclude(uint32_t min, uint32_t max);
 
-  bool operator==(const Rule &other) const;
+  bool operator==(const CharacterSet &) const;
   bool operator<(const CharacterSet &) const;
-  size_t hash_code() const;
-  rule_ptr copy() const;
-  std::string to_string() const;
-  void accept(Visitor *visitor) const;
 
   void add_set(const CharacterSet &other);
   CharacterSet remove_set(const CharacterSet &other);
@@ -37,23 +41,12 @@ class CharacterSet : public Rule {
   std::vector<CharacterRange> included_ranges() const;
   std::vector<CharacterRange> excluded_ranges() const;
 
-  bool includes_all;
   std::set<uint32_t> included_chars;
   std::set<uint32_t> excluded_chars;
+  bool includes_all;
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-namespace std {
-
-template <>
-struct hash<tree_sitter::rules::CharacterSet> {
-  size_t operator()(const tree_sitter::rules::CharacterSet &rule) const {
-    return rule.hash_code();
-  }
-};
-
-}  // namespace std
-
-#endif  // COMPILER_RULES_CHARACTER_SET_H_
+#endif  // COMPILER_RULES_CHARACTER_SET_H_

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

@@ -1,77 +1,11 @@
 #include "compiler/rules/choice.h"
-#include <string>
-#include <set>
-#include "compiler/rules/visitor.h"
-#include "compiler/util/hash_combine.h"
+#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-using std::string;
-using std::make_shared;
-using std::vector;
-using std::set;
-using util::symmetric_hash_combine;
-
-Choice::Choice(const vector<rule_ptr> &elements) : elements(elements) {}
-
-void add_choice_element(vector<rule_ptr> *vec, const rule_ptr new_rule) {
-  auto choice = new_rule->as<Choice>();
-  if (choice) {
-    for (auto &child : choice->elements)
-      add_choice_element(vec, child);
-  } else {
-    for (auto &element : *vec)
-      if (element->operator==(*new_rule))
-        return;
-    vec->push_back(new_rule);
-  }
-}
-
-rule_ptr Choice::build(const vector<rule_ptr> &inputs) {
-  vector<rule_ptr> elements;
-  for (auto &el : inputs)
-    add_choice_element(&elements, el);
-  if (elements.size() == 1)
-    return elements.front();
-  else
-    return make_shared<Choice>(elements);
-}
-
-bool Choice::operator==(const Rule &rule) const {
-  const Choice *other = rule.as<Choice>();
-  if (!other)
-    return false;
-  size_t size = elements.size();
-  if (size != other->elements.size())
-    return false;
-  for (size_t i = 0; i < size; i++)
-    if (!elements[i]->operator==(*other->elements[i]))
-      return false;
-  return true;
-}
-
-size_t Choice::hash_code() const {
-  size_t result = 0;
-  symmetric_hash_combine(&result, elements.size());
-  for (const auto &element : elements)
-    symmetric_hash_combine(&result, element);
-  return result;
-}
-
-rule_ptr Choice::copy() const {
-  return std::make_shared<Choice>(*this);
-}
-
-string Choice::to_string() const {
-  string result = "(choice";
-  for (const auto &element : elements)
-    result += " " + element->to_string();
-  return result + ")";
-}
-
-void Choice::accept(Visitor *visitor) const {
-  visitor->visit(this);
+bool Choice::operator==(const Choice &other) const {
+  return elements == other.elements;
 }
 
 }  // namespace rules

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

@@ -1,28 +1,21 @@
 #ifndef COMPILER_RULES_CHOICE_H_
 #define COMPILER_RULES_CHOICE_H_
 
-#include <string>
+#include <memory>
 #include <vector>
-#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-class Choice : public Rule {
- public:
-  explicit Choice(const std::vector<rule_ptr> &elements);
-  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 Choice {
+  std::vector<Rule> elements;
 
-  const std::vector<rule_ptr> elements;
+  bool operator==(const Choice &other) const;
 };
 
 }  // namespace rules
 }  // namespace tree_sitter
 
-#endif  // COMPILER_RULES_CHOICE_H_
+#endif  // COMPILER_RULES_CHOICE_H_

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

@@ -1,97 +1,154 @@
 #include "compiler/rules/metadata.h"
-#include <string>
-#include <map>
 #include <climits>
-#include "compiler/rules/visitor.h"
-#include "compiler/rules/blank.h"
-#include "compiler/util/hash_combine.h"
+#include <string>
+#include "compiler/rule.h"
 
 namespace tree_sitter {
 namespace rules {
 
-using std::make_shared;
-using std::map;
-using std::pair;
-using util::hash_combine;
-
-MetadataParams::MetadataParams() :
-  precedence{0},
-  associativity{AssociativityNone},
-  has_precedence{false},
-  has_associativity{false},
-  is_token{false},
-  is_string{false},
-  is_active{false},
-  is_main_token{false} {}
-
-bool MetadataParams::operator==(const MetadataParams &other) const {
-  return
-    precedence == other.precedence &&
-    associativity == other.associativity &&
-    has_precedence == other.has_precedence &&
-    has_associativity == other.has_associativity &&
-    is_token == other.is_token &&
-    is_string == other.is_string &&
-    is_active == other.is_active &&
-    is_main_token == other.is_main_token;
+using std::move;
+using std::string;
+
+bool Alias::operator==(const Alias &other) const {
+  return value == other.value && is_named == other.is_named;
 }
 
-Metadata::Metadata(rule_ptr rule, MetadataParams params)
-    : rule(rule), params(params) {}
+bool Alias::operator!=(const Alias &other) const {
+  return !operator==(other);
+}
 
-rule_ptr Metadata::build(rule_ptr rule, MetadataParams params) {
-  return std::make_shared<Metadata>(rule, params);
+bool Alias::operator<(const Alias &other) const {
+  if (value < other.value) return true;
+  if (other.value < value) return false;
+  return is_named < other.is_named;
 }
 
-rule_ptr Metadata::main_token(rule_ptr rule) {
-  MetadataParams params;
-  params.has_precedence = true;
-  params.precedence = 0;
-  params.is_main_token = true;
-  return Metadata::build(rule, params);
+Metadata::Metadata(const Rule &rule, MetadataParams params) :
+  rule(std::make_shared<Rule>(rule)), params(params) {}
+
+bool Metadata::operator==(const Metadata &other) const {
+  return rule->operator==(*other.rule) && params == other.params;
 }
 
-rule_ptr Metadata::separator(rule_ptr rule) {
-  MetadataParams params;
-  params.has_precedence = true;
-  params.precedence = INT_MIN;
-  params.is_active = true;
-  return Metadata::build(rule, params);
+template <typename T>
+static Metadata add_metadata(Rule &&rule, T &&callback) {
+  if (rule.is<Metadata>()) {
+    Metadata metadata = rule.get_unchecked<Metadata>();
+    callback(metadata.params);
+    return metadata;
+  } else {
+    MetadataParams params;
+    callback(params);
+    return Metadata{move(rule), params};
+  }
 }
 
-bool Metadata::operator==(const Rule &rule) const {
-  auto other = rule.as<Metadata>();
-  return other && other->params == params && other->rule->operator==(*this->rule);
+Metadata Metadata::merge(Rule &&rule, MetadataParams new_params) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    if (new_params.has_precedence && !params.has_precedence) {
+      params.has_precedence = true;
+      params.precedence = new_params.precedence;
+    }
+
+    if (new_params.has_associativity && !params.has_associativity) {
+      params.has_associativity = true;
+      params.associativity = new_params.associativity;
+    }
+
+    if (new_params.dynamic_precedence != 0) {
+      params.dynamic_precedence = new_params.dynamic_precedence;
+    }
+
+    if (new_params.is_string) params.is_string = true;
+    if (new_params.is_active) params.is_active = true;
+    if (new_params.is_main_token) params.is_main_token = true;
+
+    if (!new_params.alias.value.empty()) {
+      params.alias = new_params.alias;
+    }
+  });
 }
 
-size_t Metadata::hash_code() const {
-  size_t result = 0;
-  hash_combine(&result, params.precedence);
-  hash_combine<int>(&result, params.associativity);
-  hash_combine(&result, params.has_precedence);
-  hash_combine(&result, params.has_associativity);
-  hash_combine(&result, params.is_token);
-  hash_combine(&result, params.is_string);
-  hash_combine(&result, params.is_active);
-  hash_combine(&result, params.is_main_token);
-  return result;
+Metadata Metadata::token(Rule &&rule) {
+  return add_metadata(move(rule), [](MetadataParams &params) {
+    params.is_token = true;
+  });
 }
 
-rule_ptr Metadata::copy() const {
-  return make_shared<Metadata>(rule->copy(), params);
+Metadata Metadata::active_prec(int precedence, Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    params.has_precedence = true;
+    params.precedence = precedence;
+    params.is_active = true;
+  });
 }
 
-std::string Metadata::to_string() const {
-  if (params.has_precedence) {
-    return "(metadata prec:" + std::to_string(params.precedence) + " " +
-           rule->to_string() + ")";
-  } else {
-    return "(metadata " + rule->to_string() + ")";
-  }
+Metadata Metadata::prec(int precedence, Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    if (!params.has_precedence) {
+      params.has_precedence = true;
+      params.precedence = precedence;
+    }
+  });
+}
+
+Metadata Metadata::prec_left(int precedence, Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    if (!params.has_precedence) {
+      params.has_precedence = true;
+      params.precedence = precedence;
+    }
+    if (!params.has_associativity) {
+      params.has_associativity = true;
+      params.associativity = AssociativityLeft;
+    }
+  });
+}
+
+Metadata Metadata::prec_right(int precedence, Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    if (!params.has_precedence) {
+      params.has_precedence = true;
+      params.precedence = precedence;
+    }
+    if (!params.has_associativity) {
+      params.has_associativity = true;
+      params.associativity = AssociativityRight;
+    }
+  });
+}
+
+Metadata Metadata::prec_dynamic(int dynamic_precedence, Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    params.dynamic_precedence = dynamic_precedence;
+  });
+}
+
+Metadata Metadata::separator(Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    if (!params.has_precedence) {
+      params.has_precedence = true;
+      params.precedence = INT_MIN;
+    }
+    params.is_active = true;
+  });
+}
+
+Metadata Metadata::main_token(Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    if (!params.has_precedence) {
+      params.has_precedence = true;
+      params.precedence = 0;
+    }
+    params.is_main_token = true;
+  });
 }
 
-void Metadata::accept(Visitor *visitor) const {
-  visitor->visit(this);
+Metadata Metadata::alias(string &&value, bool is_named, Rule &&rule) {
+  return add_metadata(move(rule), [&](MetadataParams &params) {
+    params.alias.value = move(value);
+    params.alias.is_named = is_named;
+  });
 }
 
 }  // namespace rules