code review 6498138: spec: clarify expression statements

doc/go_spec.html

 <!--{
         "Title": "The Go Programming Language Specification",
-        "Subtitle": "Version of September 17, 2012",
+        "Subtitle": "Version of September 18, 2012",
         "Path": "/ref/spec"
 }-->
 
 <!--
 TODO
 [ ] need language about function/method calls and parameter passing rules
 [ ] last paragraph of #Assignments (constant promotion) should be elsewhere
     and mention assignment to empty interface.
 [ ] need to say something about "scope" of selectors?
 [ ] clarify what a field name is in struct declarations
@@ skipping 3777 matching lines @@
 </pre>
 
 <pre>
 Error: log.Panic("error encountered")
 </pre>
 
 
 <h3 id="Expression_statements">Expression statements</h3>
 
 <p>
-Function and method <a href="#Calls">calls</a>
-(excluding calls of <a href="#Built-in_functions">built-in functions</a>),
-and <a href="#Receive_operator">receive operations</a>

[r, 2012/09/17 21:19:38]

order here is in out in. better to go in in out or out in in. plus no parens.

Except for calls of <a href="#Built-in_functions">built-in functions</a>.
function and method <a href="#Calls">calls</a> and <a href="#Receive_operator">
receive operations</a> may appear in statement context.

[gri, 2012/09/17 21:35:24]

Done.

+With the exception of specific built-in functions,
+function and method <a href="#Calls">calls</a> and
+<a href="#Receive_operator">receive operations</a>
 can appear in statement context. Such statements may be parenthesized.
 </p>
 
 <pre class="ebnf">
 ExpressionStmt = Expression .
+</pre>
+
+<p>
+The following built-in functions are not permitted in statement context:
+</p>
+
+<pre>
+append cap complex imag len make new real
+unsafe.Alignof unsafe.Offsetof unsafe.Sizeof
 </pre>
 
 <pre>
 h(x+y)
 f.Close()
 &lt;-ch
 (&lt;-ch)
 len("foo")  // illegal if len is the built-in function
 </pre>
 
@@ skipping 988 matching lines @@
 
 <p>
 The length and capacity of a <code>nil</code> slice, map, or channel are 0.
 </p>
 
 <p>
 The expression <code>len(s)</code> is <a href="#Constants">constant</a> if
 <code>s</code> is a string constant. The expressions <code>len(s)</code> and
 <code>cap(s)</code> are constants if the type of <code>s</code> is an array
 or pointer to an array and the expression <code>s</code> does not contain
-function or method <a href="#Calls">calls</a> (excluding calls to built-in
-functions), or <a href="#Receive_operator">receive operations</a>; in this

[r, 2012/09/17 21:19:38]

"does not contain ... excluding" is hard to parse, plus the rewrite above would
help. no parens.

[gri, 2012/09/17 21:35:24]

Done.

-case <code>s</code> is not evaluated.
+<a href="#Receive_operator">channel receives</a> or
+<a href="#Calls">function calls</a>; in this case <code>s</code> is not evaluated.
 Otherwise, invocations of <code>len</code> and <code>cap</code> are not
 constant and <code>s</code> is evaluated.
 </p>
 
 
 <h3 id="Allocation">Allocation</h3>
 
 <p>
 The built-in function <code>new</code> takes a type <code>T</code> and
 returns a value of type <code>*T</code>.
@@ skipping 659 matching lines @@
 <p>
 Any pointer or value of <a href="#Types">underlying type</a> <code>uintptr</code> can be converted into
 a <code>Pointer</code> and vice versa.
 </p>
 <p>
 The functions <code>Alignof</code> and <code>Sizeof</code> take an expression <code>x</code>
 of any type and return the alignment or size, respectively, of a hypothetical variable <code>v</code>
 as if <code>v</code> was declared via <code>var v = x</code>.
 </p>
 <p>
-The function <code>Offsetof</code> takes a selector (§<a href="#Selectors">Selectors</a>) denoting a struct
-field of any type and returns the field offset in bytes relative to the
+The function <code>Offsetof</code> takes a (possibly parenthesized) <a href="#Selectors">selector</a>
+denoting a struct field of any type and returns the field offset in bytes relative to the
 struct's address.
 For a struct <code>s</code> with field <code>f</code>:
 </p>
 
 <pre>
 uintptr(unsafe.Pointer(&amp;s)) + unsafe.Offsetof(s.f) == uintptr(unsafe.Pointer(&amp;s.f))
 </pre>
 
 <p>
 Computer architectures may require memory addresses to be <i>aligned</i>;
@@ skipping 41 matching lines @@
 </li>
 
 <li>For a variable <code>x</code> of array type: <code>unsafe.Alignof(x)</code> is the same as
    <code>unsafe.Alignof(x[0])</code>, but at least 1.
 </li>
 </ol>
 
 <p>
 A struct or array type has size zero if it contains no fields (or elements, respectively) that have a size greater than zero. Two distinct zero-size variables may have the same address in memory.
 </p>