Source file src/go/printer/printer_test.go

Documentation: go/printer

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package printer
     6  
     7  import (
     8  	"bytes"
     9  	"errors"
    10  	"flag"
    11  	"fmt"
    12  	"go/ast"
    13  	"go/internal/typeparams"
    14  	"go/parser"
    15  	"go/token"
    16  	"io"
    17  	"os"
    18  	"path/filepath"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  const (
    24  	dataDir  = "testdata"
    25  	tabwidth = 8
    26  )
    27  
    28  var update = flag.Bool("update", false, "update golden files")
    29  
    30  var fset = token.NewFileSet()
    31  
    32  type checkMode uint
    33  
    34  const (
    35  	export checkMode = 1 << iota
    36  	rawFormat
    37  	normNumber
    38  	idempotent
    39  	allowTypeParams
    40  )
    41  
    42  // format parses src, prints the corresponding AST, verifies the resulting
    43  // src is syntactically correct, and returns the resulting src or an error
    44  // if any.
    45  func format(src []byte, mode checkMode) ([]byte, error) {
    46  	// parse src
    47  	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
    48  	if err != nil {
    49  		return nil, fmt.Errorf("parse: %s\n%s", err, src)
    50  	}
    51  
    52  	// filter exports if necessary
    53  	if mode&export != 0 {
    54  		ast.FileExports(f) // ignore result
    55  		f.Comments = nil   // don't print comments that are not in AST
    56  	}
    57  
    58  	// determine printer configuration
    59  	cfg := Config{Tabwidth: tabwidth}
    60  	if mode&rawFormat != 0 {
    61  		cfg.Mode |= RawFormat
    62  	}
    63  	if mode&normNumber != 0 {
    64  		cfg.Mode |= normalizeNumbers
    65  	}
    66  
    67  	// print AST
    68  	var buf bytes.Buffer
    69  	if err := cfg.Fprint(&buf, fset, f); err != nil {
    70  		return nil, fmt.Errorf("print: %s", err)
    71  	}
    72  
    73  	// make sure formatted output is syntactically correct
    74  	res := buf.Bytes()
    75  	if _, err := parser.ParseFile(fset, "", res, parser.ParseComments); err != nil {
    76  		return nil, fmt.Errorf("re-parse: %s\n%s", err, buf.Bytes())
    77  	}
    78  
    79  	return res, nil
    80  }
    81  
    82  // lineAt returns the line in text starting at offset offs.
    83  func lineAt(text []byte, offs int) []byte {
    84  	i := offs
    85  	for i < len(text) && text[i] != '\n' {
    86  		i++
    87  	}
    88  	return text[offs:i]
    89  }
    90  
    91  // diff compares a and b.
    92  func diff(aname, bname string, a, b []byte) error {
    93  	if bytes.Equal(a, b) {
    94  		return nil
    95  	}
    96  
    97  	var buf bytes.Buffer // holding long error message
    98  	// compare lengths
    99  	if len(a) != len(b) {
   100  		fmt.Fprintf(&buf, "\nlength changed: len(%s) = %d, len(%s) = %d", aname, len(a), bname, len(b))
   101  	}
   102  
   103  	// compare contents
   104  	line := 1
   105  	offs := 0
   106  	for i := 0; i < len(a) && i < len(b); i++ {
   107  		ch := a[i]
   108  		if ch != b[i] {
   109  			fmt.Fprintf(&buf, "\n%s:%d:%d: %s", aname, line, i-offs+1, lineAt(a, offs))
   110  			fmt.Fprintf(&buf, "\n%s:%d:%d: %s", bname, line, i-offs+1, lineAt(b, offs))
   111  			fmt.Fprintf(&buf, "\n\n")
   112  			break
   113  		}
   114  		if ch == '\n' {
   115  			line++
   116  			offs = i + 1
   117  		}
   118  	}
   119  
   120  	fmt.Fprintf(&buf, "\n%s:\n%s\n%s:\n%s", aname, a, bname, b)
   121  	return errors.New(buf.String())
   122  }
   123  
   124  func runcheck(t *testing.T, source, golden string, mode checkMode) {
   125  	src, err := os.ReadFile(source)
   126  	if err != nil {
   127  		t.Error(err)
   128  		return
   129  	}
   130  
   131  	res, err := format(src, mode)
   132  	if err != nil {
   133  		t.Error(err)
   134  		return
   135  	}
   136  
   137  	// update golden files if necessary
   138  	if *update {
   139  		if err := os.WriteFile(golden, res, 0644); err != nil {
   140  			t.Error(err)
   141  		}
   142  		return
   143  	}
   144  
   145  	// get golden
   146  	gld, err := os.ReadFile(golden)
   147  	if err != nil {
   148  		t.Error(err)
   149  		return
   150  	}
   151  
   152  	// formatted source and golden must be the same
   153  	if err := diff(source, golden, res, gld); err != nil {
   154  		t.Error(err)
   155  		return
   156  	}
   157  
   158  	if mode&idempotent != 0 {
   159  		// formatting golden must be idempotent
   160  		// (This is very difficult to achieve in general and for now
   161  		// it is only checked for files explicitly marked as such.)
   162  		res, err = format(gld, mode)
   163  		if err != nil {
   164  			t.Error(err)
   165  			return
   166  		}
   167  		if err := diff(golden, fmt.Sprintf("format(%s)", golden), gld, res); err != nil {
   168  			t.Errorf("golden is not idempotent: %s", err)
   169  		}
   170  	}
   171  }
   172  
   173  func check(t *testing.T, source, golden string, mode checkMode) {
   174  	// run the test
   175  	cc := make(chan int, 1)
   176  	go func() {
   177  		runcheck(t, source, golden, mode)
   178  		cc <- 0
   179  	}()
   180  
   181  	// wait with timeout
   182  	select {
   183  	case <-time.After(10 * time.Second): // plenty of a safety margin, even for very slow machines
   184  		// test running past time out
   185  		t.Errorf("%s: running too slowly", source)
   186  	case <-cc:
   187  		// test finished within allotted time margin
   188  	}
   189  }
   190  
   191  type entry struct {
   192  	source, golden string
   193  	mode           checkMode
   194  }
   195  
   196  // Use go test -update to create/update the respective golden files.
   197  var data = []entry{
   198  	{"empty.input", "empty.golden", idempotent},
   199  	{"comments.input", "comments.golden", 0},
   200  	{"comments.input", "comments.x", export},
   201  	{"comments2.input", "comments2.golden", idempotent},
   202  	{"alignment.input", "alignment.golden", idempotent},
   203  	{"linebreaks.input", "linebreaks.golden", idempotent},
   204  	{"expressions.input", "expressions.golden", idempotent},
   205  	{"expressions.input", "expressions.raw", rawFormat | idempotent},
   206  	{"declarations.input", "declarations.golden", 0},
   207  	{"statements.input", "statements.golden", 0},
   208  	{"slow.input", "slow.golden", idempotent},
   209  	{"complit.input", "complit.x", export},
   210  	{"go2numbers.input", "go2numbers.golden", idempotent},
   211  	{"go2numbers.input", "go2numbers.norm", normNumber | idempotent},
   212  	{"generics.input", "generics.golden", idempotent | allowTypeParams},
   213  	{"gobuild1.input", "gobuild1.golden", idempotent},
   214  	{"gobuild2.input", "gobuild2.golden", idempotent},
   215  	{"gobuild3.input", "gobuild3.golden", idempotent},
   216  	{"gobuild4.input", "gobuild4.golden", idempotent},
   217  	{"gobuild5.input", "gobuild5.golden", idempotent},
   218  	{"gobuild6.input", "gobuild6.golden", idempotent},
   219  	{"gobuild7.input", "gobuild7.golden", idempotent},
   220  }
   221  
   222  func TestFiles(t *testing.T) {
   223  	t.Parallel()
   224  	for _, e := range data {
   225  		if !typeparams.Enabled && e.mode&allowTypeParams != 0 {
   226  			continue
   227  		}
   228  		source := filepath.Join(dataDir, e.source)
   229  		golden := filepath.Join(dataDir, e.golden)
   230  		mode := e.mode
   231  		t.Run(e.source, func(t *testing.T) {
   232  			t.Parallel()
   233  			check(t, source, golden, mode)
   234  			// TODO(gri) check that golden is idempotent
   235  			//check(t, golden, golden, e.mode)
   236  		})
   237  	}
   238  }
   239  
   240  // TestLineComments, using a simple test case, checks that consecutive line
   241  // comments are properly terminated with a newline even if the AST position
   242  // information is incorrect.
   243  //
   244  func TestLineComments(t *testing.T) {
   245  	const src = `// comment 1
   246  	// comment 2
   247  	// comment 3
   248  	package main
   249  	`
   250  
   251  	fset := token.NewFileSet()
   252  	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
   253  	if err != nil {
   254  		panic(err) // error in test
   255  	}
   256  
   257  	var buf bytes.Buffer
   258  	fset = token.NewFileSet() // use the wrong file set
   259  	Fprint(&buf, fset, f)
   260  
   261  	nlines := 0
   262  	for _, ch := range buf.Bytes() {
   263  		if ch == '\n' {
   264  			nlines++
   265  		}
   266  	}
   267  
   268  	const expected = 3
   269  	if nlines < expected {
   270  		t.Errorf("got %d, expected %d\n", nlines, expected)
   271  		t.Errorf("result:\n%s", buf.Bytes())
   272  	}
   273  }
   274  
   275  // Verify that the printer can be invoked during initialization.
   276  func init() {
   277  	const name = "foobar"
   278  	var buf bytes.Buffer
   279  	if err := Fprint(&buf, fset, &ast.Ident{Name: name}); err != nil {
   280  		panic(err) // error in test
   281  	}
   282  	// in debug mode, the result contains additional information;
   283  	// ignore it
   284  	if s := buf.String(); !debug && s != name {
   285  		panic("got " + s + ", want " + name)
   286  	}
   287  }
   288  
   289  // Verify that the printer doesn't crash if the AST contains BadXXX nodes.
   290  func TestBadNodes(t *testing.T) {
   291  	const src = "package p\n("
   292  	const res = "package p\nBadDecl\n"
   293  	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
   294  	if err == nil {
   295  		t.Error("expected illegal program") // error in test
   296  	}
   297  	var buf bytes.Buffer
   298  	Fprint(&buf, fset, f)
   299  	if buf.String() != res {
   300  		t.Errorf("got %q, expected %q", buf.String(), res)
   301  	}
   302  }
   303  
   304  // testComment verifies that f can be parsed again after printing it
   305  // with its first comment set to comment at any possible source offset.
   306  func testComment(t *testing.T, f *ast.File, srclen int, comment *ast.Comment) {
   307  	f.Comments[0].List[0] = comment
   308  	var buf bytes.Buffer
   309  	for offs := 0; offs <= srclen; offs++ {
   310  		buf.Reset()
   311  		// Printing f should result in a correct program no
   312  		// matter what the (incorrect) comment position is.
   313  		if err := Fprint(&buf, fset, f); err != nil {
   314  			t.Error(err)
   315  		}
   316  		if _, err := parser.ParseFile(fset, "", buf.Bytes(), 0); err != nil {
   317  			t.Fatalf("incorrect program for pos = %d:\n%s", comment.Slash, buf.String())
   318  		}
   319  		// Position information is just an offset.
   320  		// Move comment one byte down in the source.
   321  		comment.Slash++
   322  	}
   323  }
   324  
   325  // Verify that the printer produces a correct program
   326  // even if the position information of comments introducing newlines
   327  // is incorrect.
   328  func TestBadComments(t *testing.T) {
   329  	t.Parallel()
   330  	const src = `
   331  // first comment - text and position changed by test
   332  package p
   333  import "fmt"
   334  const pi = 3.14 // rough circle
   335  var (
   336  	x, y, z int = 1, 2, 3
   337  	u, v float64
   338  )
   339  func fibo(n int) {
   340  	if n < 2 {
   341  		return n /* seed values */
   342  	}
   343  	return fibo(n-1) + fibo(n-2)
   344  }
   345  `
   346  
   347  	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
   348  	if err != nil {
   349  		t.Error(err) // error in test
   350  	}
   351  
   352  	comment := f.Comments[0].List[0]
   353  	pos := comment.Pos()
   354  	if fset.PositionFor(pos, false /* absolute position */).Offset != 1 {
   355  		t.Error("expected offset 1") // error in test
   356  	}
   357  
   358  	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "//-style comment"})
   359  	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "/*-style comment */"})
   360  	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "/*-style \n comment */"})
   361  	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "/*-style comment \n\n\n */"})
   362  }
   363  
   364  type visitor chan *ast.Ident
   365  
   366  func (v visitor) Visit(n ast.Node) (w ast.Visitor) {
   367  	if ident, ok := n.(*ast.Ident); ok {
   368  		v <- ident
   369  	}
   370  	return v
   371  }
   372  
   373  // idents is an iterator that returns all idents in f via the result channel.
   374  func idents(f *ast.File) <-chan *ast.Ident {
   375  	v := make(visitor)
   376  	go func() {
   377  		ast.Walk(v, f)
   378  		close(v)
   379  	}()
   380  	return v
   381  }
   382  
   383  // identCount returns the number of identifiers found in f.
   384  func identCount(f *ast.File) int {
   385  	n := 0
   386  	for range idents(f) {
   387  		n++
   388  	}
   389  	return n
   390  }
   391  
   392  // Verify that the SourcePos mode emits correct //line directives
   393  // by testing that position information for matching identifiers
   394  // is maintained.
   395  func TestSourcePos(t *testing.T) {
   396  	const src = `
   397  package p
   398  import ( "go/printer"; "math" )
   399  const pi = 3.14; var x = 0
   400  type t struct{ x, y, z int; u, v, w float32 }
   401  func (t *t) foo(a, b, c int) int {
   402  	return a*t.x + b*t.y +
   403  		// two extra lines here
   404  		// ...
   405  		c*t.z
   406  }
   407  `
   408  
   409  	// parse original
   410  	f1, err := parser.ParseFile(fset, "src", src, parser.ParseComments)
   411  	if err != nil {
   412  		t.Fatal(err)
   413  	}
   414  
   415  	// pretty-print original
   416  	var buf bytes.Buffer
   417  	err = (&Config{Mode: UseSpaces | SourcePos, Tabwidth: 8}).Fprint(&buf, fset, f1)
   418  	if err != nil {
   419  		t.Fatal(err)
   420  	}
   421  
   422  	// parse pretty printed original
   423  	// (//line directives must be interpreted even w/o parser.ParseComments set)
   424  	f2, err := parser.ParseFile(fset, "", buf.Bytes(), 0)
   425  	if err != nil {
   426  		t.Fatalf("%s\n%s", err, buf.Bytes())
   427  	}
   428  
   429  	// At this point the position information of identifiers in f2 should
   430  	// match the position information of corresponding identifiers in f1.
   431  
   432  	// number of identifiers must be > 0 (test should run) and must match
   433  	n1 := identCount(f1)
   434  	n2 := identCount(f2)
   435  	if n1 == 0 {
   436  		t.Fatal("got no idents")
   437  	}
   438  	if n2 != n1 {
   439  		t.Errorf("got %d idents; want %d", n2, n1)
   440  	}
   441  
   442  	// verify that all identifiers have correct line information
   443  	i2range := idents(f2)
   444  	for i1 := range idents(f1) {
   445  		i2 := <-i2range
   446  
   447  		if i2.Name != i1.Name {
   448  			t.Errorf("got ident %s; want %s", i2.Name, i1.Name)
   449  		}
   450  
   451  		// here we care about the relative (line-directive adjusted) positions
   452  		l1 := fset.Position(i1.Pos()).Line
   453  		l2 := fset.Position(i2.Pos()).Line
   454  		if l2 != l1 {
   455  			t.Errorf("got line %d; want %d for %s", l2, l1, i1.Name)
   456  		}
   457  	}
   458  
   459  	if t.Failed() {
   460  		t.Logf("\n%s", buf.Bytes())
   461  	}
   462  }
   463  
   464  // Verify that the SourcePos mode doesn't emit unnecessary //line directives
   465  // before empty lines.
   466  func TestIssue5945(t *testing.T) {
   467  	const orig = `
   468  package p   // line 2
   469  func f() {} // line 3
   470  
   471  var x, y, z int
   472  
   473  
   474  func g() { // line 8
   475  }
   476  `
   477  
   478  	const want = `//line src.go:2
   479  package p
   480  
   481  //line src.go:3
   482  func f() {}
   483  
   484  var x, y, z int
   485  
   486  //line src.go:8
   487  func g() {
   488  }
   489  `
   490  
   491  	// parse original
   492  	f1, err := parser.ParseFile(fset, "src.go", orig, 0)
   493  	if err != nil {
   494  		t.Fatal(err)
   495  	}
   496  
   497  	// pretty-print original
   498  	var buf bytes.Buffer
   499  	err = (&Config{Mode: UseSpaces | SourcePos, Tabwidth: 8}).Fprint(&buf, fset, f1)
   500  	if err != nil {
   501  		t.Fatal(err)
   502  	}
   503  	got := buf.String()
   504  
   505  	// compare original with desired output
   506  	if got != want {
   507  		t.Errorf("got:\n%s\nwant:\n%s\n", got, want)
   508  	}
   509  }
   510  
   511  var decls = []string{
   512  	`import "fmt"`,
   513  	"const pi = 3.1415\nconst e = 2.71828\n\nvar x = pi",
   514  	"func sum(x, y int) int\t{ return x + y }",
   515  }
   516  
   517  func TestDeclLists(t *testing.T) {
   518  	for _, src := range decls {
   519  		file, err := parser.ParseFile(fset, "", "package p;"+src, parser.ParseComments)
   520  		if err != nil {
   521  			panic(err) // error in test
   522  		}
   523  
   524  		var buf bytes.Buffer
   525  		err = Fprint(&buf, fset, file.Decls) // only print declarations
   526  		if err != nil {
   527  			panic(err) // error in test
   528  		}
   529  
   530  		out := buf.String()
   531  		if out != src {
   532  			t.Errorf("\ngot : %q\nwant: %q\n", out, src)
   533  		}
   534  	}
   535  }
   536  
   537  var stmts = []string{
   538  	"i := 0",
   539  	"select {}\nvar a, b = 1, 2\nreturn a + b",
   540  	"go f()\ndefer func() {}()",
   541  }
   542  
   543  func TestStmtLists(t *testing.T) {
   544  	for _, src := range stmts {
   545  		file, err := parser.ParseFile(fset, "", "package p; func _() {"+src+"}", parser.ParseComments)
   546  		if err != nil {
   547  			panic(err) // error in test
   548  		}
   549  
   550  		var buf bytes.Buffer
   551  		err = Fprint(&buf, fset, file.Decls[0].(*ast.FuncDecl).Body.List) // only print statements
   552  		if err != nil {
   553  			panic(err) // error in test
   554  		}
   555  
   556  		out := buf.String()
   557  		if out != src {
   558  			t.Errorf("\ngot : %q\nwant: %q\n", out, src)
   559  		}
   560  	}
   561  }
   562  
   563  func TestBaseIndent(t *testing.T) {
   564  	t.Parallel()
   565  	// The testfile must not contain multi-line raw strings since those
   566  	// are not indented (because their values must not change) and make
   567  	// this test fail.
   568  	const filename = "printer.go"
   569  	src, err := os.ReadFile(filename)
   570  	if err != nil {
   571  		panic(err) // error in test
   572  	}
   573  
   574  	file, err := parser.ParseFile(fset, filename, src, 0)
   575  	if err != nil {
   576  		panic(err) // error in test
   577  	}
   578  
   579  	for indent := 0; indent < 4; indent++ {
   580  		indent := indent
   581  		t.Run(fmt.Sprint(indent), func(t *testing.T) {
   582  			t.Parallel()
   583  			var buf bytes.Buffer
   584  			(&Config{Tabwidth: tabwidth, Indent: indent}).Fprint(&buf, fset, file)
   585  			// all code must be indented by at least 'indent' tabs
   586  			lines := bytes.Split(buf.Bytes(), []byte{'\n'})
   587  			for i, line := range lines {
   588  				if len(line) == 0 {
   589  					continue // empty lines don't have indentation
   590  				}
   591  				n := 0
   592  				for j, b := range line {
   593  					if b != '\t' {
   594  						// end of indentation
   595  						n = j
   596  						break
   597  					}
   598  				}
   599  				if n < indent {
   600  					t.Errorf("line %d: got only %d tabs; want at least %d: %q", i, n, indent, line)
   601  				}
   602  			}
   603  		})
   604  	}
   605  }
   606  
   607  // TestFuncType tests that an ast.FuncType with a nil Params field
   608  // can be printed (per go/ast specification). Test case for issue 3870.
   609  func TestFuncType(t *testing.T) {
   610  	src := &ast.File{
   611  		Name: &ast.Ident{Name: "p"},
   612  		Decls: []ast.Decl{
   613  			&ast.FuncDecl{
   614  				Name: &ast.Ident{Name: "f"},
   615  				Type: &ast.FuncType{},
   616  			},
   617  		},
   618  	}
   619  
   620  	var buf bytes.Buffer
   621  	if err := Fprint(&buf, fset, src); err != nil {
   622  		t.Fatal(err)
   623  	}
   624  	got := buf.String()
   625  
   626  	const want = `package p
   627  
   628  func f()
   629  `
   630  
   631  	if got != want {
   632  		t.Fatalf("got:\n%s\nwant:\n%s\n", got, want)
   633  	}
   634  }
   635  
   636  type limitWriter struct {
   637  	remaining int
   638  	errCount  int
   639  }
   640  
   641  func (l *limitWriter) Write(buf []byte) (n int, err error) {
   642  	n = len(buf)
   643  	if n >= l.remaining {
   644  		n = l.remaining
   645  		err = io.EOF
   646  		l.errCount++
   647  	}
   648  	l.remaining -= n
   649  	return n, err
   650  }
   651  
   652  // Test whether the printer stops writing after the first error
   653  func TestWriteErrors(t *testing.T) {
   654  	t.Parallel()
   655  	const filename = "printer.go"
   656  	src, err := os.ReadFile(filename)
   657  	if err != nil {
   658  		panic(err) // error in test
   659  	}
   660  	file, err := parser.ParseFile(fset, filename, src, 0)
   661  	if err != nil {
   662  		panic(err) // error in test
   663  	}
   664  	for i := 0; i < 20; i++ {
   665  		lw := &limitWriter{remaining: i}
   666  		err := (&Config{Mode: RawFormat}).Fprint(lw, fset, file)
   667  		if lw.errCount > 1 {
   668  			t.Fatal("Writes continued after first error returned")
   669  		}
   670  		// We expect errCount be 1 iff err is set
   671  		if (lw.errCount != 0) != (err != nil) {
   672  			t.Fatal("Expected err when errCount != 0")
   673  		}
   674  	}
   675  }
   676  
   677  // TextX is a skeleton test that can be filled in for debugging one-off cases.
   678  // Do not remove.
   679  func TestX(t *testing.T) {
   680  	const src = `
   681  package p
   682  func _() {}
   683  `
   684  	_, err := format([]byte(src), 0)
   685  	if err != nil {
   686  		t.Error(err)
   687  	}
   688  }
   689  
   690  func TestCommentedNode(t *testing.T) {
   691  	const (
   692  		input = `package main
   693  
   694  func foo() {
   695  	// comment inside func
   696  }
   697  
   698  // leading comment
   699  type bar int // comment2
   700  
   701  `
   702  
   703  		foo = `func foo() {
   704  	// comment inside func
   705  }`
   706  
   707  		bar = `// leading comment
   708  type bar int	// comment2
   709  `
   710  	)
   711  
   712  	fset := token.NewFileSet()
   713  	f, err := parser.ParseFile(fset, "input.go", input, parser.ParseComments)
   714  	if err != nil {
   715  		t.Fatal(err)
   716  	}
   717  
   718  	var buf bytes.Buffer
   719  
   720  	err = Fprint(&buf, fset, &CommentedNode{Node: f.Decls[0], Comments: f.Comments})
   721  	if err != nil {
   722  		t.Fatal(err)
   723  	}
   724  
   725  	if buf.String() != foo {
   726  		t.Errorf("got %q, want %q", buf.String(), foo)
   727  	}
   728  
   729  	buf.Reset()
   730  
   731  	err = Fprint(&buf, fset, &CommentedNode{Node: f.Decls[1], Comments: f.Comments})
   732  	if err != nil {
   733  		t.Fatal(err)
   734  	}
   735  
   736  	if buf.String() != bar {
   737  		t.Errorf("got %q, want %q", buf.String(), bar)
   738  	}
   739  }
   740  
   741  func TestIssue11151(t *testing.T) {
   742  	const src = "package p\t/*\r/1\r*\r/2*\r\r\r\r/3*\r\r+\r\r/4*/\n"
   743  	fset := token.NewFileSet()
   744  	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
   745  	if err != nil {
   746  		t.Fatal(err)
   747  	}
   748  
   749  	var buf bytes.Buffer
   750  	Fprint(&buf, fset, f)
   751  	got := buf.String()
   752  	const want = "package p\t/*/1*\r/2*\r/3*+/4*/\n" // \r following opening /* should be stripped
   753  	if got != want {
   754  		t.Errorf("\ngot : %q\nwant: %q", got, want)
   755  	}
   756  
   757  	// the resulting program must be valid
   758  	_, err = parser.ParseFile(fset, "", got, 0)
   759  	if err != nil {
   760  		t.Errorf("%v\norig: %q\ngot : %q", err, src, got)
   761  	}
   762  }
   763  
   764  // If a declaration has multiple specifications, a parenthesized
   765  // declaration must be printed even if Lparen is token.NoPos.
   766  func TestParenthesizedDecl(t *testing.T) {
   767  	// a package with multiple specs in a single declaration
   768  	const src = "package p; var ( a float64; b int )"
   769  	fset := token.NewFileSet()
   770  	f, err := parser.ParseFile(fset, "", src, 0)
   771  	if err != nil {
   772  		t.Fatal(err)
   773  	}
   774  
   775  	// print the original package
   776  	var buf bytes.Buffer
   777  	err = Fprint(&buf, fset, f)
   778  	if err != nil {
   779  		t.Fatal(err)
   780  	}
   781  	original := buf.String()
   782  
   783  	// now remove parentheses from the declaration
   784  	for i := 0; i != len(f.Decls); i++ {
   785  		f.Decls[i].(*ast.GenDecl).Lparen = token.NoPos
   786  	}
   787  	buf.Reset()
   788  	err = Fprint(&buf, fset, f)
   789  	if err != nil {
   790  		t.Fatal(err)
   791  	}
   792  	noparen := buf.String()
   793  
   794  	if noparen != original {
   795  		t.Errorf("got %q, want %q", noparen, original)
   796  	}
   797  }
   798  
   799  // Verify that we don't print a newline between "return" and its results, as
   800  // that would incorrectly cause a naked return.
   801  func TestIssue32854(t *testing.T) {
   802  	src := `package foo
   803  
   804  func f() {
   805          return Composite{
   806                  call(),
   807          }
   808  }`
   809  	fset := token.NewFileSet()
   810  	file, err := parser.ParseFile(fset, "", src, 0)
   811  	if err != nil {
   812  		panic(err)
   813  	}
   814  
   815  	// Replace the result with call(), which is on the next line.
   816  	fd := file.Decls[0].(*ast.FuncDecl)
   817  	ret := fd.Body.List[0].(*ast.ReturnStmt)
   818  	ret.Results[0] = ret.Results[0].(*ast.CompositeLit).Elts[0]
   819  
   820  	var buf bytes.Buffer
   821  	if err := Fprint(&buf, fset, ret); err != nil {
   822  		t.Fatal(err)
   823  	}
   824  	want := "return call()"
   825  	if got := buf.String(); got != want {
   826  		t.Fatalf("got %q, want %q", got, want)
   827  	}
   828  }
   829  

View as plain text