.

include/global_info.hpp

@@ -18,6 +18,11 @@ public:
     friend GlobalInfo;
     NamespaceVisitor() = delete;
   public:
+    struct Path {
+      std::vector<std::optional<utils::IdType>> path_types;
+      definition::Namespace* result;
+    }
+
     void AddImport(definition::Import&& import_info, const std::optional<std::string>& name = std::nullopt);
 
     void AddEnterNamespace(const std::string& name,
@@ -57,6 +62,8 @@ public:
     std::optional<utils::IdType> FindType(const std::optional<std::vector<std::string>>& path,
                                           const std::string& type);
 
+    std::optional<utils::IdType> FindLocalType(const std::string& type);
+
     std::optional<utils::IdType> FindAbstractType(const std::string& abstract_type);
 
     std::optional<utils::IdType> FindTypeclass(const std::string& typeclass);
@@ -96,22 +103,22 @@ public:
     return NamespaceVisitor(*this);
   }
 
-  // TODO: remember about vector realloc
+  // remember about vector realloc
   definition::Function* GetFunctionInfo(utils::IdType id) {
     return &functions_[id];
   }
 
-  // TODO: remember about vector realloc
+  // remember about vector realloc
   definition::Type* GetTypeInfo(utils::IdType id) {
     return &types_[id];
   }
 
-  // TODO: remember about vector realloc
+  // remember about vector realloc
   definition::Typeclass* GetTypeclassInfo(utils::IdType id) {
     return &typeclasses_[id];
   }
 
-  // TODO: remember about vector realloc
+  // remember about vector realloc
   definition::Constructor* GetConstructorInfo(utils::IdType id) {
     return &constructors_[id];
   }

include/interpreter_tree.hpp

@@ -557,8 +557,6 @@ struct TypeExpression {
   TypeSubExpression type;
 
   std::optional<size_t> array_size; // if array; 0 - dynamic size
-
-  utils::IdType type_id_;
 };
 
 struct ExtendedScopedAnyType {
@@ -584,6 +582,8 @@ struct ParametrizedTypeclass {
 struct ParametrizedType {
   AnyTypeIdentifier type;
   std::vector<std::unique_ptr<TypeExpression>> parameters;
+
+  std::optional<utils::IdType> type_id_; // std::nullopt, if it is namespace without type
 };
 
 // ----------------- Comments [IGNORE] -----------------

include/type_info_contexts.hpp

@@ -6,7 +6,6 @@
 #include <unordered_map>
 
 // for clangd
-#include "error_handling.hpp"
 #include "types.hpp"
 #include "utils.hpp"
 
@@ -37,13 +36,19 @@ public:
 
   // TODO: variable modifiers
   bool DefineVariable(const std::string& name, utils::IdType type_id) {
+    // check in previous contexts ??
     return contexts_.back().DefineVariable(name, type_id);
   }
 
-  bool DefineLocalAbstractType() {
-    // TODO
+  bool DefineLocalAbstractType(const std::string& name, utils::IdType type_id) {
+    if (GetLocalAbstractType(name)) {
+      return false;
+    }
+    contexts_.back().DefineLocalAbstractType(name, type_id);
+    return true;
   }
 
+
   bool RemoveVariable(const std::string& name) {
     for (ssize_t i = (ssize_t)contexts_.size() - 1; i >= 0; --i) {
       if (contexts_[i].RemoveVariable(name)) {
@@ -70,16 +75,34 @@ public:
     return std::nullopt;
   }
 
+  std::optional<utils::IdType> GetLocalAbstractType(const std::string& name) {
+    for (ssize_t i = (ssize_t)contexts_.size() - 1; i >= 0; --i) {
+      auto maybe_type = contexts_[i].GetLocalAbstractType(name);
+      if (maybe_type.has_value()) {
+        return maybe_type.value();
+      }
+    }
+    return std::nullopt;
+  }
+
 private:
   class Context {
   public:
     Context(bool hide_previous) : hide_previous_(hide_previous) {}
 
     bool DefineVariable(const std::string& name, utils::IdType type_id) {
-      if (variables_.count(name) > 0) {
+      if (local_abstract_types_.count(name) > 0) {
         return false;
       }
-      variables_[name] = type_id;
+      local_abstract_types_[name] = type_id;
+      return true;
+    }
+
+    bool DefineLocalAbstractType(const std::string& name, utils::IdType type_id) {
+      if (local_abstract_types_.count(name) > 0) {
+        return false;
+      }
+      local_abstract_types_[name] = type_id;
       return true;
     }
 
@@ -97,10 +120,21 @@ private:
       return variable_iter->second;
     }
 
+    std::optional<utils::IdType> GetLocalAbstractType(const std::string& name) {
+      auto local_abstract_type_iter = local_abstract_types_.find(name);
+
+      if (local_abstract_type_iter == local_abstract_types_.end()) {
+        return std::nullopt;
+      }
+
+      return local_abstract_type_iter->second;
+    }
+
     bool IsFirst() { return hide_previous_; }
   private:
     bool hide_previous_;
     std::unordered_map<std::string, utils::IdType> variables_;
+    std::unordered_map<std::string, utils::IdType> local_abstract_types_;
   };
 
   std::vector<Context> contexts_;