cmd: remove GOEXPERIMENT=nounified knob

This CL removes the GOEXPERIMENT=nounified knob, and any conditional
statements that depend on that knob. Further CLs to remove unreachable
code follow this one.

Updates #57410.

Change-Id: I39c147e1a83601c73f8316a001705778fee64a91
Reviewed-on: https://go-review.googlesource.com/c/go/+/458615
Run-TryBot: Matthew Dempsky <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Reviewed-by: Cherry Mui <[email protected]>

Author: mdempsky

src/cmd/compile/internal/base/debug.go

@@ -47,7 +47,6 @@ type DebugFlags struct {
 	SyncFrames            int    `help:"how many writer stack frames to include at sync points in unified export data"`
 	TypeAssert            int    `help:"print information about type assertion inlining"`
 	TypecheckInl          int    `help:"eager typechecking of inline function bodies" concurrent:"ok"`
-	Unified               int    `help:"enable unified IR construction"`
 	WB                    int    `help:"print information about write barriers"`
 	ABIWrap               int    `help:"print information about ABI wrapper generation"`
 	MayMoreStack          string `help:"call named function before all stack growth checks" concurrent:"ok"`

src/cmd/compile/internal/base/flag.go

@@ -167,9 +167,6 @@ func ParseFlags() {
 	Debug.ConcurrentOk = true
 	Debug.InlFuncsWithClosures = 1
 	Debug.InlStaticInit = 1
-	if buildcfg.Experiment.Unified {
-		Debug.Unified = 1
-	}
 	Debug.SyncFrames = -1 // disable sync markers by default
 
 	Debug.Checkptr = -1 // so we can tell whether it is set explicitly

src/cmd/compile/internal/devirtualize/devirtualize.go

@@ -57,58 +57,52 @@ func Call(call *ir.CallExpr) {
 		return
 	}
 
-	if base.Debug.Unified != 0 {
-		// N.B., stencil.go converts shape-typed values to interface type
-		// using OEFACE instead of OCONVIFACE, so devirtualization fails
-		// above instead. That's why this code is specific to unified IR.
-
-		// If typ is a shape type, then it was a type argument originally
-		// and we'd need an indirect call through the dictionary anyway.
-		// We're unable to devirtualize this call.
-		if typ.IsShape() {
-			return
-		}
+	// If typ is a shape type, then it was a type argument originally
+	// and we'd need an indirect call through the dictionary anyway.
+	// We're unable to devirtualize this call.
+	if typ.IsShape() {
+		return
+	}
 
-		// If typ *has* a shape type, then it's an shaped, instantiated
-		// type like T[go.shape.int], and its methods (may) have an extra
-		// dictionary parameter. We could devirtualize this call if we
-		// could derive an appropriate dictionary argument.
-		//
-		// TODO(mdempsky): If typ has has a promoted non-generic method,
-		// then that method won't require a dictionary argument. We could
-		// still devirtualize those calls.
-		//
-		// TODO(mdempsky): We have the *runtime.itab in recv.TypeWord. It
-		// should be possible to compute the represented type's runtime
-		// dictionary from this (e.g., by adding a pointer from T[int]'s
-		// *runtime._type to .dict.T[int]; or by recognizing static
-		// references to go:itab.T[int],iface and constructing a direct
-		// reference to .dict.T[int]).
-		if typ.HasShape() {
-			if base.Flag.LowerM != 0 {
-				base.WarnfAt(call.Pos(), "cannot devirtualize %v: shaped receiver %v", call, typ)
-			}
-			return
+	// If typ *has* a shape type, then it's an shaped, instantiated
+	// type like T[go.shape.int], and its methods (may) have an extra
+	// dictionary parameter. We could devirtualize this call if we
+	// could derive an appropriate dictionary argument.
+	//
+	// TODO(mdempsky): If typ has has a promoted non-generic method,
+	// then that method won't require a dictionary argument. We could
+	// still devirtualize those calls.
+	//
+	// TODO(mdempsky): We have the *runtime.itab in recv.TypeWord. It
+	// should be possible to compute the represented type's runtime
+	// dictionary from this (e.g., by adding a pointer from T[int]'s
+	// *runtime._type to .dict.T[int]; or by recognizing static
+	// references to go:itab.T[int],iface and constructing a direct
+	// reference to .dict.T[int]).
+	if typ.HasShape() {
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos(), "cannot devirtualize %v: shaped receiver %v", call, typ)
 		}
+		return
+	}
 
-		// Further, if sel.X's type has a shape type, then it's a shaped
-		// interface type. In this case, the (non-dynamic) TypeAssertExpr
-		// we construct below would attempt to create an itab
-		// corresponding to this shaped interface type; but the actual
-		// itab pointer in the interface value will correspond to the
-		// original (non-shaped) interface type instead. These are
-		// functionally equivalent, but they have distinct pointer
-		// identities, which leads to the type assertion failing.
-		//
-		// TODO(mdempsky): We know the type assertion here is safe, so we
-		// could instead set a flag so that walk skips the itab check. For
-		// now, punting is easy and safe.
-		if sel.X.Type().HasShape() {
-			if base.Flag.LowerM != 0 {
-				base.WarnfAt(call.Pos(), "cannot devirtualize %v: shaped interface %v", call, sel.X.Type())
-			}
-			return
+	// Further, if sel.X's type has a shape type, then it's a shaped
+	// interface type. In this case, the (non-dynamic) TypeAssertExpr
+	// we construct below would attempt to create an itab
+	// corresponding to this shaped interface type; but the actual
+	// itab pointer in the interface value will correspond to the
+	// original (non-shaped) interface type instead. These are
+	// functionally equivalent, but they have distinct pointer
+	// identities, which leads to the type assertion failing.
+	//
+	// TODO(mdempsky): We know the type assertion here is safe, so we
+	// could instead set a flag so that walk skips the itab check. For
+	// now, punting is easy and safe.
+	if sel.X.Type().HasShape() {
+		if base.Flag.LowerM != 0 {
+			base.WarnfAt(call.Pos(), "cannot devirtualize %v: shaped interface %v", call, sel.X.Type())
 		}
+		return
 	}
 
 	dt := ir.NewTypeAssertExpr(sel.Pos(), sel.X, nil)

src/cmd/compile/internal/importer/gcimporter_test.go

@@ -9,7 +9,6 @@ import (
 	"cmd/compile/internal/types2"
 	"fmt"
 	"go/build"
-	"internal/goexperiment"
 	"internal/testenv"
 	"os"
 	"os/exec"
@@ -98,7 +97,7 @@ func TestImportTestdata(t *testing.T) {
 		"exports.go":  {"go/ast", "go/token"},
 		"generics.go": nil,
 	}
-	if goexperiment.Unified {
+	if true /* was goexperiment.Unified */ {
 		// TODO(mdempsky): Fix test below to flatten the transitive
 		// Package.Imports graph. Unified IR is more precise about
 		// recreating the package import graph.
@@ -343,8 +342,12 @@ func verifyInterfaceMethodRecvs(t *testing.T, named *types2.Named, level int) {
 	// The unified IR importer always sets interface method receiver
 	// parameters to point to the Interface type, rather than the Named.
 	// See #49906.
+	//
+	// TODO(mdempsky): This is only true for the types2 importer. For
+	// the go/types importer, we duplicate the Interface and rewrite its
+	// receiver methods to match historical behavior.
 	var want types2.Type = named
-	if goexperiment.Unified {
+	if true /* was goexperiment.Unified */ {
 		want = iface
 	}
 

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

@@ -645,15 +645,13 @@ func (v *hairyVisitor) doNode(n ir.Node) bool {
 		// minimize impact to the existing inlining heuristics (in
 		// particular, to avoid breaking the existing inlinability regress
 		// tests), we need to compensate for this here.
-		if base.Debug.Unified != 0 {
-			if init := n.Rhs[0].Init(); len(init) == 1 {
-				if _, ok := init[0].(*ir.AssignListStmt); ok {
-					// 4 for each value, because each temporary variable now
-					// appears 3 times (DCL, LHS, RHS), plus an extra DCL node.
-					//
-					// 1 for the extra "tmp1, tmp2 = f()" assignment statement.
-					v.budget += 4*int32(len(n.Lhs)) + 1
-				}
+		if init := n.Rhs[0].Init(); len(init) == 1 {
+			if _, ok := init[0].(*ir.AssignListStmt); ok {
+				// 4 for each value, because each temporary variable now
+				// appears 3 times (DCL, LHS, RHS), plus an extra DCL node.
+				//
+				// 1 for the extra "tmp1, tmp2 = f()" assignment statement.
+				v.budget += 4*int32(len(n.Lhs)) + 1
 			}
 		}
 
@@ -958,49 +956,6 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlCalls *[]*ir.Inlin
 		return n
 	}
 
-	// The non-unified frontend has issues with inlining and shape parameters.
-	if base.Debug.Unified == 0 {
-		// Don't inline a function fn that has no shape parameters, but is passed at
-		// least one shape arg. This means we must be inlining a non-generic function
-		// fn that was passed into a generic function, and can be called with a shape
-		// arg because it matches an appropriate type parameters. But fn may include
-		// an interface conversion (that may be applied to a shape arg) that was not
-		// apparent when we first created the instantiation of the generic function.
-		// 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
-		// inlining in this case, see issue #49309. (1)
-		//
-		// See discussion on go.dev/cl/406475 for more background.
-		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 shape params with no-shape args", ir.FuncName(fn)))
-				}
-				return n
-			}
-		}
-	}
-
 	if base.Flag.Cfg.Instrumenting && types.IsRuntimePkg(fn.Sym().Pkg) {
 		// Runtime package must not be instrumented.
 		// Instrument skips runtime package. However, some runtime code can be

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

@@ -10,19 +10,14 @@ import (
 	"io"
 
 	"cmd/compile/internal/base"
-	"cmd/compile/internal/typecheck"
 	"cmd/internal/bio"
 )
 
 func WriteExports(out *bio.Writer) {
 	var data bytes.Buffer
 
-	if base.Debug.Unified != 0 {
-		data.WriteByte('u')
-		writeUnifiedExport(&data)
-	} else {
-		typecheck.WriteExports(&data, true)
-	}
+	data.WriteByte('u')
+	writeUnifiedExport(&data)
 
 	// The linker also looks for the $$ marker - use char after $$ to distinguish format.
 	out.WriteString("\n$$B\n") // indicate binary export format

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

@@ -231,10 +231,6 @@ func readImportFile(path string, target *ir.Package, env *types2.Context, packag
 
 	switch c {
 	case 'u':
-		if !buildcfg.Experiment.Unified {
-			base.Fatalf("unexpected export data format")
-		}
-
 		// TODO(mdempsky): This seems a bit clunky.
 		data = strings.TrimSuffix(data, "\n$$\n")
 
@@ -244,20 +240,6 @@ func readImportFile(path string, target *ir.Package, env *types2.Context, packag
 		readPackage(newPkgReader(pr), pkg1, false)
 		pkg2 = importer.ReadPackage(env, packages, pr)
 
-	case 'i':
-		if buildcfg.Experiment.Unified {
-			base.Fatalf("unexpected export data format")
-		}
-
-		typecheck.ReadImports(pkg1, data)
-
-		if packages != nil {
-			pkg2, err = importer.ImportData(packages, data, path)
-			if err != nil {
-				return
-			}
-		}
-
 	default:
 		// Indexed format is distinguished by an 'i' byte,
 		// whereas previous export formats started with 'c', 'd', or 'v'.

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

@@ -73,13 +73,7 @@ func LoadPackage(filenames []string) {
 	}
 	base.Timer.AddEvent(int64(lines), "lines")
 
-	if base.Debug.Unified != 0 {
-		unified(noders)
-		return
-	}
-
-	// Use types2 to type-check and generate IR.
-	check2(noders)
+	unified(noders)
 }
 
 func (p *noder) errorAt(pos syntax.Pos, format string, args ...interface{}) {

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

@@ -3688,11 +3688,6 @@ func (r *reader) importedDef() bool {
 }
 
 func MakeWrappers(target *ir.Package) {
-	// Only unified IR emits its own wrappers.
-	if base.Debug.Unified == 0 {
-		return
-	}
-
 	// always generate a wrapper for error.Error (#29304)
 	needWrapperTypes = append(needWrapperTypes, types.ErrorType)
 

src/cmd/compile/internal/reflectdata/helpers.go

@@ -21,7 +21,7 @@ func hasRType(n, rtype ir.Node, fieldName string) bool {
 	// gets confused by implicit conversions. Also, because
 	// package-scope statements can never be generic, so they'll never
 	// require dictionary lookups.
-	if base.Debug.Unified != 0 && ir.CurFunc.Nname.Sym().Name != "init" {
+	if ir.CurFunc.Nname.Sym().Name != "init" {
 		ir.Dump("CurFunc", ir.CurFunc)
 		base.FatalfAt(n.Pos(), "missing %s in %v: %+v", fieldName, ir.CurFunc, n)
 	}