mirror of
https://github.com/golang/go
synced 2024-11-14 08:00:22 -07:00
07cc6440dc
Background: The current spec is imprecise with respect to the parsing ambiguity
for composite literals: It says that the ambiguity arises when the TypeName form
of the LiteralType is used. The following code:
if (B) {} ...
is not using the TypeName form (but the parenthesized TypeName form) and thus
could be interpreted as:
if ((B){}) ...
instead of
if B {} ...
Both compilers and gofmt choose the latter interpretation. One could fix the
spec by making the clause regarding the parsing ambiguity more precise ("...using
the _possibly parenthesized_ TypeName form of the LiteralType..."). The alternative
(chosen here) is to simply disallow parenthesized literal types. Except for a single
test case (test/parentype.go) there appears to be no Go code under $GOROOT containing
parenthesized literal types. Furthermore, parentheses are never needed around a
literal type for correct parsing.
R=golang-dev
CC=golang-dev
https://golang.org/cl/1913041
18 lines
391 B
Go
18 lines
391 B
Go
// $G $D/$F.go
|
|
|
|
// 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 main
|
|
|
|
func f(interface{})
|
|
func g() {}
|
|
func main() {
|
|
f(map[string]string{"a":"b","c":"d"});
|
|
f([...]int{1,2,3});
|
|
f(map[string]func(){"a":g,"c":g});
|
|
f(make(chan(<-chan int)));
|
|
f(make(chan<-(chan int)));
|
|
}
|