[for-in] Further refactorings and unification around for-in.

src/types.h

 // Copyright 2014 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_TYPES_H_
 #define V8_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/handles.h"
 #include "src/objects.h"
@@ skipping 314 matching lines @@
   class BitsetType;         // Internal
   class StructuralType;     // Internal
   class UnionType;          // Internal
 
   class ClassType;
   class ConstantType;
   class RangeType;
   class ContextType;
   class ArrayType;
   class FunctionType;
+  class TupleType;
 
   typedef typename Config::template Handle<TypeImpl>::type TypeHandle;
   typedef typename Config::template Handle<ClassType>::type ClassHandle;
   typedef typename Config::template Handle<ConstantType>::type ConstantHandle;
   typedef typename Config::template Handle<RangeType>::type RangeHandle;
   typedef typename Config::template Handle<ContextType>::type ContextHandle;
   typedef typename Config::template Handle<ArrayType>::type ArrayHandle;
   typedef typename Config::template Handle<FunctionType>::type FunctionHandle;
   typedef typename Config::template Handle<UnionType>::type UnionHandle;
+  typedef typename Config::template Handle<TupleType>::type TupleHandle;
   typedef typename Config::Region Region;
 
   // Constructors.
 
   #define DEFINE_TYPE_CONSTRUCTOR(type, value)                                \
     static TypeImpl* type() {                                                 \
       return BitsetType::New(BitsetType::k##type);                            \
     }                                                                         \
     static TypeHandle type(Region* region) {                                  \
       return BitsetType::New(BitsetType::k##type, region);                    \
@@ skipping 63 matching lines @@
     return function;
   }
   static TypeHandle Function(TypeHandle result, int arity, TypeHandle* params,
                              Region* region) {
     FunctionHandle function = Function(result, Any(region), arity, region);
     for (int i = 0; i < arity; ++i) {
       function->InitParameter(i, params[i]);
     }
     return function;
   }
+  static TypeHandle Tuple(TypeHandle first, TypeHandle second, TypeHandle third,
+                          Region* region) {
+    TupleHandle tuple = TupleType::New(3, region);
+    tuple->InitElement(0, first);
+    tuple->InitElement(1, second);
+    tuple->InitElement(2, third);
+    return tuple;
+  }
 
 #define CONSTRUCT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
   static TypeHandle Name(Isolate* isolate, Region* region);
   SIMD128_TYPES(CONSTRUCT_SIMD_TYPE)
 #undef CONSTRUCT_SIMD_TYPE
 
   static TypeHandle Union(TypeHandle type1, TypeHandle type2, Region* reg);
   static TypeHandle Intersect(TypeHandle type1, TypeHandle type2, Region* reg);
 
   static TypeHandle Of(double value, Region* region) {
@@ skipping 57 matching lines @@
   }
   bool IsContext() {
     return Config::is_struct(this, StructuralType::kContextTag);
   }
   bool IsArray() {
     return Config::is_struct(this, StructuralType::kArrayTag);
   }
   bool IsFunction() {
     return Config::is_struct(this, StructuralType::kFunctionTag);
   }
+  bool IsTuple() { return Config::is_struct(this, StructuralType::kTupleTag); }
 
   ClassType* AsClass() { return ClassType::cast(this); }
   ConstantType* AsConstant() { return ConstantType::cast(this); }
   RangeType* AsRange() { return RangeType::cast(this); }
   ContextType* AsContext() { return ContextType::cast(this); }
   ArrayType* AsArray() { return ArrayType::cast(this); }
   FunctionType* AsFunction() { return FunctionType::cast(this); }
+  TupleType* AsTuple() { return TupleType::cast(this); }
 
   // Minimum and maximum of a numeric type.
   // These functions do not distinguish between -0 and +0.  If the type equals
   // kNaN, they return NaN; otherwise kNaN is ignored.  Only call these
   // functions on subtypes of Number.
   double Min();
   double Max();
 
   // Extracts a range from the type: if the type is a range or a union
   // containing a range, that range is returned; otherwise, NULL is returned.
@@ skipping 196 matching lines @@
   template<class> friend class TypeImpl;
   friend struct ZoneTypeConfig;  // For tags.
   friend struct HeapTypeConfig;
 
   enum Tag {
     kClassTag,
     kConstantTag,
     kContextTag,
     kArrayTag,
     kFunctionTag,
+    kTupleTag,
     kUnionTag
   };
 
   int Length() {
     return Config::struct_length(Config::as_struct(this));
   }
   TypeHandle Get(int i) {
     DCHECK(0 <= i && i < this->Length());
     return Config::struct_get(Config::as_struct(this), i);
   }
@@ skipping 223 matching lines @@
   }
 
   static FunctionType* cast(TypeImpl* type) {
     DCHECK(type->IsFunction());
     return static_cast<FunctionType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
+// Tuple types.
+
+template <class Config>
+class TypeImpl<Config>::TupleType : public StructuralType {
+ public:
+  int Arity() { return this->Length(); }
+  TypeHandle Element(int i) { return this->Get(i); }
+
+  void InitElement(int i, TypeHandle type) { this->Set(i, type); }
+
+  static TupleHandle New(int length, Region* region) {
+    TupleHandle type = Config::template cast<TupleType>(
+        StructuralType::New(StructuralType::kTupleTag, length, region));
+    return type;
+  }
+
+  static TupleType* cast(TypeImpl* type) {
+    DCHECK(type->IsTuple());
+    return static_cast<TupleType*>(type);
+  }
+};
+
+
+// -----------------------------------------------------------------------------
 // Type iterators.
 
 template<class Config> template<class T>
 class TypeImpl<Config>::Iterator {
  public:
   bool Done() const { return index_ < 0; }
   i::Handle<T> Current();
   void Advance();
 
  private:
@@ skipping 196 matching lines @@
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TYPES_H_