part of find_symbols_visitor done

src/build_visitor.cpp

@@ -24,7 +24,7 @@ void BuildVisitor::Visit(SourceFile* node) {
         Visit(std::get<SourceStatement>(node->statements[i]));
       } else if (current_node_type == parser::tokens::Partition) {
         node->statements[i].emplace<Partition>();
-        Visit(&std::get<Partition>(node->statements[i]));
+        Visit(&std::get<Partition>(node->statements[i]) );
       }
   }
 
@@ -1174,27 +1174,27 @@ void BuildVisitor::Visit(AnyName& node) {
 // Type
 
 void BuildVisitor::Visit(TypeConstructor* node) {
-  auto parse_node = current_node_;
-
-  current_node_ = parse_node.ChildByFieldName("type");
-  node->type = std::make_unique<ParametrizedType>();
-  Visit(node->type.get());
-
-  size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2;
-
-  node->parameters.resize(parameter_count);
-
-  for (size_t i = 0; i < parameter_count * 2; ++i) {
-    current_node_ = parse_node.NthNamedChild(i + 1);
-
-    if (i % 2 == 0) {
-      node->parameters[i / 2].first = current_node_.GetValue();
-    } else {
-      Visit(node->parameters[i / 2].second);
-    }
-  }
-
-  current_node_ = parse_node;
+  // auto parse_node = current_node_;
+  //
+  // current_node_ = parse_node.ChildByFieldName("type");
+  // node->type = std::make_unique<ParametrizedType>();
+  // Visit(node->type.get());
+  //
+  // size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2;
+  //
+  // node->parameters.resize(parameter_count);
+  //
+  // for (size_t i = 0; i < parameter_count * 2; ++i) {
+  //   current_node_ = parse_node.NthNamedChild(i + 1);
+  //
+  //   if (i % 2 == 0) {
+  //     node->parameters[i / 2].first = current_node_.GetValue();
+  //   } else {
+  //     Visit(node->parameters[i / 2].second);
+  //   }
+  // }
+  //
+  // current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(TupleType* node) {
@@ -1538,8 +1538,8 @@ void BuildVisitor::Visit(NameSubSuperExpression& node) {
   std::string current_node_type = current_node_.GetType();
 
   if (current_node_type == parser::tokens::NameIdentifier) { // optimize ??
-    // TODO: choose : node = std::make_unique<NameIdentifier>(current_node_.GetValue());
-    Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());
+    node = std::make_unique<NameIdentifier>(current_node_.GetValue());
+    //Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());
   } else if (current_node_type == parser::tokens::Literal) {
     node = std::make_unique<Literal>();
     Visit(*std::get<std::unique_ptr<Literal>>(node));

src/find_symbols_visitor.cpp

@@ -0,0 +1,492 @@
+// for clangd
+#include "../include/find_symbols_visitor.hpp"
+
+namespace interpreter {
+
+// Sources -----------------
+void FindSymbolsVisitor::Visit(SourceFile* node) {
+  for (auto& statement : node->statements) {
+    if (std::holds_alternative<Partition>(statement)) {
+      Visit(&std::get<Partition>(statement));
+    } else if (std::holds_alternative<SourceStatement>(statement)) {
+      Visitor::Visit(std::get<SourceStatement>(statement));
+    } else {
+      // error
+    }
+  }
+}
+
+void FindSymbolsVisitor::Visit(Sources* node) {
+  for (auto& statement : node->statements) {
+    Visitor::Visit(statement);
+  }
+}
+
+// Namespaces, partitions -----------------
+
+void FindSymbolsVisitor::Visit(Partition* node) {
+  // TODO
+  Visit(node->scope.get());
+}
+
+void FindSymbolsVisitor::Visit(Namespace* node) {
+  if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
+    Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
+    auto info = std::move(std::any_cast<std::pair<std::string, std::string>>(current_info_));
+    global_info_.AddEnterNamespace(info.first, info.second);
+    current_info_.reset();
+  } else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
+    Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
+    auto info = std::move(std::any_cast<std::string>(current_info_));
+    global_info_.AddEnterNamespace(std::nullopt, info);
+    current_info_.reset();
+  } else {
+    // error
+  }
+  Visit(node->scope.get());
+  global_info_.ExitNamespace();
+}
+
+// Definitions -----------------
+
+void FindSymbolsVisitor::Visit(ImportStatement* node) {
+  info::ImportInfo info;
+  info.module_name = node->module_name;
+  for (auto& symbol : node->symbols) {
+    Visitor::Visit(symbol);
+    info.symbols.push_back(std::move(std::any_cast<std::string>(current_info_)));
+  }
+  global_info_.AddImport(std::move(info));
+  // TODO: what if inside usage definition, global_info_.AddImport(std::move(info));
+}
+
+void FindSymbolsVisitor::Visit(UsageDefinition* node) {
+  global_info_.AddUsageForNextImport(node->name);
+  Visit(node->import_statement.get());
+}
+
+// <-- current position
+
+void FindSymbolsVisitor::Visit(AliasDefinition* node) {
+  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);
+  alias_info.value = std::move(value_info);
+  info.type = std::move(alias_info);
+
+  global_info_.AddType(type_info.first, info);
+}
+
+// void FindSymbolsVisitor::Visit(VariableDefinition* node) { // TODO: decide
+//   out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
+//   Visit(&node->name);
+//   out_ << " = ";
+//   Visitor::Visit(node->value);
+//   out_ << ")\n";
+// }
+
+void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
+  info::FunctionDeclarationInfo info;
+  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_type : node->argument_types) {
+    Visitor::Visit(argument_type);
+    auto type_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
+    current_info_.reset();
+    info.arg_types.push_back(std::move(type_info));
+  }
+  global_info_.AddFunctionDeclaration(node->name, std::move(info));
+}
+
+void FindSymbolsVisitor::Visit(FunctionDefinition* node) {
+  info::FunctionDefinitionInfo info;
+
+  Visit(node->name.get());
+  auto name_info = std::move(
+    std::any_cast<std::pair<std::string,
+                            std::pair<std::vector<info::ParameterInfo>,
+                                      std::vector<std::string>>>>(current_info_));
+  current_info_.reset();
+
+  info.params = std::move(name_info.second.first);
+  info.arg_names = std::move(name_info.second.second);
+  info.expression = &node->value;
+
+  global_info_.AddFunctionDefinition(name_info.first, std::move(info));
+}
+
+void FindSymbolsVisitor::Visit(AliasTypeDefinition* node) { // TODO: unite with AliasDefinition
+  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 = 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<std::pair<std::string,
+                            std::pair<std::vector<info::ParameterInfo>,
+                                      std::vector<std::string>>>>(current_info_));
+  current_info_.reset();
+
+  Visitor::Visit(node->value);
+  auto value_info = std::move(std::any_cast<std::variant<info::VariantTypeInfo,
+                                                         info::TupleTypeInfo,
+                                                         info::BuiltInTypeInfo>>(current_info_));
+  current_info_.reset();
+
+  info::AnyTypeInfo any_type_info;
+  any_type_info.params = std::move(type_info.second.first);
+  any_type_info.arg_names = std::move(type_info.second.second);
+
+  switch (value_info.index()) {
+    case 0:
+      any_type_info.info =
+        std::make_unique<info::VariantTypeInfo>(
+          std::move(std::get<info::VariantTypeInfo>(value_info)));
+      break;
+    case 1:
+      any_type_info.info =
+        std::make_unique<info::TupleTypeInfo>(
+          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;
+  }
+
+  info.type = std::move(any_type_info);
+
+  global_info_.AddType(type_info.first, std::move(info));
+}
+
+void FindSymbolsVisitor::Visit(TypeclassDefinition* node) {
+  info::TypeclassInfo info;
+
+  Visit(node->typeclass.get());
+  auto typeclass_info = std::move(
+    std::any_cast<std::pair<std::string,
+                            std::pair<std::vector<info::ParameterInfo>,
+                                      std::vector<std::string>>>>(current_info_));
+  current_info_.reset();
+  info.params = std::move(typeclass_info.second.first);
+  info.arg_names = std::move(typeclass_info.second.second);
+
+  for (auto& requirement : node->requirements) {
+    Visit(requirement.get());
+    auto requrement_info = std::move(std::any_cast<info::FunctionDeclarationInfo>(current_info_));
+    current_info_.reset();
+    info.requirements.push_back(std::move(requrement_info));
+  }
+
+  global_info_.AddTypeclass(typeclass_info.first, std::move(info));
+}
+
+// Definition parts
+
+void FindSymbolsVisitor::Visit(DefinedName* node) {
+  out_ << "(DefinedName ";
+  Visit(&node->name);
+  if (!node->parameters.empty()) {
+    out_ << "\n";
+  }
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (!node->arguments.empty()) {
+    out_ << " : \n";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(DefinedAnnotatedName* node) {
+  out_ << "(DefinedAnnotatedName ";
+  Visit(&node->name);
+  out_ << " : ";
+  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
+  }
+  out_ << " )";
+}
+
+void FindSymbolsVisitor::Visit(DefinedType* node) {
+  out_ << "(DefinedType ";
+  Visit(node->type.get());
+  if (!node->parameters.empty()) {
+    out_ << "\n";
+  }
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (!node->arguments.empty()) {
+    out_ << " : \n";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(DefinedTypeclass* node) {
+  out_ << "(DefinedTypeclass ";
+  Visit(node->typeclass.get());
+  if (!node->parameters.empty()) {
+    out_ << "\n";
+  }
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (!node->arguments.empty()) {
+    out_ << " : \n";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(DefinitionParameter* node) {
+  out_ << "(DefinitionParameter " << (!node->typeclasses.empty() > 0 ? "(" : "");
+  Visit(&node->type);
+  out_ << ' ';
+  for (auto& typeclass : node->typeclasses) {
+    Visit(typeclass.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(DefinitionArgument* node) {
+  out_ << "(DefinitionArgument " << (!node->types.empty() ? "(" : "");
+  Visit(&node->name);
+  out_ << ' ';
+  for (auto& type : node->types) {
+    Visit(type.get());
+  }
+  out_ << ")";
+}
+
+// Statements, expressions, blocks, etc. -----------------
+
+// Name
+
+void FindSymbolsVisitor::Visit(NameSuperExpression* node) {
+  out_ << "(NameSuperExpression ";
+  for (auto& variable_namespace : node->namespaces) {
+    Visitor::Visit(variable_namespace);
+    out_ << '.';
+  }
+  for (size_t i = 0; i < node->expressions.size(); ++i) {
+    Visitor::Visit(node->expressions[i]);
+    if (i + 1 < node->expressions.size()) {
+      out_ << '.';
+    }
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(NameExpression* node) {
+  out_ << "(NameExpression ";
+  for (auto& variable_namespace : node->namespaces) {
+    Visitor::Visit(variable_namespace);
+    out_ << '.';
+  }
+  for (size_t i = 0; i < node->names.size(); ++i) {
+    Visit(&node->names[i]);
+    if (i + 1 < node->names.size()) {
+      out_ << '.';
+    }
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(TupleName* node) {
+  out_ << "(TupleName ";
+  for (auto& name : node->names) {
+    out_ << '&';
+    Visit(name.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(VariantName* node) {
+  out_ << "(VariantName ";
+  for (auto& name : node->names) {
+    out_ << '|';
+    Visit(name.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(AnnotatedName* node) {
+  out_ << "(AnnotatedName ";
+  Visit(&node->name);
+  if (node->type.has_value()) {
+    out_ << " : ";
+    Visit(node->type.value().get());
+  }
+  out_ << " )";
+}
+
+// Type
+
+void FindSymbolsVisitor::Visit(TypeConstructor* node) {
+  out_ << "(TypeConstructor ";
+  Visit(node->type.get());
+  out_ << '\n';
+  for (auto& parameter : node->parameters) {
+    Visit(&parameter.first);
+    out_ << " = ";
+    Visitor::Visit(parameter.second);
+    out_ << '\n';
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(TupleType* node) {
+  out_ << "(TupleType ";
+  if (node->type.has_value()) {
+    Visit(&node->type.value());
+  }
+  out_ << ' ';
+  for (auto& entity : node->entities) {
+    out_ << "& ";
+    if (entity.first.has_value()) {
+      Visit(&entity.first.value());
+      out_ << " : ";
+    }
+    Visitor::Visit(entity.second);
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(VariantType* node) {
+  out_ << "(VariantType ";
+  if (node->type.has_value()) {
+    Visit(&node->type.value());
+  }
+  out_ << ' ';
+  for (auto& constructor : node->constructors) {
+    out_ << "| ";
+    if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
+      Visit(&std::get<TypeIdentifierDefinition>(constructor));
+    } else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
+      Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
+    } else {
+      // error
+    }
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(AnnotatedType* node) {
+  out_ << "(AnnotatedType ";
+  Visit(node->type_expression.get());
+  if (!node->annotations.empty()) {
+    out_ << " :";
+  }
+  for (auto& annotation : node->annotations) {
+    out_ << " ";
+    Visit(annotation.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(ParametrizedType* node) {
+  out_ << "(ParametrizedType ";
+  Visit(node->type_expression.get());
+  for (auto& parameter : node->parameters) {
+    out_ << ' ';
+    Visitor::Visit(parameter);
+  }
+  out_ << " )";
+}
+
+void FindSymbolsVisitor::Visit(TypeExpression* node) {
+  out_ << "(TypeExpression ";
+  for (auto& type_namespace : node->namespaces) {
+    Visitor::Visit(type_namespace);
+    out_ << '.';
+  }
+  Visit(&node->type);
+  out_ << " )";
+}
+
+// Typeclass
+
+void FindSymbolsVisitor::Visit(AnnotatedTypeclass* node) {
+  out_ << "(AnnotatedTypeclass ";
+  Visit(node->typeclass_expression.get());
+  if (!node->annotations.empty()) {
+    out_ << " :";
+  }
+  for (auto& annotation : node->annotations) {
+    out_ << " ";
+    Visit(annotation.get());
+  }
+  out_ << ")";
+}
+
+void FindSymbolsVisitor::Visit(ParametrizedTypeclass* node) {
+  out_ << "(ParametrizedTypeclass ";
+  Visit(node->typeclass_expression.get());
+  for (auto& paramater : node->parameters) {
+    out_ << ' ';
+    Visitor::Visit(paramater);
+  }
+  out_ << " )";
+}
+
+void FindSymbolsVisitor::Visit(TypeclassExpression* node) {
+  out_ << "(TypeclassExpression ";
+  for (auto& typeclass_namespace : node->namespaces) {
+    Visitor::Visit(typeclass_namespace);
+    out_ << '.';
+  }
+  Visit(&node->typeclass);
+  out_ << " )";
+}
+
+} // namespace interpreter