RFC: Switch to ast ids (instead of positions) for type feedback.

src/ast.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 115 matching lines @@
 
 class AstNode: public ZoneObject {
  public:
 #define DECLARE_TYPE_ENUM(type) k##type,
   enum Type {
     AST_NODE_LIST(DECLARE_TYPE_ENUM)
     kInvalid = -1
   };
 #undef DECLARE_TYPE_ENUM
 
-  static const int kNoNumber = -1;
-
   AstNode() : id_(GetNextId()) { count_++; }
 
   virtual ~AstNode() { }
 
   virtual void Accept(AstVisitor* v) = 0;
   virtual Type node_type() const { return kInvalid; }
 
   // Type testing & conversion functions overridden by concrete subclasses.
 #define DECLARE_NODE_FUNCTIONS(type)                  \
   virtual type* As##type() { return NULL; }
   AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
   virtual Statement* AsStatement() { return NULL; }
   virtual Expression* AsExpression() { return NULL; }
   virtual TargetCollector* AsTargetCollector() { return NULL; }
   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
   virtual IterationStatement* AsIterationStatement() { return NULL; }
   virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
   virtual Slot* AsSlot() { return NULL; }
 
   // True if the node is simple enough for us to inline calls containing it.
   virtual bool IsInlineable() const { return false; }
 
   static int Count() { return count_; }
   static void ResetIds() { current_id_ = 0; }
-  unsigned id() const { return id_; }
+  AstId id() const { return id_; }
 
  protected:
-  static unsigned GetNextId() { return current_id_++; }
-  static unsigned ReserveIdRange(int n) {
-    unsigned tmp = current_id_;
+  static AstId GetNextId() { return current_id_++; }
+  static AstId ReserveIdRange(int n) {
+    AstId tmp = current_id_;
     current_id_ += n;
     return tmp;
   }
 
  private:
-  static unsigned current_id_;
-  static unsigned count_;
-  unsigned id_;
+  static AstId current_id_;
+  static AstId count_;
+  AstId id_;
 };
 
 
 class Statement: public AstNode {
  public:
   Statement() : statement_pos_(RelocInfo::kNoPosition) {}
 
   virtual Statement* AsStatement()  { return this; }
 
   virtual Assignment* StatementAsSimpleAssignment() { return NULL; }
@@ skipping 243 matching lines @@
 
 class IterationStatement: public BreakableStatement {
  public:
   // Type testing & conversion.
   virtual IterationStatement* AsIterationStatement() { return this; }
 
   Statement* body() const { return body_; }
   void set_body(Statement* stmt) { body_ = stmt; }
 
   // Bailout support.
-  int OsrEntryId() const { return osr_entry_id_; }
+  AstId OsrEntryId() const { return osr_entry_id_; }
   virtual int ContinueId() const = 0;
 
   // Code generation
   BreakTarget* continue_target()  { return &continue_target_; }
 
  protected:
   explicit inline IterationStatement(ZoneStringList* labels);
 
   void Initialize(Statement* body) {
     body_ = body;
   }
 
  private:
   Statement* body_;
   BreakTarget continue_target_;
-  int osr_entry_id_;
+  AstId osr_entry_id_;
 };
 
 
 class DoWhileStatement: public IterationStatement {
  public:
   explicit inline DoWhileStatement(ZoneStringList* labels);
 
   DECLARE_NODE_TYPE(DoWhileStatement)
 
   void Initialize(Expression* cond, Statement* body) {
@@ skipping 1110 matching lines @@
 
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   virtual ZoneMapList* GetReceiverTypes() { return receiver_types_; }
   virtual Handle<Map> GetMonomorphicReceiverType() {
     return monomorphic_receiver_type_;
   }
 
   // Bailout support.
-  int compound_bailout_id() const { return compound_bailout_id_; }
+  AstId compound_bailout_id() const { return compound_bailout_id_; }
 
  private:
   Token::Value op_;
   Expression* target_;
   Expression* value_;
   int pos_;
   BinaryOperation* binary_operation_;
-  int compound_bailout_id_;
+  AstId compound_bailout_id_;
 
   bool block_start_;
   bool block_end_;
 
   bool is_monomorphic_;
   ZoneMapList* receiver_types_;
   Handle<Map> monomorphic_receiver_type_;
 };
 
 
@@ skipping 518 matching lines @@
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_