internal/refactor/inline: consider "", 0.0, 1.0 duplicable

There is a certain amount of arbitrariness, but these constants
are common, fundamental, and short.

Change-Id: I198e8dbb511d25d969e35a4308108dcf89f79bb0
Reviewed-on: https://go-review.googlesource.com/c/tools/+/531696
Reviewed-by: Robert Findley <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Auto-Submit: Alan Donovan <[email protected]>

Author: adonovan

internal/refactor/inline/inline.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"fmt"
 	"go/ast"
+	"go/constant"
 	"go/format"
 	"go/parser"
 	"go/token"
@@ -1816,17 +1817,30 @@ func duplicable(info *types.Info, e ast.Expr) bool {
 	switch e := e.(type) {
 	case *ast.ParenExpr:
 		return duplicable(info, e.X)
+
 	case *ast.Ident:
 		return true
+
 	case *ast.BasicLit:
-		return e.Kind == token.INT
+		v := info.Types[e].Value
+		switch e.Kind {
+		case token.INT:
+			return true // any int
+		case token.STRING:
+			return consteq(v, kZeroString) // only ""
+		case token.FLOAT:
+			return consteq(v, kZeroFloat) || consteq(v, kOneFloat) // only 0.0 or 1.0
+		}
+
 	case *ast.UnaryExpr: // e.g. +1, -1
 		return (e.Op == token.ADD || e.Op == token.SUB) && duplicable(info, e.X)
+
 	case *ast.CallExpr:
 		// Don't treat a conversion T(x) as duplicable even
 		// if x is duplicable because it could duplicate
 		// allocations. There may be cases to tease apart here.
 		return false
+
 	case *ast.SelectorExpr:
 		if sel, ok := info.Selections[e]; ok {
 			// A field or method selection x.f is referentially
@@ -1835,11 +1849,21 @@ func duplicable(info *types.Info, e ast.Expr) bool {
 		}
 		// A qualified identifier pkg.Name is referentially transparent.
 		return true
-	default:
-		return false
 	}
+	return false
+}
+
+func consteq(x, y constant.Value) bool {
+	return constant.Compare(x, token.EQL, y)
 }
 
+var (
+	kZeroInt    = constant.MakeInt64(0)
+	kZeroString = constant.MakeString("")
+	kZeroFloat  = constant.MakeFloat64(0.0)
+	kOneFloat   = constant.MakeFloat64(1.0)
+)
+
 // -- inline helpers --
 
 func assert(cond bool, msg string) {

internal/refactor/inline/inline_test.go

@@ -376,10 +376,10 @@ func TestBasics(t *testing.T) {
 		{
 			"Non-duplicable arguments are not substituted even if pure.",
 			`func f(s string, i int) { print(s, s, i, i) }`,
-			`func _() { f("", 0)  }`,
+			`func _() { f("hi", 0)  }`,
 			`func _() {
 	{
-		var s string = ""
+		var s string = "hi"
 		print(s, s, 0, 0)
 	}
 }`,
@@ -777,11 +777,11 @@ func TestNamedResultVars(t *testing.T) {
 		{
 			"Ditto, with binding decl again.",
 			`func f(y string) (x int) { return x+x+len(y+y) }`,
-			`func _() { f("") }`,
+			`func _() { f(".") }`,
 			`func _() {
 	{
 		var (
-			y string = ""
+			y string = "."
 			x int
 		)
 		_ = x + x + len(y+y)
@@ -792,11 +792,11 @@ func TestNamedResultVars(t *testing.T) {
 		{
 			"Ditto, with binding decl (due to repeated y refs).",
 			`func f(y string) (x string) { return x+y+y }`,
-			`func _() { f("") }`,
+			`func _() { f(".") }`,
 			`func _() {
 	{
 		var (
-			y string = ""
+			y string = "."
 			x string
 		)
 		_ = x + y + y
@@ -835,8 +835,8 @@ func TestNamedResultVars(t *testing.T) {
 		{
 			"Shadowing in binding decl for named results => literalization.",
 			`func f(y string) (x y) { return x+x+len(y+y) }; type y = int`,
-			`func _() { f("") }`,
-			`func _() { func(y string) (x y) { return x + x + len(y+y) }("") }`,
+			`func _() { f(".") }`,
+			`func _() { func(y string) (x y) { return x + x + len(y+y) }(".") }`,
 		},
 	})
 }