go/ssa: use valid types for synthetic values

go/ssa/builder.go

@@ -89,11 +89,6 @@ import (
 	"golang.org/x/tools/internal/versions"
 )
 
-type opaqueType struct{ name string }
-
-func (t *opaqueType) String() string         { return t.name }
-func (t *opaqueType) Underlying() types.Type { return t }
-
 var (
 	varOk    = newVar("ok", tBool)
 	varIndex = newVar("index", tInt)
@@ -107,8 +102,10 @@ var (
 	tString     = types.Typ[types.String]
 	tUntypedNil = types.Typ[types.UntypedNil]
 
-	tRangeIter  = &opaqueType{"iter"}                         // the type of all "range" iterators
-	tDeferStack = types.NewPointer(&opaqueType{"deferStack"}) // the type of a "deferStack" from ssa:deferstack()
+	// These synthetic values have inaccurate but valid Go types so that
+	// clients can safely use them with APIs that accept types.Type.
+	tRangeIter  = types.NewTuple()                            // the type of all "range" iterators
+	tDeferStack = types.NewPointer(types.NewStruct(nil, nil)) // the type of a "deferStack" from ssa:deferstack()
 	tEface      = types.NewInterfaceType(nil, nil).Complete()
 
 	// SSA Value constants.

go/ssa/builder_test.go

@@ -28,6 +28,7 @@ import (
 	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/go/ssa"
 	"golang.org/x/tools/go/ssa/ssautil"
+	"golang.org/x/tools/go/types/typeutil"
 	"golang.org/x/tools/internal/expect"
 	"golang.org/x/tools/internal/testenv"
 )
@@ -1083,6 +1084,58 @@ func TestFixedBugs(t *testing.T) {
 	}
 }
 
+func TestSyntheticValueTypes(t *testing.T) {
+	const source = `package p
+
+func rangeMap(m map[string]int) {
+	for range m {
+	}
+}
+
+func rangeFunc(seq func(func() bool)) {
+	for range seq {
+		defer func() {}()
+	}
+}
+`
+
+	pkg, _ := buildPackage(t, source, ssa.SanityCheckFunctions)
+	var rangeType, deferStackType types.Type
+	for fn := range ssautil.AllFunctions(pkg.Prog) {
+		for _, block := range fn.Blocks {
+			for _, instr := range block.Instrs {
+				switch instr := instr.(type) {
+				case *ssa.Range:
+					rangeType = instr.Type()
+				case *ssa.Defer:
+					if instr.DeferStack != nil {
+						deferStackType = instr.DeferStack.Type()
+					}
+				}
+			}
+		}
+	}
+
+	if tuple, ok := rangeType.(*types.Tuple); !ok || tuple.Len() != 0 {
+		t.Fatalf("Range type = %v (%T), want ()", rangeType, rangeType)
+	}
+	ptr, ok := deferStackType.(*types.Pointer)
+	if !ok {
+		t.Fatalf("DeferStack type = %v (%T), want *struct{}", deferStackType, deferStackType)
+	}
+	if strct, ok := ptr.Elem().Underlying().(*types.Struct); !ok || strct.NumFields() != 0 {
+		t.Errorf("DeferStack type = %v, want *struct{}", deferStackType)
+	}
+
+	// Synthetic types should work with utilities that accept go/types types.
+	var typeMap typeutil.Map
+	typeMap.Set(rangeType, true)
+	typeMap.Set(deferStackType, true)
+	if typeMap.Len() != 2 {
+		t.Errorf("type map contains %d entries, want 2", typeMap.Len())
+	}
+}
+
 func TestIssue67079(t *testing.T) {
 	// This test reproduced a race in the SSA builder nearly 100% of the time.
 

go/ssa/sanity.go

@@ -233,8 +233,6 @@ func (s *sanity) checkInstr(idx int, instr Instruction) {
 		t := v.Type()
 		if t == nil {
 			s.errorf("no type: %s = %s", v.Name(), v)
-		} else if t == tRangeIter || t == tDeferStack {
-			// not a proper type; ignore.
 		} else if b, ok := t.Underlying().(*types.Basic); ok && b.Info()&types.IsUntyped != 0 {
 			s.errorf("instruction has 'untyped' result: %s = %s : %s", v.Name(), v, t)
 		}

go/ssa/subst.go

@@ -158,9 +158,6 @@ func (subst *subster) typ(t types.Type) (res types.Type) {
 	case *types.Named:
 		return subst.named(t)
 
-	case *opaqueType:
-		return t // opaque types are never substituted
-
 	default:
 		panic("unreachable")
 	}