anchor.diff:                                  fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectNumberOfArguments(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range))
                               elif mtps.Length <> fvmtps.Length then
                                   fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectNumberOfTypeParameters(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range))
  -                            elif not (IsTyparKindMatch g amap m dispatchSlot overrideBy) then
  +                            elif not (IsTyparKindMatch compiledSig overrideBy) then
                                   fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectKindsOfGenericParameters(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range))
                               else 
                                   fail(Error(FSComp.SR.typrelMemberCannotImplement(FormatOverride denv overrideBy, NicePrint.stringOfMethInfo amap m denv dispatchSlot, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range))
  
positive.code:                    // Check that no available prior override implements this dispatch slot
                     not (DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed dispatchSlot) 
                  then 
                      // error reporting path 
                      let (CompiledSig (vargtys,_vrty,fvmtps,_)) = 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 amap m dispatchSlot) with 
                      | [] -> 
                          let possibleOverrides =
                              overrides
  
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  
            
  