part of type checker, type heck result type

include/builtin_types.hpp

@@ -1,10 +1,13 @@
 #pragma once
 
+#include <map>
 #include <string>
 
 #include "basic_nodes.hpp"
 
-namespace builtin {
+namespace builtin::types {
+
+// -- containers
 
 const static std::string TUPLE_IDENTIFIER = "Tuple";
 
@@ -16,24 +19,172 @@ const static std::string OPTIONAL_IDENTIFIER = "Optional";
 
 const static std::string RESULT_IDENTIFIER = "Result";
 
-enum class BuiltinType {
+// -- basic types
+
+const static std::string FLOAT_IDENTIFIER = "Float";
+
+const static std::string DOUBLE_IDENTIFIER = "Double";
+
+const static std::string INT_IDENTIFIER = "Int";
+
+const static std::string LONG_IDENTIFIER = "Long";
+
+const static std::string INDEX_IDENTIFIER = "Index";
+
+const static std::string CHAR_IDENTIFIER = "Char";
+
+const static std::string UNICODE_IDENTIFIER = "Unicode";
+
+const static std::string BOOL_IDENTIFIER = "Bool";
+
+const static std::string UNIT_IDENTIFIER = "Unit";
+
+const static std::string NULL_OPTION_IDENTIFIER = "Null";
+
+// const static std::string STRING_IDENTIFIER = "String"; // String is
+// Array[Char]
+
+//
+
+enum class Type {
+  // -- containers
   TUPLE,
   VARIANT,
   ARRAY,
   OPTIONAL,
   RESULT,
+  // -- basic types
+  FLOAT,
+  DOUBLE,
+  INT,
+  LONG,
+  INDEX,
+  CHAR,
+  UNICODE,
+  BOOL,
+  UNIT,
+  NULL_OPTION,
+  // -- none
   NONE,
 };
 
-inline nodes::Modifier builtin_to_modifier(BuiltinType type) {
+inline std::string to_string(Type type) {
   switch (type) {
-  case BuiltinType::OPTIONAL:
+    // -- containers
+  case Type::TUPLE:
+    return TUPLE_IDENTIFIER;
+  case Type::VARIANT:
+    return VARIANT_IDENTIFIER;
+  case Type::ARRAY:
+    return ARRAY_IDENTIFIER;
+  case Type::OPTIONAL:
+    return OPTIONAL_IDENTIFIER;
+  case Type::RESULT:
+    return RESULT_IDENTIFIER;
+  // -- basic types
+  case Type::FLOAT:
+    return FLOAT_IDENTIFIER;
+  case Type::DOUBLE:
+    return DOUBLE_IDENTIFIER;
+  case Type::INT:
+    return INT_IDENTIFIER;
+  case Type::LONG:
+    return LONG_IDENTIFIER;
+  case Type::INDEX:
+    return INDEX_IDENTIFIER;
+  case Type::CHAR:
+    return CHAR_IDENTIFIER;
+  case Type::UNICODE:
+    return UNICODE_IDENTIFIER;
+  case Type::BOOL:
+    return BOOL_IDENTIFIER;
+  case Type::UNIT:
+    return UNIT_IDENTIFIER;
+  case Type::NULL_OPTION:
+    return NULL_OPTION_IDENTIFIER;
+  // -- none
+  case Type::NONE:
+    return TUPLE_IDENTIFIER;
+  }
+
+  error_handling::handle_general_error("Unreachable");
+  exit(1); // unreachable
+}
+
+inline Type to_type(const std::string &str) {
+  static std::map<std::string, Type> builtin_types;
+  if (!builtin_types.empty()) { // if not initialized, initialize
+
+    // -- containers
+    builtin_types[TUPLE_IDENTIFIER] = Type::TUPLE;
+    builtin_types[VARIANT_IDENTIFIER] = Type::VARIANT;
+    builtin_types[ARRAY_IDENTIFIER] = Type::ARRAY;
+    builtin_types[OPTIONAL_IDENTIFIER] = Type::OPTIONAL;
+    builtin_types[RESULT_IDENTIFIER] = Type::RESULT;
+
+    // -- basic types
+    builtin_types[FLOAT_IDENTIFIER] = Type::FLOAT;
+    builtin_types[DOUBLE_IDENTIFIER] = Type::DOUBLE;
+    builtin_types[INT_IDENTIFIER] = Type::INT;
+    builtin_types[LONG_IDENTIFIER] = Type::LONG;
+    builtin_types[INDEX_IDENTIFIER] = Type::INDEX;
+    builtin_types[CHAR_IDENTIFIER] = Type::CHAR;
+    builtin_types[UNICODE_IDENTIFIER] = Type::UNICODE;
+    builtin_types[BOOL_IDENTIFIER] = Type::BOOL;
+    builtin_types[UNIT_IDENTIFIER] = Type::UNIT;
+    builtin_types[NULL_OPTION_IDENTIFIER] = Type::NULL_OPTION;
+  }
+
+  auto iter = builtin_types.find(str);
+
+  if (iter == builtin_types.end()) {
+    return Type::NONE;
+  }
+
+  return iter->second;
+}
+
+inline nodes::Modifier get_modifier(Type type) {
+  switch (type) {
+  case Type::OPTIONAL:
     return nodes::Modifier::OPTIONAL;
-  case BuiltinType::RESULT:
+  case Type::RESULT:
     return nodes::Modifier::RESULT;
   default:
     return nodes::Modifier::NONE;
   }
 }
 
-} // namespace builtin
+// std::nullopt for any parameters count
+inline std::optional<size_t> get_parameters_count(Type type) {
+  switch (type) {
+    // -- containers
+  case Type::TUPLE:
+  case Type::VARIANT:
+    return std::nullopt;
+  case Type::ARRAY:
+  case Type::OPTIONAL:
+  case Type::RESULT:
+    return 1;
+  // -- basic types
+  case Type::FLOAT:
+  case Type::DOUBLE:
+  case Type::INT:
+  case Type::LONG:
+  case Type::INDEX:
+  case Type::CHAR:
+  case Type::UNICODE:
+  case Type::BOOL:
+  case Type::UNIT:
+  case Type::NULL_OPTION:
+    return 0;
+  // -- none
+  case Type::NONE:
+    return std::nullopt;
+  }
+
+  error_handling::handle_general_error("Unreachable");
+  exit(1); // unreachable
+}
+
+} // namespace builtin::types