anchor.diff:              match relevantVirts |> List.filter (fun dispatchSlot -> OverrideImplementsDispatchSlot g amap m dispatchSlot overrideBy) with
               | [] -> 
                   // This is all error reporting
  -                match relevantVirts |> List.filter (fun dispatchSlot -> IsPartialMatch g amap m dispatchSlot overrideBy) with 
  +                match relevantVirts |> List.filter (fun dispatchSlot -> IsPartialMatch g dispatchSlot (CompiledSigOfMeth g amap m dispatchSlot) overrideBy) with 
                   | [dispatchSlot] -> 
                       errorR(OverrideDoesntOverride(denv,overrideBy,Some dispatchSlot,g,amap,m))
                   | _ -> 
  
positive.code:      
      /// Check if an override exactly matches the requirements for a dispatch slot 
      let IsExactMatch g amap m dispatchSlot (Override(_,_,_,(mtps,mtpinst),argTys,retTy,_,_) as overrideBy) =
          IsPartialMatch g amap m dispatchSlot overrideBy &&
          let (CompiledSig (vargtys,vrty,fvmtps,ttpinst)) = CompiledSigOfMeth g amap m dispatchSlot
  
          // Compare the types. CompiledSigOfMeth, GetObjectExprOverrideInfo and GetTypeMemberOverrideInfo have already 
          // applied all relevant substitutions except the renamings from fvtmps <-> mtps 
  
negative.code:     let IsImplMatch g (dispatchSlot:MethInfo) (overrideBy: OverrideInfo) = 
          // If the override is listed as only relevant to one type, and we're matching it against an abstract slot of an interface type,
          // then check that interface type is the right type.
          match overrideBy.CanImplement with 
          | CanImplementNoSlots -> false
          | CanImplementAnySlot -> true 
          | CanImplementAnyClassHierarchySlot -> not (isInterfaceTy g dispatchSlot.ApparentEnclosingType)
          | CanImplementAnyInterfaceSlot -> isInterfaceTy g dispatchSlot.ApparentEnclosingType
  
      /// Check if the kinds of type parameters match between a dispatch slot and an override.
      let IsTyparKindMatch (CompiledSig(_,_,fvmtps,_)) (Override(_,_,_,(mtps,_),_,_,_,_)) = 
          List.lengthsEqAndForall2 (fun (tp1:Typar) (tp2:Typar) -> tp1.Kind = tp2.Kind) mtps fvmtps
          
      /// Check if an override is a partial match for the requirements for a dispatch slot 
      let IsPartialMatch g (dispatchSlot:MethInfo) compiledSig (Override(_,_,_,(mtps,_),argTys,_retTy,_,_) as overrideBy) = 
          IsNameMatch dispatchSlot overrideBy &&
          let (CompiledSig (vargtys,_,fvmtps,_)) = compiledSig
          mtps.Length = fvmtps.Length &&
          IsTyparKindMatch compiledSig overrideBy && 
          argTys.Length = vargtys.Length &&
          IsImplMatch g dispatchSlot overrideBy  
            
  