func (tu TranslationUnit) ReparseTranslationUnit(unsavedFiles []UnsavedFile, options uint32) int32 {
	gos_unsavedFiles := (*reflect.SliceHeader)(unsafe.Pointer(&unsavedFiles))
	cp_unsavedFiles := (*C.struct_CXUnsavedFile)(unsafe.Pointer(gos_unsavedFiles.Data))
	return int32(C.clang_reparseTranslationUnit(tu.c, C.uint(len(unsavedFiles)), cp_unsavedFiles, C.uint(options)))
}
/*
Reparse the source files that produced this translation unit.

This routine can be used to re-parse the source files that originally
created the given translation unit, for example because those source files
have changed (either on disk or as passed via \p unsaved_files). The
source code will be reparsed with the same command-line options as it
was originally parsed.

Reparsing a translation unit invalidates all cursors and source locations
that refer into that translation unit. This makes reparsing a translation
unit semantically equivalent to destroying the translation unit and then
creating a new translation unit with the same command-line arguments.
However, it may be more efficient to reparse a translation
unit using this routine.

Parameter TU The translation unit whose contents will be re-parsed. The
translation unit must originally have been built with
clang_createTranslationUnitFromSourceFile().

Parameter num_unsaved_files The number of unsaved file entries in \p
unsaved_files.

Parameter unsaved_files The files that have not yet been saved to disk
but may be required for parsing, including the contents of
those files. The contents and name of these files (as specified by
CXUnsavedFile) are copied when necessary, so the client only needs to
guarantee their validity until the call to this function returns.

Parameter options A bitset of options composed of the flags in CXReparse_Flags.
The function clang_defaultReparseOptions() produces a default set of
options recommended for most uses, based on the translation unit.

Returns 0 if the sources could be reparsed. A non-zero error code will be
returned if reparsing was impossible, such that the translation unit is
invalid. In such cases, the only valid call for TU is
clang_disposeTranslationUnit(TU). The error codes returned by this
routine are described by the CXErrorCode enum.
package clang
import "C"
import (
	"reflect"
	"unsafe"
)
type TranslationUnit struct {
	c C.CXTranslationUnit
}
func (tu TranslationUnit) IsFileMultipleIncludeGuarded(file File) bool {
	o := C.clang_isFileMultipleIncludeGuarded(tu.c, file.c)
	return o != C.uint(0)
}
func (tu TranslationUnit) File(fileName string) File {
	c_fileName := C.CString(fileName)
	defer C.free(unsafe.Pointer(c_fileName))
	return File{C.clang_getFile(tu.c, c_fileName)}
}
func (tu TranslationUnit) Location(file File, line uint32, column uint32) SourceLocation {
	return SourceLocation{C.clang_getLocation(tu.c, file.c, C.uint(line), C.uint(column))}
}
func (tu TranslationUnit) LocationForOffset(file File, offset uint32) SourceLocation {
	return SourceLocation{C.clang_getLocationForOffset(tu.c, file.c, C.uint(offset))}
}
func (tu TranslationUnit) SkippedRanges(file File) *SourceRangeList {
	o := C.clang_getSkippedRanges(tu.c, file.c)
	var gop_o *SourceRangeList
	if o != nil {
		gop_o = &SourceRangeList{*o}
	}
	return gop_o
}
func (tu TranslationUnit) NumDiagnostics() uint32 {
	return uint32(C.clang_getNumDiagnostics(tu.c))
}
func (tu TranslationUnit) Diagnostic(index uint32) Diagnostic {
	return Diagnostic{C.clang_getDiagnostic(tu.c, C.uint(index))}
}
func (tu TranslationUnit) DiagnosticSetFromTU() DiagnosticSet {
	return DiagnosticSet{C.clang_getDiagnosticSetFromTU(tu.c)}
}
func (tu TranslationUnit) Spelling() string {
	o := cxstring{C.clang_getTranslationUnitSpelling(tu.c)}
	defer o.Dispose()
	return o.String()
}
func (tu TranslationUnit) DefaultSaveOptions() uint32 {
	return uint32(C.clang_defaultSaveOptions(tu.c))
}
func (tu TranslationUnit) SaveTranslationUnit(fileName string, options uint32) int32 {
	c_fileName := C.CString(fileName)
	defer C.free(unsafe.Pointer(c_fileName))
	return int32(C.clang_saveTranslationUnit(tu.c, c_fileName, C.uint(options)))
}
func (tu TranslationUnit) Dispose() {
	C.clang_disposeTranslationUnit(tu.c)
}
func (tu TranslationUnit) DefaultReparseOptions() uint32 {
	return uint32(C.clang_defaultReparseOptions(tu.c))
}