ext/iv/phonic/creator.h in iv-phonic-0.1.0 vs ext/iv/phonic/creator.h in iv-phonic-0.1.1

@@ -34,53 +34,64 @@
          last = stmt->body().end(); it != last; ++it) {
       (*it)->Accept(this);
       rb_ary_push(array, ret_);
     }
     rb_hash_aset(hash, SYM("body"), array);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const FunctionStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("FunctionStatement"));
     Visit(stmt->function());
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const FunctionDeclaration* decl) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("FunctionDeclaration"));
     Visit(decl->function());
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, decl);
     ret_ = hash;
   }
 
   void Visit(const VariableStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("VariableStatement"));
     rb_hash_aset(hash, SYM("const"), stmt->IsConst() ? Qtrue : Qfalse);
     VALUE array = rb_ary_new();
     for (Declarations::const_iterator it = stmt->decls().begin(),
          last = stmt->decls().end(); it != last; ++it) {
-      VALUE decl = rb_hash_new();
-      rb_hash_aset(decl, SYM("type"), rb_str_new_cstr("Declaration"));
-      Visit((*it)->name());
-      rb_hash_aset(decl, SYM("name"), ret_);
-      if ((*it)->expr()) {
-        (*it)->expr()->Accept(this);
-        rb_hash_aset(decl, SYM("expr"), ret_);
-      }
-      rb_ary_push(array, decl);
+      Visit(*it);
+      rb_ary_push(array, ret_);
     }
     rb_hash_aset(hash, SYM("body"), array);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
+  void Visit(const Declaration* decl) {
+    VALUE hash = rb_hash_new();
+    rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("Declaration"));
+    Visit(decl->name());
+    rb_hash_aset(hash, SYM("name"), ret_);
+    if (decl->expr()) {
+      decl->expr()->Accept(this);
+      rb_hash_aset(hash, SYM("expr"), ret_);
+    }
+    SetLocation(hash, decl);
+    ret_ = hash;
+  }
+
   void Visit(const EmptyStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("EmptyStatement"));
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const IfStatement* stmt) {
     VALUE hash = rb_hash_new();
@@ -91,30 +102,33 @@
     rb_hash_aset(hash, SYM("then"), ret_);
     if (stmt->else_statement()) {
       stmt->else_statement()->Accept(this);
       rb_hash_aset(hash, SYM("else"), ret_);
     }
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const DoWhileStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("DoWhileStatement"));
     stmt->cond()->Accept(this);
     rb_hash_aset(hash, SYM("cond"), ret_);
     stmt->body()->Accept(this);
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const WhileStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("WhileStatement"));
     stmt->cond()->Accept(this);
     rb_hash_aset(hash, SYM("cond"), ret_);
     stmt->body()->Accept(this);
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const ForStatement* stmt) {
     VALUE hash = rb_hash_new();
@@ -131,10 +145,11 @@
       stmt->next()->Accept(this);
       rb_hash_aset(hash, SYM("next"), ret_);
     }
     stmt->body()->Accept(this);
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const ForInStatement* stmt) {
     VALUE hash = rb_hash_new();
@@ -143,58 +158,64 @@
     rb_hash_aset(hash, SYM("each"), ret_);
     stmt->enumerable()->Accept(this);
     rb_hash_aset(hash, SYM("enum"), ret_);
     stmt->body()->Accept(this);
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const ContinueStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("ContinueStatement"));
     if (stmt->label()) {
       stmt->label()->Accept(this);
       rb_hash_aset(hash, SYM("label"), ret_);
     }
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const BreakStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("BreakStatement"));
     if (stmt->label()) {
       stmt->label()->Accept(this);
       rb_hash_aset(hash, SYM("label"), ret_);
     }
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const ReturnStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("ReturnStatement"));
     stmt->expr()->Accept(this);
     rb_hash_aset(hash, SYM("expr"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const WithStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("WithStatement"));
     stmt->context()->Accept(this);
     rb_hash_aset(hash, SYM("context"), ret_);
     stmt->body()->Accept(this);
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const LabelledStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("LabelledStatement"));
     stmt->label()->Accept(this);
     rb_hash_aset(hash, SYM("label"), ret_);
     stmt->body()->Accept(this);
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const SwitchStatement* stmt) {
     VALUE hash = rb_hash_new();
@@ -202,54 +223,65 @@
     stmt->expr()->Accept(this);
     rb_hash_aset(hash, SYM("cond"), ret_);
     VALUE array = rb_ary_new();
     for (CaseClauses::const_iterator it = stmt->clauses().begin(),
          last = stmt->clauses().end(); it != last; ++it) {
-      VALUE clause = rb_hash_new();
-      if ((*it)->IsDefault()) {
-        rb_hash_aset(clause, SYM("type"), rb_str_new_cstr("Default"));
-      } else {
-        rb_hash_aset(clause, SYM("type"), rb_str_new_cstr("Case"));
-        (*it)->expr()->Accept(this);
-        rb_hash_aset(clause, SYM("expr"), ret_);
-      }
-      VALUE stmts = rb_ary_new();
-      for (Statements::const_iterator st = (*it)->body().begin(),
-           stlast = (*it)->body().end(); st != stlast; ++st) {
-        (*st)->Accept(this);
-        rb_ary_push(stmts, ret_);
-      }
-      rb_hash_aset(clause, SYM("body"), stmts);
+      Visit(*it);
       rb_ary_push(array, ret_);
     }
     rb_hash_aset(hash, SYM("clauses"), array);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
+  void Visit(const CaseClause* cl) {
+    VALUE hash = rb_hash_new();
+    if (cl->IsDefault()) {
+      rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("Default"));
+    } else {
+      rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("Case"));
+      cl->expr()->Accept(this);
+      rb_hash_aset(hash, SYM("expr"), ret_);
+    }
+    VALUE stmts = rb_ary_new();
+    for (Statements::const_iterator st = cl->body().begin(),
+         stlast = cl->body().end(); st != stlast; ++st) {
+      (*st)->Accept(this);
+      rb_ary_push(stmts, ret_);
+    }
+    rb_hash_aset(hash, SYM("body"), stmts);
+    SetLocation(hash, cl);
+    ret_ = hash;
+  }
+
   void Visit(const ThrowStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("ThrowStatement"));
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const TryStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("TryStatement"));
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const DebuggerStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("DebuggerStatement"));
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const ExpressionStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("ExpressionStatement"));
     stmt->expr()->Accept(this);
     rb_hash_aset(hash, SYM("body"), ret_);
+    SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const Assignment* expr) {
     VALUE hash = rb_hash_new();
@@ -258,10 +290,11 @@
                  rb_str_new_cstr(core::Token::ToString(expr->op())));
     expr->left()->Accept(this);
     rb_hash_aset(hash, SYM("left"), ret_);
     expr->right()->Accept(this);
     rb_hash_aset(hash, SYM("right"), ret_);
+    SetLocation(hash, expr);
     ret_ = hash;
   }
 
   void Visit(const BinaryOperation* expr) {
     VALUE hash = rb_hash_new();
@@ -270,10 +303,11 @@
                  rb_str_new_cstr(core::Token::ToString(expr->op())));
     expr->left()->Accept(this);
     rb_hash_aset(hash, SYM("left"), ret_);
     expr->right()->Accept(this);
     rb_hash_aset(hash, SYM("right"), ret_);
+    SetLocation(hash, expr);
     ret_ = hash;
   }
 
   void Visit(const ConditionalExpression* expr) {
     VALUE hash = rb_hash_new();
@@ -282,30 +316,33 @@
     rb_hash_aset(hash, SYM("cond"), ret_);
     expr->left()->Accept(this);
     rb_hash_aset(hash, SYM("left"), ret_);
     expr->right()->Accept(this);
     rb_hash_aset(hash, SYM("right"), ret_);
+    SetLocation(hash, expr);
     ret_ = hash;
   }
 
   void Visit(const UnaryOperation* expr) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("UnaryOperation"));
     rb_hash_aset(hash, SYM("op"),
                  rb_str_new_cstr(core::Token::ToString(expr->op())));
     expr->expr()->Accept(this);
     rb_hash_aset(hash, SYM("expr"), ret_);
+    SetLocation(hash, expr);
     ret_ = hash;
   }
 
   void Visit(const PostfixExpression* expr) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("PostfixExpression"));
     rb_hash_aset(hash, SYM("op"),
                  rb_str_new_cstr(core::Token::ToString(expr->op())));
     expr->expr()->Accept(this);
     rb_hash_aset(hash, SYM("expr"), ret_);
+    SetLocation(hash, expr);
     ret_ = hash;
   }
 
   void Visit(const StringLiteral* literal) {
     VALUE hash = rb_hash_new();
@@ -315,17 +352,19 @@
                  Encoding::ConvertToDefaultInternal(
                      rb_enc_str_new(
                          reinterpret_cast<const char*>(str.data()),
                          str.size()*2,
                          rb_to_encoding(Encoding::UTF16Encoding()))));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const NumberLiteral* literal) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("NumberLiteral"));
     rb_hash_aset(hash, SYM("value"), rb_float_new(literal->value()));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const Identifier* literal) {
     VALUE hash = rb_hash_new();
@@ -335,38 +374,44 @@
                  Encoding::ConvertToDefaultInternal(
                      rb_enc_str_new(
                          reinterpret_cast<const char*>(str.data()),
                          str.size()*2,
                          rb_to_encoding(Encoding::UTF16Encoding()))));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const ThisLiteral* literal) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("ThisLiteral"));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const NullLiteral* literal) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("NullLiteral"));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const TrueLiteral* literal) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("TrueLiteral"));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const FalseLiteral* literal) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("FalseLiteral"));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const Undefined* literal) {
+    // Undefined has no location
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("Undefined"));
     ret_ = hash;
   }
 
@@ -385,10 +430,11 @@
                  Encoding::ConvertToDefaultInternal(
                      rb_enc_str_new(
                          reinterpret_cast<const char*>(flags.data()),
                          flags.size()*2,
                          rb_to_encoding(Encoding::UTF16Encoding()))));
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const ArrayLiteral* literal) {
     VALUE hash = rb_hash_new();
@@ -398,10 +444,11 @@
          last = literal->items().end(); it != last; ++it) {
       (*it)->Accept(this);
       rb_ary_push(array, ret_);
     }
     rb_hash_aset(hash, SYM("value"), array);
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const ObjectLiteral* literal) {
     using std::tr1::get;
@@ -439,10 +486,11 @@
                    SYM("value"),
                    ret_);
       rb_ary_push(array, item);
     }
     rb_hash_aset(hash, SYM("value"), array);
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const FunctionLiteral* literal) {
     VALUE hash = rb_hash_new();
@@ -467,30 +515,33 @@
         (*it)->Accept(this);
         rb_ary_push(array, ret_);
       }
       rb_hash_aset(hash, SYM("body"), array);
     }
+    SetLocation(hash, literal);
     ret_ = hash;
   }
 
   void Visit(const IndexAccess* expr) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("IndexAccess"));
     expr->target()->Accept(this);
     rb_hash_aset(hash, SYM("target"), ret_);
     expr->key()->Accept(this);
     rb_hash_aset(hash, SYM("key"), ret_);
+    SetLocation(hash, expr);
     ret_ = hash;
   }
 
   void Visit(const IdentifierAccess* expr) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), rb_str_new_cstr("IdentifierAccess"));
     expr->target()->Accept(this);
     rb_hash_aset(hash, SYM("target"), ret_);
     Visit(expr->key());
     rb_hash_aset(hash, SYM("key"), ret_);
+    SetLocation(hash, expr);
     ret_ = hash;
   }
 
   void Visit(const FunctionCall* call) {
     VALUE hash = rb_hash_new();
@@ -502,10 +553,11 @@
          last = call->args().end(); it != last; ++it) {
       (*it)->Accept(this);
       rb_ary_push(args, ret_);
     }
     rb_hash_aset(hash, SYM("args"), args);
+    SetLocation(hash, call);
     ret_ = hash;
   }
 
   void Visit(const ConstructorCall* call) {
     VALUE hash = rb_hash_new();
@@ -517,13 +569,20 @@
          last = call->args().end(); it != last; ++it) {
       (*it)->Accept(this);
       rb_ary_push(args, ret_);
     }
     rb_hash_aset(hash, SYM("args"), args);
+    SetLocation(hash, call);
     ret_ = hash;
   }
 
  private:
+
+  static void SetLocation(VALUE hash, const AstNode* node) {
+    rb_hash_aset(hash, SYM("begin"), INT2NUM(node->begin_position()));
+    rb_hash_aset(hash, SYM("end"), INT2NUM(node->end_position()));
+  }
+
   VALUE ret_;
 };
 
 } }  // namespace iv::phonic