expression nodes finished

include/basic_nodes.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+
+namespace nodes {
+
+class Node {
+public:
+  Node(std::pair<size_t, size_t> start_position,
+       std::pair<size_t, size_t> end_position)
+      : start_position_(start_position), end_position_(end_position) {}
+
+  std::pair<size_t, size_t> get_start_position() { return start_position_; }
+
+  std::pair<size_t, size_t> get_end_position() { return end_position_; }
+
+protected:
+  std::pair<size_t, size_t> start_position_;
+  std::pair<size_t, size_t> end_position_;
+};
+
+struct unit {};
+struct null {};
+
+class Literal : public Node {
+public:
+  template <typename T>
+  Literal(Node node, T &&value) : Node(node), value_(std::forward<T>(value)) {}
+
+  template <typename T> std::optional<T *> get() {
+    if (std::holds_alternative<T>(value_)) {
+      return &std::get<T>(value_);
+    }
+    return std::nullopt;
+  }
+
+  template <typename T> std::optional<const T *> get() const {
+    if (std::holds_alternative<T>(value_)) {
+      return &std::get<T>(value_);
+    }
+    return std::nullopt;
+  }
+
+private:
+  std::variant<double, long long, std::string, char, bool, unit, null> value_;
+};
+
+class Identifier : public Node {
+public:
+  enum IdentifierType {
+    SIMPLE_NAME,
+    SIMPLE_TYPE,
+    TYPECLASS,
+    ARGUMENT_NAME,
+    ARGUMENT_TYPE,
+    // ANNOTATION, used as std::string
+    OPERATOR,
+    PLACEHOLDER,
+  };
+
+  Identifier(Node node, IdentifierType type, std::string &&value)
+      : Node(node), type_(type), value_(std::move(value)) {}
+
+  Identifier(Node node, IdentifierType type, const std::string &value)
+      : Node(node), type_(type), value_(value) {}
+
+  IdentifierType get_type() { return type_; }
+
+  std::string *get() { return &value_; }
+
+  const std::string *get() const { return &value_; }
+
+private:
+  IdentifierType type_;
+  std::string value_;
+};
+
+} // namespace nodes