started to develop build_visitor

include/build_visitor.hpp

@@ -0,0 +1,148 @@
+#pragma once
+
+// for clangd
+#include "visitor.hpp"
+#include "parse_tree.hpp"
+
+namespace interpreter {
+
+class BuildVisitor : public Visitor {
+public:
+  BuildVisitor(const parser::ParseTree& parse_tree) : parse_tree_(parse_tree) {}
+
+  void VisitSourceFile(SourceFile* source_file) override {
+    current_node_ = parse_tree_.GetRoot();
+    Visit(source_file);
+  }
+
+private:
+  void Visit(Node* node) override;
+
+  // Sources -----------------
+
+  void Visit(SourceFile* node) override;
+  void Visit(Sources* node) override;
+
+  // Namespaces, partittions -----------------
+
+  void Visit(Partition* node) override;
+  void Visit(Namespace* node) override;
+
+  // Definitions -----------------
+
+  void Visit(ImportStatement* node) override;
+  void Visit(UsageDefinition* node) override;
+  void Visit(AliasDefinition* node) override;
+  void Visit(VariableDefinition* node) override;
+  void Visit(FunctionDeclaration* node) override;
+  void Visit(FunctionDefinition* node) override;
+  void Visit(AliasTypeDefinition* node) override;
+  void Visit(TypeDefinition* node) override;
+  void Visit(TypeclassDefinition* node) override;
+
+  void Visit(SourceStatement& node) override; // variant
+  void Visit(ImportSymbol& node) override; // variant
+
+  // Definition parts
+
+  void Visit(DefinedName* node) override;
+  void Visit(DefinedAnnotatedName* node) override;
+  void Visit(DefinedType* node) override;
+  void Visit(DefinedTypeclass* node) override;
+  void Visit(DefinitionParameter* node) override;
+  void Visit(DefinitionArgument* node) override;
+
+  void Visit(FunctionDeclarationType& node) override; // variant
+
+  // Flow control -----------------
+
+  void Visit(Match* node) override;
+  void Visit(Condition* node) override;
+  void Visit(DoWhileLoop* node) override;
+  void Visit(WhileLoop* node) override;
+  void Visit(ForLoop* node) override;
+  void Visit(LoopLoop* node) override;
+
+  void Visit(FlowControl& node) override; // variant
+
+  // Statements, expressions, blocks, etc. -----------------
+
+  void Visit(Block* node) override;
+  void Visit(ScopedStatement* node) override;
+
+  void Visit(LoopControlExpression& node) override; // enum
+
+  void Visit(SubExpressionToken& node) override; // variant
+  void Visit(SubExpression& node) override; // variant
+  void Visit(PrefixedExpression& node) override; // variant
+  void Visit(Expression& node) override; // variant
+  void Visit(SuperExpression& node) override; // variant
+
+  void Visit(BlockStatement& node) override; // variant
+
+  // Operators
+
+  void Visit(BinaryOperatorExpression* node) override;
+  void Visit(UnaryOperatorExpression* node) override;
+
+  // Simple Expressions
+
+  void Visit(FunctionCallExpression* node) override;
+  void Visit(TupleExpression* node) override;
+  void Visit(VariantExpression* node) override;
+  void Visit(ReturnExpression* node) override;
+
+  void Visit(FunctionArgument& node) override; // variant
+
+  // Lambda
+
+  void Visit(LambdaFunction* node) override;
+
+  // Name
+
+  void Visit(NameSuperExpression* node) override;
+  void Visit(NameExpression* node) override;
+  void Visit(TupleName* node) override;
+  void Visit(VariantName* node) override;
+  void Visit(AnnotatedName* node) override;
+
+  void Visit(AnyName& node) override; // variant
+
+  // Type
+
+  void Visit(TypeConstructor* node) override;
+  void Visit(TupleType* node) override;
+  void Visit(VariantType* node) override;
+  void Visit(AnnotatedType* node) override;
+  void Visit(ParametrizedType* node) override;
+  void Visit(TypeExpression* node) override;
+
+  void Visit(AnyType& node) override; // variant
+  void Visit(TypeSubExpression& node) override; // variant
+
+  void Visit(TypeParameter& node) override; // variant
+
+  // Typeclass
+
+  void Visit(AnnotatedTypeclass* node) override;
+  void Visit(ParametrizedTypeclass* node) override;
+  void Visit(TypeclassExpression* node) override;
+
+  // Identifiers, constants, etc. -----------------
+
+  void Visit(AnyIdentifier* node) override; // std::string
+
+  void Visit(FloatNumberLiteral* node) override;
+  void Visit(NumberLiteral* node) override;
+  void Visit(StringLiteral* node) override;
+  void Visit(CharLiteral* node) override;
+
+  void Visit(Literal& node) override; // variant
+
+  void Visit(NameSubSuperExpression& node) override; // variant
+private:
+  const parser::ParseTree& parse_tree_;
+  parser::ParseTree::Node current_node_;
+};
+
+} // namespace interpreter

include/interpreter_tree.hpp

@@ -270,6 +270,7 @@ struct Partition : public Node {
 };
 
 struct Namespace : public Node {
+  bool is_const;
   std::variant<
     std::unique_ptr<DefinedAnnotatedName>,
     std::unique_ptr<DefinedType>> name;

include/node.hpp

@@ -15,9 +15,9 @@ class Visitor;
 
 struct Node {
 //public:
-  Node(info::GlobalInfo& global_info) : global_info_(global_info) {}
+  //Node(info::GlobalInfo& global_info) : global_info_(global_info) {}
 
-  virtual void Accept(Visitor* visitor);
+  // ?? not needed ?? virtual void Accept(Visitor* visitor);
 
   /* ------------ use visitor instead ------------
   virtual void build(parser::ParseTree::Cursor& cursor) = 0; // build tree from parse tree

include/parse_token_types.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <string>
+
+namespace parser {
+
+namespace tokens {
+
+// Sources -----------------
+
+const std::string SourceFile = "source_file";
+const std::string Sources = "sources";
+
+// Namespaces, partittions -----------------
+
+const std::string Partition = "partition";
+
+// Definitions -----------------
+
+const std::string ImportStatement = "import_statement";
+const std::string UsageDefinition = "usage_definition";
+const std::string AliasDefinition = "alias_definition";
+const std::string VariableDefinition = "variable_definition";
+const std::string FunctionDeclaration = "function_declaration";
+const std::string FunctionDefinition = "function_definition";
+const std::string AliasTypeDefinition = "alias_type_definition";
+const std::string TypeDefinition = "type_definition";
+const std::string TypeclassDefinition = "typeclass_definition";
+
+const std::string SourceStatement = "source_statement";
+const std::string ImportSymbol = "import_symbol";
+
+// Definition parts
+
+const std::string DefinedName = "defined_name";
+const std::string DefinedAnnotatedName = "defined_annotated_name";
+const std::string DefinedType = "defined_type";
+const std::string DefinedTypeclass = "defined_typeclass";
+const std::string DefinitionParameter = "definition_parameter";
+const std::string DefinitionArgument = "definition_argument";
+
+const std::string FunctionDeclarationType = "function_declaration_type";
+
+// Flow control -----------------
+
+const std::string Match = "match";
+const std::string Condition = "condition";
+const std::string DoWhileLoop = "do_while_loop";
+const std::string WhileLoop = "while_loop";
+const std::string ForLoop = "for_loop";
+const std::string LoopLoop = "loop_loop";
+
+const std::string FlowControl = "flow_control";
+
+// Statements, expressions, blocks, etc. -----------------
+
+
+
+} // namespace tokens
+
+} // namespace parser

include/parse_tree.hpp

@@ -12,13 +12,13 @@ class ParseTree {
 public:
   class Node {
   public:
-    Node() = delete;
-
     std::string GetType();
     std::pair<size_t, size_t> GetStartPoint();
     std::pair<size_t, size_t> GetEndPoint();
     std::string GetAsSExpression();
 
+    std::string GetValue(); // from source
+
     bool IsNull();
     bool IsNamed();
     bool IsMissing();
@@ -31,14 +31,14 @@ public:
     Node NthNamedChild(size_t n);
     size_t NamedChildCount();
 
-    Node ChildByName(const std::string& name);
+    Node ChildByFieldName(const std::string& name);
 
     // ?? use field id instaed of name ??
     // ?? node equality check needed ??
   private:
     TSNode node_;
   };
-  class Cursor {
+  class Cursor { // ?? needed ??
   public:
     Cursor(const Node& node);
 
@@ -56,9 +56,10 @@ public:
 
   ParseTree(const std::string& input);
 
-  Node GetRoot();
+  Node GetRoot() const;
 private:
   TSTree* tree_;
+  std::string source; // for token value extraction
 };
 
 } // namespace parser

include/print_visitor.hpp

@@ -11,8 +11,7 @@ class PrintVisitor : public Visitor {
 public:
   PrintVisitor(std::ostream& out) : out_(out) {}
 
-  // -----------------
-
+private:
   void Visit(Node* node) override;
 
   // Sources -----------------
@@ -60,6 +59,8 @@ public:
   void Visit(Block* node) override;
   void Visit(ScopedStatement* node) override;
 
+  void Visit(LoopControlExpression& node) override; // enum
+
   // Operators
 
   void Visit(BinaryOperatorExpression* node) override;

include/visitor.hpp

@@ -13,8 +13,7 @@ public:
     Visit(source_file);
   }
 
-  // -----------------
-
+private:
   virtual void Visit(Node* node) {}
 
   // Sources -----------------
@@ -39,8 +38,8 @@ public:
   virtual void Visit(TypeDefinition* node) {}
   virtual void Visit(TypeclassDefinition* node) {}
 
-  void Visit(SourceStatement& node); // variant
-  void Visit(ImportSymbol& node); // variant
+  virtual void Visit(SourceStatement& node); // variant
+  virtual void Visit(ImportSymbol& node); // variant
 
   // Definition parts
 
@@ -51,7 +50,7 @@ public:
   virtual void Visit(DefinitionParameter* node) {}
   virtual void Visit(DefinitionArgument* node) {}
 
-  void Visit(FunctionDeclarationType& node); // variant
+  virtual void Visit(FunctionDeclarationType& node); // variant
 
   // Flow control -----------------
 
@@ -62,7 +61,7 @@ public:
   virtual void Visit(ForLoop* node) {}
   virtual void Visit(LoopLoop* node) {}
 
-  void Visit(FlowControl& node); // variant
+  virtual void Visit(FlowControl& node); // variant
 
   // Statements, expressions, blocks, etc. -----------------
 
@@ -71,13 +70,13 @@ public:
 
   virtual void Visit(LoopControlExpression& node) {} // enum
 
-  void Visit(SubExpressionToken& node); // variant
-  void Visit(SubExpression& node); // variant
-  void Visit(PrefixedExpression& node); // variant
-  void Visit(Expression& node); // variant
-  void Visit(SuperExpression& node); // variant
+  virtual void Visit(SubExpressionToken& node); // variant
+  virtual void Visit(SubExpression& node); // variant
+  virtual void Visit(PrefixedExpression& node); // variant
+  virtual void Visit(Expression& node); // variant
+  virtual void Visit(SuperExpression& node); // variant
 
-  void Visit(BlockStatement& node); // variant
+  virtual void Visit(BlockStatement& node); // variant
 
   // Operators
 
@@ -91,7 +90,7 @@ public:
   virtual void Visit(VariantExpression* node) {}
   virtual void Visit(ReturnExpression* node) {}
 
-  void Visit(FunctionArgument& node); // variant
+  virtual void Visit(FunctionArgument& node); // variant
 
   // Lambda
 
@@ -105,7 +104,7 @@ public:
   virtual void Visit(VariantName* node) {}
   virtual void Visit(AnnotatedName* node) {}
 
-  void Visit(AnyName& node); // variant
+  virtual void Visit(AnyName& node); // variant
 
   // Type
 
@@ -116,10 +115,10 @@ public:
   virtual void Visit(ParametrizedType* node) {}
   virtual void Visit(TypeExpression* node) {}
 
-  void Visit(AnyType& node); // variant
-  void Visit(TypeSubExpression& node); // variant
+  virtual void Visit(AnyType& node); // variant
+  virtual void Visit(TypeSubExpression& node); // variant
 
-  void Visit(TypeParameter& node); // variant
+  virtual void Visit(TypeParameter& node); // variant
 
   // Typeclass
 
@@ -136,9 +135,9 @@ public:
   virtual void Visit(StringLiteral* node) {}
   virtual void Visit(CharLiteral* node) {}
 
-  void Visit(Literal& node); // variant
+  virtual void Visit(Literal& node); // variant
 
-  void Visit(NameSubSuperExpression& node); // variant
+  virtual void Visit(NameSubSuperExpression& node); // variant
 };
 
 } // namespace interpreter