anchor.diff:      if (success) {
         var constraints = gatherer.computeConstraints();
         for (var entry in constraints.entries) {
  -        if (!entry.value.isEmpty && !_fixedTypeParameters.contains(entry.key)) {
  +        if (!entry.value.isEmpty &&
  +            !_typesInferredSoFar.containsKey(entry.key)) {
             var constraint = _constraints[entry.key]!;
             constraint.add(
               _TypeConstraint(origin, entry.key,
  
positive.code:   /// type arguments are allowed to be instantiated with generic function types.
    final bool genericMetadataIsEnabled;
  
    /// The set of type parameters for which a previous inference phase has
    /// "fixed" a type; no further constraints will be added for types in this
    /// list.
    ///
    /// Background: sometimes the upwards inference phase of generic type
    /// inference is capable of assigning a more specific type than the downwards
  
negative.code:       }
  
        var constraints = _constraints[typeParam]!;
        var previouslyInferredType = _typesInferredSoFar[typeParam];
        if (previouslyInferredType != null) {
          inferredTypes[i] = previouslyInferredType;
        } else if (partial) {
          var inferredType = _inferTypeParameterFromContext(
              constraints, extendsClause,
              isContravariant: typeParam.variance.isContravariant);
          inferredTypes[i] = inferredType;
          if (typeParam.isLegacyCovariant &&
              UnknownInferredType.isKnown(inferredType)) {
            _typesInferredSoFar[typeParam] = inferredType;
          }
        } else {
          inferredTypes[i] = _inferTypeParameterFromAll(
  