From 51f8cad8358809cd087a6b1da9a95daf785ae251 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Mon, 1 Dec 2025 17:12:43 +0000
Subject: [PATCH 01/11] Generate interace cpp wrapper

---
 src/source/CGenerator.scala | 148 +++++++++++++++++++++---------------
 1 file changed, 86 insertions(+), 62 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index 7900c8d2..83c92a67 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -44,13 +44,11 @@ class CGenerator(spec: Spec) extends Generator(spec) {
 
   def privateHeader(t: TypeDecl): String = q(spec.cppIncludePrefix + spec.cppFileIdentStyle(t.ident.name) + "." + spec.cppHeaderExt)
 
-  private def writeExternCBegin(w: IndentWriter): Unit = {
+  private def wrapExternC(w: IndentWriter, f: IndentWriter => Unit) = {
     w.wl("#ifdef __cplusplus")
     w.wl("extern \"C\" {")
     w.wl("#endif // __cplusplus")
-  }
-
-  private def writeExternCEnd(w: IndentWriter): Unit = {
+    f(w)
     w.wl("#ifdef __cplusplus")
     w.wl("} // extern \"C\"")
     w.wl("#endif // __cplusplus")
@@ -76,13 +74,7 @@ class CGenerator(spec: Spec) extends Generator(spec) {
       publicIncludes.foreach(w.wl)
 
       w.wl
-
-      writeExternCBegin(w)
-      w.wl
-
       header(w)
-
-      writeExternCEnd(w)
     })
 
     writeCFile(origin, ident, "cpp", (w: IndentWriter) => {
@@ -151,6 +143,19 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     }
   }
 
+  private def writeCppWrapperClass(ident: Ident, cppClassName: String, w: IndentWriter, body: IndentWriter => Unit): Unit = {
+    val typeName = resolveRefSymbolTypeName(ident)
+    wrapNamespace(w, spec.cppNamespace + "::c_wrappers", (w: IndentWriter) => {
+        w.w(s"template <template <typename> class Ref> class ${cppClassName}").bracedSemi {
+          w.wlOutdent("public:")
+          body(w)
+          w.wl
+          w.wlOutdent("private:")
+          w.wl(s"Ref<${typeName}> _ref;")
+        }
+      })
+  }
+
   override def generateRecord(origin: String, ident: Ident, doc: Doc, params: Seq[TypeParam], r: ast.Record): Unit = {
     val selfCpp = cppMarshal.fqTypename(ident, r)
 
@@ -162,25 +167,27 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     val resolvedConsts = r.consts.map(r => new ResolvedConst(r, typeResolver.resolve(r.ty.resolved)))
 
     writeCFilePair(origin, ident, typeResolver.publicImports.toSeq, typeResolver.privateImports.toSeq)((w: IndentWriter) => {
-      writeDoc(w, doc)
-      w.wl(s"""typedef djinni_record_ref ${typeName};""")
-      w.wl
+      wrapExternC(w, (w: IndentWriter) => {
+        writeDoc(w, doc)
+        w.wl(s"""typedef djinni_record_ref ${typeName};""")
+        w.wl
 
-      w.w(s"""${typeName} ${prefix}_new(""")
-      writeParamListWithResolvedFields(w, resolvedFields)
-      w.wl(");")
-      w.wl
+        w.w(s"""${typeName} ${prefix}_new(""")
+        writeParamListWithResolvedFields(w, resolvedFields)
+        w.wl(");")
+        w.wl
 
-      generateConstsHeader(prefix, resolvedConsts, w)
+        generateConstsHeader(prefix, resolvedConsts, w)
 
-      for (resolvedField <- resolvedFields) {
-        val fieldName = resolvedField.field.ident.name
-        val fieldTypename = resolvedField.translator.typename
-        writeDoc(w, resolvedField.field.doc)
-        w.wl(s"""${fieldTypename} ${prefix}_get_${fieldName}(${typeName} instance);""")
-        w.wl(s"""void ${prefix}_set_${fieldName}(${typeName} instance, ${fieldTypename} value);""")
-        w.wl
-      }
+        for (resolvedField <- resolvedFields) {
+          val fieldName = resolvedField.field.ident.name
+          val fieldTypename = resolvedField.translator.typename
+          writeDoc(w, resolvedField.field.doc)
+          w.wl(s"""${fieldTypename} ${prefix}_get_${fieldName}(${typeName} instance);""")
+          w.wl(s"""void ${prefix}_set_${fieldName}(${typeName} instance, ${fieldTypename} value);""")
+          w.wl
+        }
+      })
     }, (w: IndentWriter) => {
       w.w(s"""${typeName} ${prefix}_new(""")
       writeParamListWithResolvedFields(w, resolvedFields)
@@ -217,7 +224,6 @@ class CGenerator(spec: Spec) extends Generator(spec) {
         }
         w.wl
       }
-
     })
   }
 
@@ -307,6 +313,7 @@ class CGenerator(spec: Spec) extends Generator(spec) {
 
   override def generateInterface(origin: String, ident: Ident, doc: Doc, typeParams: Seq[TypeParam], i: Interface): Unit = {
     val selfCpp = cppMarshal.fqTypename(ident, i)
+    val selfCppClass = cppMarshal.typename(ident, i)
     val typeResolver = new CTypeResolver(ident, spec, cppMarshal)
     val resolvedMethods = i.methods.map(m =>
       new ResolvedMethod(
@@ -327,53 +334,70 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     val proxyClassName = s"${resolveSymbolName(ident)}_proxy_class_ref"
     val methodDefsStructName = s"${resolveSymbolName(ident)}_method_defs"
     writeCFilePair(origin, ident, typeResolver.publicImports.toSeq, typeResolver.privateImports.toSeq)((w: IndentWriter) => {
-      writeDoc(w, doc)
-      w.wl(s"""typedef djinni_interface_ref ${typeName};""")
+      wrapExternC(w, (w: IndentWriter) => {
+        writeDoc(w, doc)
+        w.wl(s"""typedef djinni_interface_ref ${typeName};""")
 
-      if (i.ext.cc) {
-        w.wl(s"""typedef djinni_proxy_class_ref ${proxyClassName};""")
-        w.wl
+        if (i.ext.cc) {
+          w.wl(s"""typedef djinni_proxy_class_ref ${proxyClassName};""")
+          w.wl
 
-        w.wl(s"""typedef struct """)
-        w.bracedEnd(s" ${methodDefsStructName};") {
+          w.wl(s"""typedef struct """)
+          w.bracedEnd(s" ${methodDefsStructName};") {
 
-          if (resolvedMethods.isEmpty) {
-            w.wl("void *reserved[1];")
-          } else {
-            for (resolvedMethod <- resolvedMethods) {
-              w.w(s"""${resolvedMethod.retTypename} (*${resolvedMethod.method.ident.name})(""")
-              writeDelimited(w, "void *" +: resolvedMethod.parameters.map(p => p.translator.typename), ", ")(s => w.w(s))
-              w.wl(");")
+            if (resolvedMethods.isEmpty) {
+              w.wl("void *reserved[1];")
+            } else {
+              for (resolvedMethod <- resolvedMethods) {
+                w.w(s"""${resolvedMethod.retTypename} (*${resolvedMethod.method.ident.name})(""")
+                writeDelimited(w, "void *" +: resolvedMethod.parameters.map(p => p.translator.typename), ", ")(s => w.w(s))
+                w.wl(");")
+              }
             }
           }
-        }
-        w.wl
+          w.wl
 
-        w.wl(s"${proxyClassName} ${prefix}_proxy_class_new(const ${methodDefsStructName} *method_defs, djinni_opaque_deallocator opaque_deallocator);")
-        w.wl
-        w.wl(s"${typeName} ${prefix}_new(${proxyClassName} proxy_class, void *opaque);")
-        w.wl("")
-      } else {
-        w.wl
-      }
+          w.wl(s"${proxyClassName} ${prefix}_proxy_class_new(const ${methodDefsStructName} *method_defs, djinni_opaque_deallocator opaque_deallocator);")
+          w.wl
+          w.wl(s"${typeName} ${prefix}_new(${proxyClassName} proxy_class, void *opaque);")
+          w.wl("")
+        } else {
+          w.wl
+        }
 
-      generateConstsHeader(prefix, resolvedConsts, w)
+        generateConstsHeader(prefix, resolvedConsts, w)
 
-      for (resolvedMethod <- resolvedMethods) {
-        writeDoc(w, resolvedMethod.method.doc)
-        w.w(s"${resolvedMethod.retTypename} ${prefix}_${resolvedMethod.resolvedName}(")
+        for (resolvedMethod <- resolvedMethods) {
+          writeDoc(w, resolvedMethod.method.doc)
+          w.w(s"${resolvedMethod.retTypename} ${prefix}_${resolvedMethod.resolvedName}(")
 
-        if (resolvedMethod.method.static) {
-          writeParamList(w, resolvedMethod.parameters.map(p => (p.translator.typename, p.field.ident.name)))
-        } else {
-          writeParamList(w, (typeName, "instance") +: resolvedMethod.parameters.map(p => (p.translator.typename, p.field.ident.name)))
-        }
+          if (resolvedMethod.method.static) {
+            writeParamList(w, resolvedMethod.parameters.map(p => (p.translator.typename, p.field.ident.name)))
+          } else {
+            writeParamList(w, (typeName, "instance") +: resolvedMethod.parameters.map(p => (p.translator.typename, p.field.ident.name)))
+          }
 
-        w.wl(");")
+          w.wl(");")
 
-        w.wl
-      }
+          w.wl
+        }
+      })
 
+      w.wl
+      writeCppWrapperClass(ident, selfCppClass, w, (w: IndentWriter) => {
+        for (resolvedMethod <- resolvedMethods) {
+            w.w(s"${resolvedMethod.retTypename} ${resolvedMethod.resolvedName}(")
+            writeParamList(w, resolvedMethod.parameters.map(p => (p.translator.typename, p.field.ident.name)))
+            w.w(") ")
+            w.braced {
+              val returnStr = if (resolvedMethod.retTypename != "void") "return " else ""
+              val argsList = resolvedMethod.parameters.map(p => (p.field.ident.name))
+              val fullArgsList = if (resolvedMethod.method.static) argsList else "_ref.get()" +: argsList
+              w.wl(s"${returnStr}${prefix}_${resolvedMethod.resolvedName}(${fullArgsList.mkString(", ")});")
+            }
+            w.wl
+          }
+      })
     }, (w: IndentWriter) => {
       if (i.ext.cc) {
         val proxyClassNameCpp = writeProxyClass(w, ident, methodDefsStructName, resolvedMethods)

From b36ba69ce7ea35a74e19181505f94affff6e8f5a Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Mon, 1 Dec 2025 17:25:40 +0000
Subject: [PATCH 02/11] Generate record cpp wrapper

---
 src/source/CGenerator.scala | 31 ++++++++++++++++++++++++++-----
 1 file changed, 26 insertions(+), 5 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index 83c92a67..ead527ce 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -158,6 +158,7 @@ class CGenerator(spec: Spec) extends Generator(spec) {
 
   override def generateRecord(origin: String, ident: Ident, doc: Doc, params: Seq[TypeParam], r: ast.Record): Unit = {
     val selfCpp = cppMarshal.fqTypename(ident, r)
+    val selfCppClass = cppMarshal.typename(ident, r)
 
     val typeResolver = new CTypeResolver(ident, spec, cppMarshal)
     val prefix = resolveSymbolName(ident.name)
@@ -188,6 +189,24 @@ class CGenerator(spec: Spec) extends Generator(spec) {
           w.wl
         }
       })
+
+      w.wl
+      writeCppWrapperClass(ident, selfCppClass, w, (w: IndentWriter) => {
+        for (resolvedField <- resolvedFields) {
+          val fieldName = resolvedField.field.ident.name
+          val fieldTypename = resolvedField.translator.typename
+          w.w(s"${fieldTypename} ${fieldName}() const")
+          w.braced {
+            w.wl(s"return ${prefix}_get_${fieldName}(_ref.get);")
+          }
+          w.wl
+          w.w(s"${fieldTypename} ${fieldName}(${fieldTypename} value)")
+          w.braced {
+            w.wl(s"${prefix}_set_${fieldName}(_ref.get, value);")
+          }
+          w.wl
+        }
+      })
     }, (w: IndentWriter) => {
       w.w(s"""${typeName} ${prefix}_new(""")
       writeParamListWithResolvedFields(w, resolvedFields)
@@ -383,9 +402,10 @@ class CGenerator(spec: Spec) extends Generator(spec) {
         }
       })
 
-      w.wl
-      writeCppWrapperClass(ident, selfCppClass, w, (w: IndentWriter) => {
-        for (resolvedMethod <- resolvedMethods) {
+      if (i.ext.cpp) {
+        w.wl
+        writeCppWrapperClass(ident, selfCppClass, w, (w: IndentWriter) => {
+          for (resolvedMethod <- resolvedMethods) {
             w.w(s"${resolvedMethod.retTypename} ${resolvedMethod.resolvedName}(")
             writeParamList(w, resolvedMethod.parameters.map(p => (p.translator.typename, p.field.ident.name)))
             w.w(") ")
@@ -396,8 +416,9 @@ class CGenerator(spec: Spec) extends Generator(spec) {
               w.wl(s"${returnStr}${prefix}_${resolvedMethod.resolvedName}(${fullArgsList.mkString(", ")});")
             }
             w.wl
-          }
-      })
+            }
+        })
+      }
     }, (w: IndentWriter) => {
       if (i.ext.cc) {
         val proxyClassNameCpp = writeProxyClass(w, ident, methodDefsStructName, resolvedMethods)

From 4d45cc8152c41039aac9ddb490f07164d938a208 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Mon, 1 Dec 2025 21:44:54 +0000
Subject: [PATCH 03/11] WIP

---
 src/source/CGenerator.scala | 67 ++++++++++++++++++++++++++-----------
 1 file changed, 48 insertions(+), 19 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index ead527ce..acb8d12a 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -44,15 +44,20 @@ class CGenerator(spec: Spec) extends Generator(spec) {
 
   def privateHeader(t: TypeDecl): String = q(spec.cppIncludePrefix + spec.cppFileIdentStyle(t.ident.name) + "." + spec.cppHeaderExt)
 
-  private def wrapExternC(w: IndentWriter, f: IndentWriter => Unit) = {
+  private def wrapIfCpp(w: IndentWriter, f: IndentWriter => Unit) = {
     w.wl("#ifdef __cplusplus")
-    w.wl("extern \"C\" {")
-    w.wl("#endif // __cplusplus")
     f(w)
-    w.wl("#ifdef __cplusplus")
-    w.wl("} // extern \"C\"")
     w.wl("#endif // __cplusplus")
   }
+  private def wrapExternC(w: IndentWriter, f: IndentWriter => Unit) = {
+    wrapIfCpp(w, (w: IndentWriter) => {
+      w.wl("extern \"C\" {")
+    })
+    f(w)
+    wrapIfCpp(w, (w: IndentWriter) => {
+      w.wl("} // extern \"C\"")
+    })
+  }
 
   private def writeCFile(origin: String, ident: Ident, ext: String, f: IndentWriter => Unit): Unit = {
     val targetDir = if (ext == "h") spec.cHeaderOutFolder else spec.cOutFolder
@@ -143,17 +148,36 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     }
   }
 
-  private def writeCppWrapperClass(ident: Ident, cppClassName: String, w: IndentWriter, body: IndentWriter => Unit): Unit = {
+  private def writeCppWrapperClass(ident: Ident, cppClassName: String, w: IndentWriter, methods: IndentWriter => Unit): Unit = {
     val typeName = resolveRefSymbolTypeName(ident)
-    wrapNamespace(w, spec.cppNamespace + "::c_wrappers", (w: IndentWriter) => {
-        w.w(s"template <template <typename> class Ref> class ${cppClassName}").bracedSemi {
-          w.wlOutdent("public:")
-          body(w)
-          w.wl
-          w.wlOutdent("private:")
-          w.wl(s"Ref<${typeName}> _ref;")
-        }
-      })
+    wrapIfCpp(w, (w: IndentWriter) => {
+      wrapNamespace(w, spec.cppNamespace + "::c_wrappers", (w: IndentWriter) => {
+          w.w(s"template <template <typename> class Ref> class ${cppClassName}").bracedSemi {
+            w.wlOutdent("public:")
+            w.wl(s"using RefType = Ref<${typeName}>;")
+            w.wl
+            w.wl(s"explicit ${cppClassName}(const RefType& ref) : _ref(ref) {}")
+            w.wl
+            w.wl(s"${cppClassName}(const ${cppClassName}&) = default;")
+            w.wl
+            w.wl(s"${cppClassName}(${cppClassName}&&) = default;")
+            w.wl
+            w.wl(s"${cppClassName}& operator=(const ${cppClassName}&) = default;")
+            w.wl
+            w.wl(s"${cppClassName}& operator=(${cppClassName}&&) = default;")
+            w.wl
+            w.wl(s"operator const RefType&() const { return _ref; }")
+            w.wl
+            w.wl(s"operator ${typeName}() const { return _ref.get(); }")
+            w.wl
+            w.wl(s"${typeName} _djinni_ref() const { return _ref.get(); }")
+            w.wl
+            methods(w)
+            w.wlOutdent("private:")
+            w.wl(s"RefType _ref;")
+          }
+        })
+    })
   }
 
   override def generateRecord(origin: String, ident: Ident, doc: Doc, params: Seq[TypeParam], r: ast.Record): Unit = {
@@ -197,12 +221,12 @@ class CGenerator(spec: Spec) extends Generator(spec) {
           val fieldTypename = resolvedField.translator.typename
           w.w(s"${fieldTypename} ${fieldName}() const")
           w.braced {
-            w.wl(s"return ${prefix}_get_${fieldName}(_ref.get);")
+            w.wl(s"return ${prefix}_get_${fieldName}(_ref.get());")
           }
           w.wl
           w.w(s"${fieldTypename} ${fieldName}(${fieldTypename} value)")
           w.braced {
-            w.wl(s"${prefix}_set_${fieldName}(_ref.get, value);")
+            w.wl(s"${prefix}_set_${fieldName}(_ref.get(), value);")
           }
           w.wl
         }
@@ -406,14 +430,19 @@ class CGenerator(spec: Spec) extends Generator(spec) {
         w.wl
         writeCppWrapperClass(ident, selfCppClass, w, (w: IndentWriter) => {
           for (resolvedMethod <- resolvedMethods) {
+            if (resolvedMethod.method.static) {
+              w.w("static ")
+            }
             w.w(s"${resolvedMethod.retTypename} ${resolvedMethod.resolvedName}(")
             writeParamList(w, resolvedMethod.parameters.map(p => (p.translator.typename, p.field.ident.name)))
             w.w(") ")
             w.braced {
-              val returnStr = if (resolvedMethod.retTypename != "void") "return " else ""
               val argsList = resolvedMethod.parameters.map(p => (p.field.ident.name))
               val fullArgsList = if (resolvedMethod.method.static) argsList else "_ref.get()" +: argsList
-              w.wl(s"${returnStr}${prefix}_${resolvedMethod.resolvedName}(${fullArgsList.mkString(", ")});")
+              if (resolvedMethod.retTypename != "void") {
+                w.w("return ")
+              }
+              w.wl(s"${prefix}_${resolvedMethod.resolvedName}(${fullArgsList.mkString(", ")});")
             }
             w.wl
             }

From 8a051592657a0d73e71bbbf318dfd32445650262 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Mon, 1 Dec 2025 22:06:27 +0000
Subject: [PATCH 04/11] cli arg

---
 src/source/CGenerator.scala | 44 ++++++++++++++++++++-----------------
 src/source/Main.scala       |  4 ++++
 src/source/generator.scala  |  1 +
 3 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index acb8d12a..9499a0b9 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -148,10 +148,12 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     }
   }
 
-  private def writeCppWrapperClass(ident: Ident, cppClassName: String, w: IndentWriter, methods: IndentWriter => Unit): Unit = {
+  private def writeCppWrapperClass(ident: Ident, w: IndentWriter, methods: IndentWriter => Unit): Unit = {
     val typeName = resolveRefSymbolTypeName(ident)
+    val cppClassName = ident.name
+    val cppNamespace = spec.cWrapperCppNamespace.getOrElse(spec.cppNamespace + "::c_wrappers")
     wrapIfCpp(w, (w: IndentWriter) => {
-      wrapNamespace(w, spec.cppNamespace + "::c_wrappers", (w: IndentWriter) => {
+      wrapNamespace(w, cppNamespace, (w: IndentWriter) => {
           w.w(s"template <template <typename> class Ref> class ${cppClassName}").bracedSemi {
             w.wlOutdent("public:")
             w.wl(s"using RefType = Ref<${typeName}>;")
@@ -214,23 +216,25 @@ class CGenerator(spec: Spec) extends Generator(spec) {
         }
       })
 
-      w.wl
-      writeCppWrapperClass(ident, selfCppClass, w, (w: IndentWriter) => {
-        for (resolvedField <- resolvedFields) {
-          val fieldName = resolvedField.field.ident.name
-          val fieldTypename = resolvedField.translator.typename
-          w.w(s"${fieldTypename} ${fieldName}() const")
-          w.braced {
-            w.wl(s"return ${prefix}_get_${fieldName}(_ref.get());")
-          }
-          w.wl
-          w.w(s"${fieldTypename} ${fieldName}(${fieldTypename} value)")
-          w.braced {
-            w.wl(s"${prefix}_set_${fieldName}(_ref.get(), value);")
+      if (spec.cWrapperCppNamespace.isDefined) {
+        w.wl
+        writeCppWrapperClass(ident, w, (w: IndentWriter) => {
+          for (resolvedField <- resolvedFields) {
+            val fieldName = resolvedField.field.ident.name
+            val fieldTypename = resolvedField.translator.typename
+            w.w(s"${fieldTypename} ${fieldName}() const")
+            w.braced {
+              w.wl(s"return ${prefix}_get_${fieldName}(_ref.get());")
+            }
+            w.wl
+            w.w(s"${fieldTypename} ${fieldName}(${fieldTypename} value)")
+            w.braced {
+              w.wl(s"${prefix}_set_${fieldName}(_ref.get(), value);")
+            }
+            w.wl
           }
-          w.wl
-        }
-      })
+        })
+      }
     }, (w: IndentWriter) => {
       w.w(s"""${typeName} ${prefix}_new(""")
       writeParamListWithResolvedFields(w, resolvedFields)
@@ -426,9 +430,9 @@ class CGenerator(spec: Spec) extends Generator(spec) {
         }
       })
 
-      if (i.ext.cpp) {
+      if (i.ext.cpp && spec.cWrapperCppNamespace.isDefined) {
         w.wl
-        writeCppWrapperClass(ident, selfCppClass, w, (w: IndentWriter) => {
+        writeCppWrapperClass(ident, w, (w: IndentWriter) => {
           for (resolvedMethod <- resolvedMethods) {
             if (resolvedMethod.method.static) {
               w.w("static ")
diff --git a/src/source/Main.scala b/src/source/Main.scala
index 44a1d464..17b4d51e 100644
--- a/src/source/Main.scala
+++ b/src/source/Main.scala
@@ -116,6 +116,7 @@ object Main {
     var cNamespace: String = ""
     var cBaseLibIncludePrefix: String = ""
     var cIncludePrefix: String = ""
+    var cWrapperCppNamespace: Option[String] = None
     var swiftOutFolder: Option[File] = None
     var swiftModule: String = "Module"
     var swiftIdentStyle = IdentStyle.swiftDefault
@@ -316,6 +317,8 @@ object Main {
         .text("The C base library's include path, relative to the C files.")
       opt[String]("c-include-prefix").valueName("...").foreach(x => cIncludePrefix = x)
         .text("The prefix for #includes of header files from C++ files.")
+      opt[String]("c-wrapper-cpp-namespace").valueName("...").foreach(x => cWrapperCppNamespace = Some(x))
+        .text("The C++ namespace to use for C API wrapper convenience classes.")
       opt[File]("swift-out").valueName("<out-folder>").foreach(x => swiftOutFolder = Some(x))
         .text("The output folder for Swift files (Generator disabled if unspecified).")
       opt[String]("swift-module").valueName("<name>").foreach(swiftModule = _)
@@ -541,6 +544,7 @@ object Main {
       cNamespace,
       cBaseLibIncludePrefix,
       cIncludePrefix,
+      cWrapperCppNamespace,
       swiftOutFolder,
       swiftIdentStyle,
       swiftModule,
diff --git a/src/source/generator.scala b/src/source/generator.scala
index 025066fa..98aedb64 100644
--- a/src/source/generator.scala
+++ b/src/source/generator.scala
@@ -118,6 +118,7 @@ package object generatorTools {
                    cNamespace: String,
                    cBaseLibIncludePrefix: String,
                    cIncludePrefix: String,
+                   cWrapperCppNamespace: Option[String],
                    swiftOutFolder: Option[File],
                    swiftIdentStyle: SwiftIdentStyle,
                    swiftModule: String,

From a0db58713636351bfb5a2ce3c624a2cb97a3addd Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Mon, 1 Dec 2025 22:08:33 +0000
Subject: [PATCH 05/11] WIP

---
 src/source/CGenerator.scala | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index 9499a0b9..3f2a6aed 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -184,7 +184,6 @@ class CGenerator(spec: Spec) extends Generator(spec) {
 
   override def generateRecord(origin: String, ident: Ident, doc: Doc, params: Seq[TypeParam], r: ast.Record): Unit = {
     val selfCpp = cppMarshal.fqTypename(ident, r)
-    val selfCppClass = cppMarshal.typename(ident, r)
 
     val typeResolver = new CTypeResolver(ident, spec, cppMarshal)
     val prefix = resolveSymbolName(ident.name)
@@ -360,7 +359,6 @@ class CGenerator(spec: Spec) extends Generator(spec) {
 
   override def generateInterface(origin: String, ident: Ident, doc: Doc, typeParams: Seq[TypeParam], i: Interface): Unit = {
     val selfCpp = cppMarshal.fqTypename(ident, i)
-    val selfCppClass = cppMarshal.typename(ident, i)
     val typeResolver = new CTypeResolver(ident, spec, cppMarshal)
     val resolvedMethods = i.methods.map(m =>
       new ResolvedMethod(

From c757fbfda5aaa6d896f018bbdfe74b109864ed4d Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Mon, 1 Dec 2025 22:50:26 +0000
Subject: [PATCH 06/11] tidy

---
 src/source/CGenerator.scala | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index 3f2a6aed..2693e122 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -53,6 +53,7 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     wrapIfCpp(w, (w: IndentWriter) => {
       w.wl("extern \"C\" {")
     })
+    w.wl
     f(w)
     wrapIfCpp(w, (w: IndentWriter) => {
       w.wl("} // extern \"C\"")
@@ -96,14 +97,15 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     writeCFilePair(origin, ident, List.empty[String], List.empty[String])((w: IndentWriter) => {
       val symbolName = resolveSymbolName(ident.name)
       val enumCasePrefix = symbolName + "_"
-      writeDoc(w, doc)
-      w.w("typedef enum")
-      w.bracedEnd(s" ${symbolName};") {
-        writeEnumOptionNone(w, e, idCpp.enum, "=", enumCasePrefix)
-        writeEnumOptions(w, e, idCpp.enum, "=", enumCasePrefix)
-        writeEnumOptionAll(w, e, idCpp.enum, "=", enumCasePrefix)
-      }
-
+      wrapExternC(w, (w: IndentWriter) => {
+        writeDoc(w, doc)
+        w.w("typedef enum")
+        w.bracedEnd(s" ${symbolName};") {
+          writeEnumOptionNone(w, e, idCpp.enum, "=", enumCasePrefix)
+          writeEnumOptions(w, e, idCpp.enum, "=", enumCasePrefix)
+          writeEnumOptionAll(w, e, idCpp.enum, "=", enumCasePrefix)
+        }
+      })
     }, (w: IndentWriter) => {
     })
   }

From a2e2ceb9955f1da6f3204c2fe0ce3f7e9c17e729 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Mon, 1 Dec 2025 23:40:48 +0000
Subject: [PATCH 07/11] tidy

---
 src/source/CGenerator.scala | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index 2693e122..0042ba85 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -155,25 +155,24 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     val cppClassName = ident.name
     val cppNamespace = spec.cWrapperCppNamespace.getOrElse(spec.cppNamespace + "::c_wrappers")
     wrapIfCpp(w, (w: IndentWriter) => {
+      w.wl("#include <utility>")
       wrapNamespace(w, cppNamespace, (w: IndentWriter) => {
           w.w(s"template <template <typename> class Ref> class ${cppClassName}").bracedSemi {
             w.wlOutdent("public:")
             w.wl(s"using RefType = Ref<${typeName}>;")
             w.wl
-            w.wl(s"explicit ${cppClassName}(const RefType& ref) : _ref(ref) {}")
-            w.wl
+            w.wl(s"${cppClassName}(const RefType& ref) : _ref(ref) {}")
+            w.wl(s"${cppClassName}(const ${typeName}& ref) : _ref(ref) {}")
+            w.wl(s"${cppClassName}(${typeName}&& ref) : _ref(std::move(ref)) {}")
             w.wl(s"${cppClassName}(const ${cppClassName}&) = default;")
-            w.wl
             w.wl(s"${cppClassName}(${cppClassName}&&) = default;")
-            w.wl
             w.wl(s"${cppClassName}& operator=(const ${cppClassName}&) = default;")
-            w.wl
             w.wl(s"${cppClassName}& operator=(${cppClassName}&&) = default;")
+            w.wl(s"${cppClassName}& operator=(const ${typeName}& ref) { _ref = ref; return *this; }")
+            w.wl(s"${cppClassName}& operator=(${typeName}&& ref) { _ref = std::move(ref); return *this; }")
             w.wl
             w.wl(s"operator const RefType&() const { return _ref; }")
-            w.wl
             w.wl(s"operator ${typeName}() const { return _ref.get(); }")
-            w.wl
             w.wl(s"${typeName} _djinni_ref() const { return _ref.get(); }")
             w.wl
             methods(w)
@@ -228,9 +227,10 @@ class CGenerator(spec: Spec) extends Generator(spec) {
               w.wl(s"return ${prefix}_get_${fieldName}(_ref.get());")
             }
             w.wl
-            w.w(s"${fieldTypename} ${fieldName}(${fieldTypename} value)")
+            w.w(s"${ident.name}& ${fieldName}(${fieldTypename} value)")
             w.braced {
               w.wl(s"${prefix}_set_${fieldName}(_ref.get(), value);")
+              w.wl("return *this;")
             }
             w.wl
           }

From bff6f2ade80a880815edd15d03b640b8ed4ca910 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Wed, 3 Dec 2025 16:53:53 +0000
Subject: [PATCH 08/11] Remove Ref template param

---
 src/source/CGenerator.scala | 66 +++++++++++++++++++++++++++----------
 1 file changed, 48 insertions(+), 18 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index 0042ba85..429cb3a6 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -157,27 +157,57 @@ class CGenerator(spec: Spec) extends Generator(spec) {
     wrapIfCpp(w, (w: IndentWriter) => {
       w.wl("#include <utility>")
       wrapNamespace(w, cppNamespace, (w: IndentWriter) => {
-          w.w(s"template <template <typename> class Ref> class ${cppClassName}").bracedSemi {
+          w.w(s"class ${cppClassName}").bracedSemi {
             w.wlOutdent("public:")
-            w.wl(s"using RefType = Ref<${typeName}>;")
             w.wl
-            w.wl(s"${cppClassName}(const RefType& ref) : _ref(ref) {}")
-            w.wl(s"${cppClassName}(const ${typeName}& ref) : _ref(ref) {}")
-            w.wl(s"${cppClassName}(${typeName}&& ref) : _ref(std::move(ref)) {}")
-            w.wl(s"${cppClassName}(const ${cppClassName}&) = default;")
-            w.wl(s"${cppClassName}(${cppClassName}&&) = default;")
-            w.wl(s"${cppClassName}& operator=(const ${cppClassName}&) = default;")
-            w.wl(s"${cppClassName}& operator=(${cppClassName}&&) = default;")
-            w.wl(s"${cppClassName}& operator=(const ${typeName}& ref) { _ref = ref; return *this; }")
-            w.wl(s"${cppClassName}& operator=(${typeName}&& ref) { _ref = std::move(ref); return *this; }")
+            w.wl(s"${cppClassName}(const ${typeName}& ref) : _ref(ref) { djinni_ref_retain(_ref); }")
+            w.wl(s"${cppClassName}(${typeName}&& ref) noexcept : _ref(std::move(ref)) {}")
+            w.wl(s"${cppClassName}(const ${cppClassName}& other) : _ref(other._ref) { djinni_ref_retain(_ref); }")
+            w.wl(s"${cppClassName}(${cppClassName}&& other) : _ref(std::move(other._ref)) { other._ref = nullptr; }")
+            w.wl(s"~${cppClassName}() { djinni_ref_release(_ref); }")
+
+            val assignOps =
+              s"""${cppClassName}& operator=(const ${cppClassName}& other) {
+                |  if (&other != this) {
+                |      auto old = _ref;
+                |      _ref = other._ref;
+                |      djinni_ref_retain(_ref);
+                |      djinni_ref_release(old);
+                |   }
+                |   return *this;
+                |}
+                |${cppClassName}& operator=(${cppClassName}&& other) noexcept {
+                |  if (&other != this) {
+                |    auto old = _ref;
+                |    _ref = other._ref;
+                |    other._ref = nullptr;
+                |
+                |    djinni_ref_release(old);
+                |  }
+                |  return *this;
+                |}
+                |${cppClassName}& operator=(${typeName}&& ref) {
+                |  auto old = _ref;
+                |  _ref = ref;
+                |  djinni_ref_release(old);
+                |  return *this;
+                |}
+                |${cppClassName}& operator=(const ${typeName}& ref) {
+                |  auto old = _ref;
+                |  _ref = ref;
+                |  djinni_ref_retain(ref);
+                |  djinni_ref_release(old);
+                |  return *this;
+                |}""".stripMargin
+            assignOps.split("\n").toSeq.foreach(line => w.wl(line))
+
             w.wl
-            w.wl(s"operator const RefType&() const { return _ref; }")
-            w.wl(s"operator ${typeName}() const { return _ref.get(); }")
-            w.wl(s"${typeName} _djinni_ref() const { return _ref.get(); }")
+            w.wl(s"operator ${typeName}() const { return _ref; }")
+            w.wl(s"${typeName} _djinni_ref() const { return _ref; }")
             w.wl
             methods(w)
             w.wlOutdent("private:")
-            w.wl(s"RefType _ref;")
+            w.wl(s"${typeName} _ref;")
           }
         })
     })
@@ -224,12 +254,12 @@ class CGenerator(spec: Spec) extends Generator(spec) {
             val fieldTypename = resolvedField.translator.typename
             w.w(s"${fieldTypename} ${fieldName}() const")
             w.braced {
-              w.wl(s"return ${prefix}_get_${fieldName}(_ref.get());")
+              w.wl(s"return ${prefix}_get_${fieldName}(_ref);")
             }
             w.wl
             w.w(s"${ident.name}& ${fieldName}(${fieldTypename} value)")
             w.braced {
-              w.wl(s"${prefix}_set_${fieldName}(_ref.get(), value);")
+              w.wl(s"${prefix}_set_${fieldName}(_ref, value);")
               w.wl("return *this;")
             }
             w.wl
@@ -442,7 +472,7 @@ class CGenerator(spec: Spec) extends Generator(spec) {
             w.w(") ")
             w.braced {
               val argsList = resolvedMethod.parameters.map(p => (p.field.ident.name))
-              val fullArgsList = if (resolvedMethod.method.static) argsList else "_ref.get()" +: argsList
+              val fullArgsList = if (resolvedMethod.method.static) argsList else "_ref" +: argsList
               if (resolvedMethod.retTypename != "void") {
                 w.w("return ")
               }

From da7ef9bf83529f55f00294afed0b7a6fda8bfe70 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Wed, 3 Dec 2025 18:16:59 +0000
Subject: [PATCH 09/11] const ref return

---
 src/source/CGenerator.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index 429cb3a6..f4fb5216 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -202,8 +202,8 @@ class CGenerator(spec: Spec) extends Generator(spec) {
             assignOps.split("\n").toSeq.foreach(line => w.wl(line))
 
             w.wl
-            w.wl(s"operator ${typeName}() const { return _ref; }")
-            w.wl(s"${typeName} _djinni_ref() const { return _ref; }")
+            w.wl(s"operator const ${typeName}&() const { return _ref; }")
+            w.wl(s"const ${typeName}& _djinni_ref() const { return _ref; }")
             w.wl
             methods(w)
             w.wlOutdent("private:")

From 36fec0e469c32a4a00c42e61b15de7606329b516 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Wed, 3 Dec 2025 21:14:01 +0000
Subject: [PATCH 10/11] Ref::get() should return const ref

---
 support-lib/cpp/djinni_c_ref.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/support-lib/cpp/djinni_c_ref.hpp b/support-lib/cpp/djinni_c_ref.hpp
index 662b07c2..c3448277 100644
--- a/support-lib/cpp/djinni_c_ref.hpp
+++ b/support-lib/cpp/djinni_c_ref.hpp
@@ -41,7 +41,7 @@ template <typename T> class Ref {
     return *this;
   }
 
-  T get() const { return _ref; }
+  const T& get() const { return _ref; }
 
 private:
   T _ref;

From 99049620e1ef30cd767bfb262b358eabb209f286 Mon Sep 17 00:00:00 2001
From: Kevin Thornberry <kthornberry@snapchat.com>
Date: Wed, 3 Dec 2025 21:52:33 +0000
Subject: [PATCH 11/11] record make() function

---
 src/source/CGenerator.scala | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/source/CGenerator.scala b/src/source/CGenerator.scala
index f4fb5216..1d67cf66 100644
--- a/src/source/CGenerator.scala
+++ b/src/source/CGenerator.scala
@@ -249,6 +249,15 @@ class CGenerator(spec: Spec) extends Generator(spec) {
       if (spec.cWrapperCppNamespace.isDefined) {
         w.wl
         writeCppWrapperClass(ident, w, (w: IndentWriter) => {
+          w.w(s"static ${ident.name} make(")
+          writeParamListWithResolvedFields(w, resolvedFields)
+          w.w(")")
+          w.braced {
+            w.w(s"return ${prefix}_new(")
+            w.w(resolvedFields.map(p => p.field.ident.name).mkString(", "))
+            w.wl(");")
+          }
+          w.wl
           for (resolvedField <- resolvedFields) {
             val fieldName = resolvedField.field.ident.name
             val fieldTypename = resolvedField.translator.typename