anchor.diff:       
       /// 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
  +        let compiledSig = CompiledSigOfMeth g amap m dispatchSlot
  +        IsPartialMatch g dispatchSlot compiledSig overrideBy &&
  +        let (CompiledSig (vargtys,vrty,fvmtps,ttpinst)) = compiledSig
   
           // Compare the types. CompiledSigOfMeth, GetObjectExprOverrideInfo and GetTypeMemberOverrideInfo have already 
           // applied all relevant substitutions except the renamings from fvtmps <-> mtps 
  
positive.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 g amap m (dispatchSlot:MethInfo) (Override(_,_,_,(mtps,_),_,_,_,_)) = 
          let (CompiledSig(_,_,fvmtps,_)) = CompiledSigOfMeth g amap m dispatchSlot 
          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 amap m (dispatchSlot:MethInfo) (Override(_,_,_,(mtps,_),argTys,_retTy,_,_) as overrideBy) = 
          IsNameMatch dispatchSlot overrideBy &&
          let (CompiledSig (vargtys,_,fvmtps,_)) = CompiledSigOfMeth g amap m dispatchSlot 
          mtps.Length = fvmtps.Length &&
          IsTyparKindMatch g amap m dispatchSlot overrideBy && 
          argTys.Length = vargtys.Length &&
          IsImplMatch g dispatchSlot overrideBy  
            
  
negative.code:                    // Check that no available prior override implements this dispatch slot
                     not (DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed dispatchSlot) 
                  then 
                      // error reporting path
                      let compiledSig = CompiledSigOfMeth g amap m dispatchSlot
                      
                      let noimpl() = 
                          if isReqdTyInterface then 
                              fail(Error(FSComp.SR.typrelNoImplementationGivenWithSuggestion(NicePrint.stringOfMethInfo amap m denv dispatchSlot), m))
                          else 
                              fail(Error(FSComp.SR.typrelNoImplementationGiven(NicePrint.stringOfMethInfo amap m denv dispatchSlot), m))
                      
                      match overrides |> List.filter (IsPartialMatch g dispatchSlot compiledSig) with 
                      | [] -> 
                          let possibleOverrides =
                              overrides
  