[bindings/go][NFC] Format code with go fmt

[aykevl]

Summary

Run go fmt (version 1.12) over the Go bindings. This cleans up lots of inconsistencies in the code, it does not change the code in a functional way.

[jdoerfert]

LGTM, but you should be careful. People sometimes like to keep the history so formating changes are hard. However, this seems to be only binding code so there is not much logic or history thereof to preserve.

[aykevl]

Yes, losing a bit of history is unfortunate. However, it will make it easier in the future to keep these bindings machine-formatted.

I don't know how well you know the Go language, but running go fmt on code is the standard basically everywhere. It's so great to not have to bikeshed about formatting.

llvm/bindings/go/llvm/dibuilder.go

result := C.LLVMDIBuilderCreateBasicType(
     C.LLVMDWARFTypeEncoding(t.Encoding),
     C.LLVMDIFlags(0),
   )
   return Metadata{C: result}
 }
 
 // DIPointerType holds the values for creating pointer type debug metadata.
 type DIPointerType struct {
-  Pointee     Metadata
-  SizeInBits  uint64
-  AlignInBits uint32 // optional
+  Pointee      Metadata
+  SizeInBits   uint64
+  AlignInBits  uint32 // optional
   AddressSpace uint32
-  Name        string // optional
+  Name         string // optional
 }
 
 // CreatePointerType creates a type that represents a pointer to another type.
 func (d *DIBuilder) CreatePointerType(t DIPointerType) Metadata {
   name := C.CString(t.Name)
   defer C.free(unsafe.Pointer(name))
   result := C.LLVMDIBuilderCreatePointerType(
     d.ref,
result := C.LLVMDIBuilderCreateSubroutineType(
     length,
     C.LLVMDIFlags(t.Flags),
   )
   return Metadata{C: result}
 }
 
 // DIStructType holds the values for creating struct type debug metadata.
 type DIStructType struct {
-  Name        string
-  File        Metadata
-  Line        int
-  SizeInBits  uint64
-  AlignInBits uint32
-  Flags       int
-  DerivedFrom Metadata
-  Elements    []Metadata
+  Name         string
+  File         Metadata
+  Line         int
+  SizeInBits   uint64
+  AlignInBits  uint32
+  Flags        int
+  DerivedFrom  Metadata
+  Elements     []Metadata
   VTableHolder Metadata // optional
   UniqueID     string
 }
 
 // CreateStructType creates struct type debug metadata.
 func (d *DIBuilder) CreateStructType(scope Metadata, t DIStructType) Metadata {
   elements, length := llvmMetadataRefs(t.Elements)
   name := C.CString(t.Name)

 func (d *DIBuilder) InsertValueAtEnd(v Value, diVarInfo, expr Metadata, l DebugLoc, bb BasicBlock) Value {
   loc := C.LLVMDIBuilderCreateDebugLocation(
     d.m.Context().C, C.uint(l.Line), C.uint(l.Col), l.Scope.C, l.InlinedAt.C)
   result := C.LLVMDIBuilderInsertDbgValueAtEnd(d.ref, v.C, diVarInfo.C, expr.C, loc, bb.C)
   return Value{C: result}
 }
 
 func (v Value) SetSubprogram(sp Metadata) {
-  C.LLVMSetSubprogram(v.C, sp.C)
+  C.LLVMSetSubprogram(v.C, sp.C)
 }
 
 func boolToCInt(v bool) C.int {
   if v {
     return 1
   }
   return 0
 }

llvm/bindings/go/llvm/ir.go

 func AttributeKindID(name string) (id uint) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   id = uint(C.LLVMGetEnumAttributeKindForName(cname, C.size_t(len(name))))
   return
 }
 
 func (c Context) CreateEnumAttribute(kind uint, val uint64) (a Attribute) {
-  a.C = C.LLVMCreateEnumAttribute(c.C, C.unsigned(kind), C.uint64_t(val))
-  return
+  a.C = C.LLVMCreateEnumAttribute(c.C, C.unsigned(kind), C.uint64_t(val))
+  return
 }
 
 func (a Attribute) GetEnumKind() (id int) {
-  id = int(C.LLVMGetEnumAttributeKind(a.C))
-  return
+  id = int(C.LLVMGetEnumAttributeKind(a.C))
+  return
 }
 
 func (a Attribute) GetEnumValue() (val uint64) {
-  val = uint64(C.LLVMGetEnumAttributeValue(a.C))
-  return
+  val = uint64(C.LLVMGetEnumAttributeValue(a.C))
+  return
 }
 
 func (c Context) CreateStringAttribute(kind string, val string) (a Attribute) {
-  ckind := C.CString(kind)
-  defer C.free(unsafe.Pointer(ckind))
-  cval := C.CString(val)
-  defer C.free(unsafe.Pointer(cval))
-  a.C = C.LLVMCreateStringAttribute(c.C,
-                                    ckind, C.unsigned(len(kind)),
-                                    cval, C.unsigned(len(val)))
-  return
+  ckind := C.CString(kind)
+  defer C.free(unsafe.Pointer(ckind))
+  cval := C.CString(val)
+  defer C.free(unsafe.Pointer(cval))
+  a.C = C.LLVMCreateStringAttribute(c.C,
+    ckind, C.unsigned(len(kind)),
+    cval, C.unsigned(len(val)))
+  return
 }
 
 func (a Attribute) GetStringKind() string {
-  length := C.unsigned(0)
-  ckind := C.LLVMGetStringAttributeKind(a.C, &length)
-  return C.GoStringN(ckind, C.int(length))
+  length := C.unsigned(0)
+  ckind := C.LLVMGetStringAttributeKind(a.C, &length)
+  return C.GoStringN(ckind, C.int(length))
 }
 
 func (a Attribute) GetStringValue() string {
-  length := C.unsigned(0)
-  ckind := C.LLVMGetStringAttributeValue(a.C, &length)
-  return C.GoStringN(ckind, C.int(length))
+  length := C.unsigned(0)
+  ckind := C.LLVMGetStringAttributeValue(a.C, &length)
+  return C.GoStringN(ckind, C.int(length))
 }
 
 func (a Attribute) IsEnum() bool {
-  return C.LLVMIsEnumAttribute(a.C) != 0;
+  return C.LLVMIsEnumAttribute(a.C) != 0
 }
 
 func (a Attribute) IsString() bool {
-  return C.LLVMIsStringAttribute(a.C) != 0;
+  return C.LLVMIsStringAttribute(a.C) != 0
 }
 
 //-------------------------------------------------------------------------
 // llvm.Module
 //-------------------------------------------------------------------------
 
 // Create and destroy modules.
 // See llvm::Module::Module.

 func (v Value) SetFunctionCallConv(cc CallConv) { C.LLVMSetFunctionCallConv(v.C, C.unsigned(cc)) }
 func (v Value) GC() string                      { return C.GoString(C.LLVMGetGC(v.C)) }
 func (v Value) SetGC(name string) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   C.LLVMSetGC(v.C, cname)
 }
 func (v Value) AddAttributeAtIndex(i int, a Attribute) {
-  C.LLVMAddAttributeAtIndex(v.C, C.LLVMAttributeIndex(i), a.C)
+  C.LLVMAddAttributeAtIndex(v.C, C.LLVMAttributeIndex(i), a.C)
 }
 func (v Value) AddFunctionAttr(a Attribute) {
-  v.AddAttributeAtIndex(C.LLVMAttributeFunctionIndex, a);
+  v.AddAttributeAtIndex(C.LLVMAttributeFunctionIndex, a)
 }
 func (v Value) GetEnumAttributeAtIndex(i int, kind uint) (a Attribute) {
-  a.C = C.LLVMGetEnumAttributeAtIndex(v.C, C.LLVMAttributeIndex(i), C.unsigned(kind))
-  return
+  a.C = C.LLVMGetEnumAttributeAtIndex(v.C, C.LLVMAttributeIndex(i), C.unsigned(kind))
+  return
 }
 func (v Value) GetEnumFunctionAttribute(kind uint) Attribute {
-  return v.GetEnumAttributeAtIndex(C.LLVMAttributeFunctionIndex, kind)
+  return v.GetEnumAttributeAtIndex(C.LLVMAttributeFunctionIndex, kind)
 }
 func (v Value) GetStringAttributeAtIndex(i int, kind string) (a Attribute) {
-  ckind := C.CString(kind)
-  defer C.free(unsafe.Pointer(ckind))
-  a.C = C.LLVMGetStringAttributeAtIndex(v.C, C.LLVMAttributeIndex(i),
-                                        ckind, C.unsigned(len(kind)))
-  return
+  ckind := C.CString(kind)
+  defer C.free(unsafe.Pointer(ckind))
+  a.C = C.LLVMGetStringAttributeAtIndex(v.C, C.LLVMAttributeIndex(i),
+    ckind, C.unsigned(len(kind)))
+  return
 }
 func (v Value) RemoveEnumAttributeAtIndex(i int, kind uint) {
-  C.LLVMRemoveEnumAttributeAtIndex(v.C, C.LLVMAttributeIndex(i), C.unsigned(kind))
+  C.LLVMRemoveEnumAttributeAtIndex(v.C, C.LLVMAttributeIndex(i), C.unsigned(kind))
 }
 func (v Value) RemoveEnumFunctionAttribute(kind uint) {
-  v.RemoveEnumAttributeAtIndex(C.LLVMAttributeFunctionIndex, kind);
+  v.RemoveEnumAttributeAtIndex(C.LLVMAttributeFunctionIndex, kind)
 }
 func (v Value) RemoveStringAttributeAtIndex(i int, kind string) {
-  ckind := C.CString(kind)
-  defer C.free(unsafe.Pointer(ckind))
-  C.LLVMRemoveStringAttributeAtIndex(v.C, C.LLVMAttributeIndex(i),
-                                     ckind, C.unsigned(len(kind)))
+  ckind := C.CString(kind)
+  defer C.free(unsafe.Pointer(ckind))
+  C.LLVMRemoveStringAttributeAtIndex(v.C, C.LLVMAttributeIndex(i),
+    ckind, C.unsigned(len(kind)))
 }
 func (v Value) AddTargetDependentFunctionAttr(attr, value string) {
   cattr := C.CString(attr)
   defer C.free(unsafe.Pointer(cattr))
   cvalue := C.CString(value)
   defer C.free(unsafe.Pointer(cvalue))
   C.LLVMAddTargetDependentFunctionAttr(v.C, cattr, cvalue)
 }
 func (v Value) SetPersonality(p Value) {
   C.LLVMSetPersonalityFn(v.C, p.C)
 }
 
 // Operations on parameters
 func (v Value) ParamsCount() int { return int(C.LLVMCountParams(v.C)) }
 func (v Value) Params() []Value {
   out := make([]Value, v.ParamsCount())
   if len(out) > 0 {
     C.LLVMGetParams(v.C, llvmValueRefPtr(&out[0]))
   }
   return out
 }
-func (v Value) Param(i int) (rv Value)  { rv.C = C.LLVMGetParam(v.C, C.unsigned(i)); return }
-func (v Value) ParamParent() (rv Value) { rv.C = C.LLVMGetParamParent(v.C); return }
-func (v Value) FirstParam() (rv Value)  { rv.C = C.LLVMGetFirstParam(v.C); return }
-func (v Value) LastParam() (rv Value)   { rv.C = C.LLVMGetLastParam(v.C); return }
-func NextParam(v Value) (rv Value)      { rv.C = C.LLVMGetNextParam(v.C); return }
-func PrevParam(v Value) (rv Value)      { rv.C = C.LLVMGetPreviousParam(v.C); return }
+func (v Value) Param(i int) (rv Value)      { rv.C = C.LLVMGetParam(v.C, C.unsigned(i)); return }
+func (v Value) ParamParent() (rv Value)     { rv.C = C.LLVMGetParamParent(v.C); return }
+func (v Value) FirstParam() (rv Value)      { rv.C = C.LLVMGetFirstParam(v.C); return }
+func (v Value) LastParam() (rv Value)       { rv.C = C.LLVMGetLastParam(v.C); return }
+func NextParam(v Value) (rv Value)          { rv.C = C.LLVMGetNextParam(v.C); return }
+func PrevParam(v Value) (rv Value)          { rv.C = C.LLVMGetPreviousParam(v.C); return }
 func (v Value) SetParamAlignment(align int) { C.LLVMSetParamAlignment(v.C, C.unsigned(align)) }
 
 // Operations on basic blocks
 func (bb BasicBlock) AsValue() (v Value)      { v.C = C.LLVMBasicBlockAsValue(bb.C); return }
 func (v Value) IsBasicBlock() bool            { return C.LLVMValueIsBasicBlock(v.C) != 0 }
 func (v Value) AsBasicBlock() (bb BasicBlock) { bb.C = C.LLVMValueAsBasicBlock(v.C); return }
 func (bb BasicBlock) Parent() (v Value)       { v.C = C.LLVMGetBasicBlockParent(bb.C); return }
 func (v Value) BasicBlocksCount() int         { return int(C.LLVMCountBasicBlocks(v.C)) }
func (b Builder) InsertWithName(instr Value, name string) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   C.LLVMInsertIntoBuilderWithName(b.C, instr.C, cname)
 }
 func (b Builder) Dispose() { C.LLVMDisposeBuilder(b.C) }
 
 // Metadata
 type DebugLoc struct {
-  Line, Col      uint
-  Scope          Metadata
-  InlinedAt      Metadata
+  Line, Col uint
+  Scope     Metadata
+  InlinedAt Metadata
 }
+
 func (b Builder) SetCurrentDebugLocation(line, col uint, scope, inlinedAt Metadata) {
   C.LLVMGoSetCurrentDebugLocation(b.C, C.unsigned(line), C.unsigned(col), scope.C, inlinedAt.C)
 }
 
 // Get current debug location. Please do not call this function until setting debug location with SetCurrentDebugLocation()
 func (b Builder) GetCurrentDebugLocation() (loc DebugLoc) {
   md := C.LLVMGoGetCurrentDebugLocation(b.C)
   loc.Line = uint(md.Line)

llvm/bindings/go/llvm/transforms_coroutines.go

 
 package llvm
 
 /*
 #include "llvm-c/Transforms/Coroutines.h"
 */
 import "C"
 
-func (pm PassManager) AddCoroEarlyPass()      { C.LLVMAddCoroEarlyPass(pm.C) }
-func (pm PassManager) AddCoroSplitPass()      { C.LLVMAddCoroSplitPass(pm.C) }
-func (pm PassManager) AddCoroElidePass()      { C.LLVMAddCoroElidePass(pm.C) }
-func (pm PassManager) AddCoroCleanupPass()    { C.LLVMAddCoroCleanupPass(pm.C) }
+func (pm PassManager) AddCoroEarlyPass()   { C.LLVMAddCoroEarlyPass(pm.C) }
+func (pm PassManager) AddCoroSplitPass()   { C.LLVMAddCoroSplitPass(pm.C) }
+func (pm PassManager) AddCoroElidePass()   { C.LLVMAddCoroElidePass(pm.C) }
+func (pm PassManager) AddCoroCleanupPass() { C.LLVMAddCoroCleanupPass(pm.C) }