[turbofan] put src/types.[h/cc] into src/compiler/types.[h/cc]

src/compiler/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_
+#ifndef V8_COMPILER_TYPES_H_
+#define V8_COMPILER_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/handles.h"
 #include "src/objects.h"
 #include "src/ostreams.h"
 
 namespace v8 {
 namespace internal {
+namespace compiler {
 
 // SUMMARY
 //
 // A simple type system for compiler-internal use. It is based entirely on
 // union types, and all subtyping hence amounts to set inclusion. Besides the
 // obvious primitive types and some predefined unions, the type language also
 // can express class types (a.k.a. specific maps) and singleton types (i.e.,
 // concrete constants).
 //
 // Types consist of two dimensions: semantic (value range) and representation.
@@ skipping 210 matching lines @@
  *     -2^31   -2^30     0      2^30    2^31    2^32
  *
  * E.g., OtherUnsigned32 (OU32) covers all integers from 2^31 to 2^32-1.
  *
  * Some of the atomic numerical bitsets are internal only (see
  * INTERNAL_BITSET_TYPE_LIST).  To a types user, they should only occur in
  * union with certain other bitsets.  For instance, OtherNumber should only
  * occur as part of PlainNumber.
  */
 
-#define PROPER_BITSET_TYPE_LIST(V) \
+#define PROPER_BITSET_TYPE_LIST(V)   \
   REPRESENTATION_BITSET_TYPE_LIST(V) \
   SEMANTIC_BITSET_TYPE_LIST(V)
 
 #define BITSET_TYPE_LIST(V)          \
   MASK_BITSET_TYPE_LIST(V)           \
   REPRESENTATION_BITSET_TYPE_LIST(V) \
   INTERNAL_BITSET_TYPE_LIST(V)       \
   SEMANTIC_BITSET_TYPE_LIST(V)
 
 class Type;
@@ skipping 73 matching lines @@
   static inline const Boundary* Boundaries();
   static inline size_t BoundariesSize();
 };
 
 // -----------------------------------------------------------------------------
 // Superclass for non-bitset types (internal).
 class TypeBase {
  protected:
   friend class Type;
 
-  enum Kind {
-    kConstant,
-    kTuple,
-    kUnion,
-    kRange
-  };
+  enum Kind { kConstant, kTuple, kUnion, kRange };
 
   Kind kind() const { return kind_; }
   explicit TypeBase(Kind kind) : kind_(kind) {}
 
   static bool IsKind(Type* type, Kind kind) {
     if (BitsetType::IsBitset(type)) return false;
     TypeBase* base = reinterpret_cast<TypeBase*>(type);
     return base->kind() == kind;
   }
 
@@ skipping 414 matching lines @@
     Type* upper = Type::Intersect(b.upper, t, zone);
     // Lower bounds are considered approximate, correct as necessary.
     if (!lower->Is(upper)) lower = upper;
     return Bounds(lower, upper);
   }
 
   bool Narrows(Bounds that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
+}  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
-#endif  // V8_TYPES_H_
+#endif  // V8_COMPILER_TYPES_H_