cmd/compile: enable more inlining for unified IR

The non-unified frontend had repeated issues with inlining and
generics (#49309, #51909, #52907), which led us to substantially
restrict inlining when shape types were present.

However, these issues are evidently not present in unified IR's
inliner, and the safety restrictions added for the non-unified
frontend can simply be disabled in unified mode.

Fixes #54497.

Change-Id: I8e6ac9f3393c588bfaf14c6452891b9640a9d1bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/424775
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@google.com>

src/cmd/compile/internal/inline/inl.go

@@ -722,44 +722,47 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
 		return n
 	}
 
-	// Don't inline a function fn that has no shape parameters, but is passed at
+	// The non-unified frontend has issues with inlining and shape parameters.
-	// least one shape arg. This means we must be inlining a non-generic function
+	if base.Debug.Unified == 0 {
-	// fn that was passed into a generic function, and can be called with a shape
+		// Don't inline a function fn that has no shape parameters, but is passed at
-	// arg because it matches an appropriate type parameters. But fn may include
+		// least one shape arg. This means we must be inlining a non-generic function
-	// an interface conversion (that may be applied to a shape arg) that was not
+		// fn that was passed into a generic function, and can be called with a shape
-	// apparent when we first created the instantiation of the generic function.
+		// arg because it matches an appropriate type parameters. But fn may include
-	// We can't handle this if we actually do the inlining, since we want to know
+		// an interface conversion (that may be applied to a shape arg) that was not
-	// all interface conversions immediately after stenciling. So, we avoid
+		// apparent when we first created the instantiation of the generic function.
-	// inlining in this case, see issue #49309. (1)
+		// We can't handle this if we actually do the inlining, since we want to know
-	//
+		// all interface conversions immediately after stenciling. So, we avoid
-	// See discussion on go.dev/cl/406475 for more background.
+		// inlining in this case, see issue #49309. (1)
-	if !fn.Type().Params().HasShape() {
+		//
-		for _, arg := range n.Args {
+		// See discussion on go.dev/cl/406475 for more background.
-			if arg.Type().HasShape() {
+		if !fn.Type().Params().HasShape() {
+			for _, arg := range n.Args {
+				if arg.Type().HasShape() {
+					if logopt.Enabled() {
+						logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
+							fmt.Sprintf("inlining function %v has no-shape params with shape args", ir.FuncName(fn)))
+					}
+					return n
+				}
+			}
+		} else {
+			// Don't inline a function fn that has shape parameters, but is passed no shape arg.
+			// See comments (1) above, and issue #51909.
+			inlineable := len(n.Args) == 0 // Function has shape in type, with no arguments can always be inlined.
+			for _, arg := range n.Args {
+				if arg.Type().HasShape() {
+					inlineable = true
+					break
+				}
+			}
+			if !inlineable {
 				if logopt.Enabled() {
 					logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
-						fmt.Sprintf("inlining function %v has no-shape params with shape args", ir.FuncName(fn)))
+						fmt.Sprintf("inlining function %v has shape params with no-shape args", ir.FuncName(fn)))
 				}
 				return n
 			}
 		}
-	} else {
-		// Don't inline a function fn that has shape parameters, but is passed no shape arg.
-		// See comments (1) above, and issue #51909.
-		inlineable := len(n.Args) == 0 // Function has shape in type, with no arguments can always be inlined.
-		for _, arg := range n.Args {
-			if arg.Type().HasShape() {
-				inlineable = true
-				break
-			}
-		}
-		if !inlineable {
-			if logopt.Enabled() {
-				logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
-					fmt.Sprintf("inlining function %v has shape params with no-shape args", ir.FuncName(fn)))
-			}
-			return n
-		}
 	}
 
 	if base.Flag.Cfg.Instrumenting && types.IsRuntimePkg(fn.Sym().Pkg) {

test/run.go

@@ -1990,6 +1990,7 @@ var go118Failures = setOf(
 	"fixedbugs/issue54343.go",  // 1.18 compiler assigns receiver parameter to global variable
 	"typeparam/nested.go",      // 1.18 compiler doesn't support function-local types with generics
 	"typeparam/issue51521.go",  // 1.18 compiler produces bad panic message and link error
+	"typeparam/issue54497.go",  // 1.18 compiler is more conservative about inlining due to repeated issues
 	"typeparam/mdempsky/16.go", // 1.18 compiler uses interface shape type in failed type assertions
 	"typeparam/mdempsky/17.go", // 1.18 compiler mishandles implicit conversions from range loops
 	"typeparam/mdempsky/18.go", // 1.18 compiler mishandles implicit conversions in select statements

test/typeparam/issue49309.go

@@ -18,6 +18,7 @@ func myfunc(c string) {
 
 //go:noinline
 func test2(a interface{}) {
+	_ = a.(string)
 }
 
 func main() {

test/typeparam/issue54497.go

@@ -0,0 +1,19 @@
+// errorcheck -0 -m
+
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that inlining works with generic functions.
+
+package testcase
+
+type C interface{ ~uint | ~uint32 | ~uint64 }
+
+func isAligned[T C](x, y T) bool { // ERROR "can inline isAligned\[uint\]" "can inline isAligned\[go\.shape\.uint\]" "inlining call to isAligned\[go\.shape\.uint\]"
+	return x%y == 0
+}
+
+func foo(x uint) bool { // ERROR "can inline foo"
+	return isAligned(x, 64) // ERROR "inlining call to isAligned\[go\.shape\.uint\]"
+}