first iteration of find_symbols_visitor

CMakeLists.txt

@@ -20,6 +20,7 @@ add_executable(lang_interpreter src/main.cpp
                                 src/visitor.cpp
                                 src/build_visitor.cpp
                                 src/print_visitor.cpp
+                                src/find_symbols_visitor.cpp
                                 src/parser.c
                                 include/parser.h
                                 tree-sitter/lib/src/lib.c)

include/build_visitor.hpp

@@ -43,7 +43,7 @@ private:
 
   void Visit(FunctionDefinition* node) override;
   void Visit(TypeDefinition* node) override;
-  void Visit(DefinitionParameter* node) override;
+  void Visit(AnyAnnotatedType* node) override;
 
   // Flow control -----------------
 
@@ -108,7 +108,6 @@ private:
   void Visit(FunctionType* 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;
 

include/find_symbols_visitor.hpp

@@ -18,9 +18,7 @@ public:
   explicit FindSymbolsVisitor(info::GlobalInfo& global_info) : global_info_(global_info) {}
 
 private:
-  //// void Visit(Node* node) override;
+   // Sources -----------------
-
-  // Sources -----------------
 
   void Visit(SourceFile* node) override;
   void Visit(Sources* node) override;
@@ -33,90 +31,93 @@ private:
   // Definitions -----------------
 
   void Visit(ImportStatement* node) override;
-  void Visit(UsageDefinition* node) override;
+  void Visit(AliasDefinitionStatement* node) override;
-  void Visit(AliasDefinition* node) override;
+  // // void Visit(VariableDefinitionStatement* node) override;
-  //// void Visit(VariableDefinition* node) override; // TODO: decide
   void Visit(FunctionDeclaration* node) override;
-  void Visit(FunctionDefinition* node) override;
+  void Visit(FunctionDefinitionStatement* node) override;
-  void Visit(AliasTypeDefinition* node) override;
+  void Visit(TypeDefinitionStatement* node) override;
-  void Visit(TypeDefinition* node) override;
+  void Visit(AbstractTypeDefinitionStatement* node) override;
-  void Visit(TypeclassDefinition* node) override;
+  void Visit(TypeclassDefinitionStatement* node) override;
 
   // Definition parts
 
-  void Visit(DefinedName* node) override;
+  // // void Visit(FunctionDefinition* node) override;
-  void Visit(DefinedAnnotatedName* node) override;
+  // // void Visit(TypeDefinition* node) override;
-  void Visit(DefinedType* node) override;
+  void Visit(AnyAnnotatedType* node) override;
-  void Visit(DefinedTypeclass* node) override;
-  void Visit(DefinitionParameter* node) override;
-  void Visit(DefinitionArgument* node) override;
 
   // Flow control -----------------
 
-  //// void Visit(MatchCase* node) override;
+  // // void Visit(MatchCase* node) override;
-  //// void Visit(Match* node) override;
+  // // void Visit(Match* node) override;
-  //// void Visit(Condition* node) override;
+  // // void Visit(Condition* node) override;
-  //// void Visit(DoWhileLoop* node) override;
+  // // void Visit(DoWhileLoop* node) override;
-  //// void Visit(WhileLoop* node) override;
+  // // void Visit(WhileLoop* node) override;
-  //// void Visit(ForLoop* node) override;
+  // // void Visit(ForLoop* node) override;
-  //// void Visit(LoopLoop* node) override;
+  // // void Visit(LoopLoop* node) override;
 
   // Statements, expressions, blocks, etc. -----------------
 
-  //// void Visit(Block* node) override;
+  // // void Visit(Block* node) override;
-  //// void Visit(ScopedStatement* node) override;
+  // //
-
+  // // void Visit(ScopedStatement* node) override;
-  //// void Visit(LoopControlExpression& node) override; // enum
 
   // Operators
 
-  //// void Visit(BinaryOperatorExpression* node) override;
+  // // void Visit(BinaryOperatorExpression* node) override;
-  //// void Visit(UnaryOperatorExpression* node) override;
+  // // void Visit(UnaryOperatorExpression* node) override;
+  // // void Visit(ReferenceExpression* node) override;
 
   // Simple Expressions
 
-  //// void Visit(FunctionCallExpression* node) override;
+  // // void Visit(FunctionCallExpression* node) override;
-  //// void Visit(TupleExpression* node) override;
+  // //
-  //// void Visit(VariantExpression* node) override;
+  // // void Visit(TupleExpression* node) override;
-  //// void Visit(ReturnExpression* node) override;
+  // // void Visit(VariantExpression* node) override;
-
+  // // void Visit(ReturnExpression* node) override;
-  // Lambda
+  // // void Visit(TypeConstructor* node) override;
-
+  // // void Visit(LambdaFunction* node) override;
-  //// void Visit(LambdaFunction* node) override;
+  // // void Visit(ArrayExpression* node) override;
+  // //
+  // // void Visit(LoopControlExpression& node) override; // enum
 
   // Name
 
-  void Visit(NameSuperExpression* node) override;
+  // // void Visit(NameExpression* node) override;
-  void Visit(NameExpression* node) override;
+  // // void Visit(TupleName* node) override;
-  void Visit(TupleName* node) override;
+  // // void Visit(VariantName* node) override;
-  void Visit(VariantName* node) override;
+  // // void Visit(AnnotatedName* node) override;
-  void Visit(AnnotatedName* node) override;
+
+  // Type, typeclass, etc. -----------------
 
   // Type
 
-  //// void Visit(TypeConstructor* node) override;
+  // // void Visit(FunctionType* node) override;
-  void Visit(TupleType* node) override;
+  // // void Visit(TupleType* node) override;
-  void Visit(VariantType* node) override;
+  // // void Visit(VariantType* node) override;
-  void Visit(AnnotatedType* node) override;
+  // // void Visit(ParametrizedType* node) override;
-  void Visit(ParametrizedType* node) override;
+  // // void Visit(TypeExpression* node) override;
-  void Visit(TypeExpression* node) override;
+  // //
+  // // void Visit(ExtendedScopedAnyType* node) override;
 
   // Typeclass
 
-  void Visit(AnnotatedTypeclass* node) override;
+  // // void Visit(ParametrizedTypeclass* node) override;
-  void Visit(ParametrizedTypeclass* node) override;
+  // // void Visit(TypeclassExpression* node) override;
-  void Visit(TypeclassExpression* node) override;
 
   // Identifiers, constants, etc. -----------------
 
-  //// void Visit(AnyIdentifier* node) override; // std::string
+  // // void Visit(ExtendedName* node) override;
+  // //
+  // // void Visit(std::string* 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(FloatNumberLiteral* node) override;
-  //// void Visit(NumberLiteral* node) override;
-  //// void Visit(StringLiteral* node) override;
-  //// void Visit(CharLiteral* node) override;
 private:
   info::GlobalInfo& global_info_;
+  bool is_in_statement = false;
   std::any current_info_;
 };
 

include/global_info.hpp

@@ -15,29 +15,22 @@ public:
     namespace_stack.push_back(&global_namespace_);
   }
 
-  template<typename T>
+  void AddImport(ImportInfo&& import_info, const std::optional<std::string>& name = std::nullopt) {
-  void AddImport(T&& import_info) {
+    if (name.has_value()) {
-    if (waiting_usage.has_value()) {
+      usages_[name.value()] = std::move(import_info);
-      usages_[waiting_usage.value()] = std::forward(import_info);
-      waiting_usage = std::nullopt;
     } else {
-      imports_.push_back(std::forward(import_info));
+      imports_.push_back(std::move(import_info));
     }
   }
 
-  void AddUsageForNextImport(const std::string& name) {
+  void AddEnterNamespace(const std::string& type,
-    if (waiting_usage.has_value()) {
+                         const std::optional<NamespaceInfo::Modifier>& modifier = std::nullopt,
-      // error
+                         const std::optional<std::string>& variable = std::nullopt) {
-    }
-    waiting_usage = name;
-  }
-
-  void AddEnterNamespace(const std::optional<std::string>& var,
-                            const std::string& type) {
     NamespaceInfo* namespace_info = &namespace_stack.back()->namespaces[type].emplace_back();
     namespace_stack.push_back(namespace_info);
 
-    namespace_info->var = var;
+    namespace_info->modifier = modifier;
+    namespace_info->variable = variable;
     namespace_info->type_name = type;
   }
 
@@ -55,36 +48,30 @@ public:
     namespace_stack.push_back(&global_namespace_);
   }
 
-  template<typename T>
   void AddFunctionDeclaration(const std::string& name,
-                              T&& function_declaration_info) {
+                              FunctionDeclarationInfo&& function_declaration_info) {
     FunctionInfo* function_info = &namespace_stack.back()->functions[name];
 
-    function_info->declaration = std::forward(function_declaration_info);
+    function_info->declaration = std::move(function_declaration_info);
   }
 
-  template<typename T>
   void AddFunctionDefinition(const std::string& name,
-                   T&& function_definition_info) {
+                   FunctionDefinitionInfo&& function_definition_info) {
     FunctionInfo* function_info = &namespace_stack.back()->functions[name];
 
-    function_info->definition = std::forward(function_definition_info);
+    function_info->definition = std::move(function_definition_info);
   }
 
-  template<typename T>
   void AddType(const std::string& type,
-               T&& type_info) {
+               TypeInfo&& type_info) {
-    &namespace_stack.back()->types[type] = std::forward(type_info);
+    namespace_stack.back()->types[type] = std::move(type_info);
   }
 
-  template<typename T>
   void AddTypeclass(const std::string& typeclass,
-                    T&& typeclass_info) {
+                    TypeclassInfo&& typeclass_info) {
-    namespace_stack.back()->typeclasses[typeclass] = std::forward(typeclass_info);
+    namespace_stack.back()->typeclasses[typeclass] = std::move(typeclass_info);
   }
 
-  // AddVar ?? // TODO: decide
-
   // FindFunction
   // FindType
 
@@ -92,7 +79,6 @@ public:
 
 private:
   std::vector<NamespaceInfo*> namespace_stack;
-  std::optional<std::string> waiting_usage;
 
   NamespaceInfo global_namespace_;
   std::vector<ImportInfo> imports_;

include/interpreter_tree.hpp

@@ -56,7 +56,12 @@ using ImportSymbol = AnyIdentifier;
 
 struct FunctionDefinition;
 struct TypeDefinition;
-struct DefinitionParameter;
+struct AnnotatedAbstractType;
+
+// TypeIdentifier <-> AbstractTypeIdentifier <-> std::string
+using AnnotatedType = AnnotatedAbstractType;
+
+using AnyAnnotatedType = AnnotatedType;
 
 // Flow control -----------------
 
@@ -168,8 +173,6 @@ using ScopedAnyName = AnyName;
 struct FunctionType;
 struct TupleType;
 struct VariantType;
-
-struct AnnotatedType;
 struct ParametrizedType;
 struct TypeExpression;
 
@@ -301,7 +304,7 @@ struct VariableDefinitionStatement {
 
 struct FunctionDeclaration {
   NameOrOperatorIdentifier name;
-  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
   std::unique_ptr<FunctionType> type;
 };
 
@@ -332,16 +335,16 @@ struct TypeclassDefinitionStatement {
 struct FunctionDefinition {
   enum { Operator, Function } modifier;
   NameOrOperatorIdentifier name;
-  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
   std::vector<ExtendedName> arguments;
 };
 
 struct TypeDefinition {
   std::unique_ptr<AnnotatedType> type;
-  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
 };
 
-struct DefinitionParameter {
+struct AnnotatedAbstractType {
   AbstractTypeIdentifier type;
   std::vector<TypeclassUsage> typeclasses;
 };
@@ -444,7 +447,7 @@ struct TypeConstructor {
 };
 
 struct LambdaFunction {
-  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
   std::vector<ExtendedName> arguments;
   Expression expression;
 };
@@ -491,11 +494,6 @@ struct VariantType {
   std::vector<std::variant<Constructor, std::unique_ptr<TupleType>>> constructors;
 };
 
-struct AnnotatedType {
-  std::unique_ptr<TypeExpression> type_expression;
-  std::vector<TypeclassUsage> annotations;
-};
-
 struct ParametrizedType {
   std::unique_ptr<TypeExpression> type_expression;
   std::vector<TypeParameter> parameters;

include/parse_token_types.hpp

@@ -32,7 +32,8 @@ const std::string TypeclassDefinitionStatement = "typeclass_definition_statement
 const std::string ImportSymbol = "import_symbol";
 const std::string FunctionDefinition = "function_definition";
 const std::string TypeDefinition = "type_definition";
-const std::string DefinitionParameter = "definition_parameter";
+const std::string AnnotatedAbstractType = "annotated_abstract_type";
+const std::string AnnotatedType = "annotated_type";
 
 // Flow control -----------------
 
@@ -91,7 +92,6 @@ const std::string ScopedAnyName = "scoped_any_name";
 const std::string FunctionType = "function_type";
 const std::string TupleType = "tuple_type";
 const std::string VariantType = "variant_type";
-const std::string AnnotatedType = "annotated_type";
 const std::string ParametrizedType = "parametrized_type";
 const std::string TypeExpression = "type_expression";
 const std::string Constructor = "constructor";

include/print_visitor.hpp

@@ -37,7 +37,7 @@ private:
 
   void Visit(FunctionDefinition* node) override;
   void Visit(TypeDefinition* node) override;
-  void Visit(DefinitionParameter* node) override;
+  void Visit(AnyAnnotatedType* node) override;
 
   // Flow control -----------------
 
@@ -88,7 +88,6 @@ private:
   void Visit(FunctionType* 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;
 

include/symbols_info.hpp

@@ -50,68 +50,46 @@ enum class BuiltInTypeInfo {
   FloatT,
 };
 
-struct TypeUsageInfo { // TODO: typeclass_expression
+struct TypeUsageInfo {
-  std::vector<std::string> param_names;
+  interpreter::tokens::ParametrizedType* node;
-  std::vector<TypeInfo*> params;
+  TypeInfo* info = nullptr;
-  std::vector<std::string> arg_names; // ??, arg expr ??
 };
 
 struct ParameterInfo {
-  std::string name;
+  std::string type;
-  std::vector<std::string> param_names; // TODO: paramaters
+  std::vector<interpreter::tokens::TypeclassUsage*> typeclass_nodes;
-  std::vector<TypeclassInfo*> param_types;
+  std::vector<TypeclassInfo*> typeclass_types;
 };
 
-struct SymbolDefinitionInfo {
+struct AbstractTypeInfo {
-  std::string name;
+  enum { Basic, Abstract } modifier;
-  std::vector<ParameterInfo> params;
+  ParameterInfo type;
-  std::vector<std::string> arg_names;
-};
-
-struct AnyTypeInfo : SymbolDefinitionInfo {
-  std::variant<std::unique_ptr<VariantTypeInfo>,
-               std::unique_ptr<TupleTypeInfo>,
-               std::unique_ptr<BuiltInTypeInfo>> info;
-};
-
-// struct VariableInfo {
-//   std::string name;
-//   std::optional<Value> value;
-//   TypeInfo* type = nullptr;
-// };
-// TODO lambda functions as value
-// TODO: decide=
-
-struct TupleTypeInfo {
-  std::optional<std::string> name;
-  std::vector<std::pair<std::optional<std::string>, AnyTypeInfo>> fields;
-};
-
-struct VariantTypeInfo {
-  std::optional<std::string> name;
-  std::vector<std::variant<std::string, TupleTypeInfo>> constructors;
-  // ?? any type instead of tuple type ??
 };
 
 struct AliasTypeInfo {
-  std::vector<std::string> params;
+  enum {Alias, Type, Let} modifier;
-  bool isAnotherType;
+  std::vector<std::string> parameters;
   TypeUsageInfo value;
 };
 
-struct  TypeInfo { std::variant<AliasTypeInfo, AnyTypeInfo> type; };
+struct AnyTypeInfo {
-
+  ParameterInfo type;
-// struct PointerInfo { // ??
+  std::vector<ParameterInfo> parameters;
-//   VariableInfo* variable;
+  interpreter::tokens::AnyType* value;
-// };
-
-struct FunctionDeclarationInfo {
-  std::vector<ParameterInfo> params;
-  std::vector<TypeUsageInfo> arg_types;
 };
 
-struct FunctionDefinitionInfo : SymbolDefinitionInfo {
+struct  TypeInfo { std::variant<AbstractTypeInfo, AliasTypeInfo, AnyTypeInfo> type; };
-  interpreter::tokens::SuperExpression* expression;
+
+struct FunctionDeclarationInfo {
+  std::vector<ParameterInfo> parameters;
+  std::vector<interpreter::tokens::AnyType*> argument_type_nodes;
+  std::vector<AnyTypeInfo*> argument_types;
+};
+
+struct FunctionDefinitionInfo {
+  std::vector<ParameterInfo> parameters;
+  std::vector<std::string> argument_names;
+  interpreter::tokens::SuperExpression* expression = nullptr;
 };
 
 struct FunctionInfo {
@@ -119,7 +97,8 @@ struct FunctionInfo {
   FunctionDefinitionInfo definition;
 };
 
-struct TypeclassInfo : SymbolDefinitionInfo {
+struct TypeclassInfo {
+  std::vector<ParameterInfo> parameters;
   std::vector<FunctionDeclarationInfo> requirements;
 };
 
@@ -129,18 +108,17 @@ struct ImportInfo {
 };
 
 struct NamespaceInfo {
+  enum Modifier { Const, Var };
+
   std::unordered_map<std::string, TypeInfo> types;
   std::unordered_map<std::string, TypeclassInfo> typeclasses;
-  // std::unordered_map<std::string, VariableInfo> variables; // TODO
   std::unordered_map<std::string, FunctionInfo> functions;
   std::unordered_map<std::string, std::vector<NamespaceInfo>> namespaces;
-  std::optional<std::string> var;
+
+  std::optional<Modifier> modifier;
+  std::optional<std::string> variable;
   std::string type_name;
   TypeInfo* type_info = nullptr;
 };
 
-using AnyTypeVariant = std::variant<VariantTypeInfo,
-                                    TupleTypeInfo,
-                                    BuiltInTypeInfo>;
-
 } // namespace info

include/visitor.hpp

@@ -41,7 +41,7 @@ protected:
 
   virtual void Visit(FunctionDefinition* node) {}
   virtual void Visit(TypeDefinition* node) {}
-  virtual void Visit(DefinitionParameter* node) {}
+  virtual void Visit(AnyAnnotatedType* node) {}
 
   // Flow control -----------------
 
@@ -106,7 +106,6 @@ protected:
   virtual void Visit(FunctionType* node) {}
   virtual void Visit(TupleType* node) {}
   virtual void Visit(VariantType* node) {}
-  virtual void Visit(AnnotatedType* node) {}
   virtual void Visit(ParametrizedType* node) {}
   virtual void Visit(TypeExpression* node) {}
 

src/build_visitor.cpp

@@ -200,7 +200,7 @@ void BuildVisitor::Visit(FunctionDeclaration* node) {
 
   for (size_t i = 0; i + 2 < child_count; ++i) {
       current_node_ = parse_node.NthNamedChild(i + 1);
-      node->parameters.push_back(std::make_unique<DefinitionParameter>());
+      node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
       Visit(node->parameters.back().get());
   }
 
@@ -346,12 +346,12 @@ void BuildVisitor::Visit(FunctionDefinition* node) {
     for (size_t i = 0; i + 1 < child_count; ++i) {
       current_node_ = parse_node.NthNamedChild(i + 1);
 
-      if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
+      if (current_node_.GetType() != parser::tokens::AnnotatedAbstractType) {
         parameters_ended = true;
       }
 
       if (!parameters_ended) {
-        node->parameters.push_back(std::make_unique<DefinitionParameter>());
+        node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
         Visit(node->parameters.back().get());
       } else {
         node->arguments.emplace_back();
@@ -375,7 +375,7 @@ void BuildVisitor::Visit(TypeDefinition* node) {
   if (child_count > 1) {
     for (size_t i = 0; i + 1 < child_count; ++i) {
       current_node_ = parse_node.NthNamedChild(i + 1);
-      node->parameters.push_back(std::make_unique<DefinitionParameter>());
+      node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
       Visit(node->parameters.back().get());
     }
   }
@@ -383,7 +383,7 @@ void BuildVisitor::Visit(TypeDefinition* node) {
   current_node_ = parse_node;
 }
 
-void BuildVisitor::Visit(DefinitionParameter* node) {
+void BuildVisitor::Visit(AnyAnnotatedType* node) {
   auto parse_node = current_node_;
 
   node->type = parse_node.ChildByFieldName("type").GetValue();
@@ -904,12 +904,12 @@ void BuildVisitor::Visit(LambdaFunction* node) {
     for (size_t i = 0; i + 1 < child_count; ++i) {
       current_node_ = parse_node.NthNamedChild(i);
 
-      if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
+      if (current_node_.GetType() != parser::tokens::AnnotatedAbstractType) {
         parameters_ended = true;
       }
 
       if (!parameters_ended) {
-        node->parameters.push_back(std::make_unique<DefinitionParameter>());
+        node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
         Visit(node->parameters.back().get());
       } else {
         node->arguments.emplace_back();
@@ -1155,27 +1155,6 @@ void BuildVisitor::Visit(VariantType* node) {
   current_node_ = parse_node;
 }
 
-void BuildVisitor::Visit(AnnotatedType* node) {
-  auto parse_node = current_node_;
-
-  current_node_ = parse_node.ChildByFieldName("type_expression");
-  node->type_expression = std::make_unique<TypeExpression>();
-  Visit(node->type_expression.get());
-
-  size_t child_count = parse_node.NamedChildCount();
-
-  if (child_count > 1) {
-    node->annotations.resize(child_count - 1);
-
-    for (size_t i = 0; i + 1 < child_count; ++i) {
-      current_node_ = parse_node.NthNamedChild(i + 1);
-      Visit(node->annotations[i]);
-    }
-  }
-
-  current_node_ = parse_node;
-}
-
 void BuildVisitor::Visit(ParametrizedType* node) {
   auto parse_node = current_node_;
 

src/find_symbols_visitor.cpp

@@ -30,19 +30,24 @@ void FindSymbolsVisitor::Visit(Partition* node) {
 }
 
 void FindSymbolsVisitor::Visit(Namespace* node) {
-  if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
+  std::optional<info::NamespaceInfo::Modifier> modifier;
-    Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
+  if (node->modifier.has_value()) {
-    auto info = std::move(std::any_cast<std::pair<std::string, std::string>>(current_info_));
+    switch (node->modifier.value()) {
-    global_info_.AddEnterNamespace(info.first, info.second);
+      case interpreter::Namespace::Var:
-    current_info_.reset();
+        modifier = info::NamespaceInfo::Var;
-  } else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
+        break;
-    Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
+      case interpreter::Namespace::Const:
-    auto info = std::move(std::any_cast<std::string>(current_info_));
+        modifier = info::NamespaceInfo::Const;
-    global_info_.AddEnterNamespace(std::nullopt, info);
+        break;
-    current_info_.reset();
+    }
-  } else {
-    // error
   }
+
+  std::optional<std::string> name;
+  if (node->name.has_value()) {
+    name = node->name.value().name;
+  }
+
+  global_info_.AddEnterNamespace(node->type, modifier, name);
   Visit(node->scope.get());
   global_info_.ExitNamespace();
 }
@@ -50,408 +55,197 @@ void FindSymbolsVisitor::Visit(Namespace* node) {
 // Definitions -----------------
 
 void FindSymbolsVisitor::Visit(ImportStatement* node) {
+  is_in_statement = true;
+
   info::ImportInfo info;
   info.module_name = node->module_name;
-  for (auto& symbol : node->symbols) {
+  info.symbols = node->symbols;
-    Visitor::Visit(symbol);
+  global_info_.AddImport(std::move(info), node->name);
-    info.symbols.push_back(std::move(std::any_cast<std::string>(current_info_))); // TODO: expressions
-  }
-  global_info_.AddImport(std::move(info));
-  // TODO: what if inside usage definition, global_info_.AddImport(std::move(info));
-}
 
-void FindSymbolsVisitor::Visit(UsageDefinition* node) {
+  is_in_statement = false;
-  global_info_.AddUsageForNextImport(node->name);
-  Visit(node->import_statement.get());
 }
 
 // <-- current position
 
-void FindSymbolsVisitor::Visit(AliasDefinition* node) {
+void FindSymbolsVisitor::Visit(AliasDefinitionStatement* node) {
+  is_in_statement = true;
+
   info::TypeInfo info;
 
-  Visit(node->type.get());
-  auto type_info = std::move(
-    std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
-  current_info_.reset();
-
-  Visit(node->value.get());
-  auto value_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
-  current_info_.reset();
-
   info::AliasTypeInfo alias_info;
-  alias_info.isAnotherType = false;
+
-  alias_info.params = std::move(type_info.second);
+  switch (node->modifier) {
-  alias_info.value = std::move(value_info);
+    case interpreter::AliasDefinitionStatement::Alias:
+      alias_info.modifier = info::AliasTypeInfo::Alias;
+      break;
+    case interpreter::AliasDefinitionStatement::Type:
+      alias_info.modifier = info::AliasTypeInfo::Type;
+      break;
+    case interpreter::AliasDefinitionStatement::Let:
+      alias_info.modifier = info::AliasTypeInfo::Let;
+      break;
+  }
+  alias_info.parameters = node->parameters;
+  alias_info.value.node = node->value.get();
+
   info.type = std::move(alias_info);
 
-  global_info_.AddType(type_info.first, info);
+  global_info_.AddType(node->type, std::move(info));
-}
 
-// void FindSymbolsVisitor::Visit(VariableDefinition* node) { // TODO: decide
+  is_in_statement = false;
-//   out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
+}
-//   Visit(&node->name);
-//   out_ << " = ";
-//   Visitor::Visit(node->value);
-//   out_ << ")\n";
-// }
 
 void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
+  bool was_in_statement = is_in_statement;
+  is_in_statement = true;
+
   info::FunctionDeclarationInfo info;
-  for (auto& parameter : node->parameters) {
+
-    Visit(parameter.get());
+  info.parameters.resize(node->parameters.size());
-    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
+  for (size_t i = 0; i < node->parameters.size(); ++i) {
+    Visit(node->parameters[i].get());
+    info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
     current_info_.reset();
-    info.params.push_back(std::move(param_info));
   }
-  for (auto& argument_type : node->argument_types) {
+
-    Visitor::Visit(argument_type);
+  info.argument_types.resize(node->type->types.size());
-    auto type_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
+  for (size_t i = 0; i < node->type->types.size(); ++i) {
-    current_info_.reset();
+    info.argument_type_nodes[i] = &node->type->types[i];
-    info.arg_types.push_back(std::move(type_info));
+  }
+
+  if (was_in_statement) {
+    current_info_ = std::move(info);
+  } else {
+    global_info_.AddFunctionDeclaration(node->name, std::move(info));
+    is_in_statement = false;
   }
-  global_info_.AddFunctionDeclaration(node->name, std::move(info));
 }
 
-void FindSymbolsVisitor::Visit(FunctionDefinition* node) {
+void FindSymbolsVisitor::Visit(FunctionDefinitionStatement* node) {
+  is_in_statement = true;
+
   info::FunctionDefinitionInfo info;
 
-  Visit(node->name.get());
+  auto definition = node->definition.get();
-  auto name_info = std::move(
+
-    std::any_cast<info::SymbolDefinitionInfo>(current_info_));
+  info.parameters.resize(definition->parameters.size());
-  current_info_.reset();
+  for (size_t i = 0; i < definition->parameters.size(); ++i) {
+    Visit(definition->parameters[i].get());
+    info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
+    current_info_.reset();
+  }
+
+  info.argument_names.resize(definition->arguments.size());
+  for (size_t i = 0; i < definition->arguments.size(); ++i) {
+    info.argument_names[i] = definition->arguments[i].name;
+  }
 
-  info.params = std::move(name_info.params);
-  info.arg_names = std::move(name_info.arg_names);
   info.expression = &node->value;
 
-  global_info_.AddFunctionDefinition(name_info.name, std::move(info));
+  global_info_.AddFunctionDefinition(definition->name, std::move(info));
+
+  is_in_statement = false;
 }
 
-void FindSymbolsVisitor::Visit(AliasTypeDefinition* node) { // TODO: unite with AliasDefinition
+void FindSymbolsVisitor::Visit(TypeDefinitionStatement* node) {
+  is_in_statement = true;
+
   info::TypeInfo info;
 
-  Visit(node->type.get());
+  auto definition = node->definition.get();
-  auto type_info = std::move(
-    std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
-  current_info_.reset();
-
-  Visit(node->value.get());
-  auto value_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
-  current_info_.reset();
-
-  info::AliasTypeInfo alias_info;
-  alias_info.isAnotherType = true;
-  alias_info.params = std::move(type_info.second);
-  alias_info.value = std::move(value_info);
-
-  info.type = std::move(alias_info);
-
-  global_info_.AddType(type_info.first, std::move(info));
-}
-
-void FindSymbolsVisitor::Visit(TypeDefinition* node) {
-  info::TypeInfo info;
-
-  Visit(node->type.get());
-  auto type_info = std::move(
-    std::any_cast<info::SymbolDefinitionInfo>(current_info_));
-  current_info_.reset();
-
-  Visitor::Visit(node->value);
-  auto value_info = std::move(std::any_cast<info::AnyTypeVariant>(current_info_));
-  current_info_.reset();
 
   info::AnyTypeInfo any_type_info;
-  any_type_info.params = std::move(type_info.params);
-  any_type_info.arg_names = std::move(type_info.arg_names);
 
-  switch (value_info.index()) {
+  Visit(definition->type.get());
-    case 0:
+  any_type_info.type = std::move(std::any_cast<info::ParameterInfo>(current_info_));
-      any_type_info.info =
+  current_info_.reset();
-        std::make_unique<info::VariantTypeInfo>(
+
-          std::move(std::get<info::VariantTypeInfo>(value_info)));
+  any_type_info.parameters.resize(definition->parameters.size());
-      break;
+  for (size_t i = 0; i < definition->parameters.size(); ++i) {
-    case 1:
+    Visit(definition->parameters[i].get());
-      any_type_info.info =
+    any_type_info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
-        std::make_unique<info::TupleTypeInfo>(
+    current_info_.reset();
-          std::move(std::get<info::TupleTypeInfo>(value_info)));
-      break;
-    case 2:
-      any_type_info.info =
-        std::make_unique<info::BuiltInTypeInfo>(
-          std::move(std::get<info::BuiltInTypeInfo>(value_info)));
-      break;
-    default:
-      // error
-      break;
   }
 
+  any_type_info.value = &node->value;
+
+  std::string type = any_type_info.type.type;
+
   info.type = std::move(any_type_info);
 
-  global_info_.AddType(type_info.name, std::move(info));
+  global_info_.AddType(type, std::move(info));
+
+  is_in_statement = false;
 }
 
-void FindSymbolsVisitor::Visit(TypeclassDefinition* node) {
+void FindSymbolsVisitor::Visit(AbstractTypeDefinitionStatement* node) {
-  info::TypeclassInfo info;
+  is_in_statement = true;
 
-  Visit(node->typeclass.get());
+  info::TypeInfo info;
-  auto typeclass_info = std::move(
+
-    std::any_cast<info::SymbolDefinitionInfo>(current_info_));
+  info::AbstractTypeInfo abstract_type_info;
+
+  Visit(node->type.get());
+  abstract_type_info.type = std::move(std::any_cast<info::ParameterInfo>(current_info_));
   current_info_.reset();
-  info.params = std::move(typeclass_info.params);
-  info.arg_names = std::move(typeclass_info.arg_names);
 
-  for (auto& requirement : node->requirements) {
+  switch (node->modifier) {
-    Visit(requirement.get());
+    case interpreter::AbstractTypeDefinitionStatement::Basic:
-    auto requrement_info = std::move(std::any_cast<info::FunctionDeclarationInfo>(current_info_));
+      abstract_type_info.modifier = info::AbstractTypeInfo::Basic;
-    current_info_.reset();
+      break;
-    info.requirements.push_back(std::move(requrement_info));
+    case interpreter::AbstractTypeDefinitionStatement::Abstract:
+      abstract_type_info.modifier = info::AbstractTypeInfo::Abstract;
+      break;
   }
 
-  global_info_.AddTypeclass(typeclass_info.name, std::move(info));
+  std::string type = abstract_type_info.type.type;
+
+  info.type = std::move(abstract_type_info);
+
+  global_info_.AddType(type, std::move(info));
+
+  is_in_statement = false;
+}
+
+void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
+  is_in_statement = true;
+
+  info::TypeclassInfo info;
+
+  auto definition = node->definition.get();
+
+  info.parameters.resize(definition->parameters.size());
+  for (size_t i = 0; i < definition->parameters.size(); ++i) {
+    Visit(definition->parameters[i].get());
+    info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
+    current_info_.reset();
+  }
+
+  info.requirements.reserve(node->requirements.size());
+  for (size_t i = 0; i < node->requirements.size(); ++i) {
+    Visit(node->requirements[i].get());
+    info.requirements[i] = std::move(std::any_cast<info::FunctionDeclarationInfo>(current_info_));
+    current_info_.reset();
+  }
+
+  global_info_.AddTypeclass(definition->type.get()->type, std::move(info));
+
+  is_in_statement = false;
 }
 
 // Definition parts
 
-void FindSymbolsVisitor::Visit(DefinedName* node) {
+void FindSymbolsVisitor::Visit(AnyAnnotatedType* node) {
-  info::SymbolDefinitionInfo info;
-
-  info.name = node->name;
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
-    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
-    current_info_.reset();
-    info.params.push_back(std::move(param_info));
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-    auto argument_info = std::move(std::any_cast<std::string>(current_info_));
-    current_info_.reset();
-    info.arg_names.push_back(std::move(argument_info));
-  }
-
-  current_info_ = std::move(info);
-}
-
-void FindSymbolsVisitor::Visit(DefinedAnnotatedName* node) { // TODO: remove
-  // Visit(&node->name);
-  if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
-    Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
-  } else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
-    Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
-  } else {
-    // no annotation
-  }
-}
-
-void FindSymbolsVisitor::Visit(DefinedType* node) {
-  info::SymbolDefinitionInfo info;
-
-  Visit(node->type.get());
-  info.name = /*...*/; // TODO
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
-    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
-    current_info_.reset();
-    info.params.push_back(std::move(param_info));
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-    auto argument_info = std::move(std::any_cast<std::string>(current_info_));
-    current_info_.reset();
-    info.arg_names.push_back(std::move(argument_info));
-  }
-
-  current_info_ = std::move(info);
-}
-
-void FindSymbolsVisitor::Visit(DefinedTypeclass* node) {
-  info::SymbolDefinitionInfo info;
-
-  Visit(node->typeclass.get());
-  info.name = /*...*/; // TODO
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
-    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
-    current_info_.reset();
-    info.params.push_back(std::move(param_info));
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-    auto argument_info = std::move(std::any_cast<std::string>(current_info_));
-    current_info_.reset();
-    info.arg_names.push_back(std::move(argument_info));
-  }
-
-  current_info_ = std::move(info);
-}
-
-void FindSymbolsVisitor::Visit(DefinitionParameter* node) {
   info::ParameterInfo info;
 
-  info.name = node->type;
+  info.type = node->type;
-  for (auto& typeclass : node->typeclasses) {
+
-    Visit(typeclass.get());
+  info.typeclass_nodes.resize(node->typeclasses.size());
-    auto typeclass_info = std::move(std::any_cast</*...*/>(current_info_));
+  for (size_t i = 0; i < node->typeclasses.size(); ++i) {
-    current_info_.reset();
+    info.typeclass_nodes[i] = &node->typeclasses[i];
-    info.param_names.push_back(std::move(typeclass_info));
   }
 
   current_info_ = std::move(info);
 }
 
-void FindSymbolsVisitor::Visit(DefinitionArgument* node) {
-  std::string info; // TODO: add type
-
-  info = node->name;
-
-  // for (auto& type : node->types) {
-  //   Visit(type.get());
-  //   auto argument_info = std::move(std::any_cast<std::string>(current_info_));
-  //   current_info_.reset();
-  //   info.types.push_back(std::move(argument_info));
-  // }
-
-  current_info_ = std::move(info);
-}
-
-// Statements, expressions, blocks, etc. -----------------
-
-// Name
-
-// void FindSymbolsVisitor::Visit(NameSuperExpression* node) {
-//   for (auto& variable_namespace : node->namespaces) {
-//     Visitor::Visit(variable_namespace);
-//   }
-//   for (size_t i = 0; i < node->expressions.size(); ++i) {
-//     Visitor::Visit(node->expressions[i]);
-//     if (i + 1 < node->expressions.size()) {
-//     }
-//   }
-// }
-//
-// void FindSymbolsVisitor::Visit(NameExpression* node) {
-//   for (auto& variable_namespace : node->namespaces) {
-//     Visitor::Visit(variable_namespace);
-//   }
-//   for (size_t i = 0; i < node->names.size(); ++i) {
-//     Visit(&node->names[i]);
-//     if (i + 1 < node->names.size()) {
-//     }
-//   }
-// }
-//
-// void FindSymbolsVisitor::Visit(TupleName* node) {
-//   for (auto& name : node->names) {
-//     Visit(name.get());
-//   }
-// }
-//
-// void FindSymbolsVisitor::Visit(VariantName* node) {
-//   for (auto& name : node->names) {
-//     Visit(name.get());
-//   }
-// }
-//
-// void FindSymbolsVisitor::Visit(AnnotatedName* node) {
-//   Visit(&node->name);
-//   if (node->type.has_value()) {
-//     Visit(node->type.value().get());
-//   }
-// }
-
-// Type
-
-void FindSymbolsVisitor::Visit(TupleType* node) {
-  info::TupleTypeInfo info;
-
-  if (node->type.has_value()) {
-    info.name = node->type.value();
-  }
-  for (auto& entity : node->entities) {
-    info.fields.emplace_back();
-    if (entity.first.has_value()) {
-      info.fields.back().first = entity.first.value();
-    }
-    Visitor::Visit(entity.second);
-    auto entity_type_info = std::move(std::any_cast<info::AnyTypeInfo>(current_info_));
-    current_info_.reset();
-    info.fields.back().second = std::move(entity_type_info);
-
-  }
-
-  current_info_ = info::AnyTypeVariant(std::move(info));
-}
-
-void FindSymbolsVisitor::Visit(VariantType* node) {
-  info::VariantTypeInfo info;
-
-  if (node->type.has_value()) {
-    info.name = node->type.value();ParametrizedType
-  }
-  for (auto& constructor : node->constructors) {
-    if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
-      info.constructors.push_back(std::get<TypeIdentifierDefinition>(constructor));
-    } else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
-      Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
-      auto constructor_tuple_info = std::move(std::any_cast<info::TupleTypeInfo>(current_info_));
-      current_info_.reset();
-      info.constructors.push_back(std::move(constructor_tuple_info));
-    } else {
-      // error
-    }
-  }
-
-  current_info_ = info::AnyTypeVariant(std::move(info));
-}
-
-void FindSymbolsVisitor::Visit(AnnotatedType* node) {
-  Visit(node->type_expression.get());
-  if (!node->annotations.empty()) {
-  }
-  for (auto& annotation : node->annotations) {
-    Visit(annotation.get());
-  }
-}
-
-void FindSymbolsVisitor::Visit(ParametrizedType* node) {
-  Visit(node->type_expression.get());
-  for (auto& parameter : node->parameters) {
-    Visitor::Visit(parameter);
-  }
-}
-
-void FindSymbolsVisitor::Visit(TypeExpression* node) {
-  for (auto& type_namespace : node->namespaces) {
-    Visitor::Visit(type_namespace);
-  }
-  Visit(&node->type);
-}
-
-// Typeclass
-
-void FindSymbolsVisitor::Visit(AnnotatedTypeclass* node) {
-  Visit(node->typeclass_expression.get());
-  if (!node->annotations.empty()) {
-  }
-  for (auto& annotation : node->annotations) {
-    Visit(annotation.get());
-  }
-}
-
-void FindSymbolsVisitor::Visit(ParametrizedTypeclass* node) {
-  Visit(node->typeclass_expression.get());
-  for (auto& paramater : node->parameters) {
-    Visitor::Visit(paramater);
-  }
-}
-
-void FindSymbolsVisitor::Visit(TypeclassExpression* node) {
-  for (auto& typeclass_namespace : node->namespaces) {
-    Visitor::Visit(typeclass_namespace);
-  }
-  Visit(&node->typeclass);
-}
-
 } // namespace interpreter

src/print_visitor.cpp

@@ -247,8 +247,8 @@ void PrintVisitor::Visit(TypeDefinition* node) {
   out_ << ' ';
 }
 
-void PrintVisitor::Visit(DefinitionParameter* node) {
+void PrintVisitor::Visit(AnyAnnotatedType* node) {
-  out_ << "[DefinitionParameter ";
+  out_ << "[Annotated (Abstract) Type ";
   Visit(&node->type);
   out_ << ']';
   if (!node->typeclasses.empty() > 0) {
@@ -590,19 +590,6 @@ void PrintVisitor::Visit(VariantType* node) {
   out_ << ')';
 }
 
-void PrintVisitor::Visit(AnnotatedType* node) {
-  out_ << "[AnnotatedType ";
-  Visit(node->type_expression.get());
-  out_ << ']';
-  if (!node->annotations.empty()) {
-    out_ << " : (";
-    for (auto& annotation : node->annotations) {
-      Visitor::Visit(annotation);
-    }
-    out_ << ')';
-  }
-}
-
 void PrintVisitor::Visit(ParametrizedType* node) {
   out_ << "[ParametrizedType] (";
   Visit(node->type_expression.get());