fixes, optional type name added

src/build_visitor.cpp

@@ -53,19 +53,11 @@ void BuildVisitor::Visit(Namespace* node) {
 
   auto parse_node = current_node_;
 
-  size_t child_count = parse_node.ChildCount();
-
-  if (child_count > 3) { // "namespace", ["var"/"const",] type, scope
-    std::string modifier = parse_node.NthChild(1).GetValue();
-    if (modifier == "const") {
-      node->modifier = utils::ClassInternalsModifier::Const;
-    } else if (modifier == "var") {
-      node->modifier = utils::ClassInternalsModifier::Var;
-    } else {
-      error_handling::HandleInternalError("Can't parse namespace modifier",
-                                          "BuildVisitor.Namespace",
-                                          &node->base);
-    }
+  std::string modifier = parse_node.NthChild(1).GetValue();
+  if (modifier == "const") {
+    node->modifier = utils::ClassInternalsModifier::Const;
+  } else if (modifier == "var") {
+    node->modifier = utils::ClassInternalsModifier::Var;
   } else {
     node->modifier = utils::ClassInternalsModifier::Static;
   }
@@ -1380,17 +1372,50 @@ void BuildVisitor::Visit(TypeExpression* node) {
   Visit(&node->type);
   ++excluded_child_count;
 
-  current_node_ = current_node_.NextSibling();
+  auto suffix_node1 = current_node_.NextSibling();
 
-  if (!current_node_.IsNull()) {
-    current_node_ = current_node_.NextSibling();
-    if (!current_node_.IsNull()) {
-      NumberLiteral literal;
-      Visit(&literal);
-      node->array_size = literal.value;
-      ++excluded_child_count;
+  // TODO: better structure // TODO: check
+  if (!suffix_node1.IsNull()) {
+    auto suffix_node2 = suffix_node1.NextSibling();
+    if (!suffix_node2.IsNull()) {
+      auto suffix_node3 = suffix_node2.NextSibling();
+      if (!suffix_node3.IsNull()) {
+        current_node_ = suffix_node2;
+
+        NumberLiteral literal;
+        Visit(&literal);
+        node->array_size = literal.value;
+        ++excluded_child_count;
+
+        node->is_optional = true;
+      } else {
+        if (suffix_node1.GetValue() == "_" && suffix_node2.GetValue() == "!") {
+          node->array_size = 0;
+
+          node->is_optional = true;
+        } else if (suffix_node1.GetValue() == "_") {
+          current_node_ = suffix_node2;
+
+          NumberLiteral literal;
+          Visit(&literal);
+          node->array_size = literal.value;
+          ++excluded_child_count;
+        } else {
+          error_handling::HandleInternalError("Undefined suffix (2 elements)",
+                                              "BuildVisitor.TypeExpression",
+                                              std::nullopt);
+        }
+      }
     } else {
-      node->array_size = 0;
+      if (suffix_node1.GetValue() == "_") {
+        node->array_size = 0;
+      } else if (suffix_node1.GetValue() == "!") {
+        node->is_optional = true;
+      } else {
+        error_handling::HandleInternalError("Undefined suffix (1 element)",
+                                            "BuildVisitor.TypeExpression",
+                                            std::nullopt);
+      }
     }
   }
 

src/global_info.cpp

@@ -235,7 +235,7 @@ utils::IdType GlobalInfo::NamespaceVisitor::AddAbstractType(const std::string& a
   //   error_handling::HandleNamesError("Can't redefine basic type as abstract type", base_node);
   // }
 
-  if (FindAbstractType(abstract_type).has_value()) {
+  if (global_info_.FindAbstractType(abstract_type).has_value()) {
     error_handling::HandleNamesError("More then one abstract type with the same name in namespace", base_node);
   }
 
@@ -385,16 +385,6 @@ std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindLocalTypeId(const
   return std::nullopt;
 }
 
-std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindAbstractTypeId(const std::string& abstract_type) {
-  auto abstract_type_id_iter = global_info_.name_to_abstract_type_.find(abstract_type);
-
-  if (abstract_type_id_iter != global_info_.name_to_abstract_type_.end()) {
-    return abstract_type_id_iter->second;
-  }
-
-  return std::nullopt;
-}
-
 std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindTypeclassId(const std::string& typeclass) {
   auto typeclass_id_iter = global_info_.name_to_typeclass_.find(typeclass);
 
@@ -578,6 +568,16 @@ std::optional<utils::IdType> GlobalInfo::AddAnnotatedTypeToGraph(interpreter::to
                                     TypeclassGraph::Modifier::Type);
 }
 
+std::optional<utils::IdType> GlobalInfo::FindAbstractTypeId(const std::string& abstract_type) {
+  auto abstract_type_id_iter = name_to_abstract_type_.find(abstract_type);
+
+  if (abstract_type_id_iter != name_to_abstract_type_.end()) {
+    return abstract_type_id_iter->second;
+  }
+
+  return std::nullopt;
+}
+
 void GlobalInfo::CollectFunctionInfo(
     utils::IdType current_namespace,
     utils::ClassInternalsModifier modifier,

src/link_symbols_visitor.cpp

@@ -134,7 +134,7 @@ void LinkSymbolsVisitor::Visit(TypeExpression* node) {
   if (maybe_type_namespace.has_value()) {
     info::definition::Namespace* type_namespace = maybe_type_namespace.value();
 
-    for (ssize_t i = (ssize_t)node->path.size(); i >= 0; --i) {
+    for (ssize_t i = (ssize_t)node->path.size() - 1; i >= 0; --i) {
       info::definition::Namespace* parent_namespace = &global_info_.GetNamespaceInfo(type_namespace->parent_namespace);
 
       auto type_iter = parent_namespace->types.find(type_namespace->type_name);

src/print_visitor.cpp

@@ -654,10 +654,14 @@ void PrintVisitor::Visit(VariantType* node) {
 }
 
 void PrintVisitor::Visit(TypeExpression* node) {
-  out_ << "[TypeExpression ";
+  out_ << "[TypeExpression";
 
   if (node->array_size.has_value()) {
-    out_ << "[array size: " << node->array_size.value() << ']';
+    out_ << " [array size: " << node->array_size.value() << ']';
+  }
+
+  if (node->is_optional) {
+    out_ << " [optional]";
   }
 
   out_ << "] (";

src/type_check_visitor.cpp

@@ -249,8 +249,6 @@ void TypeCheckVisitor::Visit(FunctionDefinitionStatement* node) {
     returned_type_ = current_type_;
   }
   if (!context_manager_.EqualValues(returned_type, returned_type_.value())) {
-    error_handling::DebugPrint(context_manager_.GetAnyValue(returned_type)->ToString());
-    error_handling::DebugPrint(context_manager_.GetAnyValue(returned_type_.value())->ToString());
     error_handling::HandleTypecheckError("Wrong function return type", node->base);
   }
   returned_type_ = std::nullopt;
@@ -284,7 +282,7 @@ void TypeCheckVisitor::Visit(TypeDefinitionStatement* node) {
     auto function_iter = type_functions.find(function.first);
 
     if (function_iter == type_functions.end() || !global_info_.GetFunctionInfo(function_iter->second).definition.has_value()) {
-      error_handling::HandleTypecheckError("Type is not satisfy typeclass requirements: " + function.first + " is not defined", node->base);
+      error_handling::HandleTypecheckError("Type not define all required functions: " + function.first + " is not defined", node->base);
     }
   }
 
@@ -1281,35 +1279,24 @@ void TypeCheckVisitor::Visit(TypeExpression* node) {
   std::unordered_map<std::string, utils::IdType> context;
   CollectTypeExpressionContext(*node, context);
 
-  // TODO: -------- remove, unneeded ------
-  // auto maybe_internal_type = info::type::ToInternalType(node->type.type);
-  //
-  // if (maybe_internal_type.has_value()) { // TODO: ???
-  //   // checks made in link_symbols_visitor
-  //   current_type_ =
-  //     context_manager_.AddValue<info::type::InternalType>(
-  //       maybe_internal_type.value(),
-  //       utils::ValueType::Tmp);
-  // } else {
-    std::optional<utils::IdType> maybe_local_abstract_type =
-      context_manager_.FindLocalType(node->type.type);
-    if (node->path.empty() && maybe_local_abstract_type.has_value()) {
-      current_type_ = maybe_local_abstract_type.value();
-    } else if (node->type.type_id_.has_value()) { // TODO: check that names are different (always true ??)
-      std::optional<info::definition::AnyType*> maybe_type_info =
-        global_info_.GetTypeInfo<info::definition::AnyType>(node->type.type_id_.value());
+  std::optional<utils::IdType> maybe_local_abstract_type =
+    context_manager_.FindLocalType(node->type.type);
+  if (node->path.empty() && maybe_local_abstract_type.has_value()) {
+    current_type_ = maybe_local_abstract_type.value();
+  } else if (node->type.type_id_.has_value()) { // TODO: check that names are different (always true ??)
+    std::optional<info::definition::AnyType*> maybe_type_info =
+      global_info_.GetTypeInfo<info::definition::AnyType>(node->type.type_id_.value());
 
-      if (!maybe_type_info.has_value()) {
-        error_handling::HandleInternalError("No AnyType found (alias types, ... not implemented)",
-                                            "TypeCheckVisitor.TypeExpression",
-                                            &node->base);
-      }
-
-      VisitDefinedType(maybe_type_info.value(), context);
-    } else {
-      error_handling::HandleTypecheckError("Type not found", node->base);
+    if (!maybe_type_info.has_value()) {
+      error_handling::HandleInternalError("No AnyType found (alias types, ... not implemented)",
+                                          "TypeCheckVisitor.TypeExpression",
+                                          &node->base);
     }
-  // }
+
+    VisitDefinedType(maybe_type_info.value(), context);
+  } else {
+    error_handling::HandleTypecheckError("Type not found", node->base);
+  }
 
   if (node->array_size.has_value()) {
     current_type_ = context_manager_.AddValue(
@@ -1317,6 +1304,12 @@ void TypeCheckVisitor::Visit(TypeExpression* node) {
       utils::ValueType::Tmp);
   }
 
+  if (node->is_optional) {
+    current_type_ = context_manager_.AddValue(
+      info::type::OptionalType(current_type_, context_manager_.GetValueManager()),
+      utils::ValueType::Tmp);
+  }
+
   node->base.type_ = current_type_;
 }
 
@@ -1433,7 +1426,10 @@ void TypeCheckVisitor::CollectTypeExpressionContext(const TypeExpression& type_e
 utils::IdType TypeCheckVisitor::TypeInContext(utils::IdType type,
                                               const std::unordered_map<std::string, utils::IdType>& context) {
   info::type::Type type_in_context = *context_manager_.GetAnyValue(type);
-  type_in_context.InContext(context);
+  auto maybe_new_type = type_in_context.InContext(context);
+  if (maybe_new_type.has_value()) {
+    return maybe_new_type.value();
+  }
   return context_manager_.AddValue(std::move(type_in_context), utils::ValueType::Tmp);
 }
 

src/typed_print_visitor.cpp

@@ -920,9 +920,13 @@ void TypedPrintVisitor::Visit(TypeExpression* node) {
     out_ << context_manager_.GetAnyValue(node->base.type_.value())->GetTypeName();
   }
 
-  out_ << ") ";
+  out_ << ")";
   if (node->array_size.has_value()) {
-    out_ << "[array size: " << node->array_size.value() << ']';
+    out_ << " [array size: " << node->array_size.value() << ']';
+  }
+
+  if (node->is_optional) {
+    out_ << " [optional]";
   }
 
   out_ << "] (";