diff --git a/intern/opensubdiv/internal/base/memory.h b/intern/opensubdiv/internal/base/memory.h
index c958416013e..f7342ed90b8 100644
--- a/intern/opensubdiv/internal/base/memory.h
+++ b/intern/opensubdiv/internal/base/memory.h
@@ -7,10 +7,8 @@
 
 #include "MEM_guardedalloc.h"
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_BASE_MEMORY_H_
diff --git a/intern/opensubdiv/internal/base/type_convert.cc b/intern/opensubdiv/internal/base/type_convert.cc
index 82b2128ce5b..cebf93f8bde 100644
--- a/intern/opensubdiv/internal/base/type_convert.cc
+++ b/intern/opensubdiv/internal/base/type_convert.cc
@@ -13,8 +13,7 @@
 #include <cassert>
 #include <opensubdiv/sdc/crease.h>
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 OpenSubdiv::Sdc::SchemeType getSchemeTypeFromCAPI(OpenSubdiv_SchemeType type)
 {
@@ -91,5 +90,4 @@ OpenSubdiv::Sdc::Options::VtxBoundaryInterpolation getVtxBoundaryInterpolationFr
   return Options::VTX_BOUNDARY_EDGE_ONLY;
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/base/type_convert.h b/intern/opensubdiv/internal/base/type_convert.h
index 03f569b3d4b..a0da9ddfb96 100644
--- a/intern/opensubdiv/internal/base/type_convert.h
+++ b/intern/opensubdiv/internal/base/type_convert.h
@@ -18,8 +18,7 @@
 
 struct OpenSubdiv_Converter;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 // Convert scheme type from C-API enum to an OpenSubdiv native enum.
 OpenSubdiv::Sdc::SchemeType getSchemeTypeFromCAPI(OpenSubdiv_SchemeType type);
@@ -36,7 +35,6 @@ OpenSubdiv_FVarLinearInterpolation getCAPIFVarLinearInterpolationFromOSD(
 OpenSubdiv::Sdc::Options::VtxBoundaryInterpolation getVtxBoundaryInterpolationFromCAPI(
     OpenSubdiv_VtxBoundaryInterpolation boundary_interpolation);
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_BASE_TYPE_CONVERT_H_
diff --git a/intern/opensubdiv/internal/base/util.cc b/intern/opensubdiv/internal/base/util.cc
index 7e74c52e8b6..1d7943643ae 100644
--- a/intern/opensubdiv/internal/base/util.cc
+++ b/intern/opensubdiv/internal/base/util.cc
@@ -4,8 +4,7 @@
 
 #include "internal/base/util.h"
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 void stringSplit(std::vector<std::string> *tokens,
                  const std::string &str,
@@ -39,5 +38,4 @@ void stringSplit(std::vector<std::string> *tokens,
   }
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/base/util.h b/intern/opensubdiv/internal/base/util.h
index 7def6240fbe..365b7a62a68 100644
--- a/intern/opensubdiv/internal/base/util.h
+++ b/intern/opensubdiv/internal/base/util.h
@@ -8,15 +8,13 @@
 #include <string>
 #include <vector>
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 void stringSplit(std::vector<std::string> *tokens,
                  const std::string &str,
                  const std::string &separators,
                  bool skip_empty);
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_BASE_UTIL_H_
diff --git a/intern/opensubdiv/internal/evaluator/eval_output.cc b/intern/opensubdiv/internal/evaluator/eval_output.cc
index 2c8d687a849..5efc13b3f39 100644
--- a/intern/opensubdiv/internal/evaluator/eval_output.cc
+++ b/intern/opensubdiv/internal/evaluator/eval_output.cc
@@ -6,9 +6,7 @@
 
 #include "internal/evaluator/eval_output.h"
 
-namespace blender {
-namespace opensubdiv {
-
+namespace blender::opensubdiv {
 bool is_adaptive(CpuPatchTable *patch_table)
 {
   return patch_table->GetPatchArrayBuffer()[0].GetDescriptor().IsAdaptive();
@@ -19,5 +17,4 @@ bool is_adaptive(GLPatchTable *patch_table)
   return patch_table->GetPatchArrays()[0].GetDescriptor().IsAdaptive();
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/evaluator/eval_output.h b/intern/opensubdiv/internal/evaluator/eval_output.h
index b5f52353ebb..dd3fc11c61c 100644
--- a/intern/opensubdiv/internal/evaluator/eval_output.h
+++ b/intern/opensubdiv/internal/evaluator/eval_output.h
@@ -23,8 +23,7 @@ using OpenSubdiv::Osd::CpuPatchTable;
 using OpenSubdiv::Osd::GLPatchTable;
 using OpenSubdiv::Osd::PatchCoord;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 // Base class for the implementation of the evaluators.
 class EvalOutputAPI::EvalOutput {
@@ -114,8 +113,6 @@ class EvalOutputAPI::EvalOutput {
   }
 };
 
-namespace {
-
 // Buffer which implements API required by OpenSubdiv and uses an existing memory as an underlying
 // storage.
 template<typename T> class RawDataWrapperBuffer {
@@ -161,7 +158,6 @@ class ConstPatchCoordWrapperBuffer : public RawDataWrapperVertexBuffer<const Pat
   {
   }
 };
-}  // namespace
 
 // Discriminators used in FaceVaryingVolatileEval in order to detect whether we are using adaptive
 // patches as the CPU and OpenGL PatchTable have different APIs.
@@ -646,7 +642,6 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput {
   DEVICE_CONTEXT *device_context_;
 };
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_EVAL_OUTPUT_H_
diff --git a/intern/opensubdiv/internal/evaluator/eval_output_cpu.cc b/intern/opensubdiv/internal/evaluator/eval_output_cpu.cc
index a7b325bb64c..71b8a92b015 100644
--- a/intern/opensubdiv/internal/evaluator/eval_output_cpu.cc
+++ b/intern/opensubdiv/internal/evaluator/eval_output_cpu.cc
@@ -4,8 +4,6 @@
  *
  * Author: Sergey Sharybin. */
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
-}
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/evaluator/eval_output_cpu.h b/intern/opensubdiv/internal/evaluator/eval_output_cpu.h
index 9c9eb332c0f..fd07d0b4c35 100644
--- a/intern/opensubdiv/internal/evaluator/eval_output_cpu.h
+++ b/intern/opensubdiv/internal/evaluator/eval_output_cpu.h
@@ -17,8 +17,7 @@ using OpenSubdiv::Far::StencilTable;
 using OpenSubdiv::Osd::CpuEvaluator;
 using OpenSubdiv::Osd::CpuVertexBuffer;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 // NOTE: Define as a class instead of typedef to make it possible
 // to have anonymous class in opensubdiv_evaluator_internal.h
@@ -48,7 +47,6 @@ class CpuEvalOutput : public VolatileEvalOutput<CpuVertexBuffer,
   }
 };
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_EVAL_OUTPUT_CPU_H_
diff --git a/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc b/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc
index 19aad131191..1072893f31d 100644
--- a/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc
+++ b/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc
@@ -11,10 +11,7 @@
 using OpenSubdiv::Osd::PatchArray;
 using OpenSubdiv::Osd::PatchArrayVector;
 
-namespace blender {
-namespace opensubdiv {
-
-namespace {
+namespace blender::opensubdiv {
 
 static void buildPatchArraysBufferFromVector(const PatchArrayVector &patch_arrays,
                                              OpenSubdiv_Buffer *patch_arrays_buffer)
@@ -27,8 +24,6 @@ static void buildPatchArraysBufferFromVector(const PatchArrayVector &patch_array
       patch_arrays_buffer, 0, patch_array_byte_site, &patch_arrays[0]);
 }
 
-}  // namespace
-
 GpuEvalOutput::GpuEvalOutput(const StencilTable *vertex_stencils,
                              const StencilTable *varying_stencils,
                              const std::vector<const StencilTable *> &all_face_varying_stencils,
@@ -110,5 +105,4 @@ void GpuEvalOutput::wrapFVarSrcBuffer(const int face_varying_channel,
   src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/evaluator/eval_output_gpu.h b/intern/opensubdiv/internal/evaluator/eval_output_gpu.h
index 54706a96d2c..faad0445b6b 100644
--- a/intern/opensubdiv/internal/evaluator/eval_output_gpu.h
+++ b/intern/opensubdiv/internal/evaluator/eval_output_gpu.h
@@ -15,8 +15,7 @@
 
 using OpenSubdiv::Osd::GLVertexBuffer;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 class GpuEvalOutput : public VolatileEvalOutput<GLVertexBuffer,
                                                 GLVertexBuffer,
@@ -53,7 +52,6 @@ class GpuEvalOutput : public VolatileEvalOutput<GLVertexBuffer,
   void wrapFVarSrcBuffer(const int face_varying_channel, OpenSubdiv_Buffer *src_buffer) override;
 };
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_EVAL_OUTPUT_GPU_H_
diff --git a/intern/opensubdiv/internal/evaluator/evaluator_capi.cc b/intern/opensubdiv/internal/evaluator/evaluator_capi.cc
index 3301208fb64..25265455965 100644
--- a/intern/opensubdiv/internal/evaluator/evaluator_capi.cc
+++ b/intern/opensubdiv/internal/evaluator/evaluator_capi.cc
@@ -14,145 +14,143 @@
 #include "internal/evaluator/evaluator_cache_impl.h"
 #include "internal/evaluator/evaluator_impl.h"
 
-namespace {
-
-void setSettings(struct OpenSubdiv_Evaluator *evaluator,
-                 const OpenSubdiv_EvaluatorSettings *settings)
+static void setSettings(struct OpenSubdiv_Evaluator *evaluator,
+                        const OpenSubdiv_EvaluatorSettings *settings)
 {
   evaluator->impl->eval_output->setSettings(settings);
 }
 
-void setCoarsePositions(OpenSubdiv_Evaluator *evaluator,
-                        const float *positions,
-                        const int start_vertex_index,
-                        const int num_vertices)
+static void setCoarsePositions(OpenSubdiv_Evaluator *evaluator,
+                               const float *positions,
+                               const int start_vertex_index,
+                               const int num_vertices)
 {
   evaluator->impl->eval_output->setCoarsePositions(positions, start_vertex_index, num_vertices);
 }
 
-void setVertexData(OpenSubdiv_Evaluator *evaluator,
-                   const float *vertex_data,
-                   const int start_vertex_index,
-                   const int num_vertices)
+static void setVertexData(OpenSubdiv_Evaluator *evaluator,
+                          const float *vertex_data,
+                          const int start_vertex_index,
+                          const int num_vertices)
 {
   evaluator->impl->eval_output->setVertexData(vertex_data, start_vertex_index, num_vertices);
 }
 
-void setVaryingData(OpenSubdiv_Evaluator *evaluator,
-                    const float *varying_data,
-                    const int start_vertex_index,
-                    const int num_vertices)
+static void setVaryingData(OpenSubdiv_Evaluator *evaluator,
+                           const float *varying_data,
+                           const int start_vertex_index,
+                           const int num_vertices)
 {
   evaluator->impl->eval_output->setVaryingData(varying_data, start_vertex_index, num_vertices);
 }
 
-void setFaceVaryingData(OpenSubdiv_Evaluator *evaluator,
-                        const int face_varying_channel,
-                        const float *face_varying_data,
-                        const int start_vertex_index,
-                        const int num_vertices)
+static void setFaceVaryingData(OpenSubdiv_Evaluator *evaluator,
+                               const int face_varying_channel,
+                               const float *face_varying_data,
+                               const int start_vertex_index,
+                               const int num_vertices)
 {
   evaluator->impl->eval_output->setFaceVaryingData(
       face_varying_channel, face_varying_data, start_vertex_index, num_vertices);
 }
 
-void setCoarsePositionsFromBuffer(OpenSubdiv_Evaluator *evaluator,
-                                  const void *buffer,
-                                  const int start_offset,
-                                  const int stride,
-                                  const int start_vertex_index,
-                                  const int num_vertices)
+static void setCoarsePositionsFromBuffer(OpenSubdiv_Evaluator *evaluator,
+                                         const void *buffer,
+                                         const int start_offset,
+                                         const int stride,
+                                         const int start_vertex_index,
+                                         const int num_vertices)
 {
   evaluator->impl->eval_output->setCoarsePositionsFromBuffer(
       buffer, start_offset, stride, start_vertex_index, num_vertices);
 }
 
-void setVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
-                              const void *buffer,
-                              const int start_offset,
-                              const int stride,
-                              const int start_vertex_index,
-                              const int num_vertices)
+static void setVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
+                                     const void *buffer,
+                                     const int start_offset,
+                                     const int stride,
+                                     const int start_vertex_index,
+                                     const int num_vertices)
 {
   evaluator->impl->eval_output->setVaryingDataFromBuffer(
       buffer, start_offset, stride, start_vertex_index, num_vertices);
 }
 
-void setFaceVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
-                                  const int face_varying_channel,
-                                  const void *buffer,
-                                  const int start_offset,
-                                  const int stride,
-                                  const int start_vertex_index,
-                                  const int num_vertices)
+static void setFaceVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
+                                         const int face_varying_channel,
+                                         const void *buffer,
+                                         const int start_offset,
+                                         const int stride,
+                                         const int start_vertex_index,
+                                         const int num_vertices)
 {
   evaluator->impl->eval_output->setFaceVaryingDataFromBuffer(
       face_varying_channel, buffer, start_offset, stride, start_vertex_index, num_vertices);
 }
 
-void refine(OpenSubdiv_Evaluator *evaluator)
+static void refine(OpenSubdiv_Evaluator *evaluator)
 {
   evaluator->impl->eval_output->refine();
 }
 
-void evaluateLimit(OpenSubdiv_Evaluator *evaluator,
-                   const int ptex_face_index,
-                   const float face_u,
-                   const float face_v,
-                   float P[3],
-                   float dPdu[3],
-                   float dPdv[3])
+static void evaluateLimit(OpenSubdiv_Evaluator *evaluator,
+                          const int ptex_face_index,
+                          const float face_u,
+                          const float face_v,
+                          float P[3],
+                          float dPdu[3],
+                          float dPdv[3])
 {
   evaluator->impl->eval_output->evaluateLimit(ptex_face_index, face_u, face_v, P, dPdu, dPdv);
 }
 
-void evaluatePatchesLimit(OpenSubdiv_Evaluator *evaluator,
-                          const OpenSubdiv_PatchCoord *patch_coords,
-                          const int num_patch_coords,
-                          float *P,
-                          float *dPdu,
-                          float *dPdv)
+static void evaluatePatchesLimit(OpenSubdiv_Evaluator *evaluator,
+                                 const OpenSubdiv_PatchCoord *patch_coords,
+                                 const int num_patch_coords,
+                                 float *P,
+                                 float *dPdu,
+                                 float *dPdv)
 {
   evaluator->impl->eval_output->evaluatePatchesLimit(
       patch_coords, num_patch_coords, P, dPdu, dPdv);
 }
 
-void evaluateVertexData(OpenSubdiv_Evaluator *evaluator,
-                        const int ptex_face_index,
-                        float face_u,
-                        float face_v,
-                        float vertex_data[3])
+static void evaluateVertexData(OpenSubdiv_Evaluator *evaluator,
+                               const int ptex_face_index,
+                               float face_u,
+                               float face_v,
+                               float vertex_data[3])
 {
   evaluator->impl->eval_output->evaluateVertexData(ptex_face_index, face_u, face_v, vertex_data);
 }
 
-void evaluateVarying(OpenSubdiv_Evaluator *evaluator,
-                     const int ptex_face_index,
-                     float face_u,
-                     float face_v,
-                     float varying[3])
+static void evaluateVarying(OpenSubdiv_Evaluator *evaluator,
+                            const int ptex_face_index,
+                            float face_u,
+                            float face_v,
+                            float varying[3])
 {
   evaluator->impl->eval_output->evaluateVarying(ptex_face_index, face_u, face_v, varying);
 }
 
-void evaluateFaceVarying(OpenSubdiv_Evaluator *evaluator,
-                         const int face_varying_channel,
-                         const int ptex_face_index,
-                         float face_u,
-                         float face_v,
-                         float face_varying[2])
+static void evaluateFaceVarying(OpenSubdiv_Evaluator *evaluator,
+                                const int face_varying_channel,
+                                const int ptex_face_index,
+                                float face_u,
+                                float face_v,
+                                float face_varying[2])
 {
   evaluator->impl->eval_output->evaluateFaceVarying(
       face_varying_channel, ptex_face_index, face_u, face_v, face_varying);
 }
 
-void getPatchMap(struct OpenSubdiv_Evaluator *evaluator,
-                 struct OpenSubdiv_Buffer *patch_map_handles,
-                 struct OpenSubdiv_Buffer *patch_map_quadtree,
-                 int *min_patch_face,
-                 int *max_patch_face,
-                 int *max_depth,
-                 int *patches_are_triangular)
+static void getPatchMap(struct OpenSubdiv_Evaluator *evaluator,
+                        struct OpenSubdiv_Buffer *patch_map_handles,
+                        struct OpenSubdiv_Buffer *patch_map_quadtree,
+                        int *min_patch_face,
+                        int *max_patch_face,
+                        int *max_depth,
+                        int *patches_are_triangular)
 {
   evaluator->impl->eval_output->getPatchMap(patch_map_handles,
                                             patch_map_quadtree,
@@ -162,70 +160,71 @@ void getPatchMap(struct OpenSubdiv_Evaluator *evaluator,
                                             patches_are_triangular);
 }
 
-void fillPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                           struct OpenSubdiv_Buffer *patch_array_buffer)
+static void fillPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                                  struct OpenSubdiv_Buffer *patch_array_buffer)
 {
   evaluator->impl->eval_output->fillPatchArraysBuffer(patch_array_buffer);
 }
 
-void wrapPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                          struct OpenSubdiv_Buffer *patch_index_buffer)
+static void wrapPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                                 struct OpenSubdiv_Buffer *patch_index_buffer)
 {
   evaluator->impl->eval_output->wrapPatchIndexBuffer(patch_index_buffer);
 }
 
-void wrapPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                          struct OpenSubdiv_Buffer *patch_param_buffer)
+static void wrapPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                                 struct OpenSubdiv_Buffer *patch_param_buffer)
 {
   evaluator->impl->eval_output->wrapPatchParamBuffer(patch_param_buffer);
 }
 
-void wrapSrcBuffer(struct OpenSubdiv_Evaluator *evaluator, struct OpenSubdiv_Buffer *src_buffer)
+static void wrapSrcBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                          struct OpenSubdiv_Buffer *src_buffer)
 {
   evaluator->impl->eval_output->wrapSrcBuffer(src_buffer);
 }
 
-void wrapSrcVertexDataBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                             struct OpenSubdiv_Buffer *src_buffer)
+static void wrapSrcVertexDataBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                                    struct OpenSubdiv_Buffer *src_buffer)
 {
   evaluator->impl->eval_output->wrapSrcVertexDataBuffer(src_buffer);
 }
 
-void fillFVarPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                               const int face_varying_channel,
-                               struct OpenSubdiv_Buffer *patch_array_buffer)
+static void fillFVarPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                                      const int face_varying_channel,
+                                      struct OpenSubdiv_Buffer *patch_array_buffer)
 {
   evaluator->impl->eval_output->fillFVarPatchArraysBuffer(face_varying_channel,
                                                           patch_array_buffer);
 }
 
-void wrapFVarPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                              const int face_varying_channel,
-                              struct OpenSubdiv_Buffer *patch_index_buffer)
+static void wrapFVarPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                                     const int face_varying_channel,
+                                     struct OpenSubdiv_Buffer *patch_index_buffer)
 {
   evaluator->impl->eval_output->wrapFVarPatchIndexBuffer(face_varying_channel, patch_index_buffer);
 }
 
-void wrapFVarPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                              const int face_varying_channel,
-                              struct OpenSubdiv_Buffer *patch_param_buffer)
+static void wrapFVarPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                                     const int face_varying_channel,
+                                     struct OpenSubdiv_Buffer *patch_param_buffer)
 {
   evaluator->impl->eval_output->wrapFVarPatchParamBuffer(face_varying_channel, patch_param_buffer);
 }
 
-void wrapFVarSrcBuffer(struct OpenSubdiv_Evaluator *evaluator,
-                       const int face_varying_channel,
-                       struct OpenSubdiv_Buffer *src_buffer)
+static void wrapFVarSrcBuffer(struct OpenSubdiv_Evaluator *evaluator,
+                              const int face_varying_channel,
+                              struct OpenSubdiv_Buffer *src_buffer)
 {
   evaluator->impl->eval_output->wrapFVarSrcBuffer(face_varying_channel, src_buffer);
 }
 
-bool hasVertexData(struct OpenSubdiv_Evaluator *evaluator)
+static bool hasVertexData(struct OpenSubdiv_Evaluator *evaluator)
 {
   return evaluator->impl->eval_output->hasVertexData();
 }
 
-void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
+static void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
 {
   evaluator->setSettings = setSettings;
 
@@ -263,8 +262,6 @@ void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
   evaluator->hasVertexData = hasVertexData;
 }
 
-}  // namespace
-
 OpenSubdiv_Evaluator *openSubdiv_createEvaluatorFromTopologyRefiner(
     OpenSubdiv_TopologyRefiner *topology_refiner,
     eOpenSubdivEvaluator evaluator_type,
diff --git a/intern/opensubdiv/internal/evaluator/evaluator_impl.cc b/intern/opensubdiv/internal/evaluator/evaluator_impl.cc
index 732c028831e..a4ac0e3e767 100644
--- a/intern/opensubdiv/internal/evaluator/evaluator_impl.cc
+++ b/intern/opensubdiv/internal/evaluator/evaluator_impl.cc
@@ -38,10 +38,7 @@ using OpenSubdiv::Far::TopologyRefiner;
 using OpenSubdiv::Osd::PatchArray;
 using OpenSubdiv::Osd::PatchCoord;
 
-namespace blender {
-namespace opensubdiv {
-
-namespace {
+namespace blender::opensubdiv {
 
 // Array implementation which stores small data on stack (or, rather, in the class itself).
 template<typename T, int kNumMaxElementsOnStack> class StackOrHeapArray {
@@ -126,10 +123,10 @@ template<typename T, int kNumMaxElementsOnStack> class StackOrHeapArray {
 // 32 is a number of inner vertices along the patch size at subdivision level 6.
 typedef StackOrHeapArray<PatchCoord, 32 * 32> StackOrHeapPatchCoordArray;
 
-void convertPatchCoordsToArray(const OpenSubdiv_PatchCoord *patch_coords,
-                               const int num_patch_coords,
-                               const PatchMap *patch_map,
-                               StackOrHeapPatchCoordArray *array)
+static void convertPatchCoordsToArray(const OpenSubdiv_PatchCoord *patch_coords,
+                                      const int num_patch_coords,
+                                      const PatchMap *patch_map,
+                                      StackOrHeapPatchCoordArray *array)
 {
   array->resize(num_patch_coords);
   for (int i = 0; i < num_patch_coords; ++i) {
@@ -139,8 +136,6 @@ void convertPatchCoordsToArray(const OpenSubdiv_PatchCoord *patch_coords,
   }
 }
 
-}  // namespace
-
 ////////////////////////////////////////////////////////////////////////////////
 // Evaluator wrapper for anonymous API.
 
@@ -410,8 +405,7 @@ bool EvalOutputAPI::hasVertexData() const
   return implementation_->hasVertexData();
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 OpenSubdiv_EvaluatorImpl::OpenSubdiv_EvaluatorImpl()
     : eval_output(NULL), patch_map(NULL), patch_table(NULL)
diff --git a/intern/opensubdiv/internal/evaluator/evaluator_impl.h b/intern/opensubdiv/internal/evaluator/evaluator_impl.h
index c01351ac3ec..632456fef19 100644
--- a/intern/opensubdiv/internal/evaluator/evaluator_impl.h
+++ b/intern/opensubdiv/internal/evaluator/evaluator_impl.h
@@ -24,8 +24,7 @@ struct OpenSubdiv_EvaluatorSettings;
 struct OpenSubdiv_PatchCoord;
 struct OpenSubdiv_TopologyRefiner;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 class PatchMap;
 
@@ -183,8 +182,7 @@ class EvalOutputAPI {
   EvalOutput *implementation_;
 };
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 struct OpenSubdiv_EvaluatorImpl {
  public:
diff --git a/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.cc b/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.cc
index fa3d0c461cf..c15c9604e8f 100644
--- a/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.cc
+++ b/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.cc
@@ -39,8 +39,7 @@ using OpenSubdiv::Osd::PatchArrayVector;
 
 extern "C" char datatoc_glsl_compute_kernel_glsl[];
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 template<class T> GLuint createSSBO(std::vector<T> const &src)
 {
@@ -657,5 +656,4 @@ bool GLComputeEvaluator::_PatchKernel::Compile(BufferDescriptor const &srcDesc,
   return true;
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.h b/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.h
index fb4c179329f..dcb54229489 100644
--- a/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.h
+++ b/intern/opensubdiv/internal/evaluator/gl_compute_evaluator.h
@@ -19,8 +19,7 @@ class StencilTable;
 }  // namespace OPENSUBDIV_VERSION
 }  // namespace OpenSubdiv
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 /// \brief GL stencil table (Shader Storage buffer)
 ///
@@ -2440,7 +2439,7 @@ class GLComputeEvaluator {
 
   void DispatchCompute(int totalDispatchSize) const;
 };
-}  // namespace opensubdiv
-}  // namespace blender
+
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_GL_COMPUTE_EVALUATOR_H_
diff --git a/intern/opensubdiv/internal/evaluator/patch_map.cc b/intern/opensubdiv/internal/evaluator/patch_map.cc
index 6d5166dd0f6..ddbc2c685e7 100644
--- a/intern/opensubdiv/internal/evaluator/patch_map.cc
+++ b/intern/opensubdiv/internal/evaluator/patch_map.cc
@@ -14,8 +14,7 @@ using OpenSubdiv::Far::PatchParam;
 using OpenSubdiv::Far::PatchParamTable;
 using OpenSubdiv::Far::PatchTable;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 //
 //  Inline quadtree assembly methods used by the constructor:
@@ -192,5 +191,4 @@ void PatchMap::initializeQuadtree(PatchTable const &patchTable)
   _quadtree.swap(tmpTree);
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/evaluator/patch_map.h b/intern/opensubdiv/internal/evaluator/patch_map.h
index 06d55b32216..7d2b790d6d8 100644
--- a/intern/opensubdiv/internal/evaluator/patch_map.h
+++ b/intern/opensubdiv/internal/evaluator/patch_map.h
@@ -10,8 +10,7 @@
 
 #include <opensubdiv/far/patchTable.h>
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 /// \brief An quadtree-based map connecting coarse faces to their sub-patches
 ///
@@ -245,7 +244,7 @@ inline PatchMap::Handle const *PatchMap::FindPatch(int faceid, double u, double
   assert(0);
   return 0;
 }
-}  // namespace opensubdiv
-}  // namespace blender
+
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_PATCH_MAP_H_
diff --git a/intern/opensubdiv/internal/topology/mesh_topology.cc b/intern/opensubdiv/internal/topology/mesh_topology.cc
index a207d980801..cb365710f15 100644
--- a/intern/opensubdiv/internal/topology/mesh_topology.cc
+++ b/intern/opensubdiv/internal/topology/mesh_topology.cc
@@ -8,8 +8,7 @@
 
 #include <cassert>
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 MeshTopology::MeshTopology() : num_vertices_(0), num_edges_(0), num_faces_(0) {}
 
@@ -253,5 +252,4 @@ void MeshTopology::finishResizeTopology()
   }
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/topology/mesh_topology.h b/intern/opensubdiv/internal/topology/mesh_topology.h
index ab1f6514f1e..395dcfd3815 100644
--- a/intern/opensubdiv/internal/topology/mesh_topology.h
+++ b/intern/opensubdiv/internal/topology/mesh_topology.h
@@ -13,8 +13,7 @@
 
 struct OpenSubdiv_Converter;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 // Simplified representation of mesh topology.
 // Only includes parts of actual mesh topology which is needed to perform
@@ -160,7 +159,6 @@ class MeshTopology {
   MEM_CXX_CLASS_ALLOC_FUNCS("MeshTopology");
 };
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 #endif  // OPENSUBDIV_MESH_TOPOLOGY_H_
diff --git a/intern/opensubdiv/internal/topology/mesh_topology_compare.cc b/intern/opensubdiv/internal/topology/mesh_topology_compare.cc
index f4e2555df6a..2349d57940f 100644
--- a/intern/opensubdiv/internal/topology/mesh_topology_compare.cc
+++ b/intern/opensubdiv/internal/topology/mesh_topology_compare.cc
@@ -13,15 +13,12 @@
 
 #include "opensubdiv_converter_capi.hh"
 
-namespace blender {
-namespace opensubdiv {
-
-namespace {
+namespace blender::opensubdiv {
 
 ////////////////////////////////////////////////////////////////////////////////
 // Quick preliminary checks.
 
-int getEffectiveNumEdges(const OpenSubdiv_Converter *converter)
+static int getEffectiveNumEdges(const OpenSubdiv_Converter *converter)
 {
   if (converter->getNumEdges == nullptr) {
     return 0;
@@ -30,8 +27,8 @@ int getEffectiveNumEdges(const OpenSubdiv_Converter *converter)
   return converter->getNumEdges(converter);
 }
 
-bool isEqualGeometryCounters(const MeshTopology &mesh_topology,
-                             const OpenSubdiv_Converter *converter)
+static bool isEqualGeometryCounters(const MeshTopology &mesh_topology,
+                                    const OpenSubdiv_Converter *converter)
 {
   if (converter->getNumVertices(converter) != mesh_topology.getNumVertices()) {
     return false;
@@ -51,7 +48,8 @@ bool isEqualGeometryCounters(const MeshTopology &mesh_topology,
 
 // Edges.
 
-bool isEqualGeometryEdge(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
+static bool isEqualGeometryEdge(const MeshTopology &mesh_topology,
+                                const OpenSubdiv_Converter *converter)
 {
   const int num_requested_edges = getEffectiveNumEdges(converter);
   if (num_requested_edges != mesh_topology.getNumEdges()) {
@@ -72,7 +70,8 @@ bool isEqualGeometryEdge(const MeshTopology &mesh_topology, const OpenSubdiv_Con
 
 // Faces.
 
-bool isEqualGeometryFace(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
+static bool isEqualGeometryFace(const MeshTopology &mesh_topology,
+                                const OpenSubdiv_Converter *converter)
 {
   const int num_requested_faces = converter->getNumFaces(converter);
   if (num_requested_faces != mesh_topology.getNumFaces()) {
@@ -99,7 +98,8 @@ bool isEqualGeometryFace(const MeshTopology &mesh_topology, const OpenSubdiv_Con
 
 // Geometry comparison entry point.
 
-bool isEqualGeometry(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
+static bool isEqualGeometry(const MeshTopology &mesh_topology,
+                            const OpenSubdiv_Converter *converter)
 {
   if (!isEqualGeometryEdge(mesh_topology, converter)) {
     return false;
@@ -117,7 +117,8 @@ bool isEqualGeometry(const MeshTopology &mesh_topology, const OpenSubdiv_Convert
 // Vertices.
 
 // TODO(sergey): Make this function usable by factory as well.
-float getEffectiveVertexSharpness(const OpenSubdiv_Converter *converter, const int vertex_index)
+static float getEffectiveVertexSharpness(const OpenSubdiv_Converter *converter,
+                                         const int vertex_index)
 {
   if (converter->isInfiniteSharpVertex != nullptr &&
       converter->isInfiniteSharpVertex(converter, vertex_index))
@@ -132,7 +133,8 @@ float getEffectiveVertexSharpness(const OpenSubdiv_Converter *converter, const i
   return 0.0f;
 }
 
-bool isEqualVertexTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
+static bool isEqualVertexTags(const MeshTopology &mesh_topology,
+                              const OpenSubdiv_Converter *converter)
 {
   const int num_vertices = mesh_topology.getNumVertices();
   for (int vertex_index = 0; vertex_index < num_vertices; ++vertex_index) {
@@ -150,7 +152,7 @@ bool isEqualVertexTags(const MeshTopology &mesh_topology, const OpenSubdiv_Conve
 // Edges.
 
 // TODO(sergey): Make this function usable by factory as well.
-float getEffectiveEdgeSharpness(const OpenSubdiv_Converter *converter, const int edge_index)
+static float getEffectiveEdgeSharpness(const OpenSubdiv_Converter *converter, const int edge_index)
 {
   if (converter->getEdgeSharpness != nullptr) {
     return converter->getEdgeSharpness(converter, edge_index);
@@ -159,7 +161,8 @@ float getEffectiveEdgeSharpness(const OpenSubdiv_Converter *converter, const int
   return 0.0f;
 }
 
-bool isEqualEdgeTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
+static bool isEqualEdgeTags(const MeshTopology &mesh_topology,
+                            const OpenSubdiv_Converter *converter)
 {
   const int num_edges = mesh_topology.getNumEdges();
   for (int edge_index = 0; edge_index < num_edges; ++edge_index) {
@@ -188,7 +191,7 @@ bool isEqualEdgeTags(const MeshTopology &mesh_topology, const OpenSubdiv_Convert
 
 // Tags comparison entry point.
 
-bool isEqualTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
+static bool isEqualTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
 {
   if (!isEqualVertexTags(mesh_topology, converter)) {
     return false;
@@ -200,8 +203,6 @@ bool isEqualTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *
   return true;
 }
 
-}  // namespace
-
 ////////////////////////////////////////////////////////////////////////////////
 // Entry point.
 
@@ -225,5 +226,4 @@ bool MeshTopology::isEqualToConverter(const OpenSubdiv_Converter *converter) con
   return true;
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/topology/mesh_topology_test.cc b/intern/opensubdiv/internal/topology/mesh_topology_test.cc
index 21610b77292..020cc52c303 100644
--- a/intern/opensubdiv/internal/topology/mesh_topology_test.cc
+++ b/intern/opensubdiv/internal/topology/mesh_topology_test.cc
@@ -7,8 +7,7 @@
 #include "internal/topology/mesh_topology.h"
 #include "testing/testing.h"
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 TEST(MeshTopology, TrivialVertexSharpness)
 {
@@ -82,5 +81,4 @@ TEST(MeshTopology, TrivialFaceTopology)
   EXPECT_TRUE(mesh_topology.isFaceVertexIndicesEqual(2, {{7, 8, 9, 10, 11}}));
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/topology/topology_refiner_capi.cc b/intern/opensubdiv/internal/topology/topology_refiner_capi.cc
index 3ab1f28a7d4..5b5c3151213 100644
--- a/intern/opensubdiv/internal/topology/topology_refiner_capi.cc
+++ b/intern/opensubdiv/internal/topology/topology_refiner_capi.cc
@@ -10,26 +10,24 @@
 #include "internal/base/type_convert.h"
 #include "internal/topology/topology_refiner_impl.h"
 
-namespace {
-
-const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
+static const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
     const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return topology_refiner->impl->topology_refiner;
 }
 
-const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
+static const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
     const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return getOSDTopologyRefiner(topology_refiner)->GetLevel(0);
 }
 
-int getSubdivisionLevel(const OpenSubdiv_TopologyRefiner *topology_refiner)
+static int getSubdivisionLevel(const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return topology_refiner->impl->settings.level;
 }
 
-bool getIsAdaptive(const OpenSubdiv_TopologyRefiner *topology_refiner)
+static bool getIsAdaptive(const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return topology_refiner->impl->settings.is_adaptive;
 }
@@ -37,17 +35,17 @@ bool getIsAdaptive(const OpenSubdiv_TopologyRefiner *topology_refiner)
 ////////////////////////////////////////////////////////////////////////////////
 // Query basic topology information from base level.
 
-int getNumVertices(const OpenSubdiv_TopologyRefiner *topology_refiner)
+static int getNumVertices(const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return getOSDTopologyBaseLevel(topology_refiner).GetNumVertices();
 }
 
-int getNumEdges(const OpenSubdiv_TopologyRefiner *topology_refiner)
+static int getNumEdges(const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return getOSDTopologyBaseLevel(topology_refiner).GetNumEdges();
 }
 
-int getNumFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
+static int getNumFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return getOSDTopologyBaseLevel(topology_refiner).GetNumFaces();
 }
@@ -62,39 +60,41 @@ static void convertArrayToRaw(const OpenSubdiv::Far::ConstIndexArray &array, int
   }
 }
 
-int getNumFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner, const int face_index)
+static int getNumFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                              const int face_index)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   return base_level.GetFaceVertices(face_index).size();
 }
 
-void getFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
-                     const int face_index,
-                     int *face_vertices_indices)
+static void getFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                            const int face_index,
+                            int *face_vertices_indices)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   OpenSubdiv::Far::ConstIndexArray array = base_level.GetFaceVertices(face_index);
   convertArrayToRaw(array, face_vertices_indices);
 }
 
-int getNumFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner, const int face_index)
+static int getNumFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                           const int face_index)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   return base_level.GetFaceEdges(face_index).size();
 }
 
-void getFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
-                  const int face_index,
-                  int *face_edges_indices)
+static void getFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                         const int face_index,
+                         int *face_edges_indices)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   OpenSubdiv::Far::ConstIndexArray array = base_level.GetFaceEdges(face_index);
   convertArrayToRaw(array, face_edges_indices);
 }
 
-void getEdgeVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
-                     const int edge_index,
-                     int edge_vertices_indices[2])
+static void getEdgeVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                            const int edge_index,
+                            int edge_vertices_indices[2])
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   OpenSubdiv::Far::ConstIndexArray array = base_level.GetEdgeVertices(edge_index);
@@ -103,22 +103,24 @@ void getEdgeVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
   edge_vertices_indices[1] = array[1];
 }
 
-int getNumVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner, const int vertex_index)
+static int getNumVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                             const int vertex_index)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   return base_level.GetVertexEdges(vertex_index).size();
 }
 
-void getVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
-                    const int vertex_index,
-                    int *vertex_edges_indices)
+static void getVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                           const int vertex_index,
+                           int *vertex_edges_indices)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   OpenSubdiv::Far::ConstIndexArray array = base_level.GetVertexEdges(vertex_index);
   convertArrayToRaw(array, vertex_edges_indices);
 }
 
-int getNumFacePtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner, const int face_index)
+static int getNumFacePtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                               const int face_index)
 {
   const int num_face_vertices = topology_refiner->getNumFaceVertices(topology_refiner, face_index);
   if (num_face_vertices == 4) {
@@ -127,7 +129,7 @@ int getNumFacePtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner, cons
   return num_face_vertices;
 }
 
-int getNumPtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
+static int getNumPtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   const int num_faces = topology_refiner->getNumFaces(topology_refiner);
   int num_ptex_faces = 0;
@@ -137,8 +139,8 @@ int getNumPtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
   return num_ptex_faces;
 }
 
-void fillFacePtexIndexOffset(const OpenSubdiv_TopologyRefiner *topology_refiner,
-                             int *face_ptex_index_offset)
+static void fillFacePtexIndexOffset(const OpenSubdiv_TopologyRefiner *topology_refiner,
+                                    int *face_ptex_index_offset)
 {
   const int num_faces = topology_refiner->getNumFaces(topology_refiner);
   int num_ptex_faces = 0;
@@ -151,28 +153,30 @@ void fillFacePtexIndexOffset(const OpenSubdiv_TopologyRefiner *topology_refiner,
 ////////////////////////////////////////////////////////////////////////////////
 // Face-varying data.
 
-int getNumFVarChannels(const struct OpenSubdiv_TopologyRefiner *topology_refiner)
+static int getNumFVarChannels(const struct OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   return base_level.GetNumFVarChannels();
 }
 
-OpenSubdiv_FVarLinearInterpolation getFVarLinearInterpolation(
+static OpenSubdiv_FVarLinearInterpolation getFVarLinearInterpolation(
     const struct OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   return blender::opensubdiv::getCAPIFVarLinearInterpolationFromOSD(
       getOSDTopologyRefiner(topology_refiner)->GetFVarLinearInterpolation());
 }
 
-int getNumFVarValues(const struct OpenSubdiv_TopologyRefiner *topology_refiner, const int channel)
+static int getNumFVarValues(const struct OpenSubdiv_TopologyRefiner *topology_refiner,
+                            const int channel)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   return base_level.GetNumFVarValues(channel);
 }
 
-const int *getFaceFVarValueIndices(const struct OpenSubdiv_TopologyRefiner *topology_refiner,
-                                   const int face_index,
-                                   const int channel)
+static const int *getFaceFVarValueIndices(
+    const struct OpenSubdiv_TopologyRefiner *topology_refiner,
+    const int face_index,
+    const int channel)
 {
   const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
   return &base_level.GetFaceFVarValues(face_index, channel)[0];
@@ -181,7 +185,7 @@ const int *getFaceFVarValueIndices(const struct OpenSubdiv_TopologyRefiner *topo
 ////////////////////////////////////////////////////////////////////////////////
 // Internal helpers.
 
-void assignFunctionPointers(OpenSubdiv_TopologyRefiner *topology_refiner)
+static void assignFunctionPointers(OpenSubdiv_TopologyRefiner *topology_refiner)
 {
   topology_refiner->getSubdivisionLevel = getSubdivisionLevel;
   topology_refiner->getIsAdaptive = getIsAdaptive;
@@ -207,15 +211,13 @@ void assignFunctionPointers(OpenSubdiv_TopologyRefiner *topology_refiner)
   topology_refiner->getFaceFVarValueIndices = getFaceFVarValueIndices;
 }
 
-OpenSubdiv_TopologyRefiner *allocateTopologyRefiner()
+static OpenSubdiv_TopologyRefiner *allocateTopologyRefiner()
 {
   OpenSubdiv_TopologyRefiner *topology_refiner = MEM_new<OpenSubdiv_TopologyRefiner>(__func__);
   assignFunctionPointers(topology_refiner);
   return topology_refiner;
 }
 
-}  // namespace
-
 OpenSubdiv_TopologyRefiner *openSubdiv_createTopologyRefinerFromConverter(
     OpenSubdiv_Converter *converter, const OpenSubdiv_TopologyRefinerSettings *settings)
 {
diff --git a/intern/opensubdiv/internal/topology/topology_refiner_factory.cc b/intern/opensubdiv/internal/topology/topology_refiner_factory.cc
index dda7be3f215..1caa4439591 100644
--- a/intern/opensubdiv/internal/topology/topology_refiner_factory.cc
+++ b/intern/opensubdiv/internal/topology/topology_refiner_factory.cc
@@ -299,12 +299,9 @@ inline void TopologyRefinerFactory<TopologyRefinerData>::reportInvalidTopology(
 } /* namespace OPENSUBDIV_VERSION */
 } /* namespace OpenSubdiv */
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
-namespace {
-
-OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
+static OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
 {
   using OpenSubdiv::Sdc::Options;
 
@@ -320,7 +317,8 @@ OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
   return options;
 }
 
-TopologyRefinerFactoryType::Options getTopologyRefinerOptions(OpenSubdiv_Converter *converter)
+static TopologyRefinerFactoryType::Options getTopologyRefinerOptions(
+    OpenSubdiv_Converter *converter)
 {
   using OpenSubdiv::Sdc::SchemeType;
 
@@ -337,8 +335,6 @@ TopologyRefinerFactoryType::Options getTopologyRefinerOptions(OpenSubdiv_Convert
   return topology_options;
 }
 
-}  // namespace
-
 TopologyRefinerImpl *TopologyRefinerImpl::createFromConverter(
     OpenSubdiv_Converter *converter, const OpenSubdiv_TopologyRefinerSettings &settings)
 {
@@ -368,5 +364,4 @@ TopologyRefinerImpl *TopologyRefinerImpl::createFromConverter(
   return topology_refiner_impl;
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/topology/topology_refiner_impl.cc b/intern/opensubdiv/internal/topology/topology_refiner_impl.cc
index 2c2ba868a86..49eb4e393d8 100644
--- a/intern/opensubdiv/internal/topology/topology_refiner_impl.cc
+++ b/intern/opensubdiv/internal/topology/topology_refiner_impl.cc
@@ -6,8 +6,7 @@
 
 #include "internal/topology/topology_refiner_impl.h"
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 TopologyRefinerImpl::TopologyRefinerImpl() : topology_refiner(nullptr) {}
 
@@ -16,5 +15,4 @@ TopologyRefinerImpl::~TopologyRefinerImpl()
   delete topology_refiner;
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
diff --git a/intern/opensubdiv/internal/topology/topology_refiner_impl.h b/intern/opensubdiv/internal/topology/topology_refiner_impl.h
index 8b4d01456c6..b982334d5c4 100644
--- a/intern/opensubdiv/internal/topology/topology_refiner_impl.h
+++ b/intern/opensubdiv/internal/topology/topology_refiner_impl.h
@@ -19,8 +19,7 @@
 
 struct OpenSubdiv_Converter;
 
-namespace blender {
-namespace opensubdiv {
+namespace blender::opensubdiv {
 
 class TopologyRefinerImpl {
  public:
@@ -61,8 +60,7 @@ class TopologyRefinerImpl {
   MEM_CXX_CLASS_ALLOC_FUNCS("TopologyRefinerImpl");
 };
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv
 
 struct OpenSubdiv_TopologyRefinerImpl : public blender::opensubdiv::TopologyRefinerImpl {};
 
diff --git a/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc b/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
index 6213497caaf..f9d65201949 100644
--- a/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
+++ b/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
@@ -12,17 +12,15 @@
 
 #include "opensubdiv_converter_capi.hh"
 
-namespace blender {
-namespace opensubdiv {
-namespace {
+namespace blender::opensubdiv {
 
-const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
+static const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
     const TopologyRefinerImpl *topology_refiner_impl)
 {
   return topology_refiner_impl->topology_refiner;
 }
 
-const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
+static const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
     const TopologyRefinerImpl *topology_refiner_impl)
 {
   return getOSDTopologyRefiner(topology_refiner_impl)->GetLevel(0);
@@ -31,16 +29,16 @@ const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
 ////////////////////////////////////////////////////////////////////////////////
 // Quick preliminary checks.
 
-bool checkSchemeTypeMatches(const TopologyRefinerImpl *topology_refiner_impl,
-                            const OpenSubdiv_Converter *converter)
+static bool checkSchemeTypeMatches(const TopologyRefinerImpl *topology_refiner_impl,
+                                   const OpenSubdiv_Converter *converter)
 {
   const OpenSubdiv::Sdc::SchemeType converter_scheme_type =
       blender::opensubdiv::getSchemeTypeFromCAPI(converter->getSchemeType(converter));
   return (converter_scheme_type == getOSDTopologyRefiner(topology_refiner_impl)->GetSchemeType());
 }
 
-bool checkOptionsMatches(const TopologyRefinerImpl *topology_refiner_impl,
-                         const OpenSubdiv_Converter *converter)
+static bool checkOptionsMatches(const TopologyRefinerImpl *topology_refiner_impl,
+                                const OpenSubdiv_Converter *converter)
 {
   typedef OpenSubdiv::Sdc::Options Options;
   const Options options = getOSDTopologyRefiner(topology_refiner_impl)->GetSchemeOptions();
@@ -54,8 +52,8 @@ bool checkOptionsMatches(const TopologyRefinerImpl *topology_refiner_impl,
   return true;
 }
 
-bool checkPreliminaryMatches(const TopologyRefinerImpl *topology_refiner_impl,
-                             const OpenSubdiv_Converter *converter)
+static bool checkPreliminaryMatches(const TopologyRefinerImpl *topology_refiner_impl,
+                                    const OpenSubdiv_Converter *converter)
 {
   return checkSchemeTypeMatches(topology_refiner_impl, converter) &&
          checkOptionsMatches(topology_refiner_impl, converter);
@@ -68,9 +66,9 @@ bool checkPreliminaryMatches(const TopologyRefinerImpl *topology_refiner_impl,
 // indexing and, possibly, move to mesh topology as well if winding affects
 // face-varyign as well.
 
-bool checkSingleUVLayerMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
-                             const OpenSubdiv_Converter *converter,
-                             const int layer_index)
+static bool checkSingleUVLayerMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
+                                    const OpenSubdiv_Converter *converter,
+                                    const int layer_index)
 {
   converter->precalcUVLayer(converter, layer_index);
   const int num_faces = base_level.GetNumFaces();
@@ -91,8 +89,8 @@ bool checkSingleUVLayerMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
   return true;
 }
 
-bool checkUVLayersMatch(const TopologyRefinerImpl *topology_refiner_impl,
-                        const OpenSubdiv_Converter *converter)
+static bool checkUVLayersMatch(const TopologyRefinerImpl *topology_refiner_impl,
+                               const OpenSubdiv_Converter *converter)
 {
   using OpenSubdiv::Far::TopologyLevel;
   const int num_layers = converter->getNumUVLayers(converter);
@@ -109,14 +107,12 @@ bool checkUVLayersMatch(const TopologyRefinerImpl *topology_refiner_impl,
   return true;
 }
 
-bool checkTopologyAttributesMatch(const TopologyRefinerImpl *topology_refiner_impl,
-                                  const OpenSubdiv_Converter *converter)
+static bool checkTopologyAttributesMatch(const TopologyRefinerImpl *topology_refiner_impl,
+                                         const OpenSubdiv_Converter *converter)
 {
   return checkUVLayersMatch(topology_refiner_impl, converter);
 }
 
-}  // namespace
-
 bool TopologyRefinerImpl::isEqualToConverter(const OpenSubdiv_Converter *converter) const
 {
   if (!blender::opensubdiv::checkPreliminaryMatches(this, converter)) {
@@ -136,5 +132,4 @@ bool TopologyRefinerImpl::isEqualToConverter(const OpenSubdiv_Converter *convert
   return true;
 }
 
-}  // namespace opensubdiv
-}  // namespace blender
+}  // namespace blender::opensubdiv