basic printers, type printers, some fixes, part of expression printers

include/type_nodes.hpp

@@ -31,6 +31,7 @@ private:
   size_t id_;
 };
 
+// can't have both optional and result modifiers ??
 class Type : public Node {
 public:
   Type(Node node, Identifier &&identifier, bool is_on_heap = false,
@@ -61,7 +62,7 @@ public:
 
   const std::string *get_name() const { return name_.get(); }
 
-  size_t get_parametrs_size() { return parameters_.size(); }
+  size_t get_parametrs_size() const { return parameters_.size(); }
 
   Type *get_parameter(size_t id) { return parameters_.at(id).get(); }
 
@@ -69,11 +70,11 @@ public:
     return parameters_.at(id).get();
   }
 
-  bool is_on_heap() { return is_on_heap_; }
+  bool is_on_heap() const { return is_on_heap_; }
 
-  bool is_optional() { return is_optional_; }
+  bool is_optional() const { return is_optional_; }
 
-  bool is_result() { return is_result_; }
+  bool is_result() const { return is_result_; }
 
 private:
   Identifier name_;
@@ -113,16 +114,32 @@ public:
             const std::vector<std::pair<std::optional<std::string>, TypeProxy>>
                 &fields)
       : Node(node) {
+    annotations_.reserve(fields.size());
     fields_.reserve(fields.size());
     for (auto &field : fields) {
       if (field.first.has_value()) {
         annotation_fields_[field.first.value()] = fields_.size();
       }
+      annotations_.push_back(field.first);
       fields_.push_back(field.second);
     }
   }
 
-  size_t size() { return fields_.size(); }
+  size_t size() const { return fields_.size(); }
+
+  std::optional<std::string *> get_annotation(size_t id) {
+    if (annotations_.at(id).has_value()) {
+      return &annotations_[id].value();
+    }
+    return std::nullopt;
+  }
+
+  std::optional<const std::string *> get_annotation(size_t id) const {
+    if (annotations_.at(id).has_value()) {
+      return &annotations_[id].value();
+    }
+    return std::nullopt;
+  }
 
   Type *get(size_t id) { return fields_.at(id).get(); }
 
@@ -150,6 +167,7 @@ public:
 private:
   std::unordered_map<std::string, size_t> annotation_fields_;
   std::vector<TypeProxy> fields_;
+  std::vector<std::optional<std::string>> annotations_;
 };
 
 class VariantType : public Node {
@@ -160,7 +178,7 @@ public:
   VariantType(Node node, const std::vector<TupleType> &constructors_)
       : Node(node), constructors_(constructors_) {}
 
-  size_t size() { return constructors_.size(); }
+  size_t size() const { return constructors_.size(); }
 
   TupleType *get(size_t id) { return &constructors_.at(id); }