anchor.diff:  
     MethodUsage.cloned(FunctionEntity function, this.parameterUsage,
         EnumSet<MemberUse> pendingUse,
  -      {this.potentialReads, this.reads, this.potentialInvokes, this.invokes})
  -      : assert(potentialReads != null),
  -        assert(potentialInvokes != null),
  -        assert(reads != null),
  -        assert(invokes != null),
  +      {required this.potentialReads,
  +      required this.reads,
  +      required this.potentialInvokes,
  +      required this.invokes})
  +      : assert((potentialReads as dynamic) != null),
  +        assert((potentialInvokes as dynamic) != null),
  +        assert((reads as dynamic) != null),
  +        assert((invokes as dynamic) != null),
           super.cloned(function, pendingUse);
   
     MethodUsage(FunctionEntity function,
  -      {this.potentialReads, this.potentialInvokes})
  +      {required this.potentialReads, required this.potentialInvokes})
         : reads = EnumSet(),
           invokes = EnumSet(),
           parameterUsage = ParameterUsage(function.parameterStructure),
  -        assert(potentialReads != null),
  -        assert(potentialInvokes != null),
  +        assert((potentialReads as dynamic) != null),
  +        assert((potentialInvokes as dynamic) != null),
           super.internal(function);
   
     @override
  
positive.code:         _unprovidedNamedParameters == null
              ? _parameterStructure.namedParameters
              : _parameterStructure.namedParameters
                  .where((n) => !_unprovidedNamedParameters.contains(n))
                  .toList(),
          _parameterStructure.requiredNamedParameters,
          _areAllTypeParametersProvided ? _parameterStructure.typeParameters : 0);
  
negative.code:       return createPotentialAccessSet(potentialAccess?.invokes);
      }
  
      if (member is FieldEntity) {
        if (member.isAssignable) {
          return FieldUsage(member,
              potentialReads: createPotentialReads(),
  