[lldb] Remove Python 2 support from the ScriptInterpreter plugin

[JDevlieghere]

Summary

We dropped downstream support for Python 2 in the previous release. Now that we have branched for the next release the window where this kind of change could introduce conflicts is closing too. Start by getting rid of Python 2 support in the Script Interpreter plugin.

[labath]

Woohoo

[lanza]

Yay, thanks Jonas!

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

inline llvm::Error exception(const char *s = nullptr) {
   return llvm::make_error<PythonException>(s);
 }
 
 inline llvm::Error keyError() {
   return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                  "key not in dict");
 }
 
-#if PY_MAJOR_VERSION < 3
-// The python 2 API declares some arguments as char* that should
-// be const char *, but it doesn't actually modify them.
-inline char *py2_const_cast(const char *s) { return const_cast<char *>(s); }
-#else
 inline const char *py2_const_cast(const char *s) { return s; }
-#endif
 
 enum class PyInitialValue { Invalid, Empty };
 
 template <typename T, typename Enable = void> struct PythonFormat;
 
 template <> struct PythonFormat<unsigned long long> {
   static constexpr char format = 'K';
   static auto get(unsigned long long value) { return value; }

 As<unsigned long long>(llvm::Expected<PythonObject> &&obj);
 
 template <>
 llvm::Expected<std::string> As<std::string>(llvm::Expected<PythonObject> &&obj);
 
 
 template <class T> class TypedPythonObject : public PythonObject {
 public:
-  // override to perform implicit type conversions on Reset
-  // This can be eliminated once we drop python 2 support.
-  static void Convert(PyRefType &type, PyObject *&py_obj) {}
-
   TypedPythonObject(PyRefType type, PyObject *py_obj) {
     if (!py_obj)
       return;
-    T::Convert(type, py_obj);
     if (T::Check(py_obj))
       PythonObject::operator=(PythonObject(type, py_obj));
     else if (type == PyRefType::Owned)
       Py_DECREF(py_obj);
   }
 
   TypedPythonObject() = default;
 };
public:
   using TypedPythonObject::TypedPythonObject;
   static llvm::Expected<PythonString> FromUTF8(llvm::StringRef string);
 
   PythonString() : TypedPythonObject() {} // MSVC requires this for some reason
 
   explicit PythonString(llvm::StringRef string); // safe, null on error
 
   static bool Check(PyObject *py_obj);
-  static void Convert(PyRefType &type, PyObject *&py_obj);
 
   llvm::StringRef GetString() const; // safe, empty string on error
 
   llvm::Expected<llvm::StringRef> AsUTF8() const;
 
   size_t GetSize() const;
 
   void SetString(llvm::StringRef string); // safe, null on error
 
   StructuredData::StringSP CreateStructuredString() const;
 };
 
 class PythonInteger : public TypedPythonObject<PythonInteger> {
 public:
   using TypedPythonObject::TypedPythonObject;
 
   PythonInteger() : TypedPythonObject() {} // MSVC requires this for some reason
 
   explicit PythonInteger(int64_t value);
 
   static bool Check(PyObject *py_obj);
-  static void Convert(PyRefType &type, PyObject *&py_obj);
 
   void SetInteger(int64_t value);
 
   StructuredData::IntegerSP CreateStructuredInteger() const;
 };
 
 class PythonBoolean : public TypedPythonObject<PythonBoolean> {
 public:

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

Expected<std::string> python::As<std::string>(Expected<PythonObject> &&obj) {
   auto str = Take<PythonString>(str_obj);
   auto utf8 = str.AsUTF8();
   if (!utf8)
     return utf8.takeError();
   return std::string(utf8.get());
 }
 
 static bool python_is_finalizing() {
-#if PY_MAJOR_VERSION == 2
-  return false;
-#elif PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 7
+#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 7
   return _Py_Finalizing != nullptr;
 #else
   return _Py_IsFinalizing();
 #endif
 }
 
 void PythonObject::Reset() {
   if (m_py_obj && Py_IsInitialized()) {
     if (python_is_finalizing()) {
       // Leak m_py_obj rather than crashing the process.
       // https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure
     } else {
       PyGILState_STATE state = PyGILState_Ensure();
       Py_DECREF(m_py_obj);
       PyGILState_Release(state);
     }
   }
   m_py_obj = nullptr;
 }
 
 Expected<long long> PythonObject::AsLongLong() const {
   if (!m_py_obj)
     return nullDeref();
-#if PY_MAJOR_VERSION < 3
-  if (!PyLong_Check(m_py_obj)) {
-    PythonInteger i(PyRefType::Borrowed, m_py_obj);
-    return i.AsLongLong();
-  }
-#endif
   assert(!PyErr_Occurred());
   long long r = PyLong_AsLongLong(m_py_obj);
   if (PyErr_Occurred())
     return exception();
   return r;
 }
 
 Expected<long long> PythonObject::AsUnsignedLongLong() const {
   if (!m_py_obj)
     return nullDeref();
-#if PY_MAJOR_VERSION < 3
-  if (!PyLong_Check(m_py_obj)) {
-    PythonInteger i(PyRefType::Borrowed, m_py_obj);
-    return i.AsUnsignedLongLong();
-  }
-#endif
   assert(!PyErr_Occurred());
   long long r = PyLong_AsUnsignedLongLong(m_py_obj);
   if (PyErr_Occurred())
     return exception();
   return r;
 }
 
 // wraps on overflow, instead of raising an error.
 Expected<unsigned long long> PythonObject::AsModuloUnsignedLongLong() const {
   if (!m_py_obj)
     return nullDeref();
-#if PY_MAJOR_VERSION < 3
-  if (!PyLong_Check(m_py_obj)) {
-    PythonInteger i(PyRefType::Borrowed, m_py_obj);
-    return i.AsModuloUnsignedLongLong();
-  }
-#endif
   assert(!PyErr_Occurred());
   unsigned long long r = PyLong_AsUnsignedLongLongMask(m_py_obj);
   if (PyErr_Occurred())
     return exception();
   return r;
 }
 
 void StructuredPythonObject::Serialize(llvm::json::OStream &s) const {
PyObjectType PythonObject::GetObjectType() const {
   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;
-#endif
   if (PythonByteArray::Check(m_py_obj))
     return PyObjectType::ByteArray;
   if (PythonBoolean::Check(m_py_obj))
     return PyObjectType::Boolean;
   if (PythonInteger::Check(m_py_obj))
     return PyObjectType::Integer;
   if (PythonFile::Check(m_py_obj))
     return PyObjectType::File;
PythonObject PythonObject::GetAttributeValue(llvm::StringRef attr) const {
   if (!PyObject_HasAttr(m_py_obj, py_attr.get()))
     return PythonObject();
 
   return PythonObject(PyRefType::Owned,
                       PyObject_GetAttr(m_py_obj, py_attr.get()));
 }
 
 StructuredData::ObjectSP PythonObject::CreateStructuredObject() const {
-#if PY_MAJOR_VERSION >= 3
   assert(PyGILState_Check());
-#endif
   switch (GetObjectType()) {
   case PyObjectType::Dictionary:
     return PythonDictionary(PyRefType::Borrowed, m_py_obj)
         .CreateStructuredDictionary();
   case PyObjectType::Boolean:
     return PythonBoolean(PyRefType::Borrowed, m_py_obj)
         .CreateStructuredBoolean();
   case PyObjectType::Integer:
StructuredData::StringSP PythonByteArray::CreateStructuredString() const {
   const char *str = reinterpret_cast<const char *>(bytes.data());
   result->SetValue(std::string(str, bytes.size()));
   return result;
 }
 
 // PythonString
 
 Expected<PythonString> PythonString::FromUTF8(llvm::StringRef string) {
-#if PY_MAJOR_VERSION >= 3
   PyObject *str = PyUnicode_FromStringAndSize(string.data(), string.size());
-#else
-  PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
-#endif
   if (!str)
     return llvm::make_error<PythonException>();
   return Take<PythonString>(str);
 }
 
 PythonString::PythonString(llvm::StringRef string) { SetString(string); }
 
 bool PythonString::Check(PyObject *py_obj) {
   if (!py_obj)
     return false;
 
   if (PyUnicode_Check(py_obj))
     return true;
-#if PY_MAJOR_VERSION < 3
-  if (PyString_Check(py_obj))
-    return true;
-#endif
   return false;
 }
 
-void PythonString::Convert(PyRefType &type, PyObject *&py_obj) {
-#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)) {
-    PyObject *s = PyUnicode_AsUTF8String(py_obj);
-    if (s == nullptr) {
-      PyErr_Clear();
-      if (type == PyRefType::Owned)
-        Py_DECREF(py_obj);
-      return;
-    }
-    if (type == PyRefType::Owned)
-      Py_DECREF(py_obj);
-    else
-      type = PyRefType::Owned;
-    py_obj = s;
-  }
-#endif
-}
-
 llvm::StringRef PythonString::GetString() const {
   auto s = AsUTF8();
   if (!s) {
     llvm::consumeError(s.takeError());
     return llvm::StringRef("");
   }
   return s.get();
 }
 
 Expected<llvm::StringRef> PythonString::AsUTF8() const {
   if (!IsValid())
     return nullDeref();
 
   Py_ssize_t size;
   const char *data;
 
-#if PY_MAJOR_VERSION >= 3
   data = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
-#else
-  char *c = NULL;
-  int r = PyString_AsStringAndSize(m_py_obj, &c, &size);
-  if (r < 0)
-    c = NULL;
-  data = c;
-#endif
 
   if (!data)
     return exception();
 
   return llvm::StringRef(data, size);
 }
 
 size_t PythonString::GetSize() const {
   if (IsValid()) {
-#if PY_MAJOR_VERSION >= 3
 #if PY_MINOR_VERSION >= 3
     return PyUnicode_GetLength(m_py_obj);
 #else
     return PyUnicode_GetSize(m_py_obj);
 #endif
-#else
-    return PyString_Size(m_py_obj);
-#endif
   }
   return 0;
 }
 
 void PythonString::SetString(llvm::StringRef string) {
   auto s = FromUTF8(string);
   if (!s) {
     llvm::consumeError(s.takeError());

 // PythonInteger
 
 PythonInteger::PythonInteger(int64_t value) { SetInteger(value); }
 
 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);
-#else
-  return PyLong_Check(py_obj) || PyInt_Check(py_obj);
-#endif
-}
-
-void PythonInteger::Convert(PyRefType &type, PyObject *&py_obj) {
-#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.
-    long long value = PyInt_AsLong(py_obj);
-    PyObject *l = nullptr;
-    if (!PyErr_Occurred())
-      l = PyLong_FromLongLong(value);
-    if (l == nullptr) {
-      PyErr_Clear();
-      if (type == PyRefType::Owned)
-        Py_DECREF(py_obj);
-      return;
-    }
-    if (type == PyRefType::Owned)
-      Py_DECREF(py_obj);
-    else
-      type = PyRefType::Owned;
-    py_obj = l;
-  }
-#endif
 }
 
 void PythonInteger::SetInteger(int64_t value) {
   *this = Take<PythonInteger>(PyLong_FromLongLong(value));
 }
 
 StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
   StructuredData::IntegerSP result(new StructuredData::Integer);
PythonObject PythonDictionary::GetItemForKey(const PythonObject &key) const {
   }
   return std::move(item.get());
 }
 
 Expected<PythonObject>
 PythonDictionary::GetItem(const PythonObject &key) const {
   if (!IsValid())
     return nullDeref();
-#if PY_MAJOR_VERSION >= 3
   PyObject *o = PyDict_GetItemWithError(m_py_obj, key.get());
   if (PyErr_Occurred())
     return exception();
-#else
-  PyObject *o = PyDict_GetItem(m_py_obj, key.get());
-#endif
   if (!o)
     return keyError();
   return Retain<PythonObject>(o);
 }
 
 Expected<PythonObject> PythonDictionary::GetItem(const Twine &key) const {
   if (!IsValid())
     return nullDeref();
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::BuiltinsModule() {
-#if PY_MAJOR_VERSION >= 3
-  return AddModule("builtins");
-#else
-  return AddModule("__builtin__");
-#endif
-}
+PythonModule PythonModule::BuiltinsModule() { return AddModule("builtins"); }
 
 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()));
 }
 
operator()(std::initializer_list<PythonObject> args) {
   PythonTuple arg_tuple(args);
   return PythonObject(PyRefType::Owned,
                       PyObject_CallObject(m_py_obj, arg_tuple.get()));
 }
 
 bool PythonFile::Check(PyObject *py_obj) {
   if (!py_obj)
     return false;
-#if PY_MAJOR_VERSION < 3
-  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`.
   auto io_module = PythonModule::Import("io");
   if (!io_module) {
     llvm::consumeError(io_module.takeError());
     return false;
   }
   auto iobase = io_module.get().Get("IOBase");
   if (!iobase) {
     llvm::consumeError(iobase.takeError());
     return false;
   }
   int r = PyObject_IsInstance(py_obj, iobase.get().get());
   if (r < 0) {
     llvm::consumeError(exception()); // clear the exception and log it.
     return false;
   }
   return !!r;
-#endif
 }
 
 const char *PythonException::toCString() const {
   if (!m_repr_bytes)
     return "unknown exception";
   return PyBytes_AS_STRING(m_repr_bytes);
 }
 
std::string PythonException::ReadBacktrace() const {
 
   return std::move(backtrace.get());
 }
 
 char PythonException::ID = 0;
 
 llvm::Expected<File::OpenOptions>
 GetOptionsForPyObject(const PythonObject &obj) {
-#if PY_MAJOR_VERSION >= 3
   auto options = File::OpenOptions(0);
   auto readable = As<bool>(obj.CallMethod("readable"));
   if (!readable)
     return readable.takeError();
   auto writable = As<bool>(obj.CallMethod("writable"));
   if (!writable)
     return writable.takeError();
   if (readable.get() && writable.get())
     options |= File::eOpenOptionReadWrite;
   else if (writable.get())
     options |= File::eOpenOptionWriteOnly;
   else if (readable.get())
     options |= File::eOpenOptionReadOnly;
   return options;
-#else
-  PythonString py_mode = obj.GetAttributeValue("mode").AsType<PythonString>();
-  return File::GetOptionsFromMode(py_mode.GetString());
-#endif
 }
 
 // Base class template for python files.   All it knows how to do
 // is hold a reference to the python object and close or flush it
 // when the File is closed.
 namespace {
 template <typename Base> class OwnedPythonFile : public Base {
 public:
public:
   bool isA(const void *classID) const override {
     return classID == &ID || NativeFile::isA(classID);
   }
   static bool classof(const File *file) { return file->isA(&ID); }
 };
 char SimplePythonFile::ID = 0;
 } // namespace
 
-#if PY_MAJOR_VERSION >= 3
-
 namespace {
 class PythonBuffer {
 public:
   PythonBuffer &operator=(const PythonBuffer &) = delete;
   PythonBuffer(const PythonBuffer &) = delete;
 
   static Expected<PythonBuffer> Create(PythonObject &obj,
                                        int flags = PyBUF_SIMPLE) {
if (!stringref)
       return Status(stringref.takeError());
     num_bytes = stringref.get().size();
     memcpy(buf, stringref.get().begin(), num_bytes);
     return Status();
   }
 };
 } // namespace
 
-#endif
-
 llvm::Expected<FileSP> PythonFile::ConvertToFile(bool borrowed) {
   if (!IsValid())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "invalid PythonFile");
 
   int fd = PyObject_AsFileDescriptor(m_py_obj);
   if (fd < 0) {
     PyErr_Clear();

 PythonFile::ConvertToFileForcingUseOfScriptingIOMethods(bool borrowed) {
 
   assert(!PyErr_Occurred());
 
   if (!IsValid())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "invalid PythonFile");
 
-#if PY_MAJOR_VERSION < 3
-
-  return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                 "not supported on python 2");
-
-#else
-
   int fd = PyObject_AsFileDescriptor(m_py_obj);
   if (fd < 0) {
     PyErr_Clear();
     fd = File::kInvalidDescriptor;
   }
 
   auto io_module = PythonModule::Import("io");
   if (!io_module)
if (!file_sp)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "python file is neither text nor binary");
 
   if (!file_sp->IsValid())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "invalid File");
 
   return file_sp;
-
-#endif
 }
 
 Expected<PythonFile> PythonFile::FromFile(File &file, const char *mode) {
   if (!file.IsValid())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "invalid file");
 
   if (auto *simple = llvm::dyn_cast<SimplePythonFile>(&file))
     return Retain<PythonFile>(simple->GetPythonObject());
-#if PY_MAJOR_VERSION >= 3
   if (auto *pythonio = llvm::dyn_cast<PythonIOFile>(&file))
     return Retain<PythonFile>(pythonio->GetPythonObject());
-#endif
 
   if (!mode) {
     auto m = file.GetOpenMode();
     if (!m)
       return m.takeError();
     mode = m.get();
   }
 
   PyObject *file_obj;
-#if PY_MAJOR_VERSION >= 3
   file_obj = PyFile_FromFd(file.GetDescriptor(), nullptr, mode, -1, nullptr,
                            "ignore", nullptr, /*closefd=*/0);
-#else
-  // I'd like to pass ::fflush here if the file is writable,  so that
-  // when the python side destructs the file object it will be flushed.
-  // However, this would be dangerous.    It can cause fflush to be called
-  // after fclose if the python program keeps a reference to the file after
-  // the original lldb_private::File has been destructed.
-  //
-  // It's all well and good to ask a python program not to use a closed file
-  // but asking a python program to make sure objects get released in a
-  // particular order is not safe.
-  //
-  // The tradeoff here is that if a python 2 program wants to make sure this
-  // file gets flushed, they'll have to do it explicitly or wait untill the
-  // original lldb File itself gets flushed.
-  file_obj = PyFile_FromFile(file.GetStream(), py2_const_cast(""),
-                             py2_const_cast(mode), [](FILE *) { return 0; });
-#endif
 
   if (!file_obj)
     return exception();
 
   return Take<PythonFile>(file_obj);
 }
 
 Error PythonScript::Init() {
if (!code) {
     PyErr_Clear();
     code =
         Py_CompileString(NullTerminated(string), "<string>", Py_single_input);
   }
   if (!code)
     return exception();
   auto code_ref = Take<PythonObject>(code);
 
-#if PY_MAJOR_VERSION < 3
-  PyObject *result =
-      PyEval_EvalCode((PyCodeObject *)code, globals.get(), locals.get());
-#else
   PyObject *result = PyEval_EvalCode(code, globals.get(), locals.get());
-#endif
 
   if (!result)
     return exception();
 
   return Take<PythonObject>(result);
 }
 
 llvm::Expected<PythonObject>

lldb/source/Plugins/ScriptInterpreter/Python/PythonReadline.cpp

 // work around LLVM pr18841 to avoid seg faults in the stock Python
 // readline.so linked against GNU readline.
 //
 // Bug on the cpython side: https://bugs.python.org/issue38634
 
 PyDoc_STRVAR(moduleDocumentation,
              "Simple readline module implementation based on libedit.");
 
-#if PY_MAJOR_VERSION >= 3
 static struct PyModuleDef readline_module = {
     PyModuleDef_HEAD_INIT, // m_base
     "lldb_editline",       // m_name
     moduleDocumentation,   // m_doc
     -1,                    // m_size
     nullptr,               // m_methods
     nullptr,               // m_reload
     nullptr,               // m_traverse
     nullptr,               // m_clear
     nullptr,               // m_free
 };
-#else
-static struct PyMethodDef moduleMethods[] = {{nullptr, nullptr, 0, nullptr}};
-#endif
 
-static char *
-#if PY_MAJOR_VERSION >= 3
-simple_readline(FILE *stdin, FILE *stdout, const char *prompt)
-#else
-simple_readline(FILE *stdin, FILE *stdout, char *prompt)
-#endif
-{
+static char *simple_readline(FILE *stdin, FILE *stdout, const char *prompt) {
   rl_instream = stdin;
   rl_outstream = stdout;
   char *line = readline(prompt);
   if (!line) {
-#if PY_MAJOR_VERSION >= 3
     char *ret = (char *)PyMem_RawMalloc(1);
-#else
-    char *ret = (char *)PyMem_Malloc(1);
-#endif
     if (ret != NULL)
       *ret = '\0';
     return ret;
   }
   if (*line)
     add_history(line);
   int n = strlen(line);
-#if PY_MAJOR_VERSION >= 3
   char *ret = (char *)PyMem_RawMalloc(n + 2);
-#else
-  char *ret = (char *)PyMem_Malloc(n + 2);
-#endif
   if (ret) {
     memcpy(ret, line, n);
     free(line);
     ret[n] = '\n';
     ret[n + 1] = '\0';
   }
   return ret;
 }
 
 PyMODINIT_FUNC initlldb_readline(void) {
   PyOS_ReadlineFunctionPointer = simple_readline;
 
-#if PY_MAJOR_VERSION >= 3
   return PyModule_Create(&readline_module);
-#else
-  Py_InitModule4("readline", moduleMethods, moduleDocumentation,
-                 static_cast<PyObject *>(NULL), PYTHON_API_VERSION);
-#endif
 }
 #endif

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::python;
 using llvm::Expected;
 
 LLDB_PLUGIN_DEFINE(ScriptInterpreterPython)
 
 // Defined in the SWIG source file
-#if PY_MAJOR_VERSION >= 3
 extern "C" PyObject *PyInit__lldb(void);
 
 #define LLDBSwigPyInit PyInit__lldb
 
-#else
-extern "C" void init_lldb(void);
-
-#define LLDBSwigPyInit init_lldb
-#endif
-
 #if defined(_WIN32)
 // Don't mess with the signal handlers on Windows.
 #define LLDB_USE_PYTHON_SET_INTERRUPT 0
 #else
 // PyErr_SetInterrupt was introduced in 3.2.
 #define LLDB_USE_PYTHON_SET_INTERRUPT                                          \
   (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 2) || (PY_MAJOR_VERSION > 3)
 #endif
if (m_was_already_initialized) {
       // We initialized the threads in this function, just unlock the GIL.
       PyEval_SaveThread();
     }
   }
 
 private:
   void InitializePythonHome() {
 #if LLDB_EMBED_PYTHON_HOME
-#if PY_MAJOR_VERSION >= 3
-    typedef wchar_t* str_type;
-#else
-    typedef char* str_type;
-#endif
+    typedef wchar_t *str_type;
     static str_type g_python_home = []() -> str_type {
       const char *lldb_python_home = LLDB_PYTHON_HOME;
       const char *absolute_python_home = nullptr;
       llvm::SmallString<64> path;
       if (llvm::sys::path::is_absolute(lldb_python_home)) {
         absolute_python_home = lldb_python_home;
       } else {
         FileSpec spec = HostInfo::GetShlibDir();
         if (!spec)
           return nullptr;
         spec.GetPath(path);
         llvm::sys::path::append(path, lldb_python_home);
         absolute_python_home = path.c_str();
       }
-#if PY_MAJOR_VERSION >= 3
       size_t size = 0;
       return Py_DecodeLocale(absolute_python_home, &size);
-#else
-      return strdup(absolute_python_home);
-#endif
     }();
     if (g_python_home != nullptr) {
       Py_SetPythonHome(g_python_home);
     }
-#else
-#if defined(__APPLE__) && PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION == 7
-    // For Darwin, the only Python version supported is the one shipped in the
-    // OS OS and linked with lldb. Other installation of Python may have higher
-    // priorities in the path, overriding PYTHONHOME and causing
-    // problems/incompatibilities. In order to avoid confusion, always hardcode
-    // the PythonHome to be right, as it's not going to change.
-    static char path[] =
-        "/System/Library/Frameworks/Python.framework/Versions/2.7";
-    Py_SetPythonHome(path);
-#endif
 #endif
   }
 
   void InitializeThreadsPrivate() {
 // Since Python 3.7 `Py_Initialize` calls `PyEval_InitThreads` inside itself,
 // so there is no way to determine whether the embedded interpreter
 // was already initialized by some external code. `PyEval_ThreadsInitialized`
 // would always return `true` and `PyGILState_Ensure/Release` flow would be

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

TEST_F(PythonDataObjectsTest, TestDictionaryResolutionWithDot) {
 
   EXPECT_THAT_EXPECTED(version_major, llvm::HasValue(PY_MAJOR_VERSION));
   EXPECT_THAT_EXPECTED(version_minor, llvm::HasValue(PY_MINOR_VERSION));
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonInteger) {
   // Test that integers behave correctly when wrapped by a PythonInteger.
 
-#if PY_MAJOR_VERSION < 3
-  // Verify that `PythonInt` works correctly when given a PyInt object.
-  // Note that PyInt doesn't exist in Python 3.x, so this is only for 2.x
-  PyObject *py_int = PyInt_FromLong(12);
-  EXPECT_TRUE(PythonInteger::Check(py_int));
-  PythonInteger python_int(PyRefType::Owned, py_int);
-
-  EXPECT_EQ(PyObjectType::Integer, python_int.GetObjectType());
-  auto python_int_value = As<long long>(python_int);
-  EXPECT_THAT_EXPECTED(python_int_value, llvm::HasValue(12));
-#endif
-
   // Verify that `PythonInteger` works correctly when given a PyLong object.
   PyObject *py_long = PyLong_FromLong(12);
   EXPECT_TRUE(PythonInteger::Check(py_long));
   PythonInteger python_long(PyRefType::Owned, py_long);
   EXPECT_EQ(PyObjectType::Integer, python_long.GetObjectType());
 
   // Verify that you can reset the value and that it is reflected properly.
   python_long.SetInteger(40);

 }
 
 TEST_F(PythonDataObjectsTest, TestPythonBytes) {
   static const char *test_bytes = "PythonDataObjectsTest::TestPythonBytes";
   PyObject *py_bytes = PyBytes_FromString(test_bytes);
   EXPECT_TRUE(PythonBytes::Check(py_bytes));
   PythonBytes python_bytes(PyRefType::Owned, py_bytes);
 
-#if PY_MAJOR_VERSION < 3
-  EXPECT_TRUE(PythonString::Check(py_bytes));
-  EXPECT_EQ(PyObjectType::String, python_bytes.GetObjectType());
-#else
   EXPECT_FALSE(PythonString::Check(py_bytes));
   EXPECT_EQ(PyObjectType::Bytes, python_bytes.GetObjectType());
-#endif
 
   llvm::ArrayRef<uint8_t> bytes = python_bytes.GetBytes();
   EXPECT_EQ(bytes.size(), strlen(test_bytes));
   EXPECT_EQ(0, ::memcmp(bytes.data(), test_bytes, bytes.size()));
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonByteArray) {
   static const char *test_bytes = "PythonDataObjectsTest::TestPythonByteArray";

 }
 
 TEST_F(PythonDataObjectsTest, TestPythonString) {
   // Test that strings behave correctly when wrapped by a PythonString.
 
   static const char *test_string = "PythonDataObjectsTest::TestPythonString1";
   static const char *test_string2 = "PythonDataObjectsTest::TestPythonString2";
 
-#if PY_MAJOR_VERSION < 3
-  // Verify that `PythonString` works correctly when given a PyString object.
-  // Note that PyString doesn't exist in Python 3.x, so this is only for 2.x
-  PyObject *py_string = PyString_FromString(test_string);
-  EXPECT_TRUE(PythonString::Check(py_string));
-  PythonString python_string(PyRefType::Owned, py_string);
-
-  EXPECT_EQ(PyObjectType::String, python_string.GetObjectType());
-  EXPECT_STREQ(test_string, python_string.GetString().data());
-#else
   // Verify that `PythonString` works correctly when given a PyUnicode object.
   PyObject *py_unicode = PyUnicode_FromString(test_string);
   EXPECT_TRUE(PythonString::Check(py_unicode));
   PythonString python_unicode(PyRefType::Owned, py_unicode);
   EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType());
   EXPECT_STREQ(test_string, python_unicode.GetString().data());
-#endif
 
   // Test that creating a `PythonString` object works correctly with the
   // string constructor
   PythonString constructed_string(test_string2);
   EXPECT_EQ(test_string2, constructed_string.GetString());
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonStringToStr) {

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

void PythonTestSuite::TearDown() {
   HostInfoBase::Terminate();
   FileSystem::Terminate();
 }
 
 // The following functions are the Pythonic implementations of the required
 // callbacks. Because they're defined in libLLDB which we cannot link for the
 // unit test, we have a 'default' implementation here.
 
-#if PY_MAJOR_VERSION >= 3
 extern "C" PyObject *PyInit__lldb(void) { return nullptr; }
-#else
-extern "C" void init_lldb(void) {}
-#endif
 
 llvm::Expected<bool> lldb_private::LLDBSwigPythonBreakpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame,
     const lldb::BreakpointLocationSP &sb_bp_loc,
     const StructuredDataImpl &args_impl) {
   return false;
 }