src/ast/type-checker-visitor.cc

   1 #include <boost/foreach.hpp>
   2
   3 #include <core/assert.hh>
   4
   5 #include <ast/cast-tables.hh>
   6 #include <ast/scope.hh>
   7 #include "type-checker-visitor.hh"
   8
   9 namespace ast
  10 {
  11   TypeCheckerVisitor::TypeCheckerVisitor()
  12     : BrowseVisitor(),
  13       scope_()
  14   {
  15   }
  16
  17   TypeCheckerVisitor::~TypeCheckerVisitor()
  18   {
  19   }
  20
  21   void
  22   TypeCheckerVisitor::visit(File & node)
  23   {
  24     scope_ = node.scope;
  25     super_t::visit(node);
  26   }
  27
  28   void
  29   TypeCheckerVisitor::visit(Function & node)
  30   {
  31     /// @todo check that the last statement is a branch or a return
  32     currentFunction_ = &node;
  33     super_t::visit(node);
  34   }
  35
  36   void
  37   TypeCheckerVisitor::visit(Block & node)
  38   {
  39     scope_ = node.scope;
  40     // We must respect this order
  41     BOOST_FOREACH (Node * varDecl, (*node.varDecls))
  42       varDecl->accept(*this);
  43     BOOST_FOREACH (Node * statement, (*node.statements))
  44       statement->accept(*this);
  45   }
  46
  47   void
  48   TypeCheckerVisitor::visit(Return & node)
  49   {
  50     node.exp->accept(*this);
  51     if (!isSameType(node.exp->type, currentFunction_->returnType))
  52     {
  53       CastExp * castExp = new CastExp;
  54       castExp->exp = node.exp;
  55       castExp->type = currentFunction_->returnType;
  56       node.exp = castExp;
  57     }
  58   }
  59
  60   void
  61   TypeCheckerVisitor::visit(AssignExp & node)
  62   {
  63     node.dest->accept(*this);
  64     node.value->accept(*this);
  65     CastExp * castExp = new CastExp();
  66     castExp->type = node.dest->type;
  67     castExp->exp = node.value;
  68     assert(node.dest->type);
  69     node.value = castExp;
  70     node.type = node.dest->type;
  71   }
  72
  73   void
  74   TypeCheckerVisitor::visit(IdExp & node)
  75   {
  76     assert(scope_);
  77     Symbol * s = scope_->findSymbol(node.symbol->name);
  78     assert(s);
  79     assert(s->type);
  80     node.type = s->type;
  81     node.symbol = s;
  82   }
  83
  84   void
  85   TypeCheckerVisitor::visit(DereferenceExp & node)
  86   {
  87     node.exp->accept(*this);
  88     Type * unrefType = unreferencedType(node.exp->type);
  89     assert_msg(unrefType->nodeType == PointerType::nodeTypeId(),
  90                "You can't dereference a non pointer type");
  91     PointerType * type = reinterpret_cast<PointerType *> (unrefType);
  92     node.type = type->type;
  93   }
  94
  95   void
  96   TypeCheckerVisitor::visit(Symbol & node)
  97   {
  98     assert(scope_);
  99     const Symbol * s = scope_->findSymbol(node.name);
 100     assert(s);
 101     assert(s->type);
 102     node.type = s->type;
 103   }
 104
 105   void
 106   TypeCheckerVisitor::visit(CastExp & node)
 107   {
 108     assert(node.exp);
 109     node.exp->accept(*this);
 110   }
 111
 112   void
 113   TypeCheckerVisitor::visit(CallExp & node)
 114   {
 115     super_t::visit(node);
 116     /// @todo generate the function's signature depending on parameters type
 117     const Symbol * s = scope_->findSymbol(node.id);
 118     assert_msg(s, "function not found in symbol table");
 119     assert(s->type);
 120
 121     assert(s->type->nodeType == FunctionType::nodeTypeId());
 122     node.ftype = reinterpret_cast<FunctionType *> (s->type);
 123     node.type = node.ftype->returnType;
 124
 125     assert(node.ftype->argsType->size() >= node.args->size());
 126     for (unsigned i = 0; i < node.args->size(); i++)
 127       (*node.args)[i] = castToType((*node.ftype->argsType)[i], (*node.args)[i]);
 128   }
 129
 130 #define VISIT(Type)                                             \
 131   void                                                          \
 132   TypeCheckerVisitor::visit(Type & node)                        \
 133   {                                                             \
 134     node.left->accept(*this);                                   \
 135     node.right->accept(*this);                                  \
 136     /**                                                         \
 137      * @todo check if type match                                \
 138      * @todo look for an overloaded operator '+'                \
 139      * @todo the cast can be applied on both nodes              \
 140      */                                                         \
 141     CastExp * castExp = castToBestType(node.left->type,         \
 142                                        node.right->type);       \
 143                                                                 \
 144     if (!castExp)                                               \
 145     {                                                           \
 146       node.type = node.left->type;                              \
 147       return;                                                   \
 148     }                                                           \
 149                                                                 \
 150     if (castExp->type == node.left->type)                       \
 151     {                                                           \
 152       castExp->exp = node.right;                                \
 153       node.right = castExp;                                     \
 154     }                                                           \
 155     else                                                        \
 156     {                                                           \
 157       castExp->exp = node.left;                                 \
 158       node.left = castExp;                                      \
 159     }                                                           \
 160     node.type = castExp->type;                                  \
 161   }
 162
 163   VISIT(AddExp)
 164   VISIT(SubExp)
 165   VISIT(MulExp)
 166   VISIT(DivExp)
 167   VISIT(ModExp)
 168
 169 #define VISIT_BITWISE_EXP(Type)                                         \
 170   void                                                                  \
 171   TypeCheckerVisitor::visit(Type & node)                                \
 172   {                                                                     \
 173     node.left->accept(*this);                                           \
 174     node.right->accept(*this);                                          \
 175                                                                         \
 176     assert_msg(!AST_IS_FLOATING_POINT_TYPE(node.left->type) &&          \
 177                !AST_IS_FLOATING_POINT_TYPE(node.right->type),           \
 178                "throw and error here, can't do bitwise operation on float."); \
 179     CastExp * castExp = castToBestType(node.left->type,                 \
 180                                        node.right->type);               \
 181                                                                         \
 182     if (!castExp)                                                       \
 183     {                                                                   \
 184       node.type = node.left->type;                                      \
 185       return;                                                           \
 186     }                                                                   \
 187                                                                         \
 188     if (castExp->type == node.left->type)                               \
 189     {                                                                   \
 190       castExp->exp = node.right;                                        \
 191       node.right = castExp;                                             \
 192     }                                                                   \
 193     else                                                                \
 194     {                                                                   \
 195       castExp->exp = node.left;                                         \
 196       node.left = castExp;                                              \
 197     }                                                                   \
 198     node.type = castExp->type;                                          \
 199   }
 200
 201   VISIT_BITWISE_EXP(AndExp)
 202   VISIT_BITWISE_EXP(OrExp)
 203   VISIT_BITWISE_EXP(XorExp)
 204
 205   VISIT_BITWISE_EXP(ShlExp)
 206   VISIT_BITWISE_EXP(AShrExp)
 207   VISIT_BITWISE_EXP(LShrExp)
 208
 209 #define VISIT_BINARY_CMP_EXP(Type)                              \
 210   void                                                          \
 211   TypeCheckerVisitor::visit(Type & node)                        \
 212   {                                                             \
 213     node.left->accept(*this);                                   \
 214     node.right->accept(*this);                                  \
 215     node.type = new BoolType;                                   \
 216     /**                                                         \
 217      * @todo check if type match                                \
 218      * @todo look for an overloaded operator '+'                \
 219      * @todo the cast can be applied on both nodes              \
 220      */                                                         \
 221     CastExp * castExp = castToBestType(node.left->type,         \
 222                                        node.right->type);       \
 223                                                                 \
 224     if (!castExp)                                               \
 225       return;                                                   \
 226                                                                 \
 227     if (castExp->type == node.left->type)                       \
 228     {                                                           \
 229       castExp->exp = node.right;                                \
 230       node.right = castExp;                                     \
 231     }                                                           \
 232     else                                                        \
 233     {                                                           \
 234       castExp->exp = node.left;                                 \
 235       node.left = castExp;                                      \
 236     }                                                           \
 237   }
 238
 239   VISIT_BINARY_CMP_EXP(EqExp)
 240   VISIT_BINARY_CMP_EXP(NeqExp)
 241   VISIT_BINARY_CMP_EXP(LtExp)
 242   VISIT_BINARY_CMP_EXP(LtEqExp)
 243   VISIT_BINARY_CMP_EXP(GtExp)
 244   VISIT_BINARY_CMP_EXP(GtEqExp)
 245
 246 #define VISIT_BINARY_BOOL_EXP(Type)                                     \
 247   void                                                                  \
 248   TypeCheckerVisitor::visit(Type & node)                                \
 249   {                                                                     \
 250     node.type = new BoolType;                                           \
 251                                                                         \
 252     node.left->accept(*this);                                           \
 253     node.right->accept(*this);                                          \
 254                                                                         \
 255     assert_msg(!AST_IS_FLOATING_POINT_TYPE(node.left->type) &&          \
 256                !AST_IS_FLOATING_POINT_TYPE(node.right->type),           \
 257                "throw and error here, can't do bitwise operation on float."); \
 258                                                                         \
 259     if (node.left->type->nodeType != BoolType::nodeTypeId())            \
 260     {                                                                   \
 261       CastExp * castExp = new CastExp;                                  \
 262       castExp->type = node.type;                                        \
 263       castExp->exp = node.left;                                         \
 264       node.left = castExp;                                              \
 265     }                                                                   \
 266     if (node.right->type->nodeType != BoolType::nodeTypeId())           \
 267     {                                                                   \
 268       CastExp * castExp = new CastExp;                                  \
 269       castExp->type = node.type;                                        \
 270       castExp->exp = node.right;                                        \
 271       node.right = castExp;                                             \
 272     }                                                                   \
 273   }
 274
 275   VISIT_BINARY_BOOL_EXP(OrOrExp)
 276   VISIT_BINARY_BOOL_EXP(AndAndExp)
 277
 278   void
 279   TypeCheckerVisitor::visit(NegExp & node)
 280   {
 281     node.exp->accept(*this);
 282     node.type = node.exp->type;
 283   }
 284
 285   void
 286   TypeCheckerVisitor::visit(NotExp & node)
 287   {
 288     node.exp->accept(*this);
 289     assert_msg(!AST_IS_FLOATING_POINT_TYPE(node.exp->type),
 290                "throw and error here, can't do bitwise operation on float.");
 291     node.type = node.exp->type;
 292   }
 293
 294   void
 295   TypeCheckerVisitor::visit(BangExp & node)
 296   {
 297     node.exp->accept(*this);
 298     assert_msg(!AST_IS_FLOATING_POINT_TYPE(node.exp->type),
 299                "throw and error here, can't do bitwise operation on float.");
 300     node.type = new BoolType;
 301     if (node.exp->type->nodeType != BoolType::nodeTypeId())
 302     {
 303       CastExp * castExp = new CastExp;
 304       castExp->exp = node.exp;
 305       castExp->type = node.type;
 306       node.exp = castExp;
 307     }
 308   }
 309
 310   void
 311   TypeCheckerVisitor::visit(ConditionalBranch & node)
 312   {
 313     node.cond->accept(*this);
 314     if (node.cond->type->nodeType == BoolType::nodeTypeId())
 315       return;
 316
 317     CastExp * castExp = new CastExp;
 318     castExp->exp = node.cond;
 319     castExp->type = new BoolType;
 320     node.cond = castExp;
 321   }
 322 }