Merge topic 'asan-fixes'

0bf793f vtkDataSetSurfaceFilter: fix reset of `OriginalCellIds`
245f211 vtkVoxelContoursToSurfaceFilter: no-op without a length
c43e57d vtkAbstractTransform: fix vtkSimpleTransform inheritance
023bf77 vtkXMLP*Reader: do not allocate for empty piece counts
aa89d0b VPICGlobal: plug memory leaks
9f77b41 TestAngleWidget*D: use anonymous namespaces
8699678 vtkTGAReader: add missing `PrintSelf` method
01da9c7 vtkSimpleScalarTree: remove unnecessary guard for `delete[]`
...

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: David Gobbi <david.gobbi@gmail.com>
Acked-by: Sean McBride <sean@rogue-research.com>
Acked-by: Cory Quammen <cory.quammen@kitware.com>
Merge-request: !8519

Common/Core/Testing/Cxx/CMakeLists.txt

@@ -180,7 +180,7 @@ vtk_add_test_cxx(vtkCommonCoreCxxTests tests
 add_executable(TestLoggerDisableSignalHandlerCxx
   TestLoggerDisableSignalHandler.cxx)
 target_link_libraries(TestLoggerDisableSignalHandlerCxx
-  PRIVATE VTK::CommonCore)
+  PRIVATE VTK::CommonCore VTK::CommonDataModel)
 add_test(NAME TestLoggerDisableSignalHandler
   COMMAND ${CMAKE_COMMAND}
   -DEXECUTABLE_PATH:FILEPATH=$<TARGET_FILE:TestLoggerDisableSignalHandlerCxx>

Common/Core/vtkRandomPool.cxx

@@ -310,6 +310,7 @@ const double* vtkRandomPool::GeneratePool()
     this->NumberOfComponents = 1;
   }
   this->ChunkSize = (this->ChunkSize < 1000 ? 1000 : this->ChunkSize);
+  delete[] this->Pool;
   this->Pool = new double[this->TotalSize];
 
   // Control the number of threads spawned.

Common/ExecutionModel/vtkSimpleScalarTree.cxx

@@ -63,6 +63,7 @@ vtkSimpleScalarTree::vtkSimpleScalarTree()
 vtkSimpleScalarTree::~vtkSimpleScalarTree()
 {
   delete[] this->Tree;
+  delete[] this->CandidateCells;
 }
 
 //------------------------------------------------------------------------------
@@ -394,11 +395,8 @@ vtkIdType vtkSimpleScalarTree::GetNumberOfCellBatches(double scalarValue)
   // Basically we do a traversal of the tree and identify potential candidates.
   // It is essential that InitTraversal() has been called first.
   this->NumCandidates = 0;
-  if (this->CandidateCells)
-  {
-    delete[] this->CandidateCells;
-    this->CandidateCells = nullptr;
-  }
+  delete[] this->CandidateCells;
+  this->CandidateCells = nullptr;
   if (this->NumCells < 1)
   {
     return 0;

Common/Math/vtk.module

@@ -12,6 +12,7 @@ DEPENDS
   VTK::CommonCore
   VTK::kissfft
 TEST_DEPENDS
+  VTK::CommonDataModel
   VTK::CommonSystem
   VTK::CommonTransforms
   VTK::TestingCore

Common/Misc/vtk.module

@@ -15,4 +15,5 @@ PRIVATE_DEPENDS
   VTK::vtksys
   VTK::exprtk
 TEST_DEPENDS
+  VTK::CommonDataModel
   VTK::TestingCore

Common/System/vtk.module

@@ -13,4 +13,5 @@ DEPENDS
 PRIVATE_DEPENDS
   VTK::vtksys
 TEST_DEPENDS
+  VTK::CommonDataModel
   VTK::TestingCore

Common/Transforms/vtkAbstractTransform.cxx

@@ -16,7 +16,7 @@
 
 #include "vtkDataArray.h"
 #include "vtkDebugLeaks.h"
-#include "vtkHomogeneousTransform.h"
+#include "vtkLinearTransform.h"
 #include "vtkMath.h"
 #include "vtkMatrix4x4.h"
 #include "vtkObjectFactory.h"
@@ -351,10 +351,10 @@ void vtkAbstractTransform::UnRegister(vtkObjectBase* o)
 
 //------------------------------------------------------------------------------
 // A very, very minimal transformation
-class vtkSimpleTransform : public vtkHomogeneousTransform
+class vtkSimpleTransform : public vtkLinearTransform
 {
 public:
-  vtkTypeMacro(vtkSimpleTransform, vtkHomogeneousTransform);
+  vtkTypeMacro(vtkSimpleTransform, vtkLinearTransform);
   static vtkSimpleTransform* New() { VTK_STANDARD_NEW_BODY(vtkSimpleTransform); }
   vtkAbstractTransform* MakeTransform() override { return vtkSimpleTransform::New(); }
   void Inverse() override

Examples/Modules/UsingVTK/CMakeLists.txt

@@ -7,7 +7,7 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}"
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
 
 # We just need the CommonCore module here.
-find_package(VTK COMPONENTS CommonCore)
+find_package(VTK COMPONENTS CommonCore CommonDataModel)
 if (NOT VTK_FOUND)
   message("Skipping example: ${VTK_NOT_FOUND_MESSAGE}")
   return ()
@@ -17,7 +17,7 @@ include(CTest)
 
 add_library(vtk_using_lib uses_vtk.cxx)
 # VTK modules act just like CMake imported targets.
-target_link_libraries(vtk_using_lib PRIVATE VTK::CommonCore)
+target_link_libraries(vtk_using_lib PRIVATE VTK::CommonCore VTK::CommonDataModel)
 target_include_directories(vtk_using_lib PUBLIC "${CMAKE_CURRENT_BINARY_DIR}")
 include(GenerateExportHeader)
 generate_export_header(vtk_using_lib)

Filters/Core/vtkProbeFilter.cxx

@@ -758,7 +758,7 @@ namespace
 // Thread local storage
 struct ProbeImageDataPointsThreadLocal
 {
-  bool BaseThread;
+  bool BaseThread = false;
   vtkSmartPointer<vtkIdList> PointIds;
 };
 

Filters/Extraction/vtkExtractBlockUsingDataAssembly.cxx

@@ -136,6 +136,7 @@ vtkExtractBlockUsingDataAssembly::vtkExtractBlockUsingDataAssembly()
 vtkExtractBlockUsingDataAssembly::~vtkExtractBlockUsingDataAssembly()
 {
   delete this->Internals;
+  delete[] this->AssemblyName;
 }
 
 //------------------------------------------------------------------------------

Filters/General/vtkAnimateModes.cxx

@@ -73,6 +73,7 @@ vtkAnimateModes::vtkAnimateModes()
   , ModeShapesRange{ 1, 1 }
   , ModeShape{ 1 }
   , DisplacementMagnitude{ 1.0 }
+  , DisplacementPreapplied(false)
   , TimeRange{ 0.0, 1.0 }
 {
   // the displacement array

Filters/General/vtkMergeVectorComponents.cxx

@@ -39,7 +39,13 @@ vtkMergeVectorComponents::vtkMergeVectorComponents()
 }
 
 //------------------------------------------------------------------------------
-vtkMergeVectorComponents::~vtkMergeVectorComponents() = default;
+vtkMergeVectorComponents::~vtkMergeVectorComponents()
+{
+  this->SetXArrayName(nullptr);
+  this->SetYArrayName(nullptr);
+  this->SetZArrayName(nullptr);
+  this->SetOutputVectorName(nullptr);
+}
 
 //------------------------------------------------------------------------------
 int vtkMergeVectorComponents::FillInputPortInformation(int vtkNotUsed(port), vtkInformation* info)

Filters/General/vtkVoxelContoursToSurfaceFilter.cxx

@@ -79,6 +79,11 @@ void vtkVoxelContoursToSurfaceFilter::SortLineList()
   double tmp[4];
   double tmpval;
 
+  if (!this->LineListLength)
+  {
+    return;
+  }
+
   // Make sure we have enough space in our sorted list
   if (this->SortedListSize < this->LineListLength)
   {

Filters/Geometry/vtkDataSetSurfaceFilter.cxx

@@ -371,6 +371,16 @@ vtkDataSetSurfaceFilter::~vtkDataSetSurfaceFilter()
 {
   this->SetOriginalCellIdsName(nullptr);
   this->SetOriginalPointIdsName(nullptr);
+  if (this->OriginalPointIds)
+  {
+    this->OriginalPointIds->Delete();
+    this->OriginalPointIds = nullptr;
+  }
+  if (this->OriginalCellIds)
+  {
+    this->OriginalCellIds->Delete();
+    this->OriginalCellIds = nullptr;
+  }
 }
 
 //------------------------------------------------------------------------------
@@ -603,7 +613,7 @@ int vtkDataSetSurfaceFilter::UniformGridExecute(
   if (this->OriginalCellIds)
   {
     this->OriginalCellIds->Delete();
-    this->OriginalPointIds = nullptr;
+    this->OriginalCellIds = nullptr;
   }
   return 1;
 }
@@ -1303,9 +1313,11 @@ int vtkDataSetSurfaceFilter::UnstructuredGridExecute(
   // Depending on the outcome, we may process the data ourselves, or send over
   // to the faster vtkGeometryFilter.
   bool mayDelegate = (info == nullptr && this->Delegation);
+  bool info_owned = false;
   if (info == nullptr)
   {
     info = vtkGeometryFilterHelper::CharacterizeUnstructuredGrid(input);
+    info_owned = true;
   }
   bool handleSubdivision = (!info->IsLinear);
 
@@ -1319,6 +1331,10 @@ int vtkDataSetSurfaceFilter::UnstructuredGridExecute(
     delete info;
     return 1;
   }
+  if (info_owned)
+  {
+    delete info;
+  }
 
   // If here, the data is gnarly and this filter will process it.
   vtkSmartPointer<vtkCellIterator> cellIter =

Filters/Geometry/vtkGeometryFilter.cxx

@@ -108,6 +108,8 @@ vtkGeometryFilter::vtkGeometryFilter()
 vtkGeometryFilter::~vtkGeometryFilter()
 {
   this->SetLocator(nullptr);
+  this->SetOriginalCellIdsName(nullptr);
+  this->SetOriginalPointIdsName(nullptr);
 }
 
 //------------------------------------------------------------------------------
@@ -2090,9 +2092,11 @@ int vtkGeometryFilter::UnstructuredGridExecute(vtkDataSet* dataSetInput, vtkPoly
   // Depending on the outcome, we may process the data ourselves, or send over
   // to the faster vtkGeometryFilter.
   bool mayDelegate = (info == nullptr && this->Delegation);
+  bool info_owned = false;
   if (info == nullptr)
   {
     info = vtkGeometryFilterHelper::CharacterizeUnstructuredGrid(input);
+    info_owned = true;
   }
 
   // Nonlinear cells are handled by vtkDataSetSurfaceFilter
@@ -2105,6 +2109,10 @@ int vtkGeometryFilter::UnstructuredGridExecute(vtkDataSet* dataSetInput, vtkPoly
     delete info;
     return 1;
   }
+  if (info_owned)
+  {
+    delete info;
+  }
 
   auto cellIter = vtk::TakeSmartPointer(input->NewCellIterator());
   vtkIdType cellId;

Filters/Modeling/vtkTrimmedExtrusionFilter.cxx

@@ -282,6 +282,7 @@ int vtkTrimmedExtrusionFilter::RequestData(vtkInformation* vtkNotUsed(request),
   {
     this->AdjustPoints(input, numPts, numCells, hits, newPts);
   }
+  delete[] hits;
 
   // Now generate the topology.
   this->ExtrudeEdges(input, output, numPts, numCells);

Filters/Parallel/Testing/Cxx/PTextureMapToSphere.cxx

@@ -108,6 +108,7 @@ void MyProcess::Execute()
   vtkNew<vtkPNGReader> PNGReader;
   PNGReader->SetFileName(fname);
   PNGReader->Update();
+  delete[] fname;
 
   vtkNew<vtkTexture> texture;
   texture->SetInputConnection(PNGReader->GetOutputPort());

Filters/ParallelFlowPaths/Testing/Cxx/TestPStreamAMR.cxx

@@ -176,6 +176,8 @@ int TestPStreamAMR(int argc, char* argv[])
   imageSource->SetCellArrayStatus("y-velocity", 1);
   imageSource->SetCellArrayStatus("z-velocity", 1);
 
+  delete[] fname;
+
   vtkNew<TestAMRVectorSource> gradientSource;
   gradientSource->SetInputConnection(imageSource->GetOutputPort());
 

Filters/ParallelFlowPaths/vtkPLagrangianParticleTracker.cxx

@@ -73,7 +73,7 @@ class MessageStream
   MessageStream& operator>>(T& t)
   {
     size_t size = sizeof(T);
-    t = *reinterpret_cast<T*>(this->Head);
+    memcpy(&t, this->Head, size);
     this->Head += size;
     return *this;
   }

Filters/ParallelFlowPaths/vtkPStreamTracer.cxx

@@ -162,7 +162,7 @@ class MyStream
   {
     unsigned int size = sizeof(T);
     AssertGe(Size, this->Head + size - this->Data);
-    t = *(reinterpret_cast<T*>(this->Head));
+    memcpy(&t, this->Head, sizeof(T));
     this->Head += size;
     return (*this);
   }

Filters/ParallelGeometry/vtkPDistributedDataFilter.cxx

@@ -1419,6 +1419,11 @@ vtkFloatArray** vtkPDistributedDataFilter::ExchangeFloatArraysLean(
       {
         vtkErrorMacro(<< "vtkPDistributedDataFilter::ExchangeIdArrays memory allocation");
         delete[] recvSize;
+        delete[] sendSize;
+        for (int i = 0; i < nprocs; ++i)
+        {
+          delete[] recvArrays[i];
+        }
         delete[] recvArrays;
         return nullptr;
       }

Filters/ParallelStatistics/vtkPOrderStatistics.cxx

@@ -293,19 +293,26 @@ void vtkPOrderStatistics::Learn(
       if (!com->GatherV(&(*sPack_l.begin()), sPack_g, nc_l, nc_g, offsets, rProc))
       {
         vtkErrorMacro("Process " << myRank << "could not gather string values.");
+        delete[] nc_g;
+        delete[] offsets;
+        delete[] sPack_g;
 
         return;
       }
+      delete[] nc_g;
+      delete[] offsets;
 
       // Reduce to global histogram on process rProc
       std::map<vtkStdString, vtkIdType> histogram;
       if (myRank == rProc)
       {
         if (this->Reduce(card_g, ncTotal, sPack_g, histogram))
         {
+          delete[] sPack_g;
           return;
         }
       } // if ( myRank == rProc )
+      delete[] sPack_g;
 
       // Create column for global histogram values of the same type as the values
       vtkStringArray* sVals_g = vtkStringArray::New();
@@ -316,6 +323,7 @@ void vtkPOrderStatistics::Learn(
       {
         vtkErrorMacro("Process " << com->GetLocalProcessId()
                                  << " could not broadcast reduced histogram values.");
+        sVals_g->Delete();
 
         return;
       }

IO/ADIOS2/vtkADIOS2VTXReader.cxx

@@ -42,6 +42,11 @@ vtkADIOS2VTXReader::vtkADIOS2VTXReader()
   this->SetNumberOfOutputPorts(1);
 }
 
+vtkADIOS2VTXReader::~vtkADIOS2VTXReader()
+{
+  this->SetFileName(nullptr);
+}
+
 int vtkADIOS2VTXReader::RequestInformation(vtkInformation* vtkNotUsed(inputVector),
   vtkInformationVector** vtkNotUsed(inputVector), vtkInformationVector* outputVector)
 {

IO/ADIOS2/vtkADIOS2VTXReader.h

@@ -53,7 +53,7 @@ class VTKIOADIOS2_EXPORT vtkADIOS2VTXReader : public vtkMultiBlockDataSetAlgorit
 
 protected:
   vtkADIOS2VTXReader();
-  ~vtkADIOS2VTXReader() = default;
+  ~vtkADIOS2VTXReader();
 
   vtkADIOS2VTXReader(const vtkADIOS2VTXReader&) = delete;
   void operator=(const vtkADIOS2VTXReader&) = delete;

IO/Image/Testing/Cxx/TestSEPReader.cxx

@@ -34,7 +34,9 @@
 
 int TestSEPReader(int argc, char* argv[])
 {
-  const std::string filename = vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/small.H");
+  char* fname = vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/small.H");
+  const std::string filename = fname;
+  delete[] fname;
 
   vtkNew<vtkSEPReader> SEPReader;
 

IO/Image/vtkJSONImageWriter.cxx

@@ -44,6 +44,7 @@ vtkJSONImageWriter::vtkJSONImageWriter()
 vtkJSONImageWriter::~vtkJSONImageWriter()
 {
   this->SetFileName(nullptr);
+  this->SetArrayName(nullptr);
 }
 
 //------------------------------------------------------------------------------

IO/Image/vtkTGAReader.cxx

@@ -194,3 +194,9 @@ int vtkTGAReader::CanReadFile(const char* fname)
 
   return 1;
 }
+
+//------------------------------------------------------------------------------
+void vtkTGAReader::PrintSelf(ostream& os, vtkIndent indent)
+{
+  this->Superclass::PrintSelf(os, indent);
+}

IO/Image/vtkTGAReader.h

@@ -34,6 +34,7 @@ class VTKIOIMAGE_EXPORT vtkTGAReader : public vtkImageReader2
 public:
   static vtkTGAReader* New();
   vtkTypeMacro(vtkTGAReader, vtkImageReader2);
+  void PrintSelf(ostream& os, vtkIndent indent) override;
 
   /**
    * Is the given file a valid TGA file?

IO/MPIParallel/vtkMPIMultiBlockPLOT3DReader.cxx

@@ -234,6 +234,7 @@ void vtkMPIMultiBlockPLOT3DReader::CloseFile(void* vfp)
   {
     vtkErrorMacro("Failed to close file!");
   }
+  delete handle;
 }
 
 //------------------------------------------------------------------------------

IO/PIO/PIOAdaptor.cxx

@@ -141,6 +141,10 @@ void BroadcastDoubleVector(
 ///////////////////////////////////////////////////////////////////////////////
 
 PIOAdaptor::PIOAdaptor(vtkMultiProcessController* ctrl)
+  : useHTG(false)
+  , useTracer(false)
+  , useFloat64(false)
+  , hasTracers(false)
 {
   this->Controller = ctrl;
   if (this->Controller)