anchor.diff:  ///
   /// Called from generated code.
   Rti instanceOrFunctionType(object, Rti testRti) {
  -  if (_isClosure(object)) {
  -    if (Rti._isUnionOfFunctionType(testRti)) {
  +  if (Rti._isUnionOfFunctionType(testRti)) {
  +    if (_isClosure(object)) {
         // If [testRti] is e.g. `FutureOr<Action>` (where `Action` is some
         // function type), we don't need to worry about the `Future<Action>`
         // branch because closures can't be `Future`s.
         Rti rti = closureFunctionType(object);
         if (rti != null) return rti;
       }
  -    return _closureInterfaceType(object);
  -  }
  -  return _nonClosureInstanceType(object);
  +  }
  +  return instanceType(object);
   }
   
   /// Returns the Rti type of [object].
  
positive.code: 
  /// Returns the structural function type of [object], or `null` if the object is
  /// not a closure.
  Rti _instanceFunctionType(object) {
    if (_isClosure(object)) return closureFunctionType(object);
    return null;
  }
  
  /// Returns Rti from types table. The types table is initialized with recipe
  /// strings.
  
negative.code:   /// between 'generic class is the base environment' and 'generic class is a
    /// singleton type argument' is resolved [TBD] (either (1) a bind1 cache, or
    /// (2)using `env._eval("@<0>")._bind(args)` in place of `env._bind1(args)`).
    ///
    /// On [Rti]s that are generic function types, results of instantiation are
    /// cached on the generic function type to ensure fast repeated
    /// instantiations.
    Object _bindCache;
  
    static Object _getBindCache(Rti rti) => rti._bindCache;
  