remove FILE* usage from SBStream.i

[lawrence_danna]

Summary

This patch removes FILE* and replaces it with SBFile and FileSP the
SWIG interface for SBStream.i. And this is the last one. With
this change, nothing in the python API will can access a FILE* method
on the C++ side.

lldb/include/lldb/API/SBStream.h

public:
   // If this stream is not redirected to a file, it will maintain a local cache
   // for the stream output whose length can be accessed using this accessor.
   size_t GetSize();
 
   void Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
 
   void RedirectToFile(const char *path, bool append);
 
+  void RedirectToFile(lldb::SBFile file);
+
+  void RedirectToFile(lldb::FileSP file);
+
   void RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership);
 
   void RedirectToFileDescriptor(int fd, bool transfer_fh_ownership);
 
   // If the stream is redirected to a file, forget about the file and if
   // ownership of the file was transferred to this object, close the file. If
   // the stream is backed by a local cache, clear this cache.
   void Clear();

lldb/packages/Python/lldbsuite/test/python_api/file_handle/TestFileHandle.py

def test_set_filehandle_none(self):
                 self.assertEqual(sbf.GetFile().fileno(), 2)
         with open(self.out_filename, 'r') as f:
             status = self.debugger.SetInputFile(f)
             self.assertTrue(status.Success())
             self.debugger.SetInputFileHandle(None, False)
             sbf = self.debugger.GetInputFile()
             if sys.version_info.major >= 3:
                 self.assertEqual(sbf.GetFile().fileno(), 0)
+
+
+    @add_test_categories(['pyapi'])
+    def test_sbstream(self):
+
+        with open(self.out_filename, 'w') as f:
+            stream = lldb.SBStream()
+            stream.RedirectToFile(f)
+            stream.Print("zork")
+        with open(self.out_filename, 'r') as f:
+            self.assertEqual(f.read().strip(), "zork")
+
+        with open(self.out_filename, 'w') as f:
+            stream = lldb.SBStream()
+            stream.RedirectToFileHandle(f, True)
+            stream.Print("Yendor")
+        with open(self.out_filename, 'r') as f:
+            self.assertEqual(f.read().strip(), "Yendor")
+
+        stream = lldb.SBStream()
+        f = open(self.out_filename,  'w')
+        stream.RedirectToFile(lldb.SBFile.Create(f, borrow=False))
+        stream.Print("Frobozz")
+        stream = None
+        self.assertTrue(f.closed)
+        with open(self.out_filename, 'r') as f:
+            self.assertEqual(f.read().strip(), "Frobozz")

lldb/scripts/interface/SBStream.i

%extend {
             self->Printf("%s", str);
         }
     }
 
     void
     RedirectToFile (const char *path, bool append);
 
     void
-    RedirectToFileHandle (FILE *fh, bool transfer_fh_ownership);
+    RedirectToFile (lldb::SBFile file);
+
+    void
+    RedirectToFile (lldb::FileSP file);
+
+    %extend {
+        %feature("autodoc", "DEPRECATED, use RedirectToFile");
+        void
+        RedirectToFileHandle (lldb::FileSP file, bool transfer_fh_ownership) {
+            self->RedirectToFile(file);
+        }
+    }
 
     void
     RedirectToFileDescriptor (int fd, bool transfer_fh_ownership);
 
     %feature("docstring", "
     If the stream is redirected to a file, forget about the file and if
     ownership of the file was transferred to this object, close the file.
     If the stream is backed by a local cache, clear this cache.") Clear;
     void
     Clear ();
 };
 
 } // namespace lldb

lldb/source/API/SBStream.cpp

 //===-- SBStream.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBStream.h"
 
 #include "SBReproducerPrivate.h"
+#include "lldb/API/SBFile.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
void SBStream::RedirectToFile(const char *path, bool append) {
   // the to new file we are redirecting to.
   if (!local_data.empty())
     m_opaque_up->Write(&local_data[0], local_data.size());
 }
 
 void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
   LLDB_RECORD_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool), fh,
                      transfer_fh_ownership);
+  FileSP file = std::make_unique<NativeFile>(fh, transfer_fh_ownership);
+  return RedirectToFile(file);
+}
+
+void SBStream::RedirectToFile(SBFile file) {
+  LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (SBFile), file)
+  RedirectToFile(file.GetFile());
+}
+
+void SBStream::RedirectToFile(FileSP file_sp) {
+  LLDB_RECORD_METHOD(void, SBStream, RedirectToFile, (FileSP), file_sp);
 
-  if (fh == nullptr)
+  if (!file_sp || !file_sp->IsValid())
     return;
 
   std::string local_data;
   if (m_opaque_up) {
     // See if we have any locally backed data. If so, copy it so we can then
     // redirect it to the file so we don't lose the data
     if (!m_is_file)
       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
   }
 
-  m_opaque_up = std::make_unique<StreamFile>(fh, transfer_fh_ownership);
+  m_opaque_up = std::make_unique<StreamFile>(file_sp);
   m_is_file = true;
 
   // If we had any data locally in our StreamString, then pass that along to
   // the to new file we are redirecting to.
   if (!local_data.empty())
     m_opaque_up->Write(&local_data[0], local_data.size());
 }
 

 template <>
 void RegisterMethods<SBStream>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ());
   LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
   LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
+  LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (FileSP));
+  LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (SBFile));
   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
   LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
   LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
 }
 
 }
 }