...
Run Format

Source file src/go/parser/parser_test.go

Documentation: go/parser

     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 parser
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"go/ast"
    11  	"go/token"
    12  	"os"
    13  	"strings"
    14  	"testing"
    15  )
    16  
    17  var validFiles = []string{
    18  	"parser.go",
    19  	"parser_test.go",
    20  	"error_test.go",
    21  	"short_test.go",
    22  }
    23  
    24  func TestParse(t *testing.T) {
    25  	for _, filename := range validFiles {
    26  		_, err := ParseFile(token.NewFileSet(), filename, nil, DeclarationErrors)
    27  		if err != nil {
    28  			t.Fatalf("ParseFile(%s): %v", filename, err)
    29  		}
    30  	}
    31  }
    32  
    33  func nameFilter(filename string) bool {
    34  	switch filename {
    35  	case "parser.go", "interface.go", "parser_test.go":
    36  		return true
    37  	case "parser.go.orig":
    38  		return true // permit but should be ignored by ParseDir
    39  	}
    40  	return false
    41  }
    42  
    43  func dirFilter(f os.FileInfo) bool { return nameFilter(f.Name()) }
    44  
    45  func TestParseDir(t *testing.T) {
    46  	path := "."
    47  	pkgs, err := ParseDir(token.NewFileSet(), path, dirFilter, 0)
    48  	if err != nil {
    49  		t.Fatalf("ParseDir(%s): %v", path, err)
    50  	}
    51  	if n := len(pkgs); n != 1 {
    52  		t.Errorf("got %d packages; want 1", n)
    53  	}
    54  	pkg := pkgs["parser"]
    55  	if pkg == nil {
    56  		t.Errorf(`package "parser" not found`)
    57  		return
    58  	}
    59  	if n := len(pkg.Files); n != 3 {
    60  		t.Errorf("got %d package files; want 3", n)
    61  	}
    62  	for filename := range pkg.Files {
    63  		if !nameFilter(filename) {
    64  			t.Errorf("unexpected package file: %s", filename)
    65  		}
    66  	}
    67  }
    68  
    69  func TestParseExpr(t *testing.T) {
    70  	// just kicking the tires:
    71  	// a valid arithmetic expression
    72  	src := "a + b"
    73  	x, err := ParseExpr(src)
    74  	if err != nil {
    75  		t.Errorf("ParseExpr(%q): %v", src, err)
    76  	}
    77  	// sanity check
    78  	if _, ok := x.(*ast.BinaryExpr); !ok {
    79  		t.Errorf("ParseExpr(%q): got %T, want *ast.BinaryExpr", src, x)
    80  	}
    81  
    82  	// a valid type expression
    83  	src = "struct{x *int}"
    84  	x, err = ParseExpr(src)
    85  	if err != nil {
    86  		t.Errorf("ParseExpr(%q): %v", src, err)
    87  	}
    88  	// sanity check
    89  	if _, ok := x.(*ast.StructType); !ok {
    90  		t.Errorf("ParseExpr(%q): got %T, want *ast.StructType", src, x)
    91  	}
    92  
    93  	// an invalid expression
    94  	src = "a + *"
    95  	if _, err := ParseExpr(src); err == nil {
    96  		t.Errorf("ParseExpr(%q): got no error", src)
    97  	}
    98  
    99  	// a valid expression followed by extra tokens is invalid
   100  	src = "a[i] := x"
   101  	if _, err := ParseExpr(src); err == nil {
   102  		t.Errorf("ParseExpr(%q): got no error", src)
   103  	}
   104  
   105  	// a semicolon is not permitted unless automatically inserted
   106  	src = "a + b\n"
   107  	if _, err := ParseExpr(src); err != nil {
   108  		t.Errorf("ParseExpr(%q): got error %s", src, err)
   109  	}
   110  	src = "a + b;"
   111  	if _, err := ParseExpr(src); err == nil {
   112  		t.Errorf("ParseExpr(%q): got no error", src)
   113  	}
   114  
   115  	// various other stuff following a valid expression
   116  	const validExpr = "a + b"
   117  	const anything = "dh3*#D)#_"
   118  	for _, c := range "!)]};," {
   119  		src := validExpr + string(c) + anything
   120  		if _, err := ParseExpr(src); err == nil {
   121  			t.Errorf("ParseExpr(%q): got no error", src)
   122  		}
   123  	}
   124  
   125  	// ParseExpr must not crash
   126  	for _, src := range valids {
   127  		ParseExpr(src)
   128  	}
   129  }
   130  
   131  func TestColonEqualsScope(t *testing.T) {
   132  	f, err := ParseFile(token.NewFileSet(), "", `package p; func f() { x, y, z := x, y, z }`, 0)
   133  	if err != nil {
   134  		t.Fatal(err)
   135  	}
   136  
   137  	// RHS refers to undefined globals; LHS does not.
   138  	as := f.Decls[0].(*ast.FuncDecl).Body.List[0].(*ast.AssignStmt)
   139  	for _, v := range as.Rhs {
   140  		id := v.(*ast.Ident)
   141  		if id.Obj != nil {
   142  			t.Errorf("rhs %s has Obj, should not", id.Name)
   143  		}
   144  	}
   145  	for _, v := range as.Lhs {
   146  		id := v.(*ast.Ident)
   147  		if id.Obj == nil {
   148  			t.Errorf("lhs %s does not have Obj, should", id.Name)
   149  		}
   150  	}
   151  }
   152  
   153  func TestVarScope(t *testing.T) {
   154  	f, err := ParseFile(token.NewFileSet(), "", `package p; func f() { var x, y, z = x, y, z }`, 0)
   155  	if err != nil {
   156  		t.Fatal(err)
   157  	}
   158  
   159  	// RHS refers to undefined globals; LHS does not.
   160  	as := f.Decls[0].(*ast.FuncDecl).Body.List[0].(*ast.DeclStmt).Decl.(*ast.GenDecl).Specs[0].(*ast.ValueSpec)
   161  	for _, v := range as.Values {
   162  		id := v.(*ast.Ident)
   163  		if id.Obj != nil {
   164  			t.Errorf("rhs %s has Obj, should not", id.Name)
   165  		}
   166  	}
   167  	for _, id := range as.Names {
   168  		if id.Obj == nil {
   169  			t.Errorf("lhs %s does not have Obj, should", id.Name)
   170  		}
   171  	}
   172  }
   173  
   174  func TestObjects(t *testing.T) {
   175  	const src = `
   176  package p
   177  import fmt "fmt"
   178  const pi = 3.14
   179  type T struct{}
   180  var x int
   181  func f() { L: }
   182  `
   183  
   184  	f, err := ParseFile(token.NewFileSet(), "", src, 0)
   185  	if err != nil {
   186  		t.Fatal(err)
   187  	}
   188  
   189  	objects := map[string]ast.ObjKind{
   190  		"p":   ast.Bad, // not in a scope
   191  		"fmt": ast.Bad, // not resolved yet
   192  		"pi":  ast.Con,
   193  		"T":   ast.Typ,
   194  		"x":   ast.Var,
   195  		"int": ast.Bad, // not resolved yet
   196  		"f":   ast.Fun,
   197  		"L":   ast.Lbl,
   198  	}
   199  
   200  	ast.Inspect(f, func(n ast.Node) bool {
   201  		if ident, ok := n.(*ast.Ident); ok {
   202  			obj := ident.Obj
   203  			if obj == nil {
   204  				if objects[ident.Name] != ast.Bad {
   205  					t.Errorf("no object for %s", ident.Name)
   206  				}
   207  				return true
   208  			}
   209  			if obj.Name != ident.Name {
   210  				t.Errorf("names don't match: obj.Name = %s, ident.Name = %s", obj.Name, ident.Name)
   211  			}
   212  			kind := objects[ident.Name]
   213  			if obj.Kind != kind {
   214  				t.Errorf("%s: obj.Kind = %s; want %s", ident.Name, obj.Kind, kind)
   215  			}
   216  		}
   217  		return true
   218  	})
   219  }
   220  
   221  func TestUnresolved(t *testing.T) {
   222  	f, err := ParseFile(token.NewFileSet(), "", `
   223  package p
   224  //
   225  func f1a(int)
   226  func f2a(byte, int, float)
   227  func f3a(a, b int, c float)
   228  func f4a(...complex)
   229  func f5a(a s1a, b ...complex)
   230  //
   231  func f1b(*int)
   232  func f2b([]byte, (int), *float)
   233  func f3b(a, b *int, c []float)
   234  func f4b(...*complex)
   235  func f5b(a s1a, b ...[]complex)
   236  //
   237  type s1a struct { int }
   238  type s2a struct { byte; int; s1a }
   239  type s3a struct { a, b int; c float }
   240  //
   241  type s1b struct { *int }
   242  type s2b struct { byte; int; *float }
   243  type s3b struct { a, b *s3b; c []float }
   244  `, 0)
   245  	if err != nil {
   246  		t.Fatal(err)
   247  	}
   248  
   249  	want := "int " + // f1a
   250  		"byte int float " + // f2a
   251  		"int float " + // f3a
   252  		"complex " + // f4a
   253  		"complex " + // f5a
   254  		//
   255  		"int " + // f1b
   256  		"byte int float " + // f2b
   257  		"int float " + // f3b
   258  		"complex " + // f4b
   259  		"complex " + // f5b
   260  		//
   261  		"int " + // s1a
   262  		"byte int " + // s2a
   263  		"int float " + // s3a
   264  		//
   265  		"int " + // s1a
   266  		"byte int float " + // s2a
   267  		"float " // s3a
   268  
   269  	// collect unresolved identifiers
   270  	var buf bytes.Buffer
   271  	for _, u := range f.Unresolved {
   272  		buf.WriteString(u.Name)
   273  		buf.WriteByte(' ')
   274  	}
   275  	got := buf.String()
   276  
   277  	if got != want {
   278  		t.Errorf("\ngot:  %s\nwant: %s", got, want)
   279  	}
   280  }
   281  
   282  var imports = map[string]bool{
   283  	`"a"`:        true,
   284  	"`a`":        true,
   285  	`"a/b"`:      true,
   286  	`"a.b"`:      true,
   287  	`"m\x61th"`:  true,
   288  	`"greek/αβ"`: true,
   289  	`""`:         false,
   290  
   291  	// Each of these pairs tests both `` vs "" strings
   292  	// and also use of invalid characters spelled out as
   293  	// escape sequences and written directly.
   294  	// For example `"\x00"` tests import "\x00"
   295  	// while "`\x00`" tests import `<actual-NUL-byte>`.
   296  	`"\x00"`:     false,
   297  	"`\x00`":     false,
   298  	`"\x7f"`:     false,
   299  	"`\x7f`":     false,
   300  	`"a!"`:       false,
   301  	"`a!`":       false,
   302  	`"a b"`:      false,
   303  	"`a b`":      false,
   304  	`"a\\b"`:     false,
   305  	"`a\\b`":     false,
   306  	"\"`a`\"":    false,
   307  	"`\"a\"`":    false,
   308  	`"\x80\x80"`: false,
   309  	"`\x80\x80`": false,
   310  	`"\xFFFD"`:   false,
   311  	"`\xFFFD`":   false,
   312  }
   313  
   314  func TestImports(t *testing.T) {
   315  	for path, isValid := range imports {
   316  		src := fmt.Sprintf("package p; import %s", path)
   317  		_, err := ParseFile(token.NewFileSet(), "", src, 0)
   318  		switch {
   319  		case err != nil && isValid:
   320  			t.Errorf("ParseFile(%s): got %v; expected no error", src, err)
   321  		case err == nil && !isValid:
   322  			t.Errorf("ParseFile(%s): got no error; expected one", src)
   323  		}
   324  	}
   325  }
   326  
   327  func TestCommentGroups(t *testing.T) {
   328  	f, err := ParseFile(token.NewFileSet(), "", `
   329  package p /* 1a */ /* 1b */      /* 1c */ // 1d
   330  /* 2a
   331  */
   332  // 2b
   333  const pi = 3.1415
   334  /* 3a */ // 3b
   335  /* 3c */ const e = 2.7182
   336  
   337  // Example from issue 3139
   338  func ExampleCount() {
   339  	fmt.Println(strings.Count("cheese", "e"))
   340  	fmt.Println(strings.Count("five", "")) // before & after each rune
   341  	// Output:
   342  	// 3
   343  	// 5
   344  }
   345  `, ParseComments)
   346  	if err != nil {
   347  		t.Fatal(err)
   348  	}
   349  	expected := [][]string{
   350  		{"/* 1a */", "/* 1b */", "/* 1c */", "// 1d"},
   351  		{"/* 2a\n*/", "// 2b"},
   352  		{"/* 3a */", "// 3b", "/* 3c */"},
   353  		{"// Example from issue 3139"},
   354  		{"// before & after each rune"},
   355  		{"// Output:", "// 3", "// 5"},
   356  	}
   357  	if len(f.Comments) != len(expected) {
   358  		t.Fatalf("got %d comment groups; expected %d", len(f.Comments), len(expected))
   359  	}
   360  	for i, exp := range expected {
   361  		got := f.Comments[i].List
   362  		if len(got) != len(exp) {
   363  			t.Errorf("got %d comments in group %d; expected %d", len(got), i, len(exp))
   364  			continue
   365  		}
   366  		for j, exp := range exp {
   367  			got := got[j].Text
   368  			if got != exp {
   369  				t.Errorf("got %q in group %d; expected %q", got, i, exp)
   370  			}
   371  		}
   372  	}
   373  }
   374  
   375  func getField(file *ast.File, fieldname string) *ast.Field {
   376  	parts := strings.Split(fieldname, ".")
   377  	for _, d := range file.Decls {
   378  		if d, ok := d.(*ast.GenDecl); ok && d.Tok == token.TYPE {
   379  			for _, s := range d.Specs {
   380  				if s, ok := s.(*ast.TypeSpec); ok && s.Name.Name == parts[0] {
   381  					if s, ok := s.Type.(*ast.StructType); ok {
   382  						for _, f := range s.Fields.List {
   383  							for _, name := range f.Names {
   384  								if name.Name == parts[1] {
   385  									return f
   386  								}
   387  							}
   388  						}
   389  					}
   390  				}
   391  			}
   392  		}
   393  	}
   394  	return nil
   395  }
   396  
   397  // Don't use ast.CommentGroup.Text() - we want to see exact comment text.
   398  func commentText(c *ast.CommentGroup) string {
   399  	var buf bytes.Buffer
   400  	if c != nil {
   401  		for _, c := range c.List {
   402  			buf.WriteString(c.Text)
   403  		}
   404  	}
   405  	return buf.String()
   406  }
   407  
   408  func checkFieldComments(t *testing.T, file *ast.File, fieldname, lead, line string) {
   409  	f := getField(file, fieldname)
   410  	if f == nil {
   411  		t.Fatalf("field not found: %s", fieldname)
   412  	}
   413  	if got := commentText(f.Doc); got != lead {
   414  		t.Errorf("got lead comment %q; expected %q", got, lead)
   415  	}
   416  	if got := commentText(f.Comment); got != line {
   417  		t.Errorf("got line comment %q; expected %q", got, line)
   418  	}
   419  }
   420  
   421  func TestLeadAndLineComments(t *testing.T) {
   422  	f, err := ParseFile(token.NewFileSet(), "", `
   423  package p
   424  type T struct {
   425  	/* F1 lead comment */
   426  	//
   427  	F1 int  /* F1 */ // line comment
   428  	// F2 lead
   429  	// comment
   430  	F2 int  // F2 line comment
   431  	// f3 lead comment
   432  	f3 int  // f3 line comment
   433  }
   434  `, ParseComments)
   435  	if err != nil {
   436  		t.Fatal(err)
   437  	}
   438  	checkFieldComments(t, f, "T.F1", "/* F1 lead comment *///", "/* F1 */// line comment")
   439  	checkFieldComments(t, f, "T.F2", "// F2 lead// comment", "// F2 line comment")
   440  	checkFieldComments(t, f, "T.f3", "// f3 lead comment", "// f3 line comment")
   441  	ast.FileExports(f)
   442  	checkFieldComments(t, f, "T.F1", "/* F1 lead comment *///", "/* F1 */// line comment")
   443  	checkFieldComments(t, f, "T.F2", "// F2 lead// comment", "// F2 line comment")
   444  	if getField(f, "T.f3") != nil {
   445  		t.Error("not expected to find T.f3")
   446  	}
   447  }
   448  
   449  // TestIssue9979 verifies that empty statements are contained within their enclosing blocks.
   450  func TestIssue9979(t *testing.T) {
   451  	for _, src := range []string{
   452  		"package p; func f() {;}",
   453  		"package p; func f() {L:}",
   454  		"package p; func f() {L:;}",
   455  		"package p; func f() {L:\n}",
   456  		"package p; func f() {L:\n;}",
   457  		"package p; func f() { ; }",
   458  		"package p; func f() { L: }",
   459  		"package p; func f() { L: ; }",
   460  		"package p; func f() { L: \n}",
   461  		"package p; func f() { L: \n; }",
   462  	} {
   463  		fset := token.NewFileSet()
   464  		f, err := ParseFile(fset, "", src, 0)
   465  		if err != nil {
   466  			t.Fatal(err)
   467  		}
   468  
   469  		var pos, end token.Pos
   470  		ast.Inspect(f, func(x ast.Node) bool {
   471  			switch s := x.(type) {
   472  			case *ast.BlockStmt:
   473  				pos, end = s.Pos()+1, s.End()-1 // exclude "{", "}"
   474  			case *ast.LabeledStmt:
   475  				pos, end = s.Pos()+2, s.End() // exclude "L:"
   476  			case *ast.EmptyStmt:
   477  				// check containment
   478  				if s.Pos() < pos || s.End() > end {
   479  					t.Errorf("%s: %T[%d, %d] not inside [%d, %d]", src, s, s.Pos(), s.End(), pos, end)
   480  				}
   481  				// check semicolon
   482  				offs := fset.Position(s.Pos()).Offset
   483  				if ch := src[offs]; ch != ';' != s.Implicit {
   484  					want := "want ';'"
   485  					if s.Implicit {
   486  						want = "but ';' is implicit"
   487  					}
   488  					t.Errorf("%s: found %q at offset %d; %s", src, ch, offs, want)
   489  				}
   490  			}
   491  			return true
   492  		})
   493  	}
   494  }
   495  
   496  // TestIncompleteSelection ensures that an incomplete selector
   497  // expression is parsed as a (blank) *ast.SelectorExpr, not a
   498  // *ast.BadExpr.
   499  func TestIncompleteSelection(t *testing.T) {
   500  	for _, src := range []string{
   501  		"package p; var _ = fmt.",             // at EOF
   502  		"package p; var _ = fmt.\ntype X int", // not at EOF
   503  	} {
   504  		fset := token.NewFileSet()
   505  		f, err := ParseFile(fset, "", src, 0)
   506  		if err == nil {
   507  			t.Errorf("ParseFile(%s) succeeded unexpectedly", src)
   508  			continue
   509  		}
   510  
   511  		const wantErr = "expected selector or type assertion"
   512  		if !strings.Contains(err.Error(), wantErr) {
   513  			t.Errorf("ParseFile returned wrong error %q, want %q", err, wantErr)
   514  		}
   515  
   516  		var sel *ast.SelectorExpr
   517  		ast.Inspect(f, func(n ast.Node) bool {
   518  			if n, ok := n.(*ast.SelectorExpr); ok {
   519  				sel = n
   520  			}
   521  			return true
   522  		})
   523  		if sel == nil {
   524  			t.Error("found no *ast.SelectorExpr")
   525  			continue
   526  		}
   527  		const wantSel = "&{fmt _}"
   528  		if fmt.Sprint(sel) != wantSel {
   529  			t.Errorf("found selector %s, want %s", sel, wantSel)
   530  			continue
   531  		}
   532  	}
   533  }
   534  
   535  func TestLastLineComment(t *testing.T) {
   536  	const src = `package main
   537  type x int // comment
   538  `
   539  	fset := token.NewFileSet()
   540  	f, err := ParseFile(fset, "", src, ParseComments)
   541  	if err != nil {
   542  		t.Fatal(err)
   543  	}
   544  	comment := f.Decls[0].(*ast.GenDecl).Specs[0].(*ast.TypeSpec).Comment.List[0].Text
   545  	if comment != "// comment" {
   546  		t.Errorf("got %q, want %q", comment, "// comment")
   547  	}
   548  }
   549  

View as plain text