anchor.diff:                    yield einfo.RemoveMethod.DisplayName ]
           else []
   
  -    let suppressedMethNames = Zset.ofList String.order (pinfoMethNames @ einfoMethNames)
  -
       let pinfos = 
           pinfosIncludingUnseen
           |> List.filter (fun x -> not (PropInfoIsUnseen m x))
   
  -    let minfoFilter (minfo:MethInfo) = 
  +    let minfoFilter (suppressedMethNames:Zset<_>) (minfo:MethInfo) = 
           let isApplicableMeth =
               match completionTargets with
               | ResolveCompletionTargets.All x -> x
  
positive.code:                       yield einfo.AddMethod.DisplayName
                        yield einfo.RemoveMethod.DisplayName ]
          
              let suppressedMethNames = Zset.ofList String.order (pinfoMethNames @ einfoMethNames)
          
              let pinfos = 
                  pinfosIncludingUnseen
                  |> List.filter (fun x -> not (PropInfoIsUnseen m x))
          
              let minfoFilter (minfo: MethInfo) = 
                  // Only show the Finalize, MemberwiseClose etc. methods on System.Object for values whose static type really is 
                  // System.Object. Few of these are typically used from F#.  
                  //
  
negative.code:             | Item.MethodGroup _ ->
                  // REVIEW: add a name filter here in the common cases?
                  let minfos = 
                      let minfos = AllMethInfosOfTypeInScope ncenv.InfoReader nenv (None,ad) PreferOverrides m ty 
                      if isNil minfos then [] else
                       
                      let suppressedMethNames = Zset.ofList String.order (pinfoMethNames @ einfoMethNames)
                      let minfos = 
                          minfos
                          |> List.filter (minfoFilter suppressedMethNames)
          
                      if isNil minfos then 
                          []
                      else
                          let minfos = 
                              let addersAndRemovers = 
                                  let hashSet = HashSet()
                                  for item in pinfoItems do
                                      match item with
                                      | Item.Event(FSEvent(_,_,addValRef,removeValRef)) -> 
                                          hashSet.Add addValRef.LogicalName |> ignore
                                          hashSet.Add removeValRef.LogicalName |> ignore
                                      | _ -> ()
                                  hashSet
          
                              if addersAndRemovers.Count = 0 then minfos
                              else minfos |> List.filter (fun minfo -> not (addersAndRemovers.Contains minfo.LogicalName))
          
          #if !NO_EXTENSIONTYPING
                          // Filter out the ones with mangled names from applying static parameters
                          let minfos = 
                              let methsWithStaticParams = 
                                  minfos 
                                  |> List.filter (fun minfo -> 
                                      match minfo.ProvidedStaticParameterInfo with 
                                      | Some (_methBeforeArguments, staticParams) -> staticParams.Length <> 0
                                      | _ -> false)
                                  |> List.map (fun minfo -> minfo.DisplayName)
          
                              if methsWithStaticParams.IsEmpty then minfos
                              else minfos |> List.filter (fun minfo -> 
                                      let nm = minfo.LogicalName
                                      not (nm.Contains "," && methsWithStaticParams |> List.exists (fun m -> nm.StartsWithOrdinal(m))))
          #endif
          
                          minfos 
      
                  // Partition methods into overload sets
                  let rec partitionl (l:MethInfo list) acc = 
  