Separate Go and C struct pointer, fixes #17

gir/girgen/generators/record.go

@@ -35,13 +35,14 @@ var recordIgnoreSuffixes = []string{
 var recordTmpl = gotmpl.NewGoTemplate(`
 	{{ GoDoc . 0 }}
 	type {{ .GoName }} struct {
-		native C.{{ .CType }}
+		nocopy gextras.NoCopy
+		native *C.{{.CType}}
 	}
 
 	{{ if .GLibGetType }}
 	func marshal{{ .GoName }}(p uintptr) (interface{}, error) {
 		b := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p)))
-		return (*{{ .GoName }})(unsafe.Pointer(b)), nil
+		return &{{ .GoName }}{native: (*C.{{.CType}})(unsafe.Pointer(b))}, nil
 	}
 	{{ end }}
 
@@ -54,11 +55,6 @@ var recordTmpl = gotmpl.NewGoTemplate(`
 
 	{{ $recv := (FirstLetter $.GoName) }}
 
-	// Native returns the underlying C source pointer.
-	func ({{ $recv }} *{{ .GoName }}) Native() unsafe.Pointer {
-		return unsafe.Pointer(&{{ FirstLetter .GoName }}.native)
-	}
-
 	{{ range .Getters }}
 	{{ GoDoc . 0 }}
 	func ({{ $recv }} *{{ $.GoName }}) {{ .Name }}() {{ .Type }} {{ .Block }}
@@ -136,8 +132,7 @@ func GenerateRecord(gen FileGeneratorWriter, record *gir.Record) bool {
 	}
 
 	writer := FileWriterFromType(gen, record)
-	// Need unsafe for the wrapper.
-	writer.Header().Import("unsafe")
+	writer.Header().ImportCore("gextras")
 
 	if record.GLibGetType != "" && !types.FilterCType(gen, record.GLibGetType) {
 		writer.Header().AddMarshaler(record.GLibGetType, recordGen.GoName)

gir/girgen/types/typeconv/c-go.go

@@ -391,17 +391,17 @@ func (conv *Converter) cgoConverter(value *ValueConverted) bool {
 			unref = "cairo_pattern_destroy"
 			value.p.Descend()
 			// Hack to fit the Pattern type.
-			value.p.Linef("_p := &struct{p unsafe.Pointer}{unsafe.Pointer(%s)}", value.InNamePtr(1))
-			value.p.Linef("%s = (*cairo.Pattern)(unsafe.Pointer(_p))", value.Out.Set)
+			value.p.Linef("_pp:= &struct{p unsafe.Pointer}{unsafe.Pointer(%s)}", value.InNamePtr(1))
+			value.p.Linef("%s = (*cairo.Pattern)(unsafe.Pointer(_pp))", value.Out.Set)
 			value.p.Ascend()
 
 		case "cairo.Region":
 			ref = "cairo_region_reference"
 			unref = "cairo_region_destroy"
 			value.p.Descend()
 			// Hack to fit the Region type.
-			value.p.Linef("_p := &struct{p unsafe.Pointer}{unsafe.Pointer(%s)}", value.InNamePtr(1))
-			value.p.Linef("%s = (*cairo.Region)(unsafe.Pointer(_p))", value.Out.Set)
+			value.p.Linef("_pp:= &struct{p unsafe.Pointer}{unsafe.Pointer(%s)}", value.InNamePtr(1))
+			value.p.Linef("%s = (*cairo.Region)(unsafe.Pointer(_pp))", value.Out.Set)
 			value.p.Ascend()
 		}
 
@@ -434,32 +434,19 @@ func (conv *Converter) cgoConverter(value *ValueConverted) bool {
 
 	switch v := value.Resolved.Extern.Type.(type) {
 	case *gir.Enum, *gir.Bitfield:
-		value.p.LineTmpl(value, "<.Out.Set> = <.OutCast 0>(<.InNamePtr 0>)")
+		value.vtmpl("<.Out.Set> = <.OutCast 0>(<.InNamePtr 0>)")
 		return true
 
 	case *gir.Class, *gir.Interface:
 		return value.cgoSetObject(conv)
 
 	case *gir.Record:
-		// We can slightly cheat here. Since Go structs are declared by wrapping
-		// the C type, we can directly cast to the C type if this is an output
-		// parameter. This saves us a copy.
-		if value.Resolved.Ptr < 2 && value.outputAllocs() {
-			value.header.Import("unsafe")
-
-			value.outDecl.Reset()
-			value.inDecl.Reset()
-
-			// Write the Go type directly.
-			value.inDecl.Linef("var %s %s", value.OutName, value.Out.Type)
-			value.In.Call = fmt.Sprintf("(*%s)(unsafe.Pointer(&%s))", value.In.Type, value.OutName)
-
-			return true
-		}
-
 		value.header.Import("unsafe")
+		value.header.ImportCore("gextras")
+
 		// Require 1 pointer to avoid weird copies.
-		value.p.LineTmpl(value, "<.Out.Set> = <.OutCast 1>(unsafe.Pointer(<.InNamePtr 1>))")
+		value.vtmpl(
+			"<.Out.Set> = <.OutCast 1>(gextras.NewStructNative(unsafe.Pointer(<.InNamePtr 1>)))")
 		if value.fail {
 			return false
 		}
@@ -482,17 +469,17 @@ func (conv *Converter) cgoConverter(value *ValueConverted) bool {
 		// We can take ownership if the type can be reference-counted anyway.
 		if value.ShouldFree() || unref {
 			value.header.Import("runtime")
-			value.p.LineTmpl(value,
+			value.vtmpl(
 				"runtime.SetFinalizer(<.OutInPtr 1><.OutName>, func(v <.OutPtr 1><.Out.Type>) {")
-
 			if free != nil {
 				value.p.Linef(
-					"C.%s((%s%s)(unsafe.Pointer(v)))",
+					"C.%s((%s%s)(gextras.StructNative(unsafe.Pointer(v))))",
 					free.CIdentifier, value.OutPtr(1), value.In.Type)
 			} else {
-				value.p.Linef("C.free(unsafe.Pointer(v))")
+				value.p.Linef(
+					"C.free(gextras.StructNative(unsafe.Pointer(v)))",
+				)
 			}
-
 			value.p.Linef("})")
 		}
 

gir/girgen/types/typeconv/go-c.go

@@ -459,7 +459,10 @@ func (conv *Converter) gocConverter(value *ValueConverted) bool {
 
 	case *gir.Record:
 		value.header.Import("unsafe")
-		value.p.LineTmpl(value, "<.Out.Set> = <.OutCast 1>(unsafe.Pointer(<.InNamePtr 1>))")
+		value.header.ImportCore("gextras")
+		value.vtmpl(
+			"<.Out.Set> = <.OutCast 1>(gextras.StructNative(unsafe.Pointer(<.InNamePtr 1>)))",
+		)
 
 		// This code might trigger a double-free.
 		// // If ShouldFree is true, then ideally, we'll be freeing the C copy of

gir/girgen/types/typeconv/value.go

@@ -371,6 +371,10 @@ func (value *ValueConverted) flush() {
 	value.Conversion = value.p.String()
 }
 
+func (value *ValueConverted) vtmpl(tmpl string) {
+	value.p.LineTmpl(value, tmpl)
+}
+
 func (value *ValueConverted) Logln(lvl logger.Level, v ...interface{}) {
 	value.log(lvl, logger.Prefix(v, value.logPrefix())...)
 }