Fixes #1445.

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/4109041

Close of closed channel panics.
Receive from closed channel never panics,
even if done repeatedly.

Fixes #1349.
Fixes #1419.

R=gri, iant, ken2, r, gri1, r2, iant2, rog, albert.strasheim, niemeyer, ejsherry
CC=golang-dev
https://golang.org/cl/3989042

The default float type is not very useful but for the most basic applications.
For instance, as it is now, using the math package requires conversions for float
variables (the arguments for math functions are usually float64). Typical real
applications tend to specify the floating point precision required.

This proposal removes the predeclared types float and complex. Variable declarations
without type specification but with constant floating point or complex initializer
expressions will assume the type float64 or complex128 respectively.

The predeclared function cmplx is renamed to complex.

R=golang-dev, rsc
CC=golang-dev
https://golang.org/cl/3423041

Fixes #1421.

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/4039042

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/3992041

Fixes #1285.

R=r, rsc, iant, ken2, r2
CC=golang-dev
https://golang.org/cl/3918041

Also fix a <p> error in go_spec.html.

Fixes #1370.

R=rsc, gri
CC=golang-dev
https://golang.org/cl/3835043

R=gri
CC=golang-dev
https://golang.org/cl/3580042

- use math.Sqrt instead of Math.sqrt
- use float64 for Point fields to match math.Sqrt
- distinguish between Point and Point3D for clarity
- add alignment sizes for complex types

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/3420041

Added a "return" to the end of an example which previously threw a compile error if used.

R=golang-dev, gri
CC=golang-dev
https://golang.org/cl/3052041

R=gri
CC=golang-dev
https://golang.org/cl/2970042

R=rsc, gri
CC=golang-dev
https://golang.org/cl/2985041

Consistency argument: A valid Go program should
remain valid after stripping leading and trailing
whitespace. This was not true so far if the last
text in the source was a line comment.

R=iant, ken2, r, rsc, r2
CC=golang-dev
https://golang.org/cl/2906041

R=r, r2
CC=golang-dev
https://golang.org/cl/2717043

R=iant, ken2, r, rsc
CC=golang-dev
https://golang.org/cl/2774041

R=rsc
CC=golang-dev
https://golang.org/cl/2761041

R=iant, ken2, r, rsc
CC=golang-dev
https://golang.org/cl/2627043

         (language change as discussed a while ago)

R=iant, ken2, r, rsc
CC=golang-dev
https://golang.org/cl/2716041

For elements which are themselves composite literals, the type may
be omitted if it is identical to the element type of the containing
composite literal.

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/2661041

Implies no embedding of pointer to interface value either.

R=gri, iant, ken2, r, r2
CC=golang-dev
https://golang.org/cl/2289041

R=iant, r, rsc, rog
CC=golang-dev
https://golang.org/cl/2226047

Fixes #451.
Fixes #770.

R=ken2
CC=golang-dev
https://golang.org/cl/2207045

R=rsc, r, iant
CC=golang-dev
https://golang.org/cl/2266043

Also: Fixed a bug in the BuiltinCall production.

R=iant, r, rsc
CC=golang-dev
https://golang.org/cl/2278041

R=rsc
CC=golang-dev
https://golang.org/cl/2250041

Also: Added examples for slices with omitted index expressions.

R=r, rsc
CC=golang-dev
https://golang.org/cl/2106047

See also https://golang.org/cl/1957045/

R=gri, rsc, r
CC=golang-dev
https://golang.org/cl/2163042

R=iant
CC=golang-dev
https://golang.org/cl/2128045

R=rsc
CC=golang-dev, r
https://golang.org/cl/2141041

No semantic change.

R=rsc
CC=golang-dev
https://golang.org/cl/2099041

R=gri, rsc
CC=golang-dev
https://golang.org/cl/2078041

R=r
CC=golang-dev
https://golang.org/cl/1941052

R=gri
CC=golang-dev
https://golang.org/cl/1960044

R=golang-dev
CC=golang-dev
https://golang.org/cl/1982042

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

R=gri
CC=golang-dev
https://golang.org/cl/1894043

R=r, rsc
CC=golang-dev
https://golang.org/cl/1766042

- nil channel in regular send or receive panics
- empty select blocks forever

R=rsc, gri, iant, ken2
CC=golang-dev
https://golang.org/cl/1825043

Fixes #891.

R=r, rsc
CC=golang-dev
https://golang.org/cl/1760043

R=r
CC=golang-dev
https://golang.org/cl/1790041