Fix MSVC handle name collisions

.github/workflows/test.yml

@@ -20,3 +20,19 @@ jobs:
       - name: Cache Rust Dependencies
         uses: Swatinem/rust-cache@v2
       - run: cargo test --all-targets
+
+  windows:
+    name: Windows MSVC Check
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: "recursive"
+      - uses: dtolnay/rust-toolchain@v1
+        with:
+          toolchain: stable
+      - name: Cache Rust Dependencies
+        uses: Swatinem/rust-cache@v2
+      - run: cargo check -p opencascade
+        env:
+          CMAKE_POLICY_VERSION_MINIMUM: "3.5"

crates/opencascade-sys/include/b_rep.hxx

@@ -12,21 +12,22 @@
 
 inline const TopoDS_Builder &BRep_Builder_upcast_to_topods_builder(const BRep_Builder &builder) { return builder; }
 
-inline std::unique_ptr<Handle_Geom_Surface> BRep_Tool_Surface(const TopoDS_Face &face) {
-  return std::unique_ptr<Handle_Geom_Surface>(new opencascade::handle<Geom_Surface>(BRep_Tool::Surface(face)));
+inline std::unique_ptr<RustHandle_Geom_Surface> BRep_Tool_Surface(const TopoDS_Face &face) {
+  return std::unique_ptr<RustHandle_Geom_Surface>(new opencascade::handle<Geom_Surface>(BRep_Tool::Surface(face)));
 }
 
-inline std::unique_ptr<Handle_Geom_Curve> BRep_Tool_Curve(const TopoDS_Edge &edge, Standard_Real &first,
-                                                          Standard_Real &last) {
-  return std::unique_ptr<Handle_Geom_Curve>(new opencascade::handle<Geom_Curve>(BRep_Tool::Curve(edge, first, last)));
+inline std::unique_ptr<RustHandle_Geom_Curve> BRep_Tool_Curve(const TopoDS_Edge &edge, Standard_Real &first,
+                                                              Standard_Real &last) {
+  return std::unique_ptr<RustHandle_Geom_Curve>(
+      new opencascade::handle<Geom_Curve>(BRep_Tool::Curve(edge, first, last)));
 }
 
 inline std::unique_ptr<gp_Pnt> BRep_Tool_Pnt(const TopoDS_Vertex &vertex) {
   return std::unique_ptr<gp_Pnt>(new gp_Pnt(BRep_Tool::Pnt(vertex)));
 }
 
-inline std::unique_ptr<Handle_Poly_Triangulation> BRep_Tool_Triangulation(const TopoDS_Face &face,
-                                                                          TopLoc_Location &location) {
-  return std::unique_ptr<Handle_Poly_Triangulation>(
+inline std::unique_ptr<RustHandle_Poly_Triangulation> BRep_Tool_Triangulation(const TopoDS_Face &face,
+                                                                              TopLoc_Location &location) {
+  return std::unique_ptr<RustHandle_Poly_Triangulation>(
       new opencascade::handle<Poly_Triangulation>(BRep_Tool::Triangulation(face, location)));
 }

crates/opencascade-sys/include/bindings_common.hxx

@@ -1,8 +1,43 @@
 #pragma once
 #include "rust/cxx.h"
 #include <NCollection_List.hxx>
+#include <Standard_Handle.hxx>
 #include <memory>
 
+class Geom2d_Curve;
+class Geom2d_Ellipse;
+class Geom2d_TrimmedCurve;
+class Geom_BSplineCurve;
+class Geom_BezierCurve;
+class Geom_BezierSurface;
+class Geom_Curve;
+class Geom_CylindricalSurface;
+class Geom_Plane;
+class Geom_Surface;
+class Geom_TrimmedCurve;
+class Law_Function;
+class Poly_Triangulation;
+class Standard_Type;
+class TColgp_HArray1OfPnt;
+class TopTools_HSequenceOfShape;
+
+using RustHandle_Geom2d_Curve = opencascade::handle<Geom2d_Curve>;
+using RustHandle_Geom2d_Ellipse = opencascade::handle<Geom2d_Ellipse>;
+using RustHandle_Geom2d_TrimmedCurve = opencascade::handle<Geom2d_TrimmedCurve>;
+using RustHandle_Geom_BSplineCurve = opencascade::handle<Geom_BSplineCurve>;
+using RustHandle_Geom_BezierCurve = opencascade::handle<Geom_BezierCurve>;
+using RustHandle_Geom_BezierSurface = opencascade::handle<Geom_BezierSurface>;
+using RustHandle_Geom_Curve = opencascade::handle<Geom_Curve>;
+using RustHandle_Geom_CylindricalSurface = opencascade::handle<Geom_CylindricalSurface>;
+using RustHandle_Geom_Plane = opencascade::handle<Geom_Plane>;
+using RustHandle_Geom_Surface = opencascade::handle<Geom_Surface>;
+using RustHandle_Geom_TrimmedCurve = opencascade::handle<Geom_TrimmedCurve>;
+using RustHandle_Law_Function = opencascade::handle<Law_Function>;
+using RustHandle_Poly_Triangulation = opencascade::handle<Poly_Triangulation>;
+using RustHandle_Standard_Type = opencascade::handle<Standard_Type>;
+using RustHandle_TColgp_HArray1OfPnt = opencascade::handle<TColgp_HArray1OfPnt>;
+using RustHandle_TopTools_HSequenceOfShape = opencascade::handle<TopTools_HSequenceOfShape>;
+
 // Generic template constructor
 template <typename T, typename... Args> std::unique_ptr<T> construct_unique(Args... args) {
   return std::unique_ptr<T>(new T(args...));

crates/opencascade-sys/include/gc.hxx

@@ -3,16 +3,16 @@
 #include <GC_MakeSegment.hxx>
 #include <bindings_common.hxx>
 
-inline std::unique_ptr<Handle_Geom_TrimmedCurve> GC_MakeSegment_Value(const GC_MakeSegment &segment) {
-  return std::unique_ptr<Handle_Geom_TrimmedCurve>(new opencascade::handle<Geom_TrimmedCurve>(segment.Value()));
+inline std::unique_ptr<RustHandle_Geom_TrimmedCurve> GC_MakeSegment_Value(const GC_MakeSegment &segment) {
+  return std::unique_ptr<RustHandle_Geom_TrimmedCurve>(new opencascade::handle<Geom_TrimmedCurve>(segment.Value()));
 }
 
-inline std::unique_ptr<Handle_Geom2d_TrimmedCurve> GCE2d_MakeSegment_point_point(const gp_Pnt2d &p1,
-                                                                                 const gp_Pnt2d &p2) {
-  return std::unique_ptr<Handle_Geom2d_TrimmedCurve>(
+inline std::unique_ptr<RustHandle_Geom2d_TrimmedCurve> GCE2d_MakeSegment_point_point(const gp_Pnt2d &p1,
+                                                                                     const gp_Pnt2d &p2) {
+  return std::unique_ptr<RustHandle_Geom2d_TrimmedCurve>(
       new opencascade::handle<Geom2d_TrimmedCurve>(GCE2d_MakeSegment(p1, p2)));
 }
 
-inline std::unique_ptr<Handle_Geom_TrimmedCurve> GC_MakeArcOfCircle_Value(const GC_MakeArcOfCircle &arc) {
-  return std::unique_ptr<Handle_Geom_TrimmedCurve>(new opencascade::handle<Geom_TrimmedCurve>(arc.Value()));
+inline std::unique_ptr<RustHandle_Geom_TrimmedCurve> GC_MakeArcOfCircle_Value(const GC_MakeArcOfCircle &arc) {
+  return std::unique_ptr<RustHandle_Geom_TrimmedCurve>(new opencascade::handle<Geom_TrimmedCurve>(arc.Value()));
 }

crates/opencascade-sys/include/geom.hxx

@@ -7,39 +7,43 @@
 #include <Geom_TrimmedCurve.hxx>
 #include <bindings_common.hxx>
 
-inline std::unique_ptr<Handle_Geom_CylindricalSurface> Geom_CylindricalSurface_new(const gp_Ax3 &axis, double radius) {
-  return std::unique_ptr<Handle_Geom_CylindricalSurface>(
+inline std::unique_ptr<RustHandle_Geom_CylindricalSurface> Geom_CylindricalSurface_new(const gp_Ax3 &axis,
+                                                                                       double radius) {
+  return std::unique_ptr<RustHandle_Geom_CylindricalSurface>(
       new opencascade::handle<Geom_CylindricalSurface>(new Geom_CylindricalSurface(axis, radius)));
 }
 
-inline std::unique_ptr<Handle_Geom_Surface> cylinder_to_surface(const Handle_Geom_CylindricalSurface &cylinder_handle) {
-  return std::unique_ptr<Handle_Geom_Surface>(new opencascade::handle<Geom_Surface>(cylinder_handle));
+inline std::unique_ptr<RustHandle_Geom_Surface>
+cylinder_to_surface(const RustHandle_Geom_CylindricalSurface &cylinder_handle) {
+  return std::unique_ptr<RustHandle_Geom_Surface>(new opencascade::handle<Geom_Surface>(cylinder_handle));
 }
 
-inline std::unique_ptr<Handle_Geom_BezierSurface> Geom_BezierSurface_new(const TColgp_Array2OfPnt &poles) {
-  return std::unique_ptr<Handle_Geom_BezierSurface>(
+inline std::unique_ptr<RustHandle_Geom_BezierSurface> Geom_BezierSurface_new(const TColgp_Array2OfPnt &poles) {
+  return std::unique_ptr<RustHandle_Geom_BezierSurface>(
       new opencascade::handle<Geom_BezierSurface>(new Geom_BezierSurface(poles)));
 }
 
-inline const gp_Pnt &handle_geom_plane_location(const Handle_Geom_Plane &plane) { return plane->Location(); }
+inline const gp_Pnt &handle_geom_plane_location(const RustHandle_Geom_Plane &plane) { return plane->Location(); }
 
-inline std::unique_ptr<Handle_Geom_BezierCurve>
+inline std::unique_ptr<RustHandle_Geom_BezierCurve>
 Geom_BezierCurve_to_handle(std::unique_ptr<Geom_BezierCurve> bezier_curve) {
-  return std::unique_ptr<Handle_Geom_BezierCurve>(new Handle_Geom_BezierCurve(bezier_curve.release()));
+  return std::unique_ptr<RustHandle_Geom_BezierCurve>(new RustHandle_Geom_BezierCurve(bezier_curve.release()));
 }
 
-inline std::unique_ptr<Handle_Geom_Surface> bezier_to_surface(const Handle_Geom_BezierSurface &bezier_handle) {
-  return std::unique_ptr<Handle_Geom_Surface>(new opencascade::handle<Geom_Surface>(bezier_handle));
+inline std::unique_ptr<RustHandle_Geom_Surface> bezier_to_surface(const RustHandle_Geom_BezierSurface &bezier_handle) {
+  return std::unique_ptr<RustHandle_Geom_Surface>(new opencascade::handle<Geom_Surface>(bezier_handle));
 }
 
-inline std::unique_ptr<Handle_Geom_Plane>
-new_HandleGeomPlane_from_HandleGeomSurface(const Handle_Geom_Surface &surface) {
-  Handle_Geom_Plane plane_handle = opencascade::handle<Geom_Plane>::DownCast(surface);
-  return std::unique_ptr<Handle_Geom_Plane>(new opencascade::handle<Geom_Plane>(plane_handle));
+inline std::unique_ptr<RustHandle_Geom_Plane>
+new_HandleGeomPlane_from_HandleGeomSurface(const RustHandle_Geom_Surface &surface) {
+  RustHandle_Geom_Plane plane_handle = opencascade::handle<Geom_Plane>::DownCast(surface);
+  return std::unique_ptr<RustHandle_Geom_Plane>(new opencascade::handle<Geom_Plane>(plane_handle));
 }
 
-inline std::unique_ptr<gp_Pnt> HandleGeomCurve_Value(const Handle_Geom_Curve &curve, const Standard_Real U) {
+inline std::unique_ptr<gp_Pnt> HandleGeomCurve_Value(const RustHandle_Geom_Curve &curve, const Standard_Real U) {
   return std::unique_ptr<gp_Pnt>(new gp_Pnt(curve->Value(U)));
 }
 
-inline const Handle_Standard_Type &DynamicType(const Handle_Geom_Surface &surface) { return surface->DynamicType(); }
+inline const RustHandle_Standard_Type &DynamicType(const RustHandle_Geom_Surface &surface) {
+  return surface->DynamicType();
+}

crates/opencascade-sys/include/geom2d.hxx

@@ -2,27 +2,28 @@
 #include <Geom2d_TrimmedCurve.hxx>
 #include <bindings_common.hxx>
 
-inline std::unique_ptr<Handle_Geom2d_Ellipse> Geom2d_Ellipse_new(const gp_Ax2d &axis, double major_radius,
-                                                                 double minor_radius) {
-  return std::unique_ptr<Handle_Geom2d_Ellipse>(
+inline std::unique_ptr<RustHandle_Geom2d_Ellipse> Geom2d_Ellipse_new(const gp_Ax2d &axis, double major_radius,
+                                                                     double minor_radius) {
+  return std::unique_ptr<RustHandle_Geom2d_Ellipse>(
       new opencascade::handle<Geom2d_Ellipse>(new Geom2d_Ellipse(axis, major_radius, minor_radius)));
 }
 
-inline std::unique_ptr<Handle_Geom2d_Curve> ellipse_to_HandleGeom2d_Curve(const Handle_Geom2d_Ellipse &ellipse_handle) {
-  return std::unique_ptr<Handle_Geom2d_Curve>(new opencascade::handle<Geom2d_Curve>(ellipse_handle));
+inline std::unique_ptr<RustHandle_Geom2d_Curve>
+ellipse_to_HandleGeom2d_Curve(const RustHandle_Geom2d_Ellipse &ellipse_handle) {
+  return std::unique_ptr<RustHandle_Geom2d_Curve>(new opencascade::handle<Geom2d_Curve>(ellipse_handle));
 }
 
-inline std::unique_ptr<Handle_Geom2d_TrimmedCurve> Geom2d_TrimmedCurve_new(const Handle_Geom2d_Curve &curve, double u1,
-                                                                           double u2) {
-  return std::unique_ptr<Handle_Geom2d_TrimmedCurve>(
+inline std::unique_ptr<RustHandle_Geom2d_TrimmedCurve> Geom2d_TrimmedCurve_new(const RustHandle_Geom2d_Curve &curve,
+                                                                               double u1, double u2) {
+  return std::unique_ptr<RustHandle_Geom2d_TrimmedCurve>(
       new opencascade::handle<Geom2d_TrimmedCurve>(new Geom2d_TrimmedCurve(curve, u1, u2)));
 }
 
-inline std::unique_ptr<Handle_Geom2d_Curve>
-HandleGeom2d_TrimmedCurve_to_curve(const Handle_Geom2d_TrimmedCurve &trimmed_curve) {
-  return std::unique_ptr<Handle_Geom2d_Curve>(new opencascade::handle<Geom2d_Curve>(trimmed_curve));
+inline std::unique_ptr<RustHandle_Geom2d_Curve>
+HandleGeom2d_TrimmedCurve_to_curve(const RustHandle_Geom2d_TrimmedCurve &trimmed_curve) {
+  return std::unique_ptr<RustHandle_Geom2d_Curve>(new opencascade::handle<Geom2d_Curve>(trimmed_curve));
 }
 
-inline std::unique_ptr<gp_Pnt2d> ellipse_value(const Handle_Geom2d_Ellipse &ellipse, double u) {
+inline std::unique_ptr<gp_Pnt2d> ellipse_value(const RustHandle_Geom2d_Ellipse &ellipse, double u) {
   return std::unique_ptr<gp_Pnt2d>(new gp_Pnt2d(ellipse->Value(u)));
 }

crates/opencascade-sys/include/geom_api.hxx

@@ -3,6 +3,6 @@
 #include <Geom_BSplineCurve.hxx>
 #include <bindings_common.hxx>
 
-inline std::unique_ptr<Handle_Geom_BSplineCurve> GeomAPI_Interpolate_Curve(const GeomAPI_Interpolate &interpolate) {
-  return std::unique_ptr<Handle_Geom_BSplineCurve>(new opencascade::handle<Geom_BSplineCurve>(interpolate.Curve()));
+inline std::unique_ptr<RustHandle_Geom_BSplineCurve> GeomAPI_Interpolate_Curve(const GeomAPI_Interpolate &interpolate) {
+  return std::unique_ptr<RustHandle_Geom_BSplineCurve>(new opencascade::handle<Geom_BSplineCurve>(interpolate.Curve()));
 }

crates/opencascade-sys/include/law.hxx

@@ -2,8 +2,8 @@
 #include <Law_Interpol.hxx>
 #include <bindings_common.hxx>
 
-inline std::unique_ptr<Handle_Law_Function> Law_Function_to_handle(std::unique_ptr<Law_Function> law_function) {
-  return std::unique_ptr<Handle_Law_Function>(new Handle_Law_Function(law_function.release()));
+inline std::unique_ptr<RustHandle_Law_Function> Law_Function_to_handle(std::unique_ptr<Law_Function> law_function) {
+  return std::unique_ptr<RustHandle_Law_Function>(new RustHandle_Law_Function(law_function.release()));
 }
 
 inline std::unique_ptr<Law_Function> Law_Interpol_into_Law_Function(std::unique_ptr<Law_Interpol> law_interpol) {

crates/opencascade-sys/include/poly.hxx

@@ -2,9 +2,9 @@
 #include <Poly_Triangulation.hxx>
 #include <bindings_common.hxx>
 
-inline std::unique_ptr<Handle_Poly_Triangulation>
+inline std::unique_ptr<RustHandle_Poly_Triangulation>
 Handle_Poly_Triangulation_new(std::unique_ptr<Poly_Triangulation> triangulation) {
-  return std::unique_ptr<Handle_Poly_Triangulation>(new Handle_Poly_Triangulation(triangulation.release()));
+  return std::unique_ptr<RustHandle_Poly_Triangulation>(new RustHandle_Poly_Triangulation(triangulation.release()));
 }
 
 inline std::unique_ptr<gp_Dir> Poly_Triangulation_Normal(const Poly_Triangulation &triangulation,

crates/opencascade-sys/include/standard.hxx

@@ -1,4 +1,4 @@
 #include <Standard_Type.hxx>
 #include <bindings_common.hxx>
 
-inline rust::String type_name(const Handle_Standard_Type &handle) { return std::string(handle->Name()); }
+inline rust::String type_name(const RustHandle_Standard_Type &handle) { return std::string(handle->Name()); }

crates/opencascade-sys/include/t_col_gp.hxx

@@ -16,7 +16,7 @@ inline std::unique_ptr<gp_Pnt> TColgp_HArray1OfPnt_Value(const TColgp_HArray1OfP
   return std::unique_ptr<gp_Pnt>(new gp_Pnt(array.Value(index)));
 }
 
-inline std::unique_ptr<Handle_TColgp_HArray1OfPnt>
+inline std::unique_ptr<RustHandle_TColgp_HArray1OfPnt>
 new_HandleTColgpHArray1OfPnt_from_TColgpHArray1OfPnt(std::unique_ptr<TColgp_HArray1OfPnt> array) {
-  return std::unique_ptr<Handle_TColgp_HArray1OfPnt>(new Handle_TColgp_HArray1OfPnt(array.release()));
+  return std::unique_ptr<RustHandle_TColgp_HArray1OfPnt>(new RustHandle_TColgp_HArray1OfPnt(array.release()));
 }

crates/opencascade-sys/include/top_tools.hxx

@@ -5,22 +5,22 @@
 #include <TopoDS_Face.hxx>
 #include <bindings_common.hxx>
 
-inline std::unique_ptr<Handle_TopTools_HSequenceOfShape> new_Handle_TopTools_HSequenceOfShape() {
+inline std::unique_ptr<RustHandle_TopTools_HSequenceOfShape> new_Handle_TopTools_HSequenceOfShape() {
   auto sequence = new TopTools_HSequenceOfShape();
   auto handle = new opencascade::handle<TopTools_HSequenceOfShape>(sequence);
 
-  return std::unique_ptr<Handle_TopTools_HSequenceOfShape>(handle);
+  return std::unique_ptr<RustHandle_TopTools_HSequenceOfShape>(handle);
 }
 
-inline void TopTools_HSequenceOfShape_append(Handle_TopTools_HSequenceOfShape &handle, const TopoDS_Shape &shape) {
+inline void TopTools_HSequenceOfShape_append(RustHandle_TopTools_HSequenceOfShape &handle, const TopoDS_Shape &shape) {
   handle->Append(shape);
 }
 
-inline Standard_Integer TopTools_HSequenceOfShape_length(const Handle_TopTools_HSequenceOfShape &handle) {
+inline Standard_Integer TopTools_HSequenceOfShape_length(const RustHandle_TopTools_HSequenceOfShape &handle) {
   return handle->Length();
 }
 
-inline const TopoDS_Shape &TopTools_HSequenceOfShape_value(const Handle_TopTools_HSequenceOfShape &handle,
+inline const TopoDS_Shape &TopTools_HSequenceOfShape_value(const RustHandle_TopTools_HSequenceOfShape &handle,
                                                            Standard_Integer index) {
   return handle->Value(index);
 }

crates/opencascade-sys/src/b_rep.rs

@@ -10,8 +10,11 @@ mod inner {
         type TopoDS_Face = crate::topo_ds::TopoDS_Face;
         type TopoDS_Edge = crate::topo_ds::TopoDS_Edge;
         type TopoDS_Vertex = crate::topo_ds::TopoDS_Vertex;
+        #[cxx_name = "RustHandle_Geom_Surface"]
         type Handle_Geom_Surface = crate::geom::Handle_Geom_Surface;
+        #[cxx_name = "RustHandle_Geom_Curve"]
         type Handle_Geom_Curve = crate::geom::Handle_Geom_Curve;
+        #[cxx_name = "RustHandle_Poly_Triangulation"]
         type Handle_Poly_Triangulation = crate::poly::Handle_Poly_Triangulation;
         type TopLoc_Location = crate::top_loc::TopLoc_Location;
 

crates/opencascade-sys/src/b_rep_builder_api.rs

@@ -16,9 +16,13 @@ mod inner {
         type TopoDS_Wire = crate::topo_ds::TopoDS_Wire;
         type TopoDS_Face = crate::topo_ds::TopoDS_Face;
         type TopoDS_Shell = crate::topo_ds::TopoDS_Shell;
+        #[cxx_name = "RustHandle_Geom_Curve"]
         type Handle_Geom_Curve = crate::geom::Handle_Geom_Curve;
+        #[cxx_name = "RustHandle_Geom_Surface"]
         type Handle_Geom_Surface = crate::geom::Handle_Geom_Surface;
+        #[cxx_name = "RustHandle_Geom2d_Curve"]
         type Handle_Geom2d_Curve = crate::geom2d::Handle_Geom2d_Curve;
+        #[cxx_name = "RustHandle_Poly_Triangulation"]
         type Handle_Poly_Triangulation = crate::poly::Handle_Poly_Triangulation;
 
         type BRepBuilderAPI_MakeVertex;

crates/opencascade-sys/src/b_rep_lib.rs

@@ -7,6 +7,7 @@ mod inner {
 
         type TopoDS_Shape = crate::topo_ds::TopoDS_Shape;
         type TopoDS_Face = crate::topo_ds::TopoDS_Face;
+        #[cxx_name = "RustHandle_Poly_Triangulation"]
         type Handle_Poly_Triangulation = crate::poly::Handle_Poly_Triangulation;
 
         type BRepLib;

crates/opencascade-sys/src/b_rep_offset_api.rs

@@ -19,6 +19,7 @@ mod inner {
         type GeomAbs_JoinType = crate::geom_abs::GeomAbs_JoinType;
         type TopTools_ListOfShape = crate::top_tools::TopTools_ListOfShape;
         type Message_ProgressRange = crate::message::Message_ProgressRange;
+        #[cxx_name = "RustHandle_Law_Function"]
         type Handle_Law_Function = crate::law::Handle_Law_Function;
 
         type BRepOffset_Mode;

crates/opencascade-sys/src/gc.rs

@@ -7,7 +7,9 @@ mod inner {
 
         type gp_Pnt = crate::gp::gp_Pnt;
         type gp_Pnt2d = crate::gp::gp_Pnt2d;
+        #[cxx_name = "RustHandle_Geom_TrimmedCurve"]
         type Handle_Geom_TrimmedCurve = crate::geom::Handle_Geom_TrimmedCurve;
+        #[cxx_name = "RustHandle_Geom2d_TrimmedCurve"]
         type Handle_Geom2d_TrimmedCurve = crate::geom2d::Handle_Geom2d_TrimmedCurve;
 
         type GC_MakeSegment;