Source: internal.go in package go/format

TODO(gri): This file and the file src/cmd/gofmt/internal.go are the same (but for this comment and the package name). Do not modify one without the other. Determine if we can factor out functionality in a public API. See also #11844 for context.


package format

import (
	"bytes"
	"go/ast"
	"go/parser"
	"go/printer"
	"go/token"
	"strings"
)

parse parses src, which was read from the named file, as a Go source file, declaration, or statement list.

func parse(fset *token.FileSet, filename string, src []byte, fragmentOk bool) (
	file *ast.File,
	sourceAdj func(src []byte, indent int) []byte,
	indentAdj int,
	err error,

Try as whole source file.

If there's no error, return. If the error is that the source file didn't begin with a package line and source fragments are ok, fall through to try as a source fragment. Stop and return on any other error.

	if err == nil || !fragmentOk || !strings.Contains(err.Error(), "expected 'package'") {
		return
	}

If this is a declaration list, make it a source file by inserting a package clause. Insert using a ';', not a newline, so that the line numbers in psrc match the ones in src.

	psrc := append([]byte("package p;"), src...)
	file, err = parser.ParseFile(fset, filename, psrc, parserMode)
	if err == nil {

Remove the package clause. Gofmt has turned the ';' into a '\n'.

			src = src[indent+len("package p\n"):]
			return bytes.TrimSpace(src)
		}
		return

If the error is that the source file didn't begin with a declaration, fall through to try as a statement list. Stop and return on any other error.

	if !strings.Contains(err.Error(), "expected declaration") {
		return
	}

If this is a statement list, make it a source file by inserting a package clause and turning the list into a function body. This handles expressions too. Insert using a ';', not a newline, so that the line numbers in fsrc match the ones in src. Add an extra '\n' before the '}' to make sure comments are flushed before the '}'.

	fsrc := append(append([]byte("package p; func _() {"), src...), '\n', '\n', '}')
	file, err = parser.ParseFile(fset, filename, fsrc, parserMode)
	if err == nil {

Cap adjusted indent to zero.

			if indent < 0 {
				indent = 0

Remove the wrapping. Gofmt has turned the "; " into a "\n\n". There will be two non-blank lines with indent, hence 2*indent.

Remove only the "}\n" suffix: remaining whitespaces will be trimmed anyway

			src = src[:len(src)-len("}\n")]
			return bytes.TrimSpace(src)

Gofmt has also indented the function body one level. Adjust that with indentAdj.

		indentAdj = -1
	}

Succeeded, or out of options.

	return
}

format formats the given package file originally obtained from src and adjusts the result based on the original source via sourceAdj and indentAdj.

func format(
	fset *token.FileSet,
	file *ast.File,
	sourceAdj func(src []byte, indent int) []byte,
	indentAdj int,
	src []byte,
	cfg printer.Config,
) ([]byte, error) {

Complete source file.

		var buf bytes.Buffer
		err := cfg.Fprint(&buf, fset, file)
		if err != nil {
			return nil, err
		}
		return buf.Bytes(), nil
	}

Partial source file. Determine and prepend leading space.

	i, j := 0, 0
	for j < len(src) && isSpace(src[j]) {
		if src[j] == '\n' {
			i = j + 1 // byte offset of last line in leading space
		}
		j++
	}
	var res []byte
	res = append(res, src[:i]...)

Determine and prepend indentation of first code line. Spaces are ignored unless there are no tabs, in which case spaces count as one tab.

	indent := 0
	hasSpace := false
	for _, b := range src[i:j] {
		switch b {
		case ' ':
			hasSpace = true
		case '\t':
			indent++
		}
	}
	if indent == 0 && hasSpace {
		indent = 1
	}
	for i := 0; i < indent; i++ {
		res = append(res, '\t')
	}

Format the source. Write it without any leading and trailing space.

	cfg.Indent = indent + indentAdj
	var buf bytes.Buffer
	err := cfg.Fprint(&buf, fset, file)
	if err != nil {
		return nil, err
	}
	out := sourceAdj(buf.Bytes(), cfg.Indent)

If the adjusted output is empty, the source was empty but (possibly) for white space. The result is the incoming source.

	if len(out) == 0 {
		return src, nil
	}

Otherwise, append output to leading space.

	res = append(res, out...)

Determine and append trailing space.

	i = len(src)
	for i > 0 && isSpace(src[i-1]) {
		i--
	}
	return append(res, src[i:]...), nil
}

isSpace reports whether the byte is a space character. isSpace defines a space as being among the following bytes: ' ', '\t', '\n' and '\r'.

func isSpace(b byte) bool {
	return b == ' ' || b == '\t' || b == '\n' || b == '\r'