*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 446 insertions, 572 deletions

diff --git a/lldb/source/Symbol/OCamlASTContext.cpp b/lldb/source/Symbol/OCamlASTContext.cpp
index 1f2f57a2af9..8176fa18fb5 100644
--- a/lldb/source/Symbol/OCamlASTContext.cpp
+++ b/lldb/source/Symbol/OCamlASTContext.cpp
@@ -1,4 +1,5 @@
-//===-- OCamlASTContext.cpp ----------------------------------------*- C++ -*-===//
+//===-- OCamlASTContext.cpp ----------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,6 +8,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "lldb/Symbol/OCamlASTContext.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
@@ -14,7 +16,6 @@
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
-#include "lldb/Symbol/OCamlASTContext.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
@@ -24,471 +25,371 @@
 using namespace lldb;
 using namespace lldb_private;
 
-namespace lldb_private
-{
-    class OCamlASTContext::OCamlType
-    {
-        public:
-            enum LLVMCastKind
-            {
-                eKindPrimitive,
-                eKindObject,
-                eKindReference,
-                eKindArray,
-                kNumKinds
-            };
+namespace lldb_private {
+class OCamlASTContext::OCamlType {
+public:
+  enum LLVMCastKind {
+    eKindPrimitive,
+    eKindObject,
+    eKindReference,
+    eKindArray,
+    kNumKinds
+  };
 
-            OCamlType(LLVMCastKind kind) : m_kind(kind) {}
+  OCamlType(LLVMCastKind kind) : m_kind(kind) {}
 
-            virtual ~OCamlType() = default;
+  virtual ~OCamlType() = default;
 
-            virtual ConstString
-                GetName() = 0;
+  virtual ConstString GetName() = 0;
 
-            virtual void
-                Dump(Stream *s) = 0;
+  virtual void Dump(Stream *s) = 0;
 
-            virtual bool
-                IsCompleteType() = 0;
+  virtual bool IsCompleteType() = 0;
 
-            LLVMCastKind
-                getKind() const
-                {
-                    return m_kind;
-                }
+  LLVMCastKind getKind() const { return m_kind; }
 
-        private:
-            LLVMCastKind m_kind;
-    };
+private:
+  LLVMCastKind m_kind;
+};
 
 } // end of namespace lldb_private
 
-namespace
-{
-
-    class OCamlPrimitiveType : public OCamlASTContext::OCamlType
-    {
-        public:
-            enum TypeKind
-            {
-                eTypeInt,
-            };
-
-            OCamlPrimitiveType(TypeKind type_kind, uint32_t byte_size) : OCamlType(OCamlType::eKindPrimitive), m_type_kind(type_kind), m_type(ConstString()), m_byte_size(byte_size) {}
-
-            OCamlPrimitiveType(TypeKind type_kind, ConstString s, uint32_t byte_size) : OCamlType(OCamlType::eKindPrimitive), m_type_kind(type_kind), m_type(s), m_byte_size(byte_size) {}
-
-            ConstString
-            GetName() override
-            {
-                switch (m_type_kind)
-                {
-                    case eTypeInt:
-                        return m_type;
-                }
-                return ConstString();
-            }
-
-            TypeKind
-            GetTypeKind()
-            {
-                return m_type_kind;
-            }
-
-            void
-            Dump(Stream *s) override
-            {
-                s->Printf("%s\n", GetName().GetCString());
-            }
-
-            bool
-            IsCompleteType() override
-            {
-                return true;
-            }
-
-            static bool
-            classof(const OCamlType *ot)
-            {
-                return ot->getKind() == OCamlType::eKindPrimitive;
-            }
-
-            uint64_t
-            GetByteSize() const
-            {
-                return m_byte_size;
-            }
-
-        private:
-            const TypeKind m_type_kind;
-            const ConstString m_type;
-            uint64_t m_byte_size;
-    };
+namespace {
+
+class OCamlPrimitiveType : public OCamlASTContext::OCamlType {
+public:
+  enum TypeKind {
+    eTypeInt,
+  };
+
+  OCamlPrimitiveType(TypeKind type_kind, uint32_t byte_size)
+      : OCamlType(OCamlType::eKindPrimitive), m_type_kind(type_kind),
+        m_type(ConstString()), m_byte_size(byte_size) {}
+
+  OCamlPrimitiveType(TypeKind type_kind, ConstString s, uint32_t byte_size)
+      : OCamlType(OCamlType::eKindPrimitive), m_type_kind(type_kind), m_type(s),
+        m_byte_size(byte_size) {}
+
+  ConstString GetName() override {
+    switch (m_type_kind) {
+    case eTypeInt:
+      return m_type;
+    }
+    return ConstString();
+  }
+
+  TypeKind GetTypeKind() { return m_type_kind; }
+
+  void Dump(Stream *s) override { s->Printf("%s\n", GetName().GetCString()); }
+
+  bool IsCompleteType() override { return true; }
+
+  static bool classof(const OCamlType *ot) {
+    return ot->getKind() == OCamlType::eKindPrimitive;
+  }
+
+  uint64_t GetByteSize() const { return m_byte_size; }
+
+private:
+  const TypeKind m_type_kind;
+  const ConstString m_type;
+  uint64_t m_byte_size;
+};
 }
 
 OCamlASTContext::OCamlASTContext()
-    : TypeSystem(eKindOCaml),
-      m_pointer_byte_size(0)
-{
-}
+    : TypeSystem(eKindOCaml), m_pointer_byte_size(0) {}
 
-OCamlASTContext::~OCamlASTContext()
-{
-}
+OCamlASTContext::~OCamlASTContext() {}
 
-ConstString
-OCamlASTContext::GetPluginNameStatic()
-{
-    return ConstString("ocaml");
+ConstString OCamlASTContext::GetPluginNameStatic() {
+  return ConstString("ocaml");
 }
 
-ConstString
-OCamlASTContext::GetPluginName()
-{
-    return OCamlASTContext::GetPluginNameStatic();
+ConstString OCamlASTContext::GetPluginName() {
+  return OCamlASTContext::GetPluginNameStatic();
 }
 
-uint32_t
-OCamlASTContext::GetPluginVersion()
-{
-    return 1;
-}
-
-lldb::TypeSystemSP
-OCamlASTContext::CreateInstance (lldb::LanguageType language, Module *module, Target *target)
-{
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_LANGUAGE));
-
-    if (language == lldb::eLanguageTypeOCaml)
-    {
-        std::shared_ptr<OCamlASTContext> ocaml_ast_sp;
-        ArchSpec arch;
-
-        if (module)
-        {
-            arch = module->GetArchitecture();
-
-            ObjectFile *objfile = module->GetObjectFile();
-            ArchSpec object_arch;
-
-            if (!objfile || !objfile->GetArchitecture(object_arch))
-                return lldb::TypeSystemSP();
-
-            ocaml_ast_sp = std::shared_ptr<OCamlASTContext>(new OCamlASTContext);
-
-            if (log) {
-                log->Printf ("((Module*)%p) [%s]->GetOCamlASTContext() = %p",
-                            (void *)module,
-                            module->GetFileSpec().GetFilename().AsCString("<anonymous>"),
-                            (void *)ocaml_ast_sp.get());
-            }
-
-        } else if (target) {
-            arch = target->GetArchitecture();
-            ocaml_ast_sp = std::shared_ptr<OCamlASTContextForExpr>(new OCamlASTContextForExpr(target->shared_from_this()));
-
-            if (log)
-            {
-                log->Printf ("((Target*)%p)->GetOCamlASTContext() = %p",
-                            (void *)target,
-                            (void *)ocaml_ast_sp.get());
-            }
-        }
-
-        if (arch.IsValid()) {
-            ocaml_ast_sp->SetAddressByteSize(arch.GetAddressByteSize());
-            return ocaml_ast_sp;
-        }
+uint32_t OCamlASTContext::GetPluginVersion() { return 1; }
+
+lldb::TypeSystemSP OCamlASTContext::CreateInstance(lldb::LanguageType language,
+                                                   Module *module,
+                                                   Target *target) {
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  if (language == lldb::eLanguageTypeOCaml) {
+    std::shared_ptr<OCamlASTContext> ocaml_ast_sp;
+    ArchSpec arch;
+
+    if (module) {
+      arch = module->GetArchitecture();
+
+      ObjectFile *objfile = module->GetObjectFile();
+      ArchSpec object_arch;
+
+      if (!objfile || !objfile->GetArchitecture(object_arch))
+        return lldb::TypeSystemSP();
+
+      ocaml_ast_sp = std::shared_ptr<OCamlASTContext>(new OCamlASTContext);
+
+      if (log) {
+        log->Printf(
+            "((Module*)%p) [%s]->GetOCamlASTContext() = %p", (void *)module,
+            module->GetFileSpec().GetFilename().AsCString("<anonymous>"),
+            (void *)ocaml_ast_sp.get());
+      }
+
+    } else if (target) {
+      arch = target->GetArchitecture();
+      ocaml_ast_sp = std::shared_ptr<OCamlASTContextForExpr>(
+          new OCamlASTContextForExpr(target->shared_from_this()));
+
+      if (log) {
+        log->Printf("((Target*)%p)->GetOCamlASTContext() = %p", (void *)target,
+                    (void *)ocaml_ast_sp.get());
+      }
     }
 
-    return lldb::TypeSystemSP();
+    if (arch.IsValid()) {
+      ocaml_ast_sp->SetAddressByteSize(arch.GetAddressByteSize());
+      return ocaml_ast_sp;
+    }
+  }
+
+  return lldb::TypeSystemSP();
 }
 
-void
-OCamlASTContext::EnumerateSupportedLanguages
-(std::set<lldb::LanguageType> &languages_for_types,
- std::set<lldb::LanguageType> &languages_for_expressions)
-{
-    static std::vector<lldb::LanguageType> s_supported_languages_for_types({lldb::eLanguageTypeOCaml});
-    static std::vector<lldb::LanguageType> s_supported_languages_for_expressions({});
+void OCamlASTContext::EnumerateSupportedLanguages(
+    std::set<lldb::LanguageType> &languages_for_types,
+    std::set<lldb::LanguageType> &languages_for_expressions) {
+  static std::vector<lldb::LanguageType> s_supported_languages_for_types(
+      {lldb::eLanguageTypeOCaml});
+  static std::vector<lldb::LanguageType> s_supported_languages_for_expressions(
+      {});
 
-    languages_for_types.insert(s_supported_languages_for_types.begin(), s_supported_languages_for_types.end());
-    languages_for_expressions.insert(s_supported_languages_for_expressions.begin(), s_supported_languages_for_expressions.end());
+  languages_for_types.insert(s_supported_languages_for_types.begin(),
+                             s_supported_languages_for_types.end());
+  languages_for_expressions.insert(
+      s_supported_languages_for_expressions.begin(),
+      s_supported_languages_for_expressions.end());
 }
 
-void
-OCamlASTContext::Initialize()
-{
-    PluginManager::RegisterPlugin (GetPluginNameStatic(),
-                                   "OCaml AST context plug-in",
-                                   CreateInstance,
-                                   EnumerateSupportedLanguages);
+void OCamlASTContext::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                "OCaml AST context plug-in", CreateInstance,
+                                EnumerateSupportedLanguages);
 }
 
-void
-OCamlASTContext::Terminate()
-{
-    PluginManager::UnregisterPlugin (CreateInstance);
+void OCamlASTContext::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-DWARFASTParser *
-OCamlASTContext::GetDWARFParser()
-{
-    if (!m_dwarf_ast_parser_ap) {
-        m_dwarf_ast_parser_ap.reset(new DWARFASTParserOCaml(*this));
-    }
+DWARFASTParser *OCamlASTContext::GetDWARFParser() {
+  if (!m_dwarf_ast_parser_ap) {
+    m_dwarf_ast_parser_ap.reset(new DWARFASTParserOCaml(*this));
+  }
 
-    return m_dwarf_ast_parser_ap.get();
+  return m_dwarf_ast_parser_ap.get();
 }
 
-bool
-OCamlASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
-                             CompilerType *element_type, uint64_t *size,
-                             bool *is_incomplete)
-{
-    return false;
+bool OCamlASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
+                                  CompilerType *element_type, uint64_t *size,
+                                  bool *is_incomplete) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size)
-{
-    return false;
+bool OCamlASTContext::IsVectorType(lldb::opaque_compiler_type_t type,
+                                   CompilerType *element_type, uint64_t *size) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsAggregateType(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsCharType(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsCharType(lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsCompleteType(lldb::opaque_compiler_type_t type)
-{
-    return static_cast<OCamlPrimitiveType *>(type)->IsCompleteType();
+bool OCamlASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) {
+  return static_cast<OCamlPrimitiveType *>(type)->IsCompleteType();
 }
 
-bool
-OCamlASTContext::IsConst(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsConst(lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length)
-{
-    return false;
+bool OCamlASTContext::IsCStringType(lldb::opaque_compiler_type_t type,
+                                    uint32_t &length) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsDefined(lldb::opaque_compiler_type_t type)
-{
-    return type != nullptr;
+bool OCamlASTContext::IsDefined(lldb::opaque_compiler_type_t type) {
+  return type != nullptr;
 }
 
-bool
-OCamlASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex)
-{
-    return false;
+bool OCamlASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type,
+                                          uint32_t &count, bool &is_complex) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsFunctionType(lldb::opaque_compiler_type_t type, bool *is_variadic_ptr)
-{
-    return false;
+bool OCamlASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
+                                     bool *is_variadic_ptr) {
+  return false;
 }
 
 uint32_t
-OCamlASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr)
-{
-    return false;
+OCamlASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
+                                        CompilerType *base_type_ptr) {
+  return false;
 }
 
-size_t
-OCamlASTContext::GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type)
-{
-    return 0;
+size_t OCamlASTContext::GetNumberOfFunctionArguments(
+    lldb::opaque_compiler_type_t type) {
+  return 0;
 }
 
 CompilerType
-OCamlASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index)
-{
-    return CompilerType();
+OCamlASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
+                                            const size_t index) {
+  return CompilerType();
 }
 
-bool
-OCamlASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type)
-{
-    return IsFunctionType(type);
+bool OCamlASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
+  return IsFunctionType(type);
 }
 
-bool
-OCamlASTContext::IsBlockPointerType (lldb::opaque_compiler_type_t type, CompilerType *function_pointer_type_ptr)
-{
-    return false;
+bool OCamlASTContext::IsBlockPointerType(
+    lldb::opaque_compiler_type_t type,
+    CompilerType *function_pointer_type_ptr) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed)
-{
-    if (OCamlPrimitiveType *ptype = llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type)))
-    {
-        switch (ptype->GetTypeKind())
-        {
-            case OCamlPrimitiveType::eTypeInt:
-                is_signed = true;
-                return true;
-        }
+bool OCamlASTContext::IsIntegerType(lldb::opaque_compiler_type_t type,
+                                    bool &is_signed) {
+  if (OCamlPrimitiveType *ptype =
+          llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type))) {
+    switch (ptype->GetTypeKind()) {
+    case OCamlPrimitiveType::eTypeInt:
+      is_signed = true;
+      return true;
     }
+  }
 
-    is_signed = false;
-    return false;
+  is_signed = false;
+  return false;
 }
 
-bool
-OCamlASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
-                                    CompilerType *target_type,
-                                    bool check_cplusplus, bool check_objc)
-{
-    return false;
+bool OCamlASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
+                                            CompilerType *target_type,
+                                            bool check_cplusplus,
+                                            bool check_objc) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsRuntimeGeneratedType(
+    lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
-{
-    if (pointee_type)
-        pointee_type->Clear();
-    return false;
+bool OCamlASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
+                                    CompilerType *pointee_type) {
+  if (pointee_type)
+    pointee_type->Clear();
+  return false;
 }
 
-bool
-OCamlASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
-{
-    return IsPointerType(type, pointee_type);
+bool OCamlASTContext::IsPointerOrReferenceType(
+    lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
+  return IsPointerType(type, pointee_type);
 }
 
-bool
-OCamlASTContext::IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool *is_rvalue)
-{
-    return false;
+bool OCamlASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
+                                      CompilerType *pointee_type,
+                                      bool *is_rvalue) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsScalarType(lldb::opaque_compiler_type_t type)
-{
-    return llvm::isa<OCamlPrimitiveType>(static_cast<OCamlType *>(type));
+bool OCamlASTContext::IsScalarType(lldb::opaque_compiler_type_t type) {
+  return llvm::isa<OCamlPrimitiveType>(static_cast<OCamlType *>(type));
 }
 
-bool
-OCamlASTContext::IsTypedefType(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::IsVoidType(lldb::opaque_compiler_type_t type)
-{
-    return false;
+bool OCamlASTContext::IsVoidType(lldb::opaque_compiler_type_t type) {
+  return false;
 }
 
-bool
-OCamlASTContext::SupportsLanguage (lldb::LanguageType language)
-{
-    return language == lldb::eLanguageTypeOCaml;
+bool OCamlASTContext::SupportsLanguage(lldb::LanguageType language) {
+  return language == lldb::eLanguageTypeOCaml;
 }
 
-bool
-OCamlASTContext::GetCompleteType(lldb::opaque_compiler_type_t type)
-{
-    if (IsCompleteType(type))
-        return true;
+bool OCamlASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) {
+  if (IsCompleteType(type))
+    return true;
 
-    return false;
+  return false;
 }
 
-uint32_t
-OCamlASTContext::GetPointerByteSize()
-{
-    return m_pointer_byte_size;
-}
+uint32_t OCamlASTContext::GetPointerByteSize() { return m_pointer_byte_size; }
 
-ConstString
-OCamlASTContext::GetTypeName(lldb::opaque_compiler_type_t type)
-{
-    if (type)
-        return static_cast<OCamlPrimitiveType *>(type)->GetName();
+ConstString OCamlASTContext::GetTypeName(lldb::opaque_compiler_type_t type) {
+  if (type)
+    return static_cast<OCamlPrimitiveType *>(type)->GetName();
 
-    return ConstString();
+  return ConstString();
 }
 
 uint32_t
-OCamlASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type)
-{
-    if (pointee_or_element_compiler_type)
-        pointee_or_element_compiler_type->Clear();
-    if (!type)
-        return 0;
-
-    if (OCamlPrimitiveType *ptype = llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type)))
-    {
-        switch (ptype->GetTypeKind())
-        {
-            case OCamlPrimitiveType::eTypeInt:
-                return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar | eTypeIsInteger | eTypeIsSigned;
-        }
+OCamlASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
+                             CompilerType *pointee_or_element_compiler_type) {
+  if (pointee_or_element_compiler_type)
+    pointee_or_element_compiler_type->Clear();
+  if (!type)
+    return 0;
+
+  if (OCamlPrimitiveType *ptype =
+          llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type))) {
+    switch (ptype->GetTypeKind()) {
+    case OCamlPrimitiveType::eTypeInt:
+      return eTypeHasValue | eTypeIsBuiltIn | eTypeIsScalar | eTypeIsInteger |
+             eTypeIsSigned;
     }
+  }
 
-    return 0;
+  return 0;
 }
 
 lldb::TypeClass
-OCamlASTContext::GetTypeClass(lldb::opaque_compiler_type_t type)
-{
-    if (llvm::isa<OCamlPrimitiveType>(static_cast<OCamlType *>(type)))
-        return eTypeClassBuiltin;
+OCamlASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
+  if (llvm::isa<OCamlPrimitiveType>(static_cast<OCamlType *>(type)))
+    return eTypeClassBuiltin;
 
-    return lldb::eTypeClassInvalid;
+  return lldb::eTypeClassInvalid;
 }
 
 lldb::BasicType
-OCamlASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type)
-{
-    return lldb::eBasicTypeInvalid;
+OCamlASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
+  return lldb::eBasicTypeInvalid;
 }
 
 lldb::LanguageType
-OCamlASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type)
-{
-    return lldb::eLanguageTypeOCaml;
+OCamlASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
+  return lldb::eLanguageTypeOCaml;
 }
 
-unsigned
-OCamlASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type)
-{
-    return 0;
+unsigned OCamlASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
+  return 0;
 }
 
 //----------------------------------------------------------------------
@@ -496,300 +397,273 @@ OCamlASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type)
 //----------------------------------------------------------------------
 
 CompilerType
-OCamlASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride)
-{
-    return CompilerType();
+OCamlASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type,
+                                     uint64_t *stride) {
+  return CompilerType();
 }
 
 CompilerType
-OCamlASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type)
-{
-    return CompilerType(this, type);
+OCamlASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) {
+  return CompilerType(this, type);
 }
 
 CompilerType
-OCamlASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type)
-{
-    return CompilerType(this, type);
+OCamlASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
+  return CompilerType(this, type);
 }
 
-int
-OCamlASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type)
-{
-    return GetNumberOfFunctionArguments(type);
+int OCamlASTContext::GetFunctionArgumentCount(
+    lldb::opaque_compiler_type_t type) {
+  return GetNumberOfFunctionArguments(type);
 }
 
-CompilerType
-OCamlASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx)
-{
-    return GetFunctionArgumentAtIndex(type, idx);
+CompilerType OCamlASTContext::GetFunctionArgumentTypeAtIndex(
+    lldb::opaque_compiler_type_t type, size_t idx) {
+  return GetFunctionArgumentAtIndex(type, idx);
 }
 
 CompilerType
-OCamlASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type)
-{
-    return CompilerType();
+OCamlASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
+  return CompilerType();
 }
 
 size_t
-OCamlASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type)
-{
-    return 0;
+OCamlASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
+  return 0;
 }
 
 TypeMemberFunctionImpl
-OCamlASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx)
-{
-    return TypeMemberFunctionImpl();
+OCamlASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
+                                          size_t idx) {
+  return TypeMemberFunctionImpl();
 }
 
 CompilerType
-OCamlASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type)
-{
-    return CompilerType(this, type);
+OCamlASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
+  return CompilerType(this, type);
 }
 
 CompilerType
-OCamlASTContext::GetPointeeType(lldb::opaque_compiler_type_t type)
-{
-    return CompilerType();
+OCamlASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) {
+  return CompilerType();
 }
 
 CompilerType
-OCamlASTContext::GetPointerType(lldb::opaque_compiler_type_t type)
-{
-    return CompilerType();
+OCamlASTContext::GetPointerType(lldb::opaque_compiler_type_t type) {
+  return CompilerType();
 }
 
 CompilerType
-OCamlASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type)
-{
-    return CompilerType();
+OCamlASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
+  return CompilerType();
 }
 
-CompilerType
-OCamlASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type)
-{
-    return CompilerType();
+CompilerType OCamlASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
+  return CompilerType();
 }
 
 CompilerType
-OCamlASTContext::GetBuiltinTypeForEncodingAndBitSize (lldb::Encoding encoding,
-                                                      size_t bit_size)
-{
-    return CompilerType();
-}
-
-uint64_t
-OCamlASTContext::GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
-{
-    if (OCamlPrimitiveType *ptype = llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type)))
-    {
-        switch (ptype->GetTypeKind())
-        {
-            case OCamlPrimitiveType::eTypeInt:
-                return ptype->GetByteSize() * 8;
-        }
+OCamlASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
+                                                     size_t bit_size) {
+  return CompilerType();
+}
+
+uint64_t OCamlASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
+                                     ExecutionContextScope *exe_scope) {
+  if (OCamlPrimitiveType *ptype =
+          llvm::dyn_cast<OCamlPrimitiveType>(static_cast<OCamlType *>(type))) {
+    switch (ptype->GetTypeKind()) {
+    case OCamlPrimitiveType::eTypeInt:
+      return ptype->GetByteSize() * 8;
     }
-    return 0;
+  }
+  return 0;
 }
 
-lldb::Encoding
-OCamlASTContext::GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count)
-{
-    count = 1;
-    bool is_signed;
-    if (IsIntegerType(type, is_signed))
-        return is_signed ? lldb::eEncodingSint : lldb::eEncodingUint;
-    bool is_complex;
-    uint32_t complex_count;
-    if (IsFloatingPointType(type, complex_count, is_complex))
-    {
-        count = complex_count;
-        return lldb::eEncodingIEEE754;
-    }
-    if (IsPointerType(type))
-        return lldb::eEncodingUint;
-    return lldb::eEncodingInvalid;
+lldb::Encoding OCamlASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
+                                            uint64_t &count) {
+  count = 1;
+  bool is_signed;
+  if (IsIntegerType(type, is_signed))
+    return is_signed ? lldb::eEncodingSint : lldb::eEncodingUint;
+  bool is_complex;
+  uint32_t complex_count;
+  if (IsFloatingPointType(type, complex_count, is_complex)) {
+    count = complex_count;
+    return lldb::eEncodingIEEE754;
+  }
+  if (IsPointerType(type))
+    return lldb::eEncodingUint;
+  return lldb::eEncodingInvalid;
 }
 
-lldb::Format
-OCamlASTContext::GetFormat(lldb::opaque_compiler_type_t type)
-{
-    if (!type)
-        return lldb::eFormatDefault;
-    return lldb::eFormatBytes;
+lldb::Format OCamlASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
+  if (!type)
+    return lldb::eFormatDefault;
+  return lldb::eFormatBytes;
 }
 
-size_t
-OCamlASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type)
-{
-    return 0;
+size_t OCamlASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
+  return 0;
 }
 
-uint32_t
-OCamlASTContext::GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes)
-{
-    if (!type || !GetCompleteType(type))
-        return 0;
+uint32_t OCamlASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
+                                         bool omit_empty_base_classes) {
+  if (!type || !GetCompleteType(type))
+    return 0;
 
-    return GetNumFields(type);
+  return GetNumFields(type);
 }
 
-uint32_t
-OCamlASTContext::GetNumFields(lldb::opaque_compiler_type_t type)
-{
-    if (!type || !GetCompleteType(type))
-        return 0;
+uint32_t OCamlASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
+  if (!type || !GetCompleteType(type))
     return 0;
-}
-
-CompilerType
-OCamlASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, 
-                                 std::string &name, uint64_t *bit_offset_ptr,
-                                 uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr)
-{
-    if (bit_offset_ptr)
-        *bit_offset_ptr = 0;
-    if (bitfield_bit_size_ptr)
-        *bitfield_bit_size_ptr = 0;
-    if (is_bitfield_ptr)
-        *is_bitfield_ptr = false;
-
-    if (!type || !GetCompleteType(type))
-        return CompilerType();
-
+  return 0;
+}
+
+CompilerType OCamlASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
+                                              size_t idx, std::string &name,
+                                              uint64_t *bit_offset_ptr,
+                                              uint32_t *bitfield_bit_size_ptr,
+                                              bool *is_bitfield_ptr) {
+  if (bit_offset_ptr)
+    *bit_offset_ptr = 0;
+  if (bitfield_bit_size_ptr)
+    *bitfield_bit_size_ptr = 0;
+  if (is_bitfield_ptr)
+    *is_bitfield_ptr = false;
+
+  if (!type || !GetCompleteType(type))
     return CompilerType();
-}
-
-CompilerType
-OCamlASTContext::GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
-                                             bool transparent_pointers, bool omit_empty_base_classes,
-                                             bool ignore_array_bounds, std::string &child_name,
-                                             uint32_t &child_byte_size, int32_t &child_byte_offset,
-                                             uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
-                                             bool &child_is_base_class, bool &child_is_deref_of_parent, ValueObject *valobj,
-                                             uint64_t &language_flags)
-{
-    child_name.clear();
-    child_byte_size = 0;
-    child_byte_offset = 0;
-    child_bitfield_bit_size = 0;
-    child_bitfield_bit_offset = 0;
-    child_is_base_class = false;
-    child_is_deref_of_parent = false;
-    language_flags = 0;
-
-    if (!type || !GetCompleteType(type))
-        return CompilerType();
 
+  return CompilerType();
+}
+
+CompilerType OCamlASTContext::GetChildCompilerTypeAtIndex(
+    lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
+    bool transparent_pointers, bool omit_empty_base_classes,
+    bool ignore_array_bounds, std::string &child_name,
+    uint32_t &child_byte_size, int32_t &child_byte_offset,
+    uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
+    bool &child_is_base_class, bool &child_is_deref_of_parent,
+    ValueObject *valobj, uint64_t &language_flags) {
+  child_name.clear();
+  child_byte_size = 0;
+  child_byte_offset = 0;
+  child_bitfield_bit_size = 0;
+  child_bitfield_bit_offset = 0;
+  child_is_base_class = false;
+  child_is_deref_of_parent = false;
+  language_flags = 0;
+
+  if (!type || !GetCompleteType(type))
     return CompilerType();
+
+  return CompilerType();
 }
 
 uint32_t
-OCamlASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes)
-{
-    if (!type || !GetCompleteType(type))
-        return UINT_MAX;
-
+OCamlASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
+                                         const char *name,
+                                         bool omit_empty_base_classes) {
+  if (!type || !GetCompleteType(type))
     return UINT_MAX;
+
+  return UINT_MAX;
 }
 
-size_t
-OCamlASTContext::GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, 
-                                               bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes)
-{
-    uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes);
-    if (index == UINT_MAX)
-        return 0;
-    child_indexes.push_back(index);
-    return 1;
+size_t OCamlASTContext::GetIndexOfChildMemberWithName(
+    lldb::opaque_compiler_type_t type, const char *name,
+    bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
+  uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes);
+  if (index == UINT_MAX)
+    return 0;
+  child_indexes.push_back(index);
+  return 1;
 }
 
 size_t
-OCamlASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size)
-{
-    assert(false);
-    return 0;
+OCamlASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
+                                           const char *s, uint8_t *dst,
+                                           size_t dst_size) {
+  assert(false);
+  return 0;
 }
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 
-void
-OCamlASTContext::DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
-                           const DataExtractor &data, lldb::offset_t data_byte_offset, size_t data_byte_size,
-                           uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary,
-                           bool verbose, uint32_t depth)
-{
-    if (!type) {
-        s->Printf("no type\n");
-        return;
-    }
+void OCamlASTContext::DumpValue(
+    lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
+    lldb::Format format, const DataExtractor &data,
+    lldb::offset_t data_byte_offset, size_t data_byte_size,
+    uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
+    bool show_summary, bool verbose, uint32_t depth) {
+  if (!type) {
+    s->Printf("no type\n");
+    return;
+  }
+
+  s->Printf("no value\n");
+
+  if (show_summary)
+    DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
+}
+
+bool OCamlASTContext::DumpTypeValue(
+    lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
+    const DataExtractor &data, lldb::offset_t byte_offset, size_t byte_size,
+    uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
+    ExecutionContextScope *exe_scope) {
+  if (!type) {
+    s->Printf("no type value\n");
+    return false;
+  }
 
-    s->Printf("no value\n");
+  if (IsScalarType(type)) {
+    return data.Dump(s, byte_offset, format, byte_size, 1, UINT64_MAX,
+                     LLDB_INVALID_ADDRESS, bitfield_bit_size,
+                     bitfield_bit_offset, exe_scope);
+  }
 
-    if (show_summary)
-        DumpSummary (type, exe_ctx, s, data, data_byte_offset, data_byte_size);
+  return false;
 }
 
-bool
-OCamlASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, 
-                               lldb::Format format, const DataExtractor &data,
-                               lldb::offset_t byte_offset, size_t byte_size, uint32_t bitfield_bit_size,
-                               uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope)
-{
-    if (!type) {
-        s->Printf("no type value\n");
-        return false;
-    }
-
-    if (IsScalarType(type))
-    {
-        return 
-        data.Dump(s, byte_offset, format, byte_size, 1, UINT64_MAX,
-                  LLDB_INVALID_ADDRESS, bitfield_bit_size, bitfield_bit_offset, exe_scope);
-    }
-
-    return false;
+void OCamlASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
+                                  ExecutionContext *exe_ctx, Stream *s,
+                                  const DataExtractor &data,
+                                  lldb::offset_t data_offset,
+                                  size_t data_byte_size) {
+  s->Printf("no summary\n");
 }
 
-void
-OCamlASTContext::DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
-                             const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size)
-{
-    s->Printf("no summary\n");
+void OCamlASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
+  StreamFile s(stdout, false);
+  DumpTypeDescription(type, &s);
 }
 
-void
-OCamlASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type)
-{
-    StreamFile s(stdout, false);
-    DumpTypeDescription(type, &s);
+void OCamlASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type,
+                                          Stream *s) {
+  static_cast<OCamlType *>(type)->Dump(s);
 }
 
-void
-OCamlASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s)
-{
-    static_cast<OCamlType *>(type)->Dump(s);
-}
-
-CompilerType
-OCamlASTContext::CreateBaseType(const ConstString &name, uint64_t byte_size)
-{
-    if (m_base_type_map.empty())
-    {
-        OCamlPrimitiveType *type = new OCamlPrimitiveType(OCamlPrimitiveType::eTypeInt, ConstString("ocaml_int"), byte_size);
-        m_base_type_map.emplace(type->GetName(), std::unique_ptr<OCamlASTContext::OCamlType>(type));
-    }
+CompilerType OCamlASTContext::CreateBaseType(const ConstString &name,
+                                             uint64_t byte_size) {
+  if (m_base_type_map.empty()) {
+    OCamlPrimitiveType *type = new OCamlPrimitiveType(
+        OCamlPrimitiveType::eTypeInt, ConstString("ocaml_int"), byte_size);
+    m_base_type_map.emplace(type->GetName(),
+                            std::unique_ptr<OCamlASTContext::OCamlType>(type));
+  }
 
-    auto it = m_base_type_map.find(name);
-    if (it == m_base_type_map.end())
-    {
-        OCamlPrimitiveType *type = new OCamlPrimitiveType(OCamlPrimitiveType::eTypeInt, name, byte_size);
-        it = m_base_type_map.emplace(name, std::unique_ptr<OCamlASTContext::OCamlType>(type)).first;
-    }
+  auto it = m_base_type_map.find(name);
+  if (it == m_base_type_map.end()) {
+    OCamlPrimitiveType *type =
+        new OCamlPrimitiveType(OCamlPrimitiveType::eTypeInt, name, byte_size);
+    it = m_base_type_map
+             .emplace(name, std::unique_ptr<OCamlASTContext::OCamlType>(type))
+             .first;
+  }
 
-    return CompilerType(this, it->second.get());
+  return CompilerType(this, it->second.get());
 }
-