1
0
mirror of https://github.com/golang/go synced 2024-09-24 21:20:13 -06:00
Commit Graph

405 Commits

Author SHA1 Message Date
Russ Cox
98553f1422 spec: remove contentious composite literal shortening
R=gri, r, gustavo, r
CC=golang-dev
https://golang.org/cl/5451099
2011-12-05 14:22:23 -05:00
Russ Cox
5f49456465 spec: additional composite literal shortenings per Go 1 plan
R=golang-dev, gri, r, r
CC=golang-dev
https://golang.org/cl/5449067
2011-12-02 14:12:53 -05:00
Russ Cox
8a8445ba71 spec: pointer to array can be sliced
This has always been true, but we lost it from the spec
somewhere along the way, probably when we disallowed
the general 'pointer to anything sliceable' slice case.

R=gri
CC=golang-dev
https://golang.org/cl/5437121
2011-12-02 13:11:30 -05:00
Russ Cox
4dfe976d97 spec: avoid slice of array literal
R=gri
CC=golang-dev
https://golang.org/cl/5451078
2011-12-02 12:30:20 -05:00
David Symonds
72a2979ef0 spec: update spacing to match gofmt, where reasonable.
R=gri, rsc
CC=golang-dev
https://golang.org/cl/5327053
2011-11-29 15:47:36 -08:00
Russ Cox
6e3e380923 allow direct conversion between string and named []byte, []rune
The allowed conversions before and after are:
        type Tstring string
        type Tbyte []byte
        type Trune []rune

        string <-> string  // ok
        string <-> []byte  // ok
        string <-> []rune // ok
        string <-> Tstring // ok
        string <-> Tbyte // was illegal, now ok
        string <-> Trune // was illegal, now ok

        Tstring <-> string  // ok
        Tstring <-> []byte  // ok
        Tstring <-> []rune // ok
        Tstring <-> Tstring // ok
        Tstring <-> Tbyte // was illegal, now ok
        Tstring <-> Trune // was illegal, now ok

Update spec, compiler, tests.  Use in a few packages.

We agreed on this a few months ago but never implemented it.

Fixes #1707.

R=golang-dev, gri, r
CC=golang-dev
https://golang.org/cl/5421057
2011-11-22 12:30:02 -05:00
Russ Cox
d03611f628 allow copy of struct containing unexported fields
An experiment: allow structs to be copied even if they
contain unexported fields.  This gives packages the
ability to return opaque values in their APIs, like reflect
does for reflect.Value but without the kludgy hacks reflect
resorts to.

In general, we trust programmers not to do silly things
like *x = *y on a package's struct pointers, just as we trust
programmers not to do unicode.Letter = unicode.Digit,
but packages that want a harder guarantee can introduce
an extra level of indirection, like in the changes to os.File
in this CL or by using an interface type.

All in one CL so that it can be rolled back more easily if
we decide this is a bad idea.

Originally discussed in March 2011.
https://groups.google.com/group/golang-dev/t/3f5d30938c7c45ef

R=golang-dev, adg, dvyukov, r, bradfitz, jan.mercl, gri
CC=golang-dev
https://golang.org/cl/5372095
2011-11-15 12:20:59 -05:00
Russ Cox
efb74460c3 spec: disallow general func, map comparisons
R=golang-dev, gri, r, r
CC=golang-dev
https://golang.org/cl/5369090
2011-11-13 22:57:45 -05:00
Rob Pike
217408abf3 crypto: update incorrect references to Cipher interface; should be Block.
R=gri, rsc, r
CC=golang-dev
https://golang.org/cl/5372050
2011-11-09 14:22:44 -08:00
Rob Pike
e223eedc8b spec: delete spurious article
A profound change to christen the new tag.

R=golang-dev, dsymonds
CC=golang-dev
https://golang.org/cl/5327062
2011-11-01 20:57:17 -07:00
Russ Cox
d9877e22fe spec: add error
R=golang-dev, dsymonds, r, r
CC=golang-dev
https://golang.org/cl/5308072
2011-11-01 21:45:02 -04:00
Charles L. Dorian
44262d1574 doc: fix typo in spec example code comment
R=r, golang-dev, adg
CC=golang-dev
https://golang.org/cl/5308071
2011-11-01 15:13:33 +09:00
Robert Griesemer
b910a27396 go spec: introduce rune type
R=r, iant, rsc, r
CC=golang-dev
https://golang.org/cl/5293048
2011-11-01 01:09:22 -04:00
Russ Cox
b7ef3c9a54 spec: define that initialization is sequential
This is true of the existing implementations, and I think
it is an important property to guarantee.

R=golang-dev, r, borman, r
CC=golang-dev
https://golang.org/cl/5321058
2011-10-27 12:22:45 -07:00
Russ Cox
e40d6e066a runtime: random offset for map iteration
R=golang-dev, r
CC=golang-dev
https://golang.org/cl/5285042
2011-10-17 18:49:02 -04:00
Robert Griesemer
c5a6b05ba4 go spec: clarifying variable declaractions w/ constants
Fixes #2377.

R=r, rsc
CC=golang-dev
https://golang.org/cl/5267048
2011-10-17 12:54:18 -07:00
Robert Griesemer
3e0c0a8add go spec: "delete" built-in function
R=golang-dev, r, rsc
CC=golang-dev
https://golang.org/cl/5272045
2011-10-17 12:53:10 -07:00
Russ Cox
f58ed4e641 gc: disallow close on receive-only channels
Fixes #2353.
Fixes #2246.

R=golang-dev, r, gri
CC=golang-dev
https://golang.org/cl/5282042
2011-10-13 16:58:04 -04:00
Russ Cox
d1bafffa4b runtime: run goroutines during init
Fixes #583.
Fixes #1776.
Fixes #2001.
Fixes #2112.

R=golang-dev, bradfitz, r, gri
CC=golang-dev
https://golang.org/cl/5265044
2011-10-13 15:54:23 -04:00
Russ Cox
fa538114ed spec: define order of multiple assignment
R=golang-dev, r, gri
CC=golang-dev
https://golang.org/cl/5240055
2011-10-13 15:44:17 -04:00
Luuk van Dijk
77fac21e82 runtime: append([]byte, string...)
Fixes #2274

R=rsc, gri, dsymonds, bradfitz, lvd
CC=golang-dev
https://golang.org/cl/5149045
2011-10-12 15:59:23 +02:00
Ian Lance Taylor
807eb29f9f go spec: remove notes about gccgo limitations, now fixed
R=gri
CC=golang-dev
https://golang.org/cl/5164041
2011-09-29 14:50:55 -07:00
Robert Griesemer
ffe70eaa3c go spec: update section on Implementation Differences
R=rsc, r
CC=golang-dev
https://golang.org/cl/4977046
2011-08-31 15:16:51 -07:00
Robert Griesemer
38a53c7ecb go spec: (up-)date
R=rsc, bradfitz, r
CC=golang-dev
https://golang.org/cl/4738042
2011-07-14 15:58:37 -07:00
Russ Cox
58e19aa4cb go: require { } around else block
R=gri, ken, r
CC=golang-dev
https://golang.org/cl/4721044
2011-07-14 17:15:52 -04:00
Russ Cox
f4c7db0ed9 spec: disallow goto into blocks
R=gri, r, r
CC=golang-dev
https://golang.org/cl/4631045
2011-06-17 12:49:04 -04:00
Robert Griesemer
2769356dda go spec: specify constant conversions
This is not a language change.

Added paragraphs specifying which conversions
yield results that are constants.

R=r, rsc, iant, ken
CC=golang-dev
https://golang.org/cl/4515176
2011-06-13 16:47:33 -07:00
Robert Griesemer
eee70b07c1 go spec: unsafe.Alignof/Offsetof/Sizeof return uintptr
This is (indirectly) a language change. Per e-mail discussion
on golang-dev.

Fixes #1943.

R=rsc, iant, r, ken
CC=golang-dev
https://golang.org/cl/4581058
2011-06-13 16:46:42 -07:00
Robert Griesemer
95b8137a16 go spec: clarify rules for append, scope rules for :=
Fixes #1936.
Fixes #1940.

R=rsc, r, iant, ken, iant
CC=golang-dev
https://golang.org/cl/4585049
2011-06-12 12:09:50 -07:00
Robert Griesemer
636c5fac2d go spec: handle a corner case of a special case for shifts...
- Added some additional examples.
- 6g appears to implement this semantics already.

Fixes #658.

R=rsc, r, iant, ken
CC=golang-dev
https://golang.org/cl/4538119
2011-06-08 09:11:18 -07:00
Rob Pike
2f655c4bb7 spec: delete spurious tag.
R=golang-dev, bradfitz
CC=golang-dev
https://golang.org/cl/4536082
2011-05-25 10:58:58 +10:00
Robert Griesemer
3c7271f057 go spec: be precise with the use of the informal ellipsis … and the Go token ...
Fixes #1867.

R=r
CC=golang-dev
https://golang.org/cl/4538092
2011-05-24 14:18:44 -07:00
Rob Pike
46f482a2fc docs: remove some prose-unworthy empty parentheses.
In our evolving style, prose should name a function "f" not "f()".

R=gri, rsc
CC=golang-dev
https://golang.org/cl/4550075
2011-05-25 06:44:09 +10:00
Rob Pike
bdbe0decc6 spec: add missing comma.
A real humdinger.

R=golang-dev, rsc
CC=golang-dev
https://golang.org/cl/4538089
2011-05-25 06:00:07 +10:00
Robert Griesemer
32d127823f go spec: clarify rules for shifts
Note: This is not a spec change.

The spec was not clear on the result type of
constant shift expressions. Made it more
explicit and added additional examples.

Also: Remove paragraph on send expressions (they
are statements, now).

Fixes #1708.

R=rsc, r, iant, r
CC=golang-dev
https://golang.org/cl/4517074
2011-05-23 14:12:42 -07:00
Nigel Tao
703b092779 spec: fix copy to return "number of elements copied", not "number
of arguments copied".

R=gri, r
CC=golang-dev
https://golang.org/cl/4550041
2011-05-15 16:04:37 -07:00
Robert Griesemer
32b822f29a go spec: fix error in production syntax
Fix analoguous error in ebnf.go which already
correctly accepted an empty production.

Fixes #1821.

R=r
CC=golang-dev
https://golang.org/cl/4526056
2011-05-13 12:54:51 -07:00
Robert Griesemer
5473103666 go spec: clarify semantics of range clause
This CL proposes some subtle language changes
in an attempt to clarify the semantics of range
clauses and simplify uses of maps.

- nil maps behave like empty maps; but attempting
  to set a value in a nil map causes a run-time panic
- nil channels are never ready for communication;
  sending or reading from a nil channel blocks forever
- if there is only one index iteration variable in a
  range clause and len(range expression) would be a constant,
  the range expression is not evaluated.
  (was discrepancy with len/cap before)
- the notion of what is a constant expression len(x)
  for (pointer to) arrays x has been generalized and
  simplified (can still be syntactically decided)
  (before: more restrictive syntactic rule that was not
  consistently implemented)

Fixes #1713.

R=r, rsc, iant, ken2, r2, bradfitz, rog
CC=golang-dev
https://golang.org/cl/4444050
2011-05-12 09:15:59 -07:00
Rob Pike
38d7bcf5e2 go spec: fix up HTML glitches.
Fixes #1786.

R=gri, adg
CC=golang-dev
https://golang.org/cl/4517043
2011-05-08 14:05:18 -07:00
Robert Griesemer
0e8032ca49 go spec: newlines cannot be used inside a char or "" string literal
R=r
CC=golang-dev
https://golang.org/cl/4462043
2011-05-05 09:03:00 -07:00
Robert Griesemer
bb7eb4002e go spec: clarify semantics of integer division
Fixes #1764.

R=rsc, r, iant, ken2
CC=golang-dev
https://golang.org/cl/4431082
2011-05-02 17:23:18 -07:00
Robert Griesemer
6af887ec03 go spec: restricted expressions may still be parenthesized
No language change.

- added a few examples with parentheses
- added a corresponding sentence to assignments
  (this explicitly permits: (_) = 0, currently allowed by 6g,
  gofmt, but marked as an error by gccgo).

R=rsc, r, iant
CC=golang-dev
https://golang.org/cl/4446071
2011-05-02 09:16:31 -07:00
Robert Griesemer
c134718611 undo CL 4428057 / 19e540fc7d7d
The CL introduces inconsistencies with respect to
the use of parentheses/grouping of receive operations.

««« original CL description
spec: narrow syntax for expression and select statements

This is not a language change, it simply expresses the
accepted cases explicitly in the respective productions.

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

R=golang-dev, rsc1
CC=golang-dev
https://golang.org/cl/4444080
2011-04-29 12:20:31 -07:00
Robert Griesemer
95f544a199 spec: narrow syntax for expression and select statements
This is not a language change, it simply expresses the
accepted cases explicitly in the respective productions.

R=rsc, r, iant
CC=golang-dev
https://golang.org/cl/4428057
2011-04-29 09:49:10 -07:00
Robert Griesemer
1bdb1803b9 go spec: for map types, mention indexing operations
(like we do for arrays and slices).

Suggested by mathieu.lonjaret@gmail.com .

R=r, rsc, iant
CC=golang-dev
https://golang.org/cl/4442074
2011-04-22 16:26:51 -07:00
Robert Griesemer
0f7acf1114 go spec: attempt at clarifying language for "append"
Specifically, fix a wrong comment.

Fixes #1717.

R=r, rsc
CC=golang-dev
https://golang.org/cl/4445050
2011-04-19 14:38:49 -07:00
Rob Pike
e6b1d424c4 spec: add parens missing from "protect" example.
Fixes #1665.

R=gri
CC=golang-dev
https://golang.org/cl/4351051
2011-04-05 11:01:25 -07:00
Ian Lance Taylor
d38d66e646 doc: gccgo now supports method expressions and multiple init functions.
R=gri
CC=golang-dev
https://golang.org/cl/4314047
2011-03-28 14:48:35 -07:00
Russ Cox
108564dabc spec: disallow unused labels
Also change labelled examples to use gofmt formatting.

R=gri, r, jnml
CC=golang-dev
https://golang.org/cl/4287046
2011-03-15 13:51:24 -04:00
Russ Cox
9f2cb86fe2 spec: remove closed from language, replaced by x, ok = <-c
R=gri, r, r2
CC=golang-dev
https://golang.org/cl/4249065
2011-03-11 14:47:02 -05:00
Robert Griesemer
fb64e0d96f go spec: clarify return statement rules
Added example of a return statement w/o expressions
in a function with a _ result parameter.

See also: http://code.google.com/p/go/issues/detail?id=1586

R=rsc, r, iant
CC=golang-dev
https://golang.org/cl/4266049
2011-03-07 16:29:07 -08:00
Robert Griesemer
967a2b38cd go spec: minor clarification of scope rule for functions
R=rsc, iant, r, r2
CC=golang-dev
https://golang.org/cl/4256050
2011-03-03 15:24:28 -08:00
Rob Pike
966bf71366 docs: make "runtime" a word only as a name for the package.
Computer people have an agglutinating streak that I like to resist.
As a time of execution: run time.
As an adjective: run-time.
As a noun: run-time support/code/library.

Signed,
Mr. Pedant.

R=golang-dev, rsc
CC=golang-dev
https://golang.org/cl/4252048
2011-03-01 13:54:22 -08:00
Robert Griesemer
a1368a6ad0 go spec: make condition mandatory in if statements
Plus a few minor HTML fixes.

Fixes #1535.

R=r, rsc, ken2, iant, r2
CC=golang-dev
https://golang.org/cl/4185065
2011-02-22 15:31:57 -08:00
Robert Griesemer
556506e869 go spec: fix local link
Fixes #1543.

R=rsc, r2
CC=golang-dev
https://golang.org/cl/4169068
2011-02-22 09:34:13 -08:00
Rob Pike
e041b9980c spec: delete incorrect obsolete mention of selector working on
pointer to interface type.

R=golang-dev, niemeyer, gri
CC=golang-dev
https://golang.org/cl/4173067
2011-02-19 15:04:56 -08:00
Robert Griesemer
f14c29a311 go spec: minor clarification on channel types
No language change.

R=r, rsc, iant, ken2, r2
CC=golang-dev
https://golang.org/cl/4168050
2011-02-15 11:33:12 -08:00
Anthony Martin
0122a667b6 go spec: fix a few typos
The spec can now be parsed with an
xml.Parser using the HTML settings.

R=gri
CC=golang-dev
https://golang.org/cl/4155042
2011-02-08 14:51:15 -08:00
Robert Griesemer
2a838d6424 go spec: clarification re: method sets of newly declared pointer types
- added an example to Type declarations section clarifying the
  situation brought up with issue 1324
- slightly re-ordered paragraphs in Types section
- added separate heading for method set section and refer to it
  from elsewhere in the spec
- no language changes

R=rsc, r, iant, ken2, r2
CC=golang-dev
https://golang.org/cl/4145043
2011-02-08 13:31:01 -08:00
Gustavo Niemeyer
f8404ee3e1 spec: fix Typeof() return type
R=golang-dev, gri
CC=golang-dev
https://golang.org/cl/4121058
2011-02-04 09:29:08 -08:00
Robert Griesemer
76f3228520 go spec, effective go: cleanups
Removed most of the detailed examples about handing panics
from the go spec since it's now covered by Effective Go.

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/4128058
2011-02-04 08:43:21 -08:00
Robert Griesemer
838b5ad9d6 go spec: move to Unicode 6.0
R=r, r2
CC=golang-dev
https://golang.org/cl/4128055
2011-02-03 12:27:41 -08:00
Robert Griesemer
fa3d0d73f0 go spec: adjust notion of Assignability
This change makes it legal to pass a struct value as receiver
outside the package declaring the struct even if the respective
struct type has non-exported fields.

This is a backwards-compatible language change motivated by the
fact that it is already possible to circumvent the assignment
restriction when calling methods through interfaces (see issue
1402).

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/3926044
2011-02-03 10:53:31 -08:00
Russ Cox
a6736cae30 spec: allow imported packages named main
Prior to this CL, there were two requirements about the
package name main.

1. The package that sits at the root of the import graph
   (the one where program execution begins)
   must be named main.

2. No other package in the program can be named main.

This CL only removes requirement #2, which can be done
without changing any other Go documentation.

The new wording and formatting is such that removing
requirement #1 can be done by deleting a single line,
but making that change is explicitly outside the scope
of this CL, because it would require changes to other
documentation at the same time.

R=gri, r, gri1
CC=golang-dev
https://golang.org/cl/4126053
2011-02-03 13:40:51 -05:00
Robert Griesemer
7fc4e37853 go spec: s/log.Crash/log.Panic/
There is no log.Crash.

R=r, rsc
CC=golang-dev
https://golang.org/cl/4058048
2011-02-01 12:51:10 -08:00
Robert Griesemer
b50ed022f5 go spec: follow-up cleanups after communication operator changes
These are syntactical changes to better reflect the communication
operator's new status in the language.

- sending to a channel is now done via a send statement
- there is no binary communication operation anymore which
  leads to a reduction of the number of precedence levels
  from 6 to 5 (yeah!)
- small semantic change: since a send operation is not part
  of the expression syntax anymore, a <- send operator is
  binding weaker than any other operator now
- receiving from a channel is done as before via the unary
  receive expression
- communication clauses in select statement now can contain
  send statements or receive expressions

R=rsc, r, iant, ken2, gri1
CC=golang-dev
https://golang.org/cl/3973051
2011-02-01 12:02:49 -08:00
Russ Cox
614391860a ebnflint: exit with non-zero status on error
Tweak spec to avoid ebnflint complaints.

R=gri
CC=golang-dev
https://golang.org/cl/3973050
2011-01-31 17:42:10 -05:00
Russ Cox
19d9a40845 spec: remove non-blocking channel operators
Add intended changes for close + closed, commented out.

R=golang-dev, niemeyer, r, gri1
CC=golang-dev
https://golang.org/cl/4013045
2011-01-27 15:34:28 -05:00
Robert Griesemer
0e1d941e5c go spec: clarify address operators.
Fixes #1445.

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/4109041
2011-01-26 11:21:23 -08:00
Russ Cox
27c74d3499 spec, runtime, tests: send on closed channel panics
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
2011-01-21 15:07:13 -05:00
Robert Griesemer
b94c0d2a77 go spec: remove float, complex in favor of float64 and complex128
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
2011-01-19 23:07:21 -05:00
Robert Griesemer
dfc5bb5ff6 go spec: adjust language for constant typing
Fixes #1421.

R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/4039042
2011-01-19 10:33:41 -08:00
Robert Griesemer
97025ebfef go_spec: specify that int and uint have the same size
R=r, rsc, iant, ken2
CC=golang-dev
https://golang.org/cl/3992041
2011-01-13 10:24:04 -08:00
Robert Griesemer
dd916be3d8 go spec: remove Maxalign from spec
Fixes #1285.

R=r, rsc, iant, ken2, r2
CC=golang-dev
https://golang.org/cl/3918041
2011-01-10 14:25:17 -08:00
Rob Pike
29d0f02bd2 effective go: explain the effect of repanicking better.
Also fix a <p> error in go_spec.html.

Fixes #1370.

R=rsc, gri
CC=golang-dev
https://golang.org/cl/3835043
2011-01-05 11:39:57 -08:00
Anthony Martin
11a016151b go spec: fix two grammar typos
R=gri
CC=golang-dev
https://golang.org/cl/3580042
2010-12-13 22:19:41 -08:00
Robert Griesemer
777a96a5b0 go_spec: fixed a couple omissions/type errors
- 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
2010-12-02 12:32:14 -08:00
Anschel Schaffer-Cohen
5083eedf88 Fixed recover() documentation.
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
2010-11-12 09:57:46 -08:00
Peter Mundy
5928e1d4dc doc: fix go_spec spelling errors
R=gri
CC=golang-dev
https://golang.org/cl/2970042
2010-11-09 10:10:57 -08:00
Peter Mundy
9626180918 doc: fix go_spec spelling error
R=rsc, gri
CC=golang-dev
https://golang.org/cl/2985041
2010-11-09 08:46:13 -08:00
Robert Griesemer
d73d1c5f32 go spec: line comments may end in EOF
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
2010-11-04 13:48:32 -07:00
Robert Griesemer
11684680fa go spec: append is now implemented
R=r, r2
CC=golang-dev
https://golang.org/cl/2717043
2010-10-29 11:44:48 -07:00
Robert Griesemer
904adfdc46 go spec: clarify return type of append, argument type for ...T parameters
R=iant, ken2, r, rsc
CC=golang-dev
https://golang.org/cl/2774041
2010-10-27 10:44:31 -07:00
Robert Griesemer
a8abb64a71 go spec: note re: append() not being implemented yet
R=rsc
CC=golang-dev
https://golang.org/cl/2761041
2010-10-26 20:30:35 -07:00
Robert Griesemer
07e983a965 go spec: append built-in
R=iant, ken2, r, rsc
CC=golang-dev
https://golang.org/cl/2627043
2010-10-25 16:50:31 -07:00
Robert Griesemer
425bbadd3c go_spec: allow copy() to copy bytes from a string into a []byte
(language change as discussed a while ago)

R=iant, ken2, r, rsc
CC=golang-dev
https://golang.org/cl/2716041
2010-10-25 16:41:06 -07:00
Robert Griesemer
a12141e5f4 go spec: relaxed syntax for array, slice, and map composite literals
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
2010-10-22 08:58:52 -07:00
Russ Cox
bee2d5b0ad gc, spec, tests: no auto-indirect of pointer to interface value
Implies no embedding of pointer to interface value either.

R=gri, iant, ken2, r, r2
CC=golang-dev
https://golang.org/cl/2289041
2010-09-30 14:59:41 -04:00
Robert Griesemer
5474e166bc go spec: clarifications for range clause
R=iant, r, rsc, rog
CC=golang-dev
https://golang.org/cl/2226047
2010-09-28 14:44:19 -07:00
Russ Cox
00ffd59c1a gc: fix reflect table method receiver
Fixes #451.
Fixes #770.

R=ken2
CC=golang-dev
https://golang.org/cl/2207045
2010-09-28 13:43:50 -04:00
Robert Griesemer
0e66a13d10 go_spec: EOF may insert a semicolon
R=rsc, r, iant
CC=golang-dev
https://golang.org/cl/2266043
2010-09-27 18:59:11 -07:00
Robert Griesemer
ac771a8a47 go spec: ... changes
Also: Fixed a bug in the BuiltinCall production.

R=iant, r, rsc
CC=golang-dev
https://golang.org/cl/2278041
2010-09-24 14:08:28 -07:00
Joe Poirier
d4c8a54579 doc: fix typo in go_spec.html
R=rsc
CC=golang-dev
https://golang.org/cl/2250041
2010-09-20 10:51:05 -07:00
Robert Griesemer
9e5bf27acb go_spec: consistent use of 'low', 'high' in slices section
Also: Added examples for slices with omitted index expressions.

R=r, rsc
CC=golang-dev
https://golang.org/cl/2106047
2010-09-07 16:32:35 -07:00
Scott Lawrence
0c1695b42e spec: Allow omission of low slice bound
See also https://golang.org/cl/1957045/

R=gri, rsc, r
CC=golang-dev
https://golang.org/cl/2163042
2010-09-07 14:30:17 -07:00
Robert Griesemer
947e2180e9 go_spec: fix typo (pointed out by Hiroshi Iwatani)
R=iant
CC=golang-dev
https://golang.org/cl/2128045
2010-09-07 11:14:36 -07:00
Robert Griesemer
c423e95da6 go spec clarification: arrays must be addressable to be sliceable
R=rsc
CC=golang-dev, r
https://golang.org/cl/2141041
2010-09-02 10:16:31 -07:00
Rob Pike
cb2730e60c spec: delete spurious space (missed fix from previous review)
No semantic change.

R=rsc
CC=golang-dev
https://golang.org/cl/2099041
2010-09-01 10:48:45 +10:00
Rob Pike
68f1609eb4 spec: fix a couple of tiny glitches
R=gri, rsc
CC=golang-dev
https://golang.org/cl/2078041
2010-09-01 10:40:50 +10:00
Ian Lance Taylor
659966a988 doc: Update gccgo information for recent changes.
R=r
CC=golang-dev
https://golang.org/cl/1941052
2010-08-23 17:50:30 -07:00
Rob Pike
132d2f11a8 spec: delete erroneous word 'pointer' in specification of select.
R=gri
CC=golang-dev
https://golang.org/cl/1960044
2010-08-16 06:42:41 +10:00
Stephen Ma
0d40e40f5e spec: trivial syntax fix
R=golang-dev
CC=golang-dev
https://golang.org/cl/1982042
2010-08-14 10:27:24 +10:00
Robert Griesemer
07cc6440dc go_spec: don't allow parens around the literal type of composite literals
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
2010-07-29 18:13:41 -07:00
Andrew Gerrand
88fc337fa2 spec: add recover to predeclared identifiers list
R=gri
CC=golang-dev
https://golang.org/cl/1894043
2010-07-27 15:03:30 +10:00
Robert Griesemer
dc60c5a7ec go spec: clarification of channel close()
R=r, rsc
CC=golang-dev
https://golang.org/cl/1766042
2010-07-14 16:09:22 -07:00
Rob Pike
041d11623f Go specification: Lock down some details about channels and select:
- 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
2010-07-13 16:23:54 -07:00
Robert Griesemer
0c2e6b3637 go spec: specify len/cap for nil slices, maps, and channels
Fixes #891.

R=r, rsc
CC=golang-dev
https://golang.org/cl/1760043
2010-07-13 11:54:57 -07:00
Robert Griesemer
73ca127e67 go/spec: fix typo
R=r
CC=golang-dev
https://golang.org/cl/1790041
2010-07-09 13:02:54 -07:00
Russ Cox
f4429181df spec: restrict when len(x) is constant
R=gri, iant, ken2, r
CC=golang-dev
https://golang.org/cl/1687047
2010-07-01 17:49:47 -07:00
Russ Cox
e495351ff7 spec: struct tags must be identical for types to be identical
We didn't mention this explicitly during our discussions,
but I think it fits the "identical types are spelled identically"
rule that we used.

R=gri, iant, ken2, r, rsc1
CC=golang-dev
https://golang.org/cl/1698043
2010-06-21 12:42:33 -07:00
Russ Cox
9562592342 spec: remove ... (keeping ...T)
R=gri, iant, ken2, r, r2
CC=golang-dev
https://golang.org/cl/1632041
2010-06-12 11:37:13 -07:00
Rob Pike
db8c2b1803 spec: clarify that result parameters are always zeroed before the function executes.
R=golang-dev
CC=golang-dev
https://golang.org/cl/1641043
2010-06-11 21:30:03 -07:00
Robert Griesemer
440cc95470 go spec: rename "assignment compatible" -> "assignable"
R=r, rsc
CC=golang-dev
https://golang.org/cl/1590041
2010-06-07 17:40:21 -07:00
Robert Griesemer
7bc03718f4 go spec: clean-up and consolidation of spec with implementation
Specifically:
- introduced notion of "underlying type"
- removed notion of type compatibility
- consolidated rules about assignment compatibility in
  assignment compatibility section
- be consistent with specyfing that nil is the value
  for uninitialized variables that can be nil (this
  was not specified clearly for pointers, functions, interfaces)
- added/fixed various related links throughout
- clarify language on conversions

R=rsc, r, iant, ken2
CC=golang-dev
https://golang.org/cl/1536041
2010-06-07 15:49:39 -07:00
Robert Griesemer
1d282a8eb2 go spec: Base comparison compatibility on assignment compatibility.
Specifically:
- Simplified definition of comparison compatibility and folded into
  section on comparison operators since it's only used there.

This is a small language change/cleanup. As a consequence:
- An interface value may now be compared against a non-interface value.
- Channels with opposite directions cannot be compared directly anymore
  (per discussion with rsc).

R=rsc, r, iant, ken2
CC=golang-dev
https://golang.org/cl/1462041
2010-06-03 16:55:50 -07:00
Robert Griesemer
63f014910d go spec: change def. of "type compatibility" to be non-recursive
and adjust conversion rules.

Also:
- clarification of type identity (no language change)
- adjust special rules for channel assignment/comparison to
  require identical element types (in correspondence to non-
  recursiveness of type compatibility)

R=rsc, iant, ken2, r
CC=golang-dev
https://golang.org/cl/1376042
2010-05-28 14:17:30 -07:00
Robert Griesemer
31f2503cde go spec: Disallow &a notation to obtain a slice
from an array; one needs to write a[0:] instead.

R=rsc, r, iant, ken2
CC=golang-dev
https://golang.org/cl/1365041
2010-05-27 17:23:25 -07:00
Evan Shaw
67d30bb696 spec: Fix link to fallthrough statements
R=golang-dev, gri
CC=golang-dev
https://golang.org/cl/1303041
2010-05-25 18:24:07 -07:00
Robert Griesemer
c7e03a32b3 go spec: minor fix, to match conversion rules 4 and 5
R=rsc
CC=golang-dev
https://golang.org/cl/1270042
2010-05-24 21:25:01 -07:00
Robert Griesemer
934a520d75 go spec: fix and clarify syntax of conversions
Fixes #803.

R=rsc, r, iant, ken2
CC=golang-dev
https://golang.org/cl/1281041
2010-05-24 14:58:26 -07:00
Russ Cox
e7561de09a spec: index of non-addressable array is not addressable
Motivated by:

func f() []int
func g() [10]int

f()[1] = 1  // ok
g()[1] = 1 // ERROR

R=gri
CC=golang-dev
https://golang.org/cl/1278041
2010-05-24 14:31:43 -07:00
Evan Shaw
cb4e9f8508 spec: Fix a code tag
R=golang-dev, gri
CC=golang-dev
https://golang.org/cl/1266042
2010-05-23 11:21:47 -07:00
Robert Griesemer
3af4803704 go spec: added imaginary literal to semicolon rules (was missing)
- also added links to the respective sections
- reformatted section for better (source html) readability
- added missing closing </li>'s in many places

R=r
CC=golang-dev
https://golang.org/cl/1220041
2010-05-14 13:11:48 -07:00
Robert Griesemer
56ca697269 go spec: simplify section on channel types
R=rsc, iant, r
CC=golang-dev
https://golang.org/cl/1171041
2010-05-07 18:22:40 -07:00
Robert Griesemer
df674ffb43 go spec: clarification of make arguments,
specification of runtime exceptions for
make and division by zero

R=r, rsc, ken2, iant
CC=golang-dev
https://golang.org/cl/1081041
2010-05-04 17:31:40 -07:00
Robert Griesemer
39f009cb8e go spec: fix iota description
R=r, rsc
CC=golang-dev
https://golang.org/cl/946046
2010-04-29 10:57:27 -07:00
Rob Pike
de92199648 spec: clarify "continue" with label. the text was obvious in intent but
inaccurate in meaning.

R=gri
CC=golang-dev
https://golang.org/cl/964045
2010-04-28 13:18:40 -07:00
Robert Griesemer
f5b3c14f31 go spec: fix wrong comment
Fixes #743.

R=r, rsc
CC=golang-dev
https://golang.org/cl/944044
2010-04-27 17:52:44 -07:00
Evan Shaw
21110c799d spec: Fix run-time panic header id
Everything was linking to "Run_time_panics", but the id was "Run_time_errors".

R=golang-dev, r
CC=golang-dev
https://golang.org/cl/961042
2010-04-22 10:14:53 -07:00
Russ Cox
6aad41919b go_spec updates
R=r, iant
CC=golang-dev
https://golang.org/cl/921041
2010-04-13 20:55:57 -07:00
Joe Poirier
d37e87c1b2 gp_spec typo fix: code example in the "Handling panics" section
R=rsc, adg
CC=golang-dev
https://golang.org/cl/881047
2010-04-08 10:25:57 +10:00
Robert Griesemer
d4a1619733 go spec: correct clarification of type declaration
R=rsc, r
CC=golang-dev
https://golang.org/cl/855043
2010-04-01 12:48:34 -07:00
Robert Griesemer
735e00d4a0 go spec: clarification of type declarations
R=r, rsc
CC=golang-dev
https://golang.org/cl/849044
2010-03-31 16:37:22 -07:00
Robert Griesemer
e8e4987ba3 godoc: support for title and subtitle headers when serving .html docs
and use it to show version (date) of go spec

Fixes #68.

R=rsc
CC=golang-dev, r
https://golang.org/cl/848042
2010-03-30 17:37:42 -07:00
Andrew Gerrand
10b77f7a2b spec: typo in switch sample code, missing semicolon
Fixes #697

R=r
CC=golang-dev
https://golang.org/cl/804042
2010-03-29 13:12:08 +11:00
Russ Cox
97d0e8fe6c gc: allow taking address of out parameters
Fixes #186.

R=ken2
CC=golang-dev
https://golang.org/cl/793041
2010-03-26 18:01:02 -07:00
Rob Pike
5bb29fb116 spec changes for panic and recover.
R=rsc, gri
CC=golang-dev
https://golang.org/cl/763041
2010-03-25 17:59:59 -07:00
Rob Pike
bf9b8f2c17 Delete panicln from the spec.
R=rsc, gri, iant, ken2
CC=golang-dev
https://golang.org/cl/738041
2010-03-24 15:17:00 -07:00
Robert Griesemer
48f0cd2bd5 go spec: modification of defer statement
R=r, rsc, ken2, iant
CC=golang-dev
https://golang.org/cl/708041
2010-03-23 17:30:14 -07:00
Robert Griesemer
29f1ca528b Go spec: map indexing never raises a runtime exception.
Also: Actual map key must be assignment-compatible with
formal map key type.

Fixes #357.

R=r, iant, rsc, ken2
CC=golang-dev
https://golang.org/cl/673042
2010-03-23 14:01:51 -07:00
Ian Lance Taylor
11a218444f Revert previous change: complexN only converts to complexN.
This was discussed with Ken and Russ.  6g has been changed,
and both compilers now work this way.  This avoids a double
type conversion--first to the float type, then to the complex
type.

R=r
CC=golang-dev, ken2, rsc
https://golang.org/cl/419042
2010-03-10 20:38:38 -08:00
Robert Griesemer
ef4c2b85a0 go_spec.html: fix typo and link
R=r
CC=golang-dev
https://golang.org/cl/382045
2010-03-10 15:29:36 -08:00
Ian Lance Taylor
18187e7d49 Complex values may only be compared for equality or inequality.
R=gri, r
CC=golang-dev
https://golang.org/cl/294042
2010-03-08 14:05:46 -08:00
Ian Lance Taylor
5cf707b499 Clarify that conversions to complex are OK.
R=r
CC=golang-dev
https://golang.org/cl/296042
2010-03-08 13:45:03 -08:00
Rob Pike
7297087101 Spec for complex numbers
R=rsc, ken2, gri, iant
CC=cw, golang-dev
https://golang.org/cl/227041
2010-03-04 12:35:16 -08:00
Robert Griesemer
f42e8833b3 language spec: make NUL byte rule an implementation restriction
R=rsc, r, iant, ken2
CC=golang-dev
https://golang.org/cl/211041
2010-02-17 15:50:34 -08:00
Russ Cox
b7d9ffeecd spec: disallow NUL in source files
R=r
CC=golang-dev
https://golang.org/cl/209042
2010-02-16 16:47:18 -08:00
Rob Pike
1811fac7cb specification of []int(string) and []byte(string).
also clarify other string conversions.

R=rsc, iant, gri, ken2
CC=golang-dev
https://golang.org/cl/207103
2010-02-17 11:26:09 +11:00
Rob Pike
810def8484 ...T is now implemented
R=rsc, gri
CC=golang-dev
https://golang.org/cl/198050
2010-02-01 18:59:23 -08:00
Rob Pike
22a4952bd2 note that ...T is not yet implemented.
R=rsc
CC=golang-dev
https://golang.org/cl/194114
2010-01-27 13:45:16 -08:00