anchor.diff:      }
   
       return t;
  -  }
  -
  -  /// Remove "fuzzy arrow" in this function type.
  -  ///
  -  /// Normally we treat dynamically typed parameters as bottom for function
  -  /// types. This allows type tests such as `if (f is SingleArgFunction)`.
  -  /// It also requires a dynamic check on the parameter type to call these
  -  /// functions.
  -  ///
  -  /// When we convert to a strict arrow, dynamically typed parameters become
  -  /// top. This is safe to do for known functions, like top-level or local
  -  /// functions and static methods. Those functions must already be essentially
  -  /// treating dynamic as top.
  -  ///
  -  /// Only the outer-most arrow can be strict. Any others must be fuzzy, because
  -  /// we don't know what function value will be passed there.
  -  // TODO(jmesserly): should we use a real "fuzzyArrow" bit on the function
  -  // type? That would allow us to implement this in the subtype relation.
  -  // TODO(jmesserly): we'll need to factor this differently if we want to
  -  // move CodeChecker's functionality into existing analyzer. Likely we can
  -  // let the Expression have a strict arrow, then in places were we do
  -  // inference, convert back to a fuzzy arrow.
  -  FunctionType _removeFuzz(FunctionType t) {
  -    bool foundFuzz = false;
  -    List<ParameterElement> parameters = <ParameterElement>[];
  -    for (ParameterElement p in t.parameters) {
  -      ParameterElement newP = _removeParameterFuzz(p);
  -      parameters.add(newP);
  -      if (p != newP) foundFuzz = true;
  -    }
  -    if (!foundFuzz) {
  -      return t;
  -    }
  -
  -    FunctionElementImpl function = new FunctionElementImpl("", -1);
  -    function.synthetic = true;
  -    function.returnType = t.returnType;
  -    function.shareTypeParameters(t.typeFormals);
  -    function.shareParameters(parameters);
  -    return function.type = new FunctionTypeImpl(function);
  -  }
  -
  -  /// Removes fuzzy arrow, see [_removeFuzz].
  -  ParameterElement _removeParameterFuzz(ParameterElement p) {
  -    if (p.type.isDynamic) {
  -      return new ParameterElementImpl.synthetic(
  -          p.name, typeProvider.objectType, p.parameterKind);
  -    }
  -    return p;
     }
   
     /// Given an expression, return its type assuming it is
  
positive.code:     // in the restricted system, but List<dynamic> <: Iterable<T> in dart.
      if (from.isAssignableTo(to)) {
        _recordMessage(DownCast.create(rules, expr, from, to));
      }
    }
  
  
negative.code:       functionType = _elementType(parent.element);
      } else {
        assert(parent is FunctionExpression);
        functionType =
            (parent as FunctionExpression).staticType ?? DynamicTypeImpl.instance;
      }
  
      var type = functionType.returnType;
  