Remove default constructor & noexcept

Author: JDevlieghere

lldb/include/lldb/Utility/NonNullSharedPtr.h

@@ -17,8 +17,7 @@ namespace lldb_private {
 /// A non-nullable shared pointer that always holds a valid object.
 ///
 /// NonNullSharedPtr is a smart pointer wrapper around std::shared_ptr that
-/// guarantees the pointer is never null. If default-constructed, it creates
-/// a default-constructed instance of T.
+/// guarantees the pointer is never null.
 ///
 /// This class is used for enforcing invariants at the type level and
 /// eliminating entire classes of null pointer bugs.
@@ -28,8 +27,6 @@ template <typename T> class NonNullSharedPtr : private std::shared_ptr<T> {
   using Base = std::shared_ptr<T>;
 
 public:
-  NonNullSharedPtr() : Base(std::make_shared<T>()) {}
-
   NonNullSharedPtr(const std::shared_ptr<T> &t)
       : Base(t ? t : std::make_shared<T>()) {
     assert(t && "NonNullSharedPtr initialized from NULL shared_ptr");
@@ -42,15 +39,14 @@ template <typename T> class NonNullSharedPtr : private std::shared_ptr<T> {
 
   NonNullSharedPtr(const NonNullSharedPtr &other) : Base(other) {}
 
-  NonNullSharedPtr(NonNullSharedPtr &&other) noexcept
-      : Base(std::move(other)) {}
+  NonNullSharedPtr(NonNullSharedPtr &&other) : Base(std::move(other)) {}
 
   NonNullSharedPtr &operator=(const NonNullSharedPtr &other) {
     Base::operator=(other);
     return *this;
   }
 
-  NonNullSharedPtr &operator=(NonNullSharedPtr &&other) noexcept {
+  NonNullSharedPtr &operator=(NonNullSharedPtr &&other) {
     Base::operator=(std::move(other));
     return *this;
   }
@@ -62,7 +58,7 @@ template <typename T> class NonNullSharedPtr : private std::shared_ptr<T> {
   using Base::use_count;
   using Base::operator bool;
 
-  void swap(NonNullSharedPtr &other) noexcept { Base::swap(other); }
+  void swap(NonNullSharedPtr &other) { Base::swap(other); }
 
   /// Explicitly deleted operations that could introduce nullptr.
   /// @{
@@ -77,7 +73,7 @@ template <typename T> class NonNullSharedPtr : private std::shared_ptr<T> {
 /// lookup (ADL) and efficient swapping.
 template <typename T>
 void swap(lldb_private::NonNullSharedPtr<T> &lhs,
-          lldb_private::NonNullSharedPtr<T> &rhs) noexcept {
+          lldb_private::NonNullSharedPtr<T> &rhs) {
   lhs.swap(rhs);
 }
 

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

@@ -139,7 +139,7 @@ void BreakpointResolverFileLine::FilterContexts(SymbolContextList &sc_list) {
     if (!sc.block)
       continue;
 
-    SupportFileSP file_sp;
+    SupportFileSP file_sp = std::make_shared<SupportFile>();
     uint32_t line;
     const Block *inline_block = sc.block->GetContainingInlinedBlock();
     if (inline_block) {

lldb/source/Core/Disassembler.cpp

@@ -208,7 +208,7 @@ Disassembler::GetFunctionDeclLineEntry(const SymbolContext &sc) {
     return {};
 
   LineEntry prologue_end_line = sc.line_entry;
-  SupportFileSP func_decl_file_sp;
+  SupportFileSP func_decl_file_sp = std::make_shared<SupportFile>();
   uint32_t func_decl_line;
   sc.function->GetStartLineSourceInfo(func_decl_file_sp, func_decl_line);
 
@@ -539,7 +539,8 @@ void Disassembler::PrintInstructions(Debugger &debugger, const ArchSpec &arch,
                 LineEntry prologue_end_line = sc.line_entry;
                 if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
                                                         prologue_end_line)) {
-                  SupportFileSP func_decl_file_sp;
+                  SupportFileSP func_decl_file_sp =
+                      std::make_shared<SupportFile>();
                   uint32_t func_decl_line;
                   sc.function->GetStartLineSourceInfo(func_decl_file_sp,
                                                       func_decl_line);

lldb/source/Symbol/Function.cpp

@@ -302,7 +302,7 @@ void Function::GetStartLineSourceInfo(SupportFileSP &source_file_sp,
 
 llvm::Expected<std::pair<SupportFileSP, Function::SourceRange>>
 Function::GetSourceInfo() {
-  SupportFileSP source_file_sp;
+  SupportFileSP source_file_sp = std::make_shared<SupportFile>();
   uint32_t start_line;
   GetStartLineSourceInfo(source_file_sp, start_line);
   LineTable *line_table = m_comp_unit->GetLineTable();

lldb/source/Symbol/LineTable.cpp

@@ -327,7 +327,7 @@ void LineTable::Dump(Stream *s, Target *target, Address::DumpStyle style,
                      Address::DumpStyle fallback_style, bool show_line_ranges) {
   const size_t count = m_entries.size();
   LineEntry line_entry;
-  SupportFileSP prev_file;
+  SupportFileSP prev_file = std::make_shared<SupportFile>();
   for (size_t idx = 0; idx < count; ++idx) {
     ConvertEntryAtIndexToLineEntry(idx, line_entry);
     line_entry.Dump(s, target, !prev_file->Equal(*line_entry.original_file_sp),

lldb/source/Utility/FileSpecList.cpp

@@ -216,7 +216,7 @@ const FileSpec &SupportFileList::GetFileSpecAtIndex(size_t idx) const {
 SupportFileSP SupportFileList::GetSupportFileAtIndex(size_t idx) const {
   if (idx < m_files.size())
     return m_files[idx];
-  return {};
+  return std::make_shared<SupportFile>();
 }
 
 // Return the size in bytes that this object takes in memory. This returns the