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

src/types.cc

 // 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.
 
 #include <iomanip>
 
 #include "src/types.h"
 
 #include "src/ostreams.h"
 #include "src/types-inl.h"
@@ skipping 156 matching lines @@
       bitset |= SEMANTIC(type->AsUnion()->Get(i)->BitsetLub());
     }
     return bitset;
   }
   if (type->IsClass()) return type->AsClass()->Lub();
   if (type->IsConstant()) return type->AsConstant()->Lub();
   if (type->IsRange()) return type->AsRange()->Lub();
   if (type->IsContext()) return kInternal & kTaggedPointer;
   if (type->IsArray()) return kOtherObject;
   if (type->IsFunction()) return kFunction;
+  if (type->IsTuple()) return kInternal;
   UNREACHABLE();
   return kNone;
 }
 
 
 template<class Config>
 typename TypeImpl<Config>::bitset
 TypeImpl<Config>::BitsetType::Lub(i::Map* map) {
   DisallowHeapAllocation no_allocation;
   switch (map->instance_type()) {
@@ skipping 309 matching lines @@
     if (this_fun->Arity() != that_fun->Arity() ||
         !this_fun->Result()->Equals(that_fun->Result()) ||
         !this_fun->Receiver()->Equals(that_fun->Receiver())) {
       return false;
     }
     for (int i = 0, n = this_fun->Arity(); i < n; ++i) {
       if (!this_fun->Parameter(i)->Equals(that_fun->Parameter(i))) return false;
     }
     return true;
   }
+  if (this->IsTuple()) {

[Jarin, 2016/01/25 10:00:26]

There should be a comment somewhere (probably on the TupleType class def) which
says how the subtyping works on tuples (invariant in tuple elements).

[Benedikt Meurer, 2016/01/25 10:05:05]

As discussed offline, not saying anything about that since the rest of the
classes are also undocumented. We'll have to fix that at some point tho.

+    if (!that->IsTuple()) return false;
+    TupleType* this_tuple = this->AsTuple();
+    TupleType* that_tuple = that->AsTuple();
+    if (this_tuple->Arity() != that_tuple->Arity()) {
+      return false;
+    }
+    for (int i = 0, n = this_tuple->Arity(); i < n; ++i) {
+      if (!this_tuple->Element(i)->Equals(that_tuple->Element(i))) return false;
+    }
+    return true;
+  }
   UNREACHABLE();
   return false;
 }
 
 
 template <class Config>
 typename TypeImpl<Config>::bitset TypeImpl<Config>::Representation() {
   return REPRESENTATION(this->BitsetLub());
 }
 
@@ skipping 715 matching lines @@
     TypeHandle res = Convert<OtherType>(type->AsFunction()->Result(), region);
     TypeHandle rcv = Convert<OtherType>(type->AsFunction()->Receiver(), region);
     FunctionHandle function = FunctionType::New(
         res, rcv, type->AsFunction()->Arity(), region);
     for (int i = 0; i < function->Arity(); ++i) {
       TypeHandle param = Convert<OtherType>(
           type->AsFunction()->Parameter(i), region);
       function->InitParameter(i, param);
     }
     return function;
+  } else if (type->IsTuple()) {
+    TupleHandle tuple = TupleType::New(type->AsTuple()->Arity(), region);
+    for (int i = 0; i < tuple->Arity(); ++i) {
+      tuple->InitElement(
+          i, Convert<OtherType>(type->AsTuple()->Element(i), region));
+    }
+    return tuple;
   } else {
     UNREACHABLE();
     return None(region);
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // Printing.
 
@@ skipping 97 matching lines @@
         this->AsFunction()->Receiver()->PrintTo(os, dim);
         os << ".";
       }
       os << "(";
       for (int i = 0; i < this->AsFunction()->Arity(); ++i) {
         if (i > 0) os << ", ";
         this->AsFunction()->Parameter(i)->PrintTo(os, dim);
       }
       os << ")->";
       this->AsFunction()->Result()->PrintTo(os, dim);
+    } else if (this->IsTuple()) {
+      os << "<";
+      for (int i = 0, n = this->AsTuple()->Arity(); i < n; ++i) {
+        TypeHandle type_i = this->AsTuple()->Element(i);
+        if (i > 0) os << ", ";
+        type_i->PrintTo(os, dim);
+      }
+      os << ">";
     } else {
       UNREACHABLE();
     }
   }
   if (dim == BOTH_DIMS) os << "/";
   if (dim != SEMANTIC_DIM) {
     BitsetType::Print(os, REPRESENTATION(this->BitsetLub()));
   }
 }
 
@@ skipping 27 matching lines @@
 
 template TypeImpl<ZoneTypeConfig>::TypeHandle
   TypeImpl<ZoneTypeConfig>::Convert<HeapType>(
     TypeImpl<HeapTypeConfig>::TypeHandle, TypeImpl<ZoneTypeConfig>::Region*);
 template TypeImpl<HeapTypeConfig>::TypeHandle
   TypeImpl<HeapTypeConfig>::Convert<Type>(
     TypeImpl<ZoneTypeConfig>::TypeHandle, TypeImpl<HeapTypeConfig>::Region*);
 
 }  // namespace internal
 }  // namespace v8