type-checker.hh

Go to the documentation of this file.

#ifndef TYPE_TYPE_CHECKER_HH
# define TYPE_TYPE_CHECKER_HH

# include <string>
# include <ast/default-visitor.hh>
# include <ast/non-object-visitor.hh>

# include <misc/set.hh>
# include <misc/error.hh>
# include <type/fwd.hh>

namespace type
{

  class TypeChecker : public ast::DefaultVisitor, public ast::NonObjectVisitor
  {
  public:
    typedef ast::DefaultVisitor super_type;
    using super_type::operator();

  public:
    TypeChecker();
    const misc::error& error_get() const;

  protected:
    const Type* type(ast::Typable& e);
    const Record* type(const ast::fields_type& e);
    const Record* type(const ast::VarDecs& e);


    // ------------------ //
    // Helping routines.  //
    // ------------------ //
  protected:

    void error(const ast::Ast& loc, const std::string& msg);

    template <typename T>
    void error(const ast::Ast& loc, const std::string& msg, const T& exp);

    template <typename T, typename U>
    void error_and_recover(T& loc, const std::string& msg, const U& exp);

    void type_mismatch(const ast::Ast& loc,
                       const std::string& exp1, const Type& type1,
                       const std::string& exp2, const Type& type2);



    void check_type(ast::Exp& e, const std::string& s, const Type& t);
    void check_type(ast::Dec& e, const std::string& s, const Type& t);

    void check_types(const ast::Ast& loc,
                     const std::string& exp1, const Type& type1,
                     const std::string& exp2, const Type& type2);
    void check_types(const ast::Ast& loc,
                     const std::string& exp1, ast::Typable& type1,
                     const std::string& exp2, ast::Typable& type2);

  protected:

    template <typename NodeType>
    void type_default(NodeType& e, const type::Type* type);

    template <typename NodeType>
    void created_type_default(NodeType& e, const type::Type* type);

    template <typename NodeType>
    void type_set(NodeType& e, const type::Type* type);

    // ------------------------- //
    // The core of the visitor.  //
    // ------------------------- //

    // ---------------- //
    // Visiting /Var/.  //
    // ---------------- //

    virtual void operator()(ast::SimpleVar& e) override;
  // FIXME: Some code was deleted here (Other Var nodes).



    // ---------------- //
    // Visiting /Exp/.  //
    // ---------------- //

    // Literals.
    virtual void operator()(ast::NilExp&) override;
    virtual void operator()(ast::IntExp&) override;
    virtual void operator()(ast::StringExp&) override;

    // Complex values.
    virtual void operator()(ast::RecordExp& e) override;
    virtual void operator()(ast::OpExp& e) override;
  // FIXME: Some code was deleted here (Other Exp nodes).

    // ---------------- //
    // Visiting /Dec/.  //
    // ---------------- //




    template <class D>
    void decs_visit(ast::AnyDecs<D>& e);

    template <class D>
    void visit_dec_header(D& e);

    template <class D>
    void visit_dec_body(D& e);

    template <typename Routine_Type, typename Routine_Node>
    void visit_routine_body(Routine_Node& e);

    virtual void operator()(ast::FunctionDecs& e) override;
    virtual void operator()(ast::FunctionDec&) override;

    virtual void operator()(ast::TypeDecs& e) override;
    virtual void operator()(ast::TypeDec&) override;

    virtual void operator()(ast::VarDec& e) override;

    // --------------- //
    // Visiting /Ty/.  //
    // --------------- //

    virtual void operator()(ast::NameTy& e) override;
    virtual void operator()(ast::RecordTy& e) override;
    virtual void operator()(ast::ArrayTy& e) override;

  protected:
    misc::error error_;
    misc::set<const ast::VarDec*> var_read_only_;
  };

  template <>
  void TypeChecker::visit_dec_header<ast::FunctionDec>(ast::FunctionDec& e);
  template <>
  void TypeChecker::visit_dec_body<ast::FunctionDec>(ast::FunctionDec& e);


  template <>
  void TypeChecker::visit_dec_header<ast::TypeDec>(ast::TypeDec& e);
  template <>
  void TypeChecker::visit_dec_body<ast::TypeDec>(ast::TypeDec& e);
}

# include <type/type-checker.hxx>

#endif // !TYPE_TYPE_CHECKER_HH