Make unittests work in component build

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_COMPILER_TYPES_H_
 #define V8_COMPILER_TYPES_H_
 
+#include "src/base/compiler-specific.h"
 #include "src/conversions.h"
+#include "src/globals.h"
 #include "src/handles.h"
 #include "src/objects.h"
 #include "src/ostreams.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // SUMMARY
 //
@@ skipping 164 matching lines @@
 
 #define BITSET_TYPE_LIST(V)    \
   INTERNAL_BITSET_TYPE_LIST(V) \
   PROPER_BITSET_TYPE_LIST(V)
 
 class Type;
 
 // -----------------------------------------------------------------------------
 // Bitset types (internal).
 
-class BitsetType {
+class V8_EXPORT_PRIVATE BitsetType {
  public:
   typedef uint32_t bitset;  // Internal
 
   enum : uint32_t {
 #define DECLARE_TYPE(type, value) k##type = (value),
     BITSET_TYPE_LIST(DECLARE_TYPE)
 #undef DECLARE_TYPE
         kUnusedEOL = 0
   };
 
@@ skipping 107 matching lines @@
   explicit OtherNumberConstantType(double value)
       : TypeBase(kOtherNumberConstant), value_(value) {
     CHECK(IsOtherNumberConstant(value));
   }
 
   BitsetType::bitset Lub() { return BitsetType::kOtherNumber; }
 
   double value_;
 };
 
-class HeapConstantType : public TypeBase {
+class V8_EXPORT_PRIVATE HeapConstantType : public NON_EXPORTED_BASE(TypeBase) {
  public:
   i::Handle<i::HeapObject> Value() { return object_; }
 
  private:
   friend class Type;
   friend class BitsetType;
 
   static Type* New(i::Handle<i::HeapObject> value, Zone* zone) {
     BitsetType::bitset bitset = BitsetType::Lub(*value);
     return AsType(new (zone->New(sizeof(HeapConstantType)))
@@ skipping 147 matching lines @@
   }
 
   static UnionType* cast(Type* type) {
     DCHECK(IsKind(type, kUnion));
     return static_cast<UnionType*>(FromType(type));
   }
 
   bool Wellformed();
 };
 
-class Type {
+class V8_EXPORT_PRIVATE Type {
  public:
   typedef BitsetType::bitset bitset;  // Internal
 
 // Constructors.
 #define DEFINE_TYPE_CONSTRUCTOR(type, value) \
   static Type* type() { return BitsetType::New(BitsetType::k##type); }
   PROPER_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
 #undef DEFINE_TYPE_CONSTRUCTOR
 
   static Type* SignedSmall() {
@@ skipping 139 matching lines @@
                           RangeType::Limits* limits, Zone* zone);
   static Type* NormalizeUnion(Type* unioned, int size, Zone* zone);
   static Type* NormalizeRangeAndBitset(Type* range, bitset* bits, Zone* zone);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_TYPES_H_