Forking the type system between Crankshaft & Turbofan.

src/ic/ic-state.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_IC_STATE_H_
 #define V8_IC_STATE_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 102 matching lines @@
   bool UseInlinedSmiCode() const {
     return KindMaybeSmi(left_kind_) || KindMaybeSmi(right_kind_);
   }
 
   static const int FIRST_TOKEN = Token::BIT_OR;
   static const int LAST_TOKEN = Token::MOD;
 
   Token::Value op() const { return op_; }
   Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
 
-  Type* GetLeftType() const { return KindToType(left_kind_); }
-  Type* GetRightType() const { return KindToType(right_kind_); }
-  Type* GetResultType() const;
+  AstType* GetLeftType() const { return KindToType(left_kind_); }
+  AstType* GetRightType() const { return KindToType(right_kind_); }
+  AstType* GetResultType() const;
 
   void Update(Handle<Object> left, Handle<Object> right, Handle<Object> result);
 
   Isolate* isolate() const { return isolate_; }
 
   enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
   Kind kind() const {
     return KindGeneralize(KindGeneralize(left_kind_, right_kind_),
                           result_kind_);
   }
 
  private:
   friend std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
 
   Kind UpdateKind(Handle<Object> object, Kind kind) const;
 
   static const char* KindToString(Kind kind);
-  static Type* KindToType(Kind kind);
+  static AstType* KindToType(Kind kind);
   static bool KindMaybeSmi(Kind kind) {
     return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
   }
   static bool KindLessGeneralThan(Kind kind1, Kind kind2) {
     if (kind1 == NONE) return true;
     if (kind1 == kind2) return true;
     if (kind2 == GENERIC) return true;
     if (kind2 == STRING) return false;
     return kind1 <= kind2;
   }
@@ skipping 41 matching lines @@
     SMI,
     NUMBER,
     STRING,
     INTERNALIZED_STRING,
     UNIQUE_NAME,     // Symbol or InternalizedString
     RECEIVER,        // JSReceiver
     KNOWN_RECEIVER,  // JSReceiver with specific map (faster check)
     GENERIC
   };
 
-  static Type* StateToType(Zone* zone, State state,
-                           Handle<Map> map = Handle<Map>());
+  static AstType* StateToType(Zone* zone, State state,
+                              Handle<Map> map = Handle<Map>());
 
   static State NewInputState(State old_state, Handle<Object> value);
 
   static const char* GetStateName(CompareICState::State state);
 
   static State TargetState(Isolate* isolate, State old_state, State old_left,
                            State old_right, Token::Value op,
                            bool has_inlined_smi_code, Handle<Object> x,
                            Handle<Object> y);
 };
@@ skipping 49 matching lines @@
                                                << LanguageModeState::kShift;
 
  private:
   const ExtraICState state_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_IC_STATE_H_