Type checker compiles and runs

Author: Git-i

include/yoyo/ir_gen.h

@@ -49,8 +49,8 @@ namespace Yoyo
  requires std::same_as<std::remove_cvref_t<decltype(*list.begin())>, Type>
  {
  if (std::ranges::empty(list)) return "";
- std::string final = "::<" + list.begin()->full_name();
- for (auto& tp : std::ranges::subrange(list.begin() + 1, list.end()))
+ std::string final = "::<" + (*list.begin()).full_name();
+ for (const auto& tp : std::ranges::subrange(list.begin() + 1, list.end()))
  final += "," + tp.full_name();
  final += ">";
  return final;

include/yoyo/type.h

@@ -112,15 +112,14 @@ namespace Yoyo
  [[nodiscard]] bool is_lambda() const {return name.starts_with("__lambda");}
  [[nodiscard]] std::string full_name() const;
  [[nodiscard]] std::string full_name_no_block() const;
+ [[nodiscard]] std::string full_name_no_generics() const;
  [[nodiscard]] std::string pretty_name(const std::string& block) const;
 
  [[nodiscard]] size_t bitsize(IRGenerator* irgen) const;
  //there's no actual sorting, just to fulfill `set` requirements
- bool operator<(const Type& other) const
+ auto operator<=>(const Type& other) const
  {
- if(module == other.module) return name < other.name;
- return module < other.module;
-
+ return full_name() <=> other.full_name();
  }
 
  };

include/yoyo/type_checker.h

@@ -81,6 +81,10 @@ namespace Yoyo
  Type type;
  Expression* expr;
  };
+ struct NonOwningConstraint {
+ Type type;
+ Expression* expr;
+ };
  // type can be called (a function or lambda)
  struct IsInvocableConstraint {
  Type type;
@@ -137,32 +141,35 @@ namespace Yoyo
  IsReturnOfConstraint,
  ImplInterfaceConstraint,
  ExtractsToConstraint,
- RefExtractsToConstraint
+ RefExtractsToConstraint,
+ NonOwningConstraint
  >;
  /// represents the possible types a variable can be
  class Domain {
- enum TriState : uint8_t { None = 0, False, True };
  bool is_infinite = true;
- TriState is_owning = None;
-
  public:
  // set of concrete types a type can be
  // it must be one of the elements in a group
  struct Group {
  std::vector<Type> types;
  void add_type(Type&&);
  };
- std::optional<Error> add_and_intersect(Group&&);
- void constrain_to_store(uint64_t);
- void constrain_to_store(int64_t);
- void constrain_to_store(double);
- std::optional<Error> merge_intersect(Domain&&);
- std::optional<Error> equal_constrain(Type&& other);
+ // add a group of types and intersect it with the current group
+ [[nodiscard]] std::optional<Error> add_and_intersect(Group&&);
+ [[nodiscard]] std::optional<Error> constrain_to_store(uint64_t);
+ [[nodiscard]] std::optional<Error> constrain_to_store(int64_t);
+ [[nodiscard]] std::optional<Error> constrain_to_store(double);
+ // basically `add_and_intersect` but with an entire domain
+ [[nodiscard]] std::optional<Error> merge_intersect(Domain&&);
+ // this solves the domain
+ [[nodiscard]] std::optional<Error> equal_constrain(Type other);
+ bool is_solved();
+ Type get_solution();
  private:
- std::vector<Group> concrete_types;
+ Group concrete_types;
  };
  // This is a union-find
- // but variables maintain thier domain (set of types they can possibly be)
+ // but variables maintain their domain (set of types they can possibly be)
  // checked with each constraint
  struct UnificationTable {
  std::vector<uint32_t> parents;
@@ -193,12 +200,21 @@ namespace Yoyo
  struct TypeCheckerState {
  std::vector<std::unordered_map<std::string, Type>> variables;
  std::vector<TypeCheckerConstraint> constraints;
+ UnificationTable tbl;
+ // the return type of the function being checked
  Type return_type;
+ // Creates a new type variable
  Type new_type_var();
+ // Adds a new constraint to be checked
+ // (should not be called by the constraint checker, it has a special method for that)
  void add_constraint(TypeCheckerConstraint);
- void unify_types(const Type&, const Type&);
+ // given 2 type variables, make them equal to each other
+ void unify_types(const Type&, const Type&, IRGenerator* irgen);
+ // append a new block for variables
  void push_variable_block();
+ // remove a block for variables
  void pop_variable_block();
+ // register a new variable
  void create_variable(std::string name, Type type);
  // applies a type substitution if possible
  // else converts it to its most solved form
@@ -211,6 +227,7 @@ namespace Yoyo
  bool has_error;
  IRGenerator* irgen;
  TypeCheckerState* state;
+ std::vector<TypeCheckerConstraint> temp_constraints;
  bool operator()(IsIntegerConstraint& con);
  bool operator()(CanStoreIntegerConstraint& con);
  bool operator()(IsFloatConstraint& con);
@@ -230,6 +247,7 @@ namespace Yoyo
  bool operator()(ImplInterfaceConstraint& con);
  bool operator()(ExtractsToConstraint& con);
  bool operator()(RefExtractsToConstraint& con);
+ bool operator()(NonOwningConstraint& con);
 
  void add_new_constraint(TypeCheckerConstraint);
  };
@@ -240,7 +258,7 @@ namespace Yoyo
  TypeCheckerState* state;
  void operator()(FunctionDeclaration*) {}
  void operator()(ClassDeclaration*) {}
- void operator()(VariableDeclaration*) {}
+ void operator()(VariableDeclaration*);
  void operator()(IfStatement*);
  void operator()(WhileStatement*);
  void operator()(ForStatement*);
@@ -252,18 +270,18 @@ namespace Yoyo
  void operator()(ModuleImport*) {}
  void operator()(ConditionalExtraction*);
  void operator()(WithStatement*);
- void operator()(OperatorOverload*);
- void operator()(GenericFunctionDeclaration*);
- void operator()(AliasDeclaration*);
- void operator()(GenericAliasDeclaration*);
- void operator()(GenericClassDeclaration*);
- void operator()(InterfaceDeclaration*);
- void operator()(BreakStatement*);
- void operator()(ContinueStatement*);
- void operator()(ConstantDeclaration*);
- void operator()(CImportDeclaration*);
- void operator()(UnionDeclaration*);
- void operator()(MacroDeclaration*);
+ void operator()(OperatorOverload*) {}
+ void operator()(GenericFunctionDeclaration*) {}
+ void operator()(AliasDeclaration*) {}
+ void operator()(GenericAliasDeclaration*) {}
+ void operator()(GenericClassDeclaration*) {}
+ void operator()(InterfaceDeclaration*) {}
+ void operator()(BreakStatement*) {}
+ void operator()(ContinueStatement*) {}
+ void operator()(ConstantDeclaration*){}
+ void operator()(CImportDeclaration*) {}
+ void operator()(UnionDeclaration*) {}
+ void operator()(MacroDeclaration*) {}
 
  FunctionType operator()(IntegerLiteral*) const;
  FunctionType operator()(BooleanLiteral*) const;

src/yoyo/borrow_checker.cpp

@@ -211,8 +211,7 @@ namespace Yoyo
  auto tuple = checker.make_object();
  for (auto& elem : exp->elements) {
  auto elem_eval = std::visit(*this, elem->toVariant());
- auto type = std::visit(ExpressionTypeChecker{ irgen }, elem->toVariant());
- clone_into(checker, elem_eval, tuple, *type, exp, irgen); // TODO: update when type system is better
+ clone_into(checker, elem_eval, tuple, exp->evaluated_type, exp, irgen); // TODO: update when type system is better
  }
  return tuple;
  }

src/yoyo/type.cpp

@@ -23,6 +23,10 @@ namespace Yoyo
  }
  return final;
  }
+ std::string Type::full_name_no_generics() const
+ {
+ return block_hash + name;
+ }
  //TODO: move to util header !??
  std::vector<std::string_view> split(std::string_view str, std::string_view delim)
  {
@@ -804,6 +808,8 @@ namespace Yoyo
  return "[" + pretty_name_suffix(tp.subtypes[0]) + ":&]";
  if (tp.name == "__called_fn")
  return "called " + tp.signature->pretty_name("");
+ if (tp.name.starts_with("?"))
+ return "{unknown}";
  return tp.name;
  }
  std::string Type::pretty_name(const std::string& block) const