src/pkg/go/printer/testdata/expressions.input

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package expressions

type T struct {
	x, y, z int
}

var (
	a, b, c, d, e int;
	under_bar int;
	longIdentifier1, longIdentifier2, longIdentifier3 int;
	t0, t1, t2 T;
	s string;
	p *int;
)


func _() {
	// no spaces around simple or parenthesized expressions
	_ = a+b;
	_ = a+b+c;
	_ = a+b-c;
	_ = a-b-c;
	_ = a+(b*c);
	_ = a+(b/c);
	_ = a-(b%c);
	_ = 1+a;
	_ = a+1;
	_ = a+b+1;
	_ = s[1:2];
	_ = s[a:b];
	_ = s[0:len(s)];
	_ = s[0]<<1;
	_ = (s[0]<<1)&0xf;
	_ = s[0] << 2 | s[1] >> 4;
	_ = "foo"+s;
	_ = s+"foo";
	_ = 'a'+'b';
	_ = len(s)/2;
	_ = len(t0.x)/a;

	// spaces around expressions of different precedence or expressions containing spaces
	_ = a + -b;
	_ = a - ^b;
	_ = a / *p;
	_ = a + b*c;
	_ = 1 + b*c;
	_ = a + 2*c;
	_ = a + c*2;
	_ = 1 + 2*3;
	_ = s[1 : 2*3];
	_ = s[a : b-c];
	_ = s[a+b : len(s)];
	_ = s[len(s) : -a];
	_ = s[a : len(s)+1];
	_ = s[a : len(s)+1]+s;

	// spaces around operators with equal or lower precedence than comparisons
	_ = a == b;
	_ = a != b;
	_ = a > b;
	_ = a >= b;
	_ = a < b;
	_ = a <= b;
	_ = a < b && c > d;
	_ = a < b || c > d;

	// spaces around "long" operands
	_ = a + longIdentifier1;
	_ = longIdentifier1 + a;
	_ = longIdentifier1 + longIdentifier2 * longIdentifier3;
	_ = s + "a longer string";

	// some selected cases
	_ = a + t0.x;
	_ = a + t0.x + t1.x * t2.x;
	_ = a + b + c + d + e + 2*3;
	_ = a + b + c + 2*3 + d + e;
	_ = (a+b+c)*2;
	_ = a - b + c - d + (a+b+c) + d&e;
	_ = under_bar-1;
	_ = Open(dpath + "/file", O_WRONLY | O_CREAT, 0666);
	_ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx);
}


func _() {
	a+b;
	a+b+c;
	a+b*c;
	a+(b*c);
	(a+b)*c;
	a+(b*c*d);
	a+(b*c+d);

	1<<x;
	-1<<x;
	1<<x-1;
	-1<<x-1;

	f(a+b);
	f(a+b+c);
	f(a+b*c);
	f(a+(b*c));
	f(1<<x-1, 1<<x-2);

	1<<d.logWindowSize-1;

	buf = make(x, 2*cap(b.buf) + n);

	dst[i*3+2] = dbuf[0]<<2;
	dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4;

	b.buf = b.buf[0:b.off+m+n];
	b.buf = b.buf[0:b.off+m*n];
	f(b.buf[0:b.off+m+n]);

	signed += ' '*8;
	tw.octal(header[148:155], chksum);

	x > 0 && i >= 0;

	x1, x0 := x>>w2, x&m2;
	z0 = t1<<w2+t0;
	z1 = (t1+t0>>w2)>>w2;
	q1, r1 := x1/d1, x1%d1;
	r1 = r1*b2 | x0>>w2;
	x1 = (x1<<z)|(x0>>(uint(w)-z));
	x1 = x1<<z | x0>>(uint(w)-z);

	buf[0:len(buf)+1];
	buf[0:n+1];

	a,b = b,a;
	a = b+c;
	a = b*c+d;
	a*b+c;
	a-b-c;
	a-(b-c);
	a-b*c;
	a-(b*c);
	a*b/c;
	a/ *b;
	x[a|^b];
	x[a/ *b];
	a& ^b;
	a+ +b;
	a- -b;
	x[a*-b];
	x[a+ +b];
	x^y^z;
	b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF];
	len(longVariableName)*2;

	token(matchType + xlength<<lengthShift + xoffset);
}


func _() {
	_ = T{};
	_ = struct{}{};
	_ = [10]T{};
	_ = [...]T{};
	_ = []T{};
	_ = map[int]T{};

	_ = (T){};
	_ = (struct{}){};
	_ = ([10]T){};
	_ = ([...]T){};
	_ = ([]T){};
	_ = (map[int]T){};
}


// one-line structs/interfaces in composite literals (up to a threshold)
func _() {
	_ = struct{}{};
	_ = struct{ x int }{0};
	_ = struct{ x, y, z int }{0, 1, 2};
	_ = struct{ int }{0};
	_ = struct{ s struct { int } }{struct{ int}{0}};  // compositeLit context not propagated => multiLine result
}


func _() {
	// do not modify literals
	_ = "tab1	tab2	tab3	end";  // string contains 3 tabs
	_ = "tab1 tab2 tab3 end";  // same string with 3 blanks - may be unaligned because editors see tabs in strings
	_ = "";  // this comment should be aligned with the one on the previous line
	_ = ``;
	_ = `
`;
_ = `foo
		bar`;
}


func _() {
	// one-line function literals
	_ = func() {};
	_ = func() int {
		return 0;
	};
	_ = func(x, y int) bool {
		return x < y
	};

	f(func() {});
	f(func() int {
		return 0;
	});
	f(func(x, y int) bool {
		return x < y
	});
}


func _() {
	// not not add extra indentation to multi-line string lists
	_ = "foo" "bar";
	_ = "foo"
	"bar"
	"bah";
	_ = []string {
		"abc"
		"def",
		"foo"
		"bar"
	}
}


const _ = F1 +
	`string = "%s";`
	`ptr = *;`
	`datafmt.T2 = s ["-" p "-"];`


const _ =
	`datafmt "datafmt";`
	`default = "%v";`
	`array = *;`
	`datafmt.T3 = s  {" " a a / ","};`


const _ = `datafmt "datafmt";`
`default = "%v";`
`array = *;`
`datafmt.T3 = s  {" " a a / ","};`


func _() {
	_ = F1 +
		`string = "%s";`
		`ptr = *;`
		`datafmt.T2 = s ["-" p "-"];`;

	_ =
		`datafmt "datafmt";`
		`default = "%v";`
		`array = *;`
		`datafmt.T3 = s  {" " a a / ","};`;

	_ = `datafmt "datafmt";`
	`default = "%v";`
	`array = *;`
	`datafmt.T3 = s  {" " a a / ","};`
}


func _() {
	// respect source lines in multi-line expressions
	_ = a+
	b+
	c;
	_ = a < b ||
		b < a;
	_ = "933262154439441526816992388562667004907159682643816214685929"
	"638952175999932299156089414639761565182862536979208272237582"
	"51185210916864000000000000000000000000";  // 100!
	_ = "170141183460469231731687303715884105727";  // prime
}


// Alignment after overlong lines
const (
	_ = "991";
	_ = "2432902008176640000";  // 20!
	_ = "933262154439441526816992388562667004907159682643816214685929"
	"638952175999932299156089414639761565182862536979208272237582"
	"51185210916864000000000000000000000000";  // 100!
	_ = "170141183460469231731687303715884105727";  // prime
)


func same(t, u *Time) bool {
	// respect source lines in multi-line expressions
	return t.Year == u.Year
		&& t.Month == u.Month
		&& t.Day == u.Day
		&& t.Hour == u.Hour
		&& t.Minute == u.Minute
		&& t.Second == u.Second
		&& t.Weekday == u.Weekday
		&& t.ZoneOffset == u.ZoneOffset
		&& t.Zone == u.Zone
}


func (p *parser) charClass() {
	// respect source lines in multi-line expressions
	if cc.negate && len(cc.ranges) == 2 &&
		cc.ranges[0] == '\n' && cc.ranges[1] == '\n' {
		nl := new(_NotNl);
		p.re.add(nl);
	}
}


func addState(s []state, inst instr, match []int) {
	// handle comments correctly in multi-line expressions
	for i := 0; i < l; i++ {
		if s[i].inst.index() == index && // same instruction
		   s[i].match[0] < pos {	// earlier match already going; leftmost wins
		   	return s
		 }
	}
}