...
  
  Package format
	
	
		
		
		
		
			
				
			
			
				
				
Package format implements standard formatting of Go source.
Note that formatting of Go source code changes over time, so tools relying on
consistent formatting should execute a specific version of the gofmt binary
instead of using this package. That way, the formatting will be stable, and
the tools won't need to be recompiled each time gofmt changes.
For example, pre-submit checks that use this package directly would behave
differently depending on what Go version each developer uses, causing the
check to be inherently fragile.
			 
		 
		
		
		
		
			
		
 
		
			
                        
                          In the call graph viewer below, each node
                          is a function belonging to this package
                          and its children are the functions it
                          calls—perhaps dynamically.
                        
                        
                          The root nodes are the entry points of the
                          package: functions that may be called from
                          outside the package.  
                          There may be non-exported or anonymous
                          functions among them if they are called
                          dynamically from another package.
                        
                        
                          Click a node to visit that function's source code.
                          From there you can visit its callers by
                          clicking its declaring func
                          token.
                        
                        
                          Functions may be omitted if they were
                          determined to be unreachable in the
                          particular programs or tests that were
                          analyzed.
                        
                        
                        
                                                
		 
		  
		
		
		
			
			
			
			func Node(dst io.Writer, fset *token.FileSet, node interface{}) error
			
Node formats node in canonical gofmt style and writes the result to dst.
The node type must be *ast.File, *printer.CommentedNode, []ast.Decl,
[]ast.Stmt, or assignment-compatible to ast.Expr, ast.Decl, ast.Spec,
or ast.Stmt. Node does not modify node. Imports are not sorted for
nodes representing partial source files (for instance, if the node is
not an *ast.File or a *printer.CommentedNode not wrapping an *ast.File).
The function may return early (before the entire result is written)
and return a formatting error, for instance due to an incorrect AST.
			
			
		
			
			
			
			func Source(src []byte) ([]byte, error)
			
Source formats src in canonical gofmt style and returns the result
or an (I/O or syntax) error. src is expected to be a syntactically
correct Go source file, or a list of Go declarations or statements.
If src is a partial source file, the leading and trailing space of src
is applied to the result (such that it has the same leading and trailing
space as src), and the result is indented by the same amount as the first
line of src containing code. Imports are not sorted for partial source files.