*** 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, 704 insertions, 967 deletions

diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
index 6ea4c6869c9..17028cb4d18 100644
--- a/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
+++ b/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
@@ -1,4 +1,5 @@
-//===-- PythonDataObjects.cpp ------------------------------------*- C++ -*-===//
+//===-- PythonDataObjects.cpp ------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -30,1284 +31,1020 @@
 using namespace lldb_private;
 using namespace lldb;
 
-void
-StructuredPythonObject::Dump(Stream &s, bool pretty_print) const
-{
-    s << "Python Obj: 0x" << GetValue();
+void StructuredPythonObject::Dump(Stream &s, bool pretty_print) const {
+  s << "Python Obj: 0x" << GetValue();
 }
 
 //----------------------------------------------------------------------
 // PythonObject
 //----------------------------------------------------------------------
 
-void
-PythonObject::Dump(Stream &strm) const
-{
-    if (m_py_obj)
-    {
-        FILE *file = ::tmpfile();
-        if (file)
-        {
-            ::PyObject_Print (m_py_obj, file, 0);
-            const long length = ftell (file);
-            if (length)
-            {
-                ::rewind(file);
-                std::vector<char> file_contents (length,'\0');
-                const size_t length_read = ::fread (file_contents.data(), 1, file_contents.size(), file);
-                if (length_read > 0)
-                    strm.Write (file_contents.data(), length_read);
-            }
-            ::fclose (file);
-        }
+void PythonObject::Dump(Stream &strm) const {
+  if (m_py_obj) {
+    FILE *file = ::tmpfile();
+    if (file) {
+      ::PyObject_Print(m_py_obj, file, 0);
+      const long length = ftell(file);
+      if (length) {
+        ::rewind(file);
+        std::vector<char> file_contents(length, '\0');
+        const size_t length_read =
+            ::fread(file_contents.data(), 1, file_contents.size(), file);
+        if (length_read > 0)
+          strm.Write(file_contents.data(), length_read);
+      }
+      ::fclose(file);
     }
-    else
-        strm.PutCString ("NULL");
-}
-
-PyObjectType
-PythonObject::GetObjectType() const
-{
-    if (!IsAllocated())
-        return PyObjectType::None;
-
-    if (PythonModule::Check(m_py_obj))
-        return PyObjectType::Module;
-    if (PythonList::Check(m_py_obj))
-        return PyObjectType::List;
-    if (PythonTuple::Check(m_py_obj))
-        return PyObjectType::Tuple;
-    if (PythonDictionary::Check(m_py_obj))
-        return PyObjectType::Dictionary;
-    if (PythonString::Check(m_py_obj))
-        return PyObjectType::String;
+  } else
+    strm.PutCString("NULL");
+}
+
+PyObjectType PythonObject::GetObjectType() const {
+  if (!IsAllocated())
+    return PyObjectType::None;
+
+  if (PythonModule::Check(m_py_obj))
+    return PyObjectType::Module;
+  if (PythonList::Check(m_py_obj))
+    return PyObjectType::List;
+  if (PythonTuple::Check(m_py_obj))
+    return PyObjectType::Tuple;
+  if (PythonDictionary::Check(m_py_obj))
+    return PyObjectType::Dictionary;
+  if (PythonString::Check(m_py_obj))
+    return PyObjectType::String;
 #if PY_MAJOR_VERSION >= 3
-    if (PythonBytes::Check(m_py_obj))
-        return PyObjectType::Bytes;
+  if (PythonBytes::Check(m_py_obj))
+    return PyObjectType::Bytes;
 #endif
-    if (PythonByteArray::Check(m_py_obj))
-        return PyObjectType::ByteArray;
-    if (PythonInteger::Check(m_py_obj))
-        return PyObjectType::Integer;
-    if (PythonFile::Check(m_py_obj))
-        return PyObjectType::File;
-    if (PythonCallable::Check(m_py_obj))
-        return PyObjectType::Callable;
-    return PyObjectType::Unknown;
-}
-
-PythonString
-PythonObject::Repr() const
-{
-    if (!m_py_obj)
-        return PythonString();
-    PyObject *repr = PyObject_Repr(m_py_obj);
-    if (!repr)
-        return PythonString();
-    return PythonString(PyRefType::Owned, repr);
-}
-
-PythonString
-PythonObject::Str() const
-{
-    if (!m_py_obj)
-        return PythonString();
-    PyObject *str = PyObject_Str(m_py_obj);
-    if (!str)
-        return PythonString();
-    return PythonString(PyRefType::Owned, str);
+  if (PythonByteArray::Check(m_py_obj))
+    return PyObjectType::ByteArray;
+  if (PythonInteger::Check(m_py_obj))
+    return PyObjectType::Integer;
+  if (PythonFile::Check(m_py_obj))
+    return PyObjectType::File;
+  if (PythonCallable::Check(m_py_obj))
+    return PyObjectType::Callable;
+  return PyObjectType::Unknown;
+}
+
+PythonString PythonObject::Repr() const {
+  if (!m_py_obj)
+    return PythonString();
+  PyObject *repr = PyObject_Repr(m_py_obj);
+  if (!repr)
+    return PythonString();
+  return PythonString(PyRefType::Owned, repr);
+}
+
+PythonString PythonObject::Str() const {
+  if (!m_py_obj)
+    return PythonString();
+  PyObject *str = PyObject_Str(m_py_obj);
+  if (!str)
+    return PythonString();
+  return PythonString(PyRefType::Owned, str);
 }
 
 PythonObject
-PythonObject::ResolveNameWithDictionary(llvm::StringRef name, const PythonDictionary &dict)
-{
-    size_t dot_pos = name.find_first_of('.');
-    llvm::StringRef piece = name.substr(0, dot_pos);
-    PythonObject result = dict.GetItemForKey(PythonString(piece));
-    if (dot_pos == llvm::StringRef::npos)
-    {
-        // There was no dot, we're done.
-        return result;
-    }
+PythonObject::ResolveNameWithDictionary(llvm::StringRef name,
+                                        const PythonDictionary &dict) {
+  size_t dot_pos = name.find_first_of('.');
+  llvm::StringRef piece = name.substr(0, dot_pos);
+  PythonObject result = dict.GetItemForKey(PythonString(piece));
+  if (dot_pos == llvm::StringRef::npos) {
+    // There was no dot, we're done.
+    return result;
+  }
+
+  // There was a dot.  The remaining portion of the name should be looked up in
+  // the context of the object that was found in the dictionary.
+  return result.ResolveName(name.substr(dot_pos + 1));
+}
+
+PythonObject PythonObject::ResolveName(llvm::StringRef name) const {
+  // Resolve the name in the context of the specified object.  If,
+  // for example, `this` refers to a PyModule, then this will look for
+  // `name` in this module.  If `this` refers to a PyType, then it will
+  // resolve `name` as an attribute of that type.  If `this` refers to
+  // an instance of an object, then it will resolve `name` as the value
+  // of the specified field.
+  //
+  // This function handles dotted names so that, for example, if `m_py_obj`
+  // refers to the `sys` module, and `name` == "path.append", then it
+  // will find the function `sys.path.append`.
+
+  size_t dot_pos = name.find_first_of('.');
+  if (dot_pos == llvm::StringRef::npos) {
+    // No dots in the name, we should be able to find the value immediately
+    // as an attribute of `m_py_obj`.
+    return GetAttributeValue(name);
+  }
+
+  // Look up the first piece of the name, and resolve the rest as a child of
+  // that.
+  PythonObject parent = ResolveName(name.substr(0, dot_pos));
+  if (!parent.IsAllocated())
+    return PythonObject();
 
-    // There was a dot.  The remaining portion of the name should be looked up in
-    // the context of the object that was found in the dictionary.
-    return result.ResolveName(name.substr(dot_pos + 1));
+  // Tail recursion.. should be optimized by the compiler
+  return parent.ResolveName(name.substr(dot_pos + 1));
 }
 
-PythonObject
-PythonObject::ResolveName(llvm::StringRef name) const
-{
-    // Resolve the name in the context of the specified object.  If,
-    // for example, `this` refers to a PyModule, then this will look for
-    // `name` in this module.  If `this` refers to a PyType, then it will
-    // resolve `name` as an attribute of that type.  If `this` refers to
-    // an instance of an object, then it will resolve `name` as the value
-    // of the specified field.
-    //
-    // This function handles dotted names so that, for example, if `m_py_obj`
-    // refers to the `sys` module, and `name` == "path.append", then it
-    // will find the function `sys.path.append`.
-
-    size_t dot_pos = name.find_first_of('.');
-    if (dot_pos == llvm::StringRef::npos)
-    {
-        // No dots in the name, we should be able to find the value immediately
-        // as an attribute of `m_py_obj`.
-        return GetAttributeValue(name);
-    }
+bool PythonObject::HasAttribute(llvm::StringRef attr) const {
+  if (!IsValid())
+    return false;
+  PythonString py_attr(attr);
+  return !!PyObject_HasAttr(m_py_obj, py_attr.get());
+}
 
-    // Look up the first piece of the name, and resolve the rest as a child of that.
-    PythonObject parent = ResolveName(name.substr(0, dot_pos));
-    if (!parent.IsAllocated())
-        return PythonObject();
+PythonObject PythonObject::GetAttributeValue(llvm::StringRef attr) const {
+  if (!IsValid())
+    return PythonObject();
 
-    // Tail recursion.. should be optimized by the compiler
-    return parent.ResolveName(name.substr(dot_pos + 1));
-}
+  PythonString py_attr(attr);
+  if (!PyObject_HasAttr(m_py_obj, py_attr.get()))
+    return PythonObject();
 
-bool
-PythonObject::HasAttribute(llvm::StringRef attr) const
-{
-    if (!IsValid())
-        return false;
-    PythonString py_attr(attr);
-    return !!PyObject_HasAttr(m_py_obj, py_attr.get());
+  return PythonObject(PyRefType::Owned,
+                      PyObject_GetAttr(m_py_obj, py_attr.get()));
 }
 
-PythonObject
-PythonObject::GetAttributeValue(llvm::StringRef attr) const
-{
-    if (!IsValid())
-        return PythonObject();
-
-    PythonString py_attr(attr);
-    if (!PyObject_HasAttr(m_py_obj, py_attr.get()))
-        return PythonObject();
-
-    return PythonObject(PyRefType::Owned,
-        PyObject_GetAttr(m_py_obj, py_attr.get()));
-}
-
-bool
-PythonObject::IsNone() const
-{
-    return m_py_obj == Py_None;
-}
-
-bool
-PythonObject::IsValid() const
-{
-    return m_py_obj != nullptr;
-}
-
-bool
-PythonObject::IsAllocated() const
-{
-    return IsValid() && !IsNone();
-}
-
-StructuredData::ObjectSP
-PythonObject::CreateStructuredObject() const
-{
-    switch (GetObjectType())
-    {
-        case PyObjectType::Dictionary:
-            return PythonDictionary(PyRefType::Borrowed, m_py_obj).CreateStructuredDictionary();
-        case PyObjectType::Integer:
-            return PythonInteger(PyRefType::Borrowed, m_py_obj).CreateStructuredInteger();
-        case PyObjectType::List:
-            return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
-        case PyObjectType::String:
-            return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
-        case PyObjectType::Bytes:
-            return PythonBytes(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
-        case PyObjectType::ByteArray:
-            return PythonByteArray(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
-        case PyObjectType::None:
-            return StructuredData::ObjectSP();
-        default:
-            return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj));
-    }
+bool PythonObject::IsNone() const { return m_py_obj == Py_None; }
+
+bool PythonObject::IsValid() const { return m_py_obj != nullptr; }
+
+bool PythonObject::IsAllocated() const { return IsValid() && !IsNone(); }
+
+StructuredData::ObjectSP PythonObject::CreateStructuredObject() const {
+  switch (GetObjectType()) {
+  case PyObjectType::Dictionary:
+    return PythonDictionary(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredDictionary();
+  case PyObjectType::Integer:
+    return PythonInteger(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredInteger();
+  case PyObjectType::List:
+    return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
+  case PyObjectType::String:
+    return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
+  case PyObjectType::Bytes:
+    return PythonBytes(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
+  case PyObjectType::ByteArray:
+    return PythonByteArray(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredString();
+  case PyObjectType::None:
+    return StructuredData::ObjectSP();
+  default:
+    return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj));
+  }
 }
 
 //----------------------------------------------------------------------
 // PythonString
 //----------------------------------------------------------------------
-PythonBytes::PythonBytes() : PythonObject()
-{
-}
+PythonBytes::PythonBytes() : PythonObject() {}
 
-PythonBytes::PythonBytes(llvm::ArrayRef<uint8_t> bytes) : PythonObject()
-{
-    SetBytes(bytes);
+PythonBytes::PythonBytes(llvm::ArrayRef<uint8_t> bytes) : PythonObject() {
+  SetBytes(bytes);
 }
 
-PythonBytes::PythonBytes(const uint8_t *bytes, size_t length) : PythonObject()
-{
-    SetBytes(llvm::ArrayRef<uint8_t>(bytes, length));
+PythonBytes::PythonBytes(const uint8_t *bytes, size_t length) : PythonObject() {
+  SetBytes(llvm::ArrayRef<uint8_t>(bytes, length));
 }
 
-PythonBytes::PythonBytes(PyRefType type, PyObject *py_obj) : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
+PythonBytes::PythonBytes(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
 }
 
-PythonBytes::PythonBytes(const PythonBytes &object) : PythonObject(object)
-{
-}
+PythonBytes::PythonBytes(const PythonBytes &object) : PythonObject(object) {}
 
-PythonBytes::~PythonBytes()
-{
-}
+PythonBytes::~PythonBytes() {}
 
-bool
-PythonBytes::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    if (PyBytes_Check(py_obj))
-        return true;
+bool PythonBytes::Check(PyObject *py_obj) {
+  if (!py_obj)
     return false;
+  if (PyBytes_Check(py_obj))
+    return true;
+  return false;
 }
 
-void
-PythonBytes::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonBytes::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonBytes::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonBytes::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-llvm::ArrayRef<uint8_t>
-PythonBytes::GetBytes() const
-{
-    if (!IsValid())
-        return llvm::ArrayRef<uint8_t>();
+llvm::ArrayRef<uint8_t> PythonBytes::GetBytes() const {
+  if (!IsValid())
+    return llvm::ArrayRef<uint8_t>();
 
-    Py_ssize_t size;
-    char *c;
+  Py_ssize_t size;
+  char *c;
 
-    PyBytes_AsStringAndSize(m_py_obj, &c, &size);
-    return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
+  PyBytes_AsStringAndSize(m_py_obj, &c, &size);
+  return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
 }
 
-size_t
-PythonBytes::GetSize() const
-{
-    if (!IsValid())
-        return 0;
-    return PyBytes_Size(m_py_obj);
+size_t PythonBytes::GetSize() const {
+  if (!IsValid())
+    return 0;
+  return PyBytes_Size(m_py_obj);
 }
 
-void
-PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes)
-{
-    const char *data = reinterpret_cast<const char *>(bytes.data());
-    PyObject *py_bytes = PyBytes_FromStringAndSize(data, bytes.size());
-    PythonObject::Reset(PyRefType::Owned, py_bytes);
+void PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes) {
+  const char *data = reinterpret_cast<const char *>(bytes.data());
+  PyObject *py_bytes = PyBytes_FromStringAndSize(data, bytes.size());
+  PythonObject::Reset(PyRefType::Owned, py_bytes);
 }
 
-StructuredData::StringSP
-PythonBytes::CreateStructuredString() const
-{
-    StructuredData::StringSP result(new StructuredData::String);
-    Py_ssize_t size;
-    char *c;
-    PyBytes_AsStringAndSize(m_py_obj, &c, &size);
-    result->SetValue(std::string(c, size));
-    return result;
+StructuredData::StringSP PythonBytes::CreateStructuredString() const {
+  StructuredData::StringSP result(new StructuredData::String);
+  Py_ssize_t size;
+  char *c;
+  PyBytes_AsStringAndSize(m_py_obj, &c, &size);
+  result->SetValue(std::string(c, size));
+  return result;
 }
 
-PythonByteArray::PythonByteArray(llvm::ArrayRef<uint8_t> bytes) : PythonByteArray(bytes.data(), bytes.size())
-{
-}
+PythonByteArray::PythonByteArray(llvm::ArrayRef<uint8_t> bytes)
+    : PythonByteArray(bytes.data(), bytes.size()) {}
 
-PythonByteArray::PythonByteArray(const uint8_t *bytes, size_t length)
-{
-    const char *str = reinterpret_cast<const char *>(bytes);
-    Reset(PyRefType::Owned, PyByteArray_FromStringAndSize(str, length));
+PythonByteArray::PythonByteArray(const uint8_t *bytes, size_t length) {
+  const char *str = reinterpret_cast<const char *>(bytes);
+  Reset(PyRefType::Owned, PyByteArray_FromStringAndSize(str, length));
 }
 
-PythonByteArray::PythonByteArray(PyRefType type, PyObject *o)
-{
-    Reset(type, o);
+PythonByteArray::PythonByteArray(PyRefType type, PyObject *o) {
+  Reset(type, o);
 }
 
-PythonByteArray::PythonByteArray(const PythonBytes &object) : PythonObject(object)
-{
-}
+PythonByteArray::PythonByteArray(const PythonBytes &object)
+    : PythonObject(object) {}
 
-PythonByteArray::~PythonByteArray()
-{
-}
+PythonByteArray::~PythonByteArray() {}
 
-bool
-PythonByteArray::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    if (PyByteArray_Check(py_obj))
-        return true;
+bool PythonByteArray::Check(PyObject *py_obj) {
+  if (!py_obj)
     return false;
+  if (PyByteArray_Check(py_obj))
+    return true;
+  return false;
 }
 
-void
-PythonByteArray::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonByteArray::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonByteArray::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonByteArray::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-llvm::ArrayRef<uint8_t>
-PythonByteArray::GetBytes() const
-{
-    if (!IsValid())
-        return llvm::ArrayRef<uint8_t>();
+llvm::ArrayRef<uint8_t> PythonByteArray::GetBytes() const {
+  if (!IsValid())
+    return llvm::ArrayRef<uint8_t>();
 
-    char *c = PyByteArray_AsString(m_py_obj);
-    size_t size = GetSize();
-    return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
+  char *c = PyByteArray_AsString(m_py_obj);
+  size_t size = GetSize();
+  return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
 }
 
-size_t
-PythonByteArray::GetSize() const
-{
-    if (!IsValid())
-        return 0;
+size_t PythonByteArray::GetSize() const {
+  if (!IsValid())
+    return 0;
 
-    return PyByteArray_Size(m_py_obj);
+  return PyByteArray_Size(m_py_obj);
 }
 
-StructuredData::StringSP
-PythonByteArray::CreateStructuredString() const
-{
-    StructuredData::StringSP result(new StructuredData::String);
-    llvm::ArrayRef<uint8_t> bytes = GetBytes();
-    const char *str = reinterpret_cast<const char *>(bytes.data());
-    result->SetValue(std::string(str, bytes.size()));
-    return result;
+StructuredData::StringSP PythonByteArray::CreateStructuredString() const {
+  StructuredData::StringSP result(new StructuredData::String);
+  llvm::ArrayRef<uint8_t> bytes = GetBytes();
+  const char *str = reinterpret_cast<const char *>(bytes.data());
+  result->SetValue(std::string(str, bytes.size()));
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonString
 //----------------------------------------------------------------------
 
-PythonString::PythonString(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
+PythonString::PythonString(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
 }
 
-PythonString::PythonString(const PythonString &object)
-    : PythonObject(object)
-{
-}
+PythonString::PythonString(const PythonString &object) : PythonObject(object) {}
 
-PythonString::PythonString(llvm::StringRef string)
-    : PythonObject()
-{
-    SetString(string);
+PythonString::PythonString(llvm::StringRef string) : PythonObject() {
+  SetString(string);
 }
 
-PythonString::PythonString(const char *string)
-    : PythonObject()
-{
-    SetString(llvm::StringRef(string));
+PythonString::PythonString(const char *string) : PythonObject() {
+  SetString(llvm::StringRef(string));
 }
 
-PythonString::PythonString()
-    : PythonObject()
-{
-}
+PythonString::PythonString() : PythonObject() {}
 
-PythonString::~PythonString ()
-{
-}
+PythonString::~PythonString() {}
 
-bool
-PythonString::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonString::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    if (PyUnicode_Check(py_obj))
-        return true;
+  if (PyUnicode_Check(py_obj))
+    return true;
 #if PY_MAJOR_VERSION < 3
-    if (PyString_Check(py_obj))
-        return true;
+  if (PyString_Check(py_obj))
+    return true;
 #endif
-    return false;
+  return false;
 }
 
-void
-PythonString::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonString::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonString::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonString::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 #if PY_MAJOR_VERSION < 3
-    // In Python 2, Don't store PyUnicode objects directly, because we need
-    // access to their underlying character buffers which Python 2 doesn't
-    // provide.
-    if (PyUnicode_Check(py_obj))
-        result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(result.get()));
+  // In Python 2, Don't store PyUnicode objects directly, because we need
+  // access to their underlying character buffers which Python 2 doesn't
+  // provide.
+  if (PyUnicode_Check(py_obj))
+    result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(result.get()));
 #endif
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-llvm::StringRef
-PythonString::GetString() const
-{
-    if (!IsValid())
-        return llvm::StringRef();
+llvm::StringRef PythonString::GetString() const {
+  if (!IsValid())
+    return llvm::StringRef();
 
-    Py_ssize_t size;
-    char *c;
+  Py_ssize_t size;
+  char *c;
 
 #if PY_MAJOR_VERSION >= 3
-    c = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
+  c = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
 #else
-    PyString_AsStringAndSize(m_py_obj, &c, &size);
+  PyString_AsStringAndSize(m_py_obj, &c, &size);
 #endif
-    return llvm::StringRef(c, size);
+  return llvm::StringRef(c, size);
 }
 
-size_t
-PythonString::GetSize() const
-{
-    if (IsValid())
-    {
+size_t PythonString::GetSize() const {
+  if (IsValid()) {
 #if PY_MAJOR_VERSION >= 3
-        return PyUnicode_GetSize(m_py_obj);
+    return PyUnicode_GetSize(m_py_obj);
 #else
-        return PyString_Size(m_py_obj);
+    return PyString_Size(m_py_obj);
 #endif
-    }
-    return 0;
+  }
+  return 0;
 }
 
-void
-PythonString::SetString (llvm::StringRef string)
-{
+void PythonString::SetString(llvm::StringRef string) {
 #if PY_MAJOR_VERSION >= 3
-    PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
-    PythonObject::Reset(PyRefType::Owned, unicode);
+  PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
+  PythonObject::Reset(PyRefType::Owned, unicode);
 #else
-    PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
-    PythonObject::Reset(PyRefType::Owned, str);
+  PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
+  PythonObject::Reset(PyRefType::Owned, str);
 #endif
 }
 
-StructuredData::StringSP
-PythonString::CreateStructuredString() const
-{
-    StructuredData::StringSP result(new StructuredData::String);
-    result->SetValue(GetString());
-    return result;
+StructuredData::StringSP PythonString::CreateStructuredString() const {
+  StructuredData::StringSP result(new StructuredData::String);
+  result->SetValue(GetString());
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonInteger
 //----------------------------------------------------------------------
 
-PythonInteger::PythonInteger()
-    : PythonObject()
-{
-
-}
+PythonInteger::PythonInteger() : PythonObject() {}
 
 PythonInteger::PythonInteger(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a integer type
+    : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a integer type
 }
 
 PythonInteger::PythonInteger(const PythonInteger &object)
-    : PythonObject(object)
-{
-}
+    : PythonObject(object) {}
 
-PythonInteger::PythonInteger(int64_t value)
-    : PythonObject()
-{
-    SetInteger(value);
+PythonInteger::PythonInteger(int64_t value) : PythonObject() {
+  SetInteger(value);
 }
 
+PythonInteger::~PythonInteger() {}
 
-PythonInteger::~PythonInteger ()
-{
-}
-
-bool
-PythonInteger::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonInteger::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
 #if PY_MAJOR_VERSION >= 3
-    // Python 3 does not have PyInt_Check.  There is only one type of
-    // integral value, long.
-    return PyLong_Check(py_obj);
+  // Python 3 does not have PyInt_Check.  There is only one type of
+  // integral value, long.
+  return PyLong_Check(py_obj);
 #else
-    return PyLong_Check(py_obj) || PyInt_Check(py_obj);
+  return PyLong_Check(py_obj) || PyInt_Check(py_obj);
 #endif
 }
 
-void
-PythonInteger::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonInteger::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonInteger::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonInteger::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
 #if PY_MAJOR_VERSION < 3
-    // Always store this as a PyLong, which makes interoperability between
-    // Python 2.x and Python 3.x easier.  This is only necessary in 2.x,
-    // since 3.x doesn't even have a PyInt.
-    if (PyInt_Check(py_obj))
-    {
-        // Since we converted the original object to a different type, the new
-        // object is an owned object regardless of the ownership semantics requested
-        // by the user.
-        result.Reset(PyRefType::Owned, PyLong_FromLongLong(PyInt_AsLong(py_obj)));
-    }
+  // Always store this as a PyLong, which makes interoperability between
+  // Python 2.x and Python 3.x easier.  This is only necessary in 2.x,
+  // since 3.x doesn't even have a PyInt.
+  if (PyInt_Check(py_obj)) {
+    // Since we converted the original object to a different type, the new
+    // object is an owned object regardless of the ownership semantics requested
+    // by the user.
+    result.Reset(PyRefType::Owned, PyLong_FromLongLong(PyInt_AsLong(py_obj)));
+  }
 #endif
 
-    assert(PyLong_Check(result.get()) && "Couldn't get a PyLong from this PyObject");
-
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
-}
-
-int64_t
-PythonInteger::GetInteger() const
-{
-    if (m_py_obj)
-    {
-        assert(PyLong_Check(m_py_obj) && "PythonInteger::GetInteger has a PyObject that isn't a PyLong");
-
-        int overflow = 0;
-        int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow);
-        if (overflow != 0)
-        {
-            // We got an integer that overflows, like 18446744072853913392L
-            // we can't use PyLong_AsLongLong() as it will return
-            // 0xffffffffffffffff. If we use the unsigned long long
-            // it will work as expected.
-            const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj);
-            result = *((int64_t *)&uval);
-        }
-        return result;
+  assert(PyLong_Check(result.get()) &&
+         "Couldn't get a PyLong from this PyObject");
+
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
+}
+
+int64_t PythonInteger::GetInteger() const {
+  if (m_py_obj) {
+    assert(PyLong_Check(m_py_obj) &&
+           "PythonInteger::GetInteger has a PyObject that isn't a PyLong");
+
+    int overflow = 0;
+    int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow);
+    if (overflow != 0) {
+      // We got an integer that overflows, like 18446744072853913392L
+      // we can't use PyLong_AsLongLong() as it will return
+      // 0xffffffffffffffff. If we use the unsigned long long
+      // it will work as expected.
+      const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj);
+      result = *((int64_t *)&uval);
     }
-    return UINT64_MAX;
+    return result;
+  }
+  return UINT64_MAX;
 }
 
-void
-PythonInteger::SetInteger(int64_t value)
-{
-    PythonObject::Reset(PyRefType::Owned, PyLong_FromLongLong(value));
+void PythonInteger::SetInteger(int64_t value) {
+  PythonObject::Reset(PyRefType::Owned, PyLong_FromLongLong(value));
 }
 
-StructuredData::IntegerSP
-PythonInteger::CreateStructuredInteger() const
-{
-    StructuredData::IntegerSP result(new StructuredData::Integer);
-    result->SetValue(GetInteger());
-    return result;
+StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
+  StructuredData::IntegerSP result(new StructuredData::Integer);
+  result->SetValue(GetInteger());
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonList
 //----------------------------------------------------------------------
 
-PythonList::PythonList(PyInitialValue value)
-    : PythonObject()
-{
-    if (value == PyInitialValue::Empty)
-        Reset(PyRefType::Owned, PyList_New(0));
+PythonList::PythonList(PyInitialValue value) : PythonObject() {
+  if (value == PyInitialValue::Empty)
+    Reset(PyRefType::Owned, PyList_New(0));
 }
 
-PythonList::PythonList(int list_size)
-    : PythonObject()
-{
-    Reset(PyRefType::Owned, PyList_New(list_size));
+PythonList::PythonList(int list_size) : PythonObject() {
+  Reset(PyRefType::Owned, PyList_New(list_size));
 }
 
-PythonList::PythonList(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a list
+PythonList::PythonList(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a list
 }
 
-PythonList::PythonList(const PythonList &list)
-    : PythonObject(list)
-{
-}
+PythonList::PythonList(const PythonList &list) : PythonObject(list) {}
 
-PythonList::~PythonList ()
-{
-}
+PythonList::~PythonList() {}
 
-bool
-PythonList::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    return PyList_Check(py_obj);
+bool PythonList::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyList_Check(py_obj);
 }
 
-void
-PythonList::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonList::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonList::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonList::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-uint32_t
-PythonList::GetSize() const
-{
-    if (IsValid())
-        return PyList_GET_SIZE(m_py_obj);
-    return 0;
+uint32_t PythonList::GetSize() const {
+  if (IsValid())
+    return PyList_GET_SIZE(m_py_obj);
+  return 0;
 }
 
-PythonObject
-PythonList::GetItemAtIndex(uint32_t index) const
-{
-    if (IsValid())
-        return PythonObject(PyRefType::Borrowed, PyList_GetItem(m_py_obj, index));
-    return PythonObject();
+PythonObject PythonList::GetItemAtIndex(uint32_t index) const {
+  if (IsValid())
+    return PythonObject(PyRefType::Borrowed, PyList_GetItem(m_py_obj, index));
+  return PythonObject();
 }
 
-void
-PythonList::SetItemAtIndex(uint32_t index, const PythonObject &object)
-{
-    if (IsAllocated() && object.IsValid())
-    {
-        // PyList_SetItem is documented to "steal" a reference, so we need to
-        // convert it to an owned reference by incrementing it.
-        Py_INCREF(object.get());
-        PyList_SetItem(m_py_obj, index, object.get());
-    }
+void PythonList::SetItemAtIndex(uint32_t index, const PythonObject &object) {
+  if (IsAllocated() && object.IsValid()) {
+    // PyList_SetItem is documented to "steal" a reference, so we need to
+    // convert it to an owned reference by incrementing it.
+    Py_INCREF(object.get());
+    PyList_SetItem(m_py_obj, index, object.get());
+  }
 }
 
-void
-PythonList::AppendItem(const PythonObject &object)
-{
-    if (IsAllocated() && object.IsValid())
-    {
-        // `PyList_Append` does *not* steal a reference, so do not call `Py_INCREF`
-        // here like we do with `PyList_SetItem`.
-        PyList_Append(m_py_obj, object.get());
-    }
+void PythonList::AppendItem(const PythonObject &object) {
+  if (IsAllocated() && object.IsValid()) {
+    // `PyList_Append` does *not* steal a reference, so do not call `Py_INCREF`
+    // here like we do with `PyList_SetItem`.
+    PyList_Append(m_py_obj, object.get());
+  }
 }
 
-StructuredData::ArraySP
-PythonList::CreateStructuredArray() const
-{
-    StructuredData::ArraySP result(new StructuredData::Array);
-    uint32_t count = GetSize();
-    for (uint32_t i = 0; i < count; ++i)
-    {
-        PythonObject obj = GetItemAtIndex(i);
-        result->AddItem(obj.CreateStructuredObject());
-    }
-    return result;
+StructuredData::ArraySP PythonList::CreateStructuredArray() const {
+  StructuredData::ArraySP result(new StructuredData::Array);
+  uint32_t count = GetSize();
+  for (uint32_t i = 0; i < count; ++i) {
+    PythonObject obj = GetItemAtIndex(i);
+    result->AddItem(obj.CreateStructuredObject());
+  }
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonTuple
 //----------------------------------------------------------------------
 
-PythonTuple::PythonTuple(PyInitialValue value)
-    : PythonObject()
-{
-    if (value == PyInitialValue::Empty)
-        Reset(PyRefType::Owned, PyTuple_New(0));
+PythonTuple::PythonTuple(PyInitialValue value) : PythonObject() {
+  if (value == PyInitialValue::Empty)
+    Reset(PyRefType::Owned, PyTuple_New(0));
 }
 
-PythonTuple::PythonTuple(int tuple_size)
-    : PythonObject()
-{
-    Reset(PyRefType::Owned, PyTuple_New(tuple_size));
+PythonTuple::PythonTuple(int tuple_size) : PythonObject() {
+  Reset(PyRefType::Owned, PyTuple_New(tuple_size));
 }
 
-PythonTuple::PythonTuple(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a tuple
+PythonTuple::PythonTuple(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a tuple
 }
 
-PythonTuple::PythonTuple(const PythonTuple &tuple)
-    : PythonObject(tuple)
-{
-}
+PythonTuple::PythonTuple(const PythonTuple &tuple) : PythonObject(tuple) {}
 
-PythonTuple::PythonTuple(std::initializer_list<PythonObject> objects)
-{
-    m_py_obj = PyTuple_New(objects.size());
+PythonTuple::PythonTuple(std::initializer_list<PythonObject> objects) {
+  m_py_obj = PyTuple_New(objects.size());
 
-    uint32_t idx = 0;
-    for (auto object : objects)
-    {
-        if (object.IsValid())
-            SetItemAtIndex(idx, object);
-        idx++;
-    }
+  uint32_t idx = 0;
+  for (auto object : objects) {
+    if (object.IsValid())
+      SetItemAtIndex(idx, object);
+    idx++;
+  }
 }
 
-PythonTuple::PythonTuple(std::initializer_list<PyObject*> objects)
-{
-    m_py_obj = PyTuple_New(objects.size());
+PythonTuple::PythonTuple(std::initializer_list<PyObject *> objects) {
+  m_py_obj = PyTuple_New(objects.size());
 
-    uint32_t idx = 0;
-    for (auto py_object : objects)
-    {
-        PythonObject object(PyRefType::Borrowed, py_object);
-        if (object.IsValid())
-            SetItemAtIndex(idx, object);
-        idx++;
-    }
+  uint32_t idx = 0;
+  for (auto py_object : objects) {
+    PythonObject object(PyRefType::Borrowed, py_object);
+    if (object.IsValid())
+      SetItemAtIndex(idx, object);
+    idx++;
+  }
 }
 
-PythonTuple::~PythonTuple()
-{
-}
+PythonTuple::~PythonTuple() {}
 
-bool
-PythonTuple::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    return PyTuple_Check(py_obj);
+bool PythonTuple::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyTuple_Check(py_obj);
 }
 
-void
-PythonTuple::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonTuple::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonTuple::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonTuple::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-uint32_t
-PythonTuple::GetSize() const
-{
-    if (IsValid())
-        return PyTuple_GET_SIZE(m_py_obj);
-    return 0;
+uint32_t PythonTuple::GetSize() const {
+  if (IsValid())
+    return PyTuple_GET_SIZE(m_py_obj);
+  return 0;
 }
 
-PythonObject
-PythonTuple::GetItemAtIndex(uint32_t index) const
-{
-    if (IsValid())
-        return PythonObject(PyRefType::Borrowed, PyTuple_GetItem(m_py_obj, index));
-    return PythonObject();
+PythonObject PythonTuple::GetItemAtIndex(uint32_t index) const {
+  if (IsValid())
+    return PythonObject(PyRefType::Borrowed, PyTuple_GetItem(m_py_obj, index));
+  return PythonObject();
 }
 
-void
-PythonTuple::SetItemAtIndex(uint32_t index, const PythonObject &object)
-{
-    if (IsAllocated() && object.IsValid())
-    {
-        // PyTuple_SetItem is documented to "steal" a reference, so we need to
-        // convert it to an owned reference by incrementing it.
-        Py_INCREF(object.get());
-        PyTuple_SetItem(m_py_obj, index, object.get());
-    }
+void PythonTuple::SetItemAtIndex(uint32_t index, const PythonObject &object) {
+  if (IsAllocated() && object.IsValid()) {
+    // PyTuple_SetItem is documented to "steal" a reference, so we need to
+    // convert it to an owned reference by incrementing it.
+    Py_INCREF(object.get());
+    PyTuple_SetItem(m_py_obj, index, object.get());
+  }
 }
 
-StructuredData::ArraySP
-PythonTuple::CreateStructuredArray() const
-{
-    StructuredData::ArraySP result(new StructuredData::Array);
-    uint32_t count = GetSize();
-    for (uint32_t i = 0; i < count; ++i)
-    {
-        PythonObject obj = GetItemAtIndex(i);
-        result->AddItem(obj.CreateStructuredObject());
-    }
-    return result;
+StructuredData::ArraySP PythonTuple::CreateStructuredArray() const {
+  StructuredData::ArraySP result(new StructuredData::Array);
+  uint32_t count = GetSize();
+  for (uint32_t i = 0; i < count; ++i) {
+    PythonObject obj = GetItemAtIndex(i);
+    result->AddItem(obj.CreateStructuredObject());
+  }
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonDictionary
 //----------------------------------------------------------------------
 
-PythonDictionary::PythonDictionary(PyInitialValue value)
-    : PythonObject()
-{
-    if (value == PyInitialValue::Empty)
-        Reset(PyRefType::Owned, PyDict_New());
+PythonDictionary::PythonDictionary(PyInitialValue value) : PythonObject() {
+  if (value == PyInitialValue::Empty)
+    Reset(PyRefType::Owned, PyDict_New());
 }
 
 PythonDictionary::PythonDictionary(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
+    : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
 }
 
 PythonDictionary::PythonDictionary(const PythonDictionary &object)
-    : PythonObject(object)
-{
-}
+    : PythonObject(object) {}
 
-PythonDictionary::~PythonDictionary ()
-{
-}
+PythonDictionary::~PythonDictionary() {}
 
-bool
-PythonDictionary::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonDictionary::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    return PyDict_Check(py_obj);
+  return PyDict_Check(py_obj);
 }
 
-void
-PythonDictionary::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonDictionary::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonDictionary::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonDictionary::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-uint32_t
-PythonDictionary::GetSize() const
-{
-    if (IsValid())
-        return PyDict_Size(m_py_obj);
-    return 0;
+uint32_t PythonDictionary::GetSize() const {
+  if (IsValid())
+    return PyDict_Size(m_py_obj);
+  return 0;
 }
 
-PythonList
-PythonDictionary::GetKeys() const
-{
-    if (IsValid())
-        return PythonList(PyRefType::Owned, PyDict_Keys(m_py_obj));
-    return PythonList(PyInitialValue::Invalid);
+PythonList PythonDictionary::GetKeys() const {
+  if (IsValid())
+    return PythonList(PyRefType::Owned, PyDict_Keys(m_py_obj));
+  return PythonList(PyInitialValue::Invalid);
 }
 
-PythonObject
-PythonDictionary::GetItemForKey(const PythonObject &key) const
-{
-    if (IsAllocated() && key.IsValid())
-        return PythonObject(PyRefType::Borrowed, PyDict_GetItem(m_py_obj, key.get()));
-    return PythonObject();
+PythonObject PythonDictionary::GetItemForKey(const PythonObject &key) const {
+  if (IsAllocated() && key.IsValid())
+    return PythonObject(PyRefType::Borrowed,
+                        PyDict_GetItem(m_py_obj, key.get()));
+  return PythonObject();
 }
 
-void
-PythonDictionary::SetItemForKey(const PythonObject &key, const PythonObject &value)
-{
-    if (IsAllocated() && key.IsValid() && value.IsValid())
-        PyDict_SetItem(m_py_obj, key.get(), value.get());
+void PythonDictionary::SetItemForKey(const PythonObject &key,
+                                     const PythonObject &value) {
+  if (IsAllocated() && key.IsValid() && value.IsValid())
+    PyDict_SetItem(m_py_obj, key.get(), value.get());
 }
 
 StructuredData::DictionarySP
-PythonDictionary::CreateStructuredDictionary() const
-{
-    StructuredData::DictionarySP result(new StructuredData::Dictionary);
-    PythonList keys(GetKeys());
-    uint32_t num_keys = keys.GetSize();
-    for (uint32_t i = 0; i < num_keys; ++i)
-    {
-        PythonObject key = keys.GetItemAtIndex(i);
-        PythonObject value = GetItemForKey(key);
-        StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
-        result->AddItem(key.Str().GetString(), structured_value);
-    }
-    return result;
+PythonDictionary::CreateStructuredDictionary() const {
+  StructuredData::DictionarySP result(new StructuredData::Dictionary);
+  PythonList keys(GetKeys());
+  uint32_t num_keys = keys.GetSize();
+  for (uint32_t i = 0; i < num_keys; ++i) {
+    PythonObject key = keys.GetItemAtIndex(i);
+    PythonObject value = GetItemForKey(key);
+    StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
+    result->AddItem(key.Str().GetString(), structured_value);
+  }
+  return result;
 }
 
-PythonModule::PythonModule() : PythonObject()
-{
-}
+PythonModule::PythonModule() : PythonObject() {}
 
-PythonModule::PythonModule(PyRefType type, PyObject *py_obj)
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a module
+PythonModule::PythonModule(PyRefType type, PyObject *py_obj) {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a module
 }
 
-PythonModule::PythonModule(const PythonModule &dict) : PythonObject(dict)
-{
-}
+PythonModule::PythonModule(const PythonModule &dict) : PythonObject(dict) {}
 
-PythonModule::~PythonModule()
-{
-}
+PythonModule::~PythonModule() {}
 
-PythonModule
-PythonModule::BuiltinsModule()
-{
+PythonModule PythonModule::BuiltinsModule() {
 #if PY_MAJOR_VERSION >= 3
-    return AddModule("builtins");
+  return AddModule("builtins");
 #else
-    return AddModule("__builtin__");
+  return AddModule("__builtin__");
 #endif
 }
 
-PythonModule
-PythonModule::MainModule()
-{
-    return AddModule("__main__");
-}
+PythonModule PythonModule::MainModule() { return AddModule("__main__"); }
 
-PythonModule
-PythonModule::AddModule(llvm::StringRef module)
-{
-    std::string str = module.str();
-    return PythonModule(PyRefType::Borrowed, PyImport_AddModule(str.c_str()));
+PythonModule PythonModule::AddModule(llvm::StringRef module) {
+  std::string str = module.str();
+  return PythonModule(PyRefType::Borrowed, PyImport_AddModule(str.c_str()));
 }
 
-
-PythonModule
-PythonModule::ImportModule(llvm::StringRef module)
-{
-    std::string str = module.str();
-    return PythonModule(PyRefType::Owned, PyImport_ImportModule(str.c_str()));
+PythonModule PythonModule::ImportModule(llvm::StringRef module) {
+  std::string str = module.str();
+  return PythonModule(PyRefType::Owned, PyImport_ImportModule(str.c_str()));
 }
 
-bool
-PythonModule::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonModule::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    return PyModule_Check(py_obj);
+  return PyModule_Check(py_obj);
 }
 
-void
-PythonModule::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonModule::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonModule::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonModule::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-PythonDictionary
-PythonModule::GetDictionary() const
-{
-    return PythonDictionary(PyRefType::Borrowed, PyModule_GetDict(m_py_obj));
+PythonDictionary PythonModule::GetDictionary() const {
+  return PythonDictionary(PyRefType::Borrowed, PyModule_GetDict(m_py_obj));
 }
 
-PythonCallable::PythonCallable() : PythonObject()
-{
-}
+PythonCallable::PythonCallable() : PythonObject() {}
 
-PythonCallable::PythonCallable(PyRefType type, PyObject *py_obj)
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a callable
+PythonCallable::PythonCallable(PyRefType type, PyObject *py_obj) {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a callable
 }
 
 PythonCallable::PythonCallable(const PythonCallable &callable)
-    : PythonObject(callable)
-{
-}
+    : PythonObject(callable) {}
 
-PythonCallable::~PythonCallable()
-{
-}
+PythonCallable::~PythonCallable() {}
 
-bool
-PythonCallable::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonCallable::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    return PyCallable_Check(py_obj);
+  return PyCallable_Check(py_obj);
 }
 
-void
-PythonCallable::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonCallable::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonCallable::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonCallable::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
+PythonCallable::ArgInfo PythonCallable::GetNumArguments() const {
+  ArgInfo result = {0, false, false, false};
+  if (!IsValid())
+    return result;
 
-PythonCallable::ArgInfo
-PythonCallable::GetNumArguments() const
-{
-    ArgInfo result = { 0, false, false, false };
-    if (!IsValid())
-        return result;
-
-    PyObject *py_func_obj = m_py_obj;
-    if (PyMethod_Check(py_func_obj))
-    {
-        py_func_obj = PyMethod_GET_FUNCTION(py_func_obj);
-        PythonObject im_self = GetAttributeValue("im_self");
-        if (im_self.IsValid() && !im_self.IsNone())
+  PyObject *py_func_obj = m_py_obj;
+  if (PyMethod_Check(py_func_obj)) {
+    py_func_obj = PyMethod_GET_FUNCTION(py_func_obj);
+    PythonObject im_self = GetAttributeValue("im_self");
+    if (im_self.IsValid() && !im_self.IsNone())
+      result.is_bound_method = true;
+  } else {
+    // see if this is a callable object with an __call__ method
+    if (!PyFunction_Check(py_func_obj)) {
+      PythonObject __call__ = GetAttributeValue("__call__");
+      if (__call__.IsValid()) {
+        auto __callable__ = __call__.AsType<PythonCallable>();
+        if (__callable__.IsValid()) {
+          py_func_obj = PyMethod_GET_FUNCTION(__callable__.get());
+          PythonObject im_self = GetAttributeValue("im_self");
+          if (im_self.IsValid() && !im_self.IsNone())
             result.is_bound_method = true;
-    }
-    else
-    {
-        // see if this is a callable object with an __call__ method
-        if (!PyFunction_Check(py_func_obj))
-        {
-            PythonObject __call__ = GetAttributeValue("__call__");
-            if (__call__.IsValid())
-            {
-                auto __callable__ = __call__.AsType<PythonCallable>();
-                if (__callable__.IsValid())
-                {
-                    py_func_obj = PyMethod_GET_FUNCTION(__callable__.get());
-                    PythonObject im_self = GetAttributeValue("im_self");
-                    if (im_self.IsValid() && !im_self.IsNone())
-                        result.is_bound_method = true;
-                }
-            }
         }
+      }
     }
+  }
 
-    if (!py_func_obj)
-        return result;
-
-    PyCodeObject* code = (PyCodeObject*)PyFunction_GET_CODE(py_func_obj);
-    if (!code)
-        return result;
+  if (!py_func_obj)
+    return result;
 
-    result.count = code->co_argcount;
-    result.has_varargs = !!(code->co_flags & CO_VARARGS);
-    result.has_kwargs = !!(code->co_flags & CO_VARKEYWORDS);
+  PyCodeObject *code = (PyCodeObject *)PyFunction_GET_CODE(py_func_obj);
+  if (!code)
     return result;
-}
 
-PythonObject
-PythonCallable::operator ()()
-{
-    return PythonObject(PyRefType::Owned,
-        PyObject_CallObject(m_py_obj, nullptr));
+  result.count = code->co_argcount;
+  result.has_varargs = !!(code->co_flags & CO_VARARGS);
+  result.has_kwargs = !!(code->co_flags & CO_VARKEYWORDS);
+  return result;
 }
 
-PythonObject
-PythonCallable::operator ()(std::initializer_list<PyObject*> args)
-{
-    PythonTuple arg_tuple(args);
-    return PythonObject(PyRefType::Owned,
-        PyObject_CallObject(m_py_obj, arg_tuple.get()));
+PythonObject PythonCallable::operator()() {
+  return PythonObject(PyRefType::Owned, PyObject_CallObject(m_py_obj, nullptr));
 }
 
-PythonObject
-PythonCallable::operator ()(std::initializer_list<PythonObject> args)
-{
-    PythonTuple arg_tuple(args);
-    return PythonObject(PyRefType::Owned,
-        PyObject_CallObject(m_py_obj, arg_tuple.get()));
+PythonObject PythonCallable::
+operator()(std::initializer_list<PyObject *> args) {
+  PythonTuple arg_tuple(args);
+  return PythonObject(PyRefType::Owned,
+                      PyObject_CallObject(m_py_obj, arg_tuple.get()));
 }
 
-PythonFile::PythonFile()
-    : PythonObject()
-{
+PythonObject PythonCallable::
+operator()(std::initializer_list<PythonObject> args) {
+  PythonTuple arg_tuple(args);
+  return PythonObject(PyRefType::Owned,
+                      PyObject_CallObject(m_py_obj, arg_tuple.get()));
 }
 
-PythonFile::PythonFile(File &file, const char *mode)
-{
-    Reset(file, mode);
-}
+PythonFile::PythonFile() : PythonObject() {}
 
-PythonFile::PythonFile(const char *path, const char *mode)
-{
-    lldb_private::File file(path, GetOptionsFromMode(mode));
-    Reset(file, mode);
-}
+PythonFile::PythonFile(File &file, const char *mode) { Reset(file, mode); }
 
-PythonFile::PythonFile(PyRefType type, PyObject *o)
-{
-    Reset(type, o);
+PythonFile::PythonFile(const char *path, const char *mode) {
+  lldb_private::File file(path, GetOptionsFromMode(mode));
+  Reset(file, mode);
 }
 
-PythonFile::~PythonFile()
-{
-}
+PythonFile::PythonFile(PyRefType type, PyObject *o) { Reset(type, o); }
+
+PythonFile::~PythonFile() {}
 
-bool
-PythonFile::Check(PyObject *py_obj)
-{
+bool PythonFile::Check(PyObject *py_obj) {
 #if PY_MAJOR_VERSION < 3
-    return PyFile_Check(py_obj);
+  return PyFile_Check(py_obj);
 #else
-    // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a
-    // first-class object type anymore.  `PyFile_FromFd` is just a thin wrapper
-    // over `io.open()`, which returns some object derived from `io.IOBase`.
-    // As a result, the only way to detect a file in Python 3 is to check whether
-    // it inherits from `io.IOBase`.  Since it is possible for non-files to also
-    // inherit from `io.IOBase`, we additionally verify that it has the `fileno`
-    // attribute, which should guarantee that it is backed by the file system.
-    PythonObject io_module(PyRefType::Owned, PyImport_ImportModule("io"));
-    PythonDictionary io_dict(PyRefType::Borrowed, PyModule_GetDict(io_module.get()));
-    PythonObject io_base_class = io_dict.GetItemForKey(PythonString("IOBase"));
-
-    PythonObject object_type(PyRefType::Owned, PyObject_Type(py_obj));
-
-    if (1 != PyObject_IsSubclass(object_type.get(), io_base_class.get()))
-        return false;
-    if (!object_type.HasAttribute("fileno"))
-        return false;
+  // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a
+  // first-class object type anymore.  `PyFile_FromFd` is just a thin wrapper
+  // over `io.open()`, which returns some object derived from `io.IOBase`.
+  // As a result, the only way to detect a file in Python 3 is to check whether
+  // it inherits from `io.IOBase`.  Since it is possible for non-files to also
+  // inherit from `io.IOBase`, we additionally verify that it has the `fileno`
+  // attribute, which should guarantee that it is backed by the file system.
+  PythonObject io_module(PyRefType::Owned, PyImport_ImportModule("io"));
+  PythonDictionary io_dict(PyRefType::Borrowed,
+                           PyModule_GetDict(io_module.get()));
+  PythonObject io_base_class = io_dict.GetItemForKey(PythonString("IOBase"));
+
+  PythonObject object_type(PyRefType::Owned, PyObject_Type(py_obj));
+
+  if (1 != PyObject_IsSubclass(object_type.get(), io_base_class.get()))
+    return false;
+  if (!object_type.HasAttribute("fileno"))
+    return false;
 
-    return true;
+  return true;
 #endif
 }
 
-void
-PythonFile::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonFile::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonFile::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonFile::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-    // overflow since it calls back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-void
-PythonFile::Reset(File &file, const char *mode)
-{
-    if (!file.IsValid())
-    {
-        Reset();
-        return;
-    }
+void PythonFile::Reset(File &file, const char *mode) {
+  if (!file.IsValid()) {
+    Reset();
+    return;
+  }
 
-    char *cmode = const_cast<char *>(mode);
+  char *cmode = const_cast<char *>(mode);
 #if PY_MAJOR_VERSION >= 3
-    Reset(PyRefType::Owned,
-        PyFile_FromFd(file.GetDescriptor(), nullptr, cmode, -1, nullptr, "ignore", nullptr, 0));
+  Reset(PyRefType::Owned, PyFile_FromFd(file.GetDescriptor(), nullptr, cmode,
+                                        -1, nullptr, "ignore", nullptr, 0));
 #else
-    // Read through the Python source, doesn't seem to modify these strings
-    Reset(PyRefType::Owned,
-        PyFile_FromFile(file.GetStream(), const_cast<char *>(""), cmode, nullptr));
+  // Read through the Python source, doesn't seem to modify these strings
+  Reset(PyRefType::Owned,
+        PyFile_FromFile(file.GetStream(), const_cast<char *>(""), cmode,
+                        nullptr));
 #endif
 }
 
-uint32_t
-PythonFile::GetOptionsFromMode(llvm::StringRef mode)
-{
-    if (mode.empty())
-        return 0;
-
-    return llvm::StringSwitch<uint32_t>(mode.str().c_str())
-    .Case("r",   File::eOpenOptionRead)
-    .Case("w",   File::eOpenOptionWrite)
-    .Case("a",   File::eOpenOptionWrite|File::eOpenOptionAppend|File::eOpenOptionCanCreate)
-    .Case("r+",  File::eOpenOptionRead|File::eOpenOptionWrite)
-    .Case("w+",  File::eOpenOptionRead|File::eOpenOptionWrite|File::eOpenOptionCanCreate|File::eOpenOptionTruncate)
-    .Case("a+",  File::eOpenOptionRead|File::eOpenOptionWrite|File::eOpenOptionAppend|File::eOpenOptionCanCreate)
-    .Default(0);
-}
+uint32_t PythonFile::GetOptionsFromMode(llvm::StringRef mode) {
+  if (mode.empty())
+    return 0;
 
-bool
-PythonFile::GetUnderlyingFile(File &file) const
-{
-    if (!IsValid())
-        return false;
+  return llvm::StringSwitch<uint32_t>(mode.str().c_str())
+      .Case("r", File::eOpenOptionRead)
+      .Case("w", File::eOpenOptionWrite)
+      .Case("a", File::eOpenOptionWrite | File::eOpenOptionAppend |
+                     File::eOpenOptionCanCreate)
+      .Case("r+", File::eOpenOptionRead | File::eOpenOptionWrite)
+      .Case("w+", File::eOpenOptionRead | File::eOpenOptionWrite |
+                      File::eOpenOptionCanCreate | File::eOpenOptionTruncate)
+      .Case("a+", File::eOpenOptionRead | File::eOpenOptionWrite |
+                      File::eOpenOptionAppend | File::eOpenOptionCanCreate)
+      .Default(0);
+}
+
+bool PythonFile::GetUnderlyingFile(File &file) const {
+  if (!IsValid())
+    return false;
 
-    file.Close();
-    // We don't own the file descriptor returned by this function, make sure the
-    // File object knows about that.
-    file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false);
-    PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>();
-    file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString()));
-    return file.IsValid();
+  file.Close();
+  // We don't own the file descriptor returned by this function, make sure the
+  // File object knows about that.
+  file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false);
+  PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>();
+  file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString()));
+  return file.IsValid();
 }
 
-
 #endif