code review 7392053: exp/ssa: a number of bug fixes.

src/pkg/exp/ssa/interp/value.go

 package interp
 
 // Values
 //
 // All interpreter values are "boxed" in the empty interface, value.
 // The range of possible dynamic types within value are:
 //
 // - bool
 // - numbers (all built-in int/float/complex types are distinguished)
 // - string
@@ skipping 208 matching lines @@
         case rtype:
                 return x.eq(y)
 
                 // Since the following types don't support comparison,
                 // these cases are only reachable if one of x or y is
                 // (literally) nil.
         case *hashmap:
                 return x == y.(*hashmap)
         case map[value]value:
                 return (x != nil) == (y.(map[value]value) != nil)
-        case *ssa.Function:
-                return x == y.(*ssa.Function)
-        case *closure:
-                return x == y.(*closure)
+        case *ssa.Function, *closure:
+                return x == y
         case []value:
                 return (x != nil) == (y.([]value) != nil)
         }
         panic(fmt.Sprintf("comparing incomparable type %T", x))
 }
 
 // Returns an integer hash of x such that equals(x, y) => hash(x) == hash(y).
 func hash(x value) int {
         switch x := x.(type) {
         case bool:
@@ skipping 215 matching lines @@
         it.i += n
         return okv
 }
 
 type mapIter chan [2]value
 
 func (it mapIter) next() tuple {
         kv, ok := <-it
         return tuple{ok, kv[0], kv[1]}
 }