// Copyright 2012 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.

// Test case for error messages/parser synchronization
// after missing commas.

package p

var _ = []int{
	0/* ERROR AFTER "missing ','" */
}

var _ = []int{
	0,
	1,
	2,
	3/* ERROR AFTER "missing ','" */

// Issue 4162. Trailing commas now allowed in conversions.

package p

// All these are valid now.
var (
	_ = int(1.0,)      // comma was always permitted (like function call)
	_ = []byte("foo",) // was syntax error: unexpected comma
	_ = chan int(nil,) // was syntax error: unexpected comma
	_ = (func())(nil,) // was syntax error: unexpected comma

		clause.Expression = s.Expression
	} else {
		clause.Expression = s
	}
}

// CommaExpression represents a group of expressions separated by commas.
type CommaExpression struct {
	Exprs []Expression
}

func (comma CommaExpression) Build(builder Builder) {
	for idx, expr := range comma.Exprs {
		if idx > 0 {
			_, _ = builder.WriteString(", ")
		}
		expr.Build(builder)
	}

package json

import (
	"strings"
)

// tagOptions is the string following a comma in a struct field's "json"
// tag, or the empty string. It does not include the leading comma.
type tagOptions string

// parseTag splits a struct field's json tag into its name and
// comma-separated options.
func parseTag(tag string) (string, tagOptions) {
	tag, opt, _ := strings.Cut(tag, ",")

stdout '\[x.go\]'

go list -f {{.GoFiles}} -tags tag2
stdout '\[y\.go\]'

go list -f {{.GoFiles}} -tags 'tag1 tag2'
stdout '\[x\.go y\.go\]'

go list -f {{.GoFiles}} -tags tag1,tag2 # commas allowed as of Go 1.13
stdout '\[x\.go y\.go\]'

-- x/go.mod --
module x

-- x/x.go --
// +build tag1

package y

-- x/y.go --
// +build tag2

// run

// 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.

// Test trailing commas. DO NOT gofmt THIS FILE.

package main

var a = []int{1, 2, }
var b = [5]int{1, 2, 3, }
var c = []int{1, }
var d = [...]int{1, 2, 3, }

func main() {
	if len(a) != 2 {
		println("len a", len(a))
		panic("fail")
	}
	if len(b) != 5 {

# The original version of this file is located in the https://github.com/istio/common-files repo.
# If you're looking at this file in a different repo and want to make a change, please go to the
# common-files repo, make the change there and check it in. Then come back to this repo and run
# "make update-common".

rules:
  braces: disable
  brackets: disable
  colons: enable
  commas: disable
  comments: disable
  comments-indentation: disable

	re(`-shared`),
	re(`-?-static([-a-z0-9+]*)`),
	re(`-?-stdlib=([^@\-].*)`),
	re(`-v`),

	// Note that any wildcards in -Wl need to exclude comma,
	// since -Wl splits its argument at commas and passes
	// them all to the linker uninterpreted. Allowing comma
	// in a wildcard would allow tunneling arbitrary additional
	// linker arguments through one of these.
	re(`-Wl,--(no-)?allow-multiple-definition`),

func _() {
	_ = T{
		1,	// comment after comma
		2,	/* comment after comma */
		3,	// comment after comma
	}
	_ = T{
		1,	// comment after comma
		2,	/* comment after comma */
		3,	// comment after comma
	}
	_ = T{
		/* comment before literal */ 1,
		2,	/* comment before comma - ok to move after comma */
		3,	/* comment before comma - ok to move after comma */
	}

		`cookie="quoted"`,
	},
	{
		&Cookie{Name: "cookie", Value: "quoted with spaces", Quoted: true},
		`cookie="quoted with spaces"`,
	},
	{
		&Cookie{Name: "cookie", Value: "quoted,with,commas", Quoted: true},
		`cookie="quoted,with,commas"`,
	},
}

func TestWriteSetCookies(t *testing.T) {
	defer log.SetOutput(os.Stderr)
	var logbuf strings.Builder
	log.SetOutput(&logbuf)