cmd/compile: don't wrap numeric or type literals in OPAREN

It's only necessary to wrap named OTYPE or OLITERAL nodes, because
their line numbers reflect the line number of the declaration, rather
than use.

Saves a lot of wrapper nodes in composite-literal-heavy packages like
Unicode.

name       old alloc/op    new alloc/op    delta
Template      41.8MB ± 0%     41.8MB ± 0%  -0.07%        (p=0.000 n=10+10)
Unicode       36.6MB ± 0%     34.2MB ± 0%  -6.55%        (p=0.000 n=10+10)
GoTypes        123MB ± 0%      123MB ± 0%  -0.02%        (p=0.004 n=10+10)
Compiler       495MB ± 0%      495MB ± 0%  -0.03%        (p=0.000 n=10+10)

name       old allocs/op   new allocs/op   delta
Template        409k ± 0%       409k ± 0%  -0.05%        (p=0.029 n=10+10)
Unicode         371k ± 0%       354k ± 0%  -4.48%         (p=0.000 n=10+9)
GoTypes        1.22M ± 0%      1.22M ± 0%    ~           (p=0.075 n=10+10)
Compiler       4.44M ± 0%      4.44M ± 0%  -0.02%        (p=0.000 n=10+10)

Change-Id: Id1183170835125c778fb41b7e76d06d5ecd4f7a1
Reviewed-on: https://go-review.googlesource.com/32021
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

src/cmd/compile/internal/gc/noder.go

@@ -1053,7 +1053,12 @@ func (p *noder) wrapname(n syntax.Node, x *Node) *Node {
 	// These nodes do not carry line numbers.
 	// Introduce a wrapper node to give them the correct line.
 	switch x.Op {
-	case ONAME, ONONAME, OTYPE, OPACK, OLITERAL:
+	case OTYPE, OLITERAL:
+		if x.Sym == nil {
+			break
+		}
+		fallthrough
+	case ONAME, ONONAME, OPACK:
 		x = p.nod(n, OPAREN, x, nil)
 		x.Implicit = true
 	}

src/cmd/compile/internal/gc/subr.go

@@ -202,10 +202,10 @@ func setlineno(n *Node) int32 {
 	lno := lineno
 	if n != nil {
 		switch n.Op {
-		case ONAME, OTYPE, OPACK:
+		case ONAME, OPACK:
 			break
 
-		case OLITERAL:
+		case OLITERAL, OTYPE:
 			if n.Sym != nil {
 				break
 			}