Removed a bunch of useless return statements at end of methods

Found and auto-fixed by clang-tidy’s readability-redundant-control-flow check.

Though I did have to manualy fix whitespace after it.

Charts/Core/vtkChart.cxx

@@ -153,7 +153,6 @@ vtkIdType vtkChart::GetNumberOfAxes()
 //-----------------------------------------------------------------------------
 void vtkChart::RecalculateBounds()
 {
-  return;
 }
 
 //-----------------------------------------------------------------------------

Charts/Core/vtkChartParallelCoordinates.cxx

@@ -413,7 +413,6 @@ void vtkChartParallelCoordinates::CalculatePlotTransform()
 //-----------------------------------------------------------------------------
 void vtkChartParallelCoordinates::RecalculateBounds()
 {
-  return;
 }
 
 //-----------------------------------------------------------------------------

Charts/Core/vtkColorTransferFunctionItem.cxx

@@ -146,7 +146,6 @@ void vtkColorTransferFunctionItem::ComputeTexture()
     }
   }
   delete [] values;
-  return;
 }
 
 //-----------------------------------------------------------------------------

Charts/Core/vtkCompositeTransferFunctionItem.cxx

@@ -144,5 +144,4 @@ void vtkCompositeTransferFunctionItem::ComputeTexture()
     }
   }
   delete [] values;
-  return;
 }

Charts/Core/vtkLookupTableItem.cxx

@@ -129,5 +129,4 @@ void vtkLookupTableItem::ComputeTexture()
       ptr+=4;
     }
   }
-  return;
 }

Charts/Core/vtkPiecewiseFunctionItem.cxx

@@ -146,5 +146,4 @@ void vtkPiecewiseFunctionItem::ComputeTexture()
     }
   }
   delete[] values;
-  return;
 }

Charts/Core/vtkPlotBar.cxx

@@ -1013,7 +1013,6 @@ void vtkPlotBar::SelectColorArray(const vtkStdString& arrayName)
   vtkDebugMacro(<< "SelectColorArray called with invalid column name.");
   this->ColorArrayName = "";
   this->Modified();
-  return;
 }
 
 //-----------------------------------------------------------------------------

Charts/Core/vtkPlotParallelCoordinates.cxx

@@ -479,7 +479,6 @@ void vtkPlotParallelCoordinates::SelectColorArray(const vtkStdString &arrayName)
   vtkDebugMacro(<< "SelectColorArray called with invalid column name.");
   this->ColorArrayName = "";
   this->Modified();
-  return;
 }
 
 //-----------------------------------------------------------------------------

Charts/Core/vtkPlotPoints.cxx

@@ -996,7 +996,6 @@ void vtkPlotPoints::SelectColorArray(const vtkStdString& arrayName)
   vtkDebugMacro(<< "SelectColorArray called with invalid column name.");
   this->ColorArrayName = "";
   this->Modified();
-  return;
 }
 
 //-----------------------------------------------------------------------------

Common/Core/vtkLookupTable.cxx

@@ -697,8 +697,6 @@ void vtkLookupTable::GetColorAsUnsignedChars(const double colorIn[4],
     else if (v > 1.0) { v = 1.0; }
     colorOut[c] = static_cast<unsigned char>( v * 255.0 + 0.5 );
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/Testing/Cxx/UnitTestTriangleIntersection.cxx

@@ -125,7 +125,6 @@ void DrawTriangles(double* p1, double* q1, double* r1,
   // Render and interact
   renderWindow->Render();
   renderWindowInteractor->Start();
-  return;
 }
 }
 

Common/DataModel/vtkCellLocator.cxx

@@ -1020,8 +1020,6 @@ void vtkCellLocator::GetBucketNeighbors(int ijk[3], int ndivs, int level)
       }
     }
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/vtkCellTypes.cxx

@@ -205,7 +205,6 @@ void vtkCellTypes::InsertCell(int cellId, unsigned char type, int loc)
   {
     this->MaxId = cellId;
   }
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/vtkDataObject.cxx

@@ -324,7 +324,6 @@ void vtkDataObject::RemoveNamedFieldInformation(vtkInformation *info,
       return;
     }
   }
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/vtkHyperOctree.cxx

@@ -3226,7 +3226,6 @@ void vtkHyperOctreeLightWeightCursor::ToChild(int child)
     this->IsLeaf=node->IsChildLeaf(child);
     this->Level += 1;
   }
-  return;
 }
 
 

Common/DataModel/vtkImageData.cxx

@@ -680,8 +680,6 @@ void vtkImageData::GetPoint(vtkIdType ptId, double x[3])
   {
     x[i] = origin[i] + (loc[i]+extent[i*2]) * spacing[i];
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/vtkKdTree.cxx

@@ -294,8 +294,6 @@ void vtkKdTree::DeleteCellLists()
   }
 
   this->InitializeCellLists();
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -552,8 +550,6 @@ void vtkKdTree::GetRegionsAtLevel(int level, vtkKdNode **nodes)
   }
 
   vtkKdTree::_GetRegionsAtLevel(level, nodes, this->Top);
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -570,7 +566,6 @@ void vtkKdTree::GetLeafNodeIds(vtkKdNode *node, vtkIntArray *ids)
   {
     ids->InsertNextValue(id);
   }
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -730,8 +725,6 @@ void vtkKdTree::ComputeCellCenter(vtkDataSet *set, int cellId, double *center)
   this->ComputeCellCenter(set->GetCell(cellId), center, weights);
 
   delete [] weights;
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -743,8 +736,6 @@ void vtkKdTree::ComputeCellCenter(vtkCell *cell, double *center,
   int subId = cell->GetParametricCenter(pcoords);
 
   cell->EvaluateLocation(subId, pcoords, center, weights);
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -917,7 +908,6 @@ void vtkKdTree::BuildLocator()
   this->SetCalculator(this->Top);
 
   this->UpdateProgress(1.0);
-  return;
 }
 
 int vtkKdTree::ProcessUserDefinedCuts(double *minBounds)
@@ -1610,8 +1600,6 @@ void vtkKdTree::SelfRegister(vtkKdNode *kd)
     this->SelfRegister(kd->GetLeft());
     this->SelfRegister(kd->GetRight());
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -3553,14 +3541,12 @@ int vtkKdTree::findRegion(vtkKdNode *node, double x, double y, double z)
 void vtkKdTree::CreateCellLists()
 {
   this->CreateCellLists(static_cast<int *>(NULL), 0);
-  return;
 }
 
 //----------------------------------------------------------------------------
 void vtkKdTree::CreateCellLists(int *regionList, int listSize)
 {
   this->CreateCellLists(this->GetDataSet(), regionList, listSize);
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -3574,7 +3560,6 @@ void vtkKdTree::CreateCellLists(int dataSetIndex, int *regionList, int listSize)
   }
 
   this->CreateCellLists(dataSet, regionList, listSize);
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/vtkMeanValueCoordinatesInterpolator.cxx

@@ -353,8 +353,6 @@ void vtkComputeMVCWeightsForPolygonMesh(double x[3], T *pts, vtkIdType npts,
   {
     weights[pid] /= sumWeight;
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -534,8 +532,6 @@ void vtkComputeMVCWeightsForTriangleMesh(double x[3], T *pts, vtkIdType npts,
   {
     weights[pid] /= sumWeight;
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -609,8 +605,6 @@ void vtkMeanValueCoordinatesInterpolator::ComputeInterpolationWeights(
     vtkMeanValueCoordinatesInterpolator::
       ComputeInterpolationWeightsForPolygonMesh(x,pts,iter,weights);
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/vtkPlanesIntersection.cxx

@@ -547,8 +547,6 @@ void vtkPlanesIntersection::ComputeNormal(double *p1, double *p2, double *p3,
   v2[0] = p3[0] - p2[0]; v2[1] = p3[1] - p2[1]; v2[2] = p3[2] - p2[2];
 
   vtkMath::Cross(v1, v2, normal);
-
-  return;
 }
 int vtkPlanesIntersection::GoodNormal(double *n)
 {

Common/DataModel/vtkPointLocator.cxx

@@ -1008,8 +1008,6 @@ void vtkPointLocator::GetBucketNeighbors(vtkNeighborPoints* buckets,
       }
     }
   }
-
-  return;
 }
 
 

Common/DataModel/vtkPolygon.cxx

@@ -560,8 +560,6 @@ void vtkPolygon::InterpolateFunctionsUsingMVC(double x[3], double *weights)
   {
     weights[i] /= sum;
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/DataModel/vtkQuadratureSchemeDefinition.cxx

@@ -219,7 +219,6 @@ void vtkQuadratureSchemeDefinition::PrintSelf(ostream &sout, vtkIndent indent)
     }
     sout << ")" << endl;
   }
-  return;
 }
 
 

Common/DataModel/vtkStaticPointLocator.cxx

@@ -250,8 +250,6 @@ GetBucketNeighbors(NeighborBuckets* buckets, const int ijk[3],
       }
     }
   }
-
-  return;
 }
 
 //-----------------------------------------------------------------------------

Common/DataModel/vtkStructuredData.cxx

@@ -357,8 +357,6 @@ void vtkStructuredData::GetPointCells(vtkIdType ptId, vtkIdList *cellIds,
       cellIds->InsertNextId(cellId);
     }
   }
-
-  return;
 }
 
 //------------------------------------------------------------------------------

Common/ExecutionModel/vtkSphereTree.cxx

@@ -1698,8 +1698,6 @@ ExtractCellIds(const unsigned char *selected, vtkIdList *cellIds,
       }
     }
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/Math/vtkQuaternionInterpolator.cxx

@@ -283,8 +283,6 @@ void vtkQuaternionInterpolator::InterpolateQuaternion(double t,
     q = qc.Slerp(2.0*T*(1.0-T),qd);
     q.NormalizeWithAngleInDegrees();
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Common/Misc/vtkFunctionParser.cxx

@@ -2283,8 +2283,6 @@ void vtkFunctionParser::CheckExpression(int &pos, char **error)
   // The string is ok
   delete [] expectCommaOnParenthesisCount;
   delete [] expectTwoCommasOnParenthesisCount;
-
-  return;
 }
 
 //-----------------------------------------------------------------------------

Common/Misc/vtkPolygonBuilder.cxx

@@ -113,7 +113,6 @@ void vtkPolygonBuilder::InsertTriangle(vtkIdType* abc)
       }
     }
   }
-  return;
 }
 
 void vtkPolygonBuilder::GetPolygons(vtkIdListCollection* polys)

Domains/Chemistry/vtkBlueObeliskDataParser.cxx

@@ -145,8 +145,6 @@ void vtkBlueObeliskDataParser::StartElement(const char *name,
   {
     vtkDebugMacro(<<"Unhandled BODR element: " << name);
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -453,7 +451,6 @@ void vtkBlueObeliskDataParser::SetCurrentValue(const char *data)
     default:
       vtkDebugMacro(<<"Called with no CurrentValueType. data: "<<data);
   }
-  return;
 }
 
 //----------------------------------------------------------------------------

Domains/Chemistry/vtkCMLMoleculeReader.cxx

@@ -179,8 +179,6 @@ void vtkCMLParser::StartElement(const char *name, const char **attr)
     }
     vtkDebugMacro(<<desc);
   }
-
-  return;
 }
 
 void vtkCMLParser::EndElement(const char *)

Domains/Chemistry/vtkProgrammableElectronicData.cxx

@@ -91,8 +91,6 @@ void vtkProgrammableElectronicData::SetNumberOfMOs(vtkIdType size)
   this->MOs->resize(size);
 
   this->Modified();
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Filters/Core/vtkConnectivityFilter.cxx

@@ -520,8 +520,6 @@ void vtkConnectivityFilter::TraverseAndMark (vtkDataSet *input)
     this->Wave2 = tmpWave;
     tmpWave->Reset();
   } //while wave is not empty
-
-  return;
 }
 
 // Obtain the number of connected regions.

Filters/Core/vtkDecimatePro.cxx

@@ -1097,8 +1097,6 @@ void vtkDecimatePro::SplitVertex(vtkIdType ptId, int type,
     cellIds->Delete();
     group->Delete();
   }
-
-  return;
 }
 
 

Filters/Core/vtkHull.cxx

@@ -278,8 +278,6 @@ void  vtkHull::SetPlanes( vtkPlanes *planes )
       }//for all planes
     }//if points and normals
   }//if planes defined
-
-  return;
 }
 
 // Add the six planes that represent the faces on a cube

Filters/Core/vtkPolyDataConnectivityFilter.cxx

@@ -505,8 +505,6 @@ void vtkPolyDataConnectivityFilter::TraverseAndMark ()
     this->Wave2.clear();
     this->Wave2.reserve(numCells);
   } //while wave is not empty
-
-  return;
 }
 
 // --------------------------------------------------------------------------

Filters/Core/vtkPolyDataNormals.cxx

@@ -593,8 +593,6 @@ void vtkPolyDataNormals::TraverseAndOrder (void)
     this->Wave2 = tmpWave;
     this->Wave2->Reset();
   } //while wave still propagating
-
-  return;
 }
 
 //
@@ -754,8 +752,6 @@ void vtkPolyDataNormals::MarkAndSplit (vtkIdType ptId)
       }//replace ptId with split point
     }//if not in first regions and requiring splitting
   }//for all cells connected to ptId
-
-  return;
 }
 
 void vtkPolyDataNormals::PrintSelf(ostream& os, vtkIndent indent)

Filters/Core/vtkQuadricDecimation.cxx

@@ -819,7 +819,6 @@ void vtkQuadricDecimation::UpdateEdgeData(vtkIdType pt0Id, vtkIdType pt1Id)
   }
 
   changedEdges->Delete();
-  return;
 }
 
 //----------------------------------------------------------------------------

Filters/Extraction/vtkExtractCells.cxx

@@ -91,8 +91,6 @@ void vtkExtractCells::AddCellList(vtkIdList *l)
   }
 
   this->Modified();
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -106,8 +104,6 @@ void vtkExtractCells::AddCellRange(vtkIdType from, vtkIdType to)
   }
 
   this->Modified();
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -267,8 +263,6 @@ void vtkExtractCells::Copy(vtkDataSet *input, vtkUnstructuredGrid *output)
   cellPoints->Delete();
 
   output->Squeeze();
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -468,8 +462,6 @@ void vtkExtractCells::CopyCellsDataSet(vtkIdList *ptMap, vtkDataSet *input,
   }
 
   cellPoints->Delete();
-
-  return;
 }
 
 //----------------------------------------------------------------------------
@@ -562,8 +554,6 @@ void vtkExtractCells::CopyCellsUnstructuredGrid(vtkIdList *ptMap,
   locationArray->Delete();
   newcells->Delete();
   cellArray->Delete();
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Filters/FlowPaths/vtkStreamTracer.cxx

@@ -1199,7 +1199,6 @@ void vtkStreamTracer::Integrate(vtkPointData *input0Data,
   delete[] weights;
 
   output->Squeeze();
-  return;
 }
 
 void vtkStreamTracer::GenerateNormals(vtkPolyData* output, double* firstNormal,

Filters/General/vtkExtractSelectedFrustum.cxx

@@ -1159,8 +1159,6 @@ void vtkExtractSelectedFrustum::PlaneClipEdge(double *V0, double *V1, int pid,
     overts[noverts*3+2] = V1[2];
     noverts++;
   }
-
-  return;
 }
 
 //----------------------------------------------------------------------------

Filters/General/vtkMergeCells.cxx

@@ -562,8 +562,6 @@ void vtkMergeCells::StartUGrid(vtkDataSet *set)
     ugrid->GetCellData()->CopyGlobalIdsOn();
   }
   ugrid->GetCellData()->CopyAllocate(*cellList, this->TotalNumberOfCells);
-
-  return;
 }
 
 void vtkMergeCells::Finish()
@@ -581,8 +579,6 @@ void vtkMergeCells::Finish()
   }
 
   ugrid->Squeeze();
-
-  return;
 }
 
 //  Use an array of global node ids to map all points to

Filters/Generic/vtkGenericStreamTracer.cxx

@@ -1185,7 +1185,6 @@ void vtkGenericStreamTracer::Integrate(
   delete[] values;
 
   output->Squeeze();
-  return;
 }
 
 //-----------------------------------------------------------------------------

Filters/Hybrid/vtkGreedyTerrainDecimation.cxx

@@ -155,7 +155,6 @@ void vtkGreedyTerrainDecimation::EstimateOutputSize(const vtkIdType numInputPts,
 
   numPts = numTris/2 + 1;
   numPts = (numPts < 4 ? 4 : numPts); //insure enough storage for initial four corner points
-  return;
 }
 
 //----------------------------------------------------------------------

Filters/Modeling/vtkCookieCutter.cxx

@@ -378,8 +378,6 @@ namespace {
 
     // Update the sorted points array, now clean!
     sortedPoints = newSortedPoints;
-
-    return;
   }
 
   // Classify polyline segments----------------------------------------------

Filters/Parallel/vtkPKdTree.cxx

@@ -260,7 +260,6 @@ void vtkPKdTree::AllCheckParameters()
     this->SetNumberOfRegionsOrMore(param0[3]);
     this->RegionAssignment       = param0[4];
   }
-  return;
 }
 
 #define BoundsToMinMax(bounds,min,max) \
@@ -460,7 +459,6 @@ done:
 
   this->UpdateBuildTime();
   this->UpdateProgress(1.0);
-  return;
 }
 int vtkPKdTree::MultiProcessBuildLocator(double *volBounds)
 {
@@ -584,8 +582,6 @@ void vtkPKdTree::SingleProcessBuildLocator()
   {
     this->UpdateRegionAssignment();
   }
-
-  return;
 }
 typedef struct _vtkNodeInfo{
   vtkKdNode *kd;
@@ -887,7 +883,6 @@ void vtkPKdTree::ExchangeVals(int pos1, int pos2)
 
     this->SetLocalVal(pos2, otherval);
   }
-  return;
 }
 
 // Given an array X with element indices ranging from L to R, and
@@ -1101,8 +1096,6 @@ void vtkPKdTree::SetLocalVal(int pos, float *val)
   this->CurrentPtArray[localOffset]   = val[0];
   this->CurrentPtArray[localOffset+1] = val[1];
   this->CurrentPtArray[localOffset+2] = val[2];
-
-  return;
 }
 void vtkPKdTree::ExchangeLocalVals(int pos1, int pos2)
 {
@@ -1128,8 +1121,6 @@ void vtkPKdTree::ExchangeLocalVals(int pos1, int pos2)
   pt2[0] = temp[0];
   pt2[1] = temp[1];
   pt2[2] = temp[2];
-