anchor.diff:                        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) = 
  +            let minfoFilter (suppressedMethNames:Zset<_>) (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#.  
                   //
  
positive.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 
                          |> List.filter minfoFilter
          
                      let minfos = 
                          let addersAndRemovers = 
                              pinfoItems 
                              |> List.collect (function Item.Event(FSEvent(_,_,addValRef,removeValRef)) -> [addValRef.LogicalName;removeValRef.LogicalName] | _ -> [])
                              |> set
          
                          if addersAndRemovers.IsEmpty 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 = 
  
negative.code:                   yield einfo.RemoveMethod.DisplayName ]
          else []
  
      let pinfos = 
          pinfosIncludingUnseen
          |> List.filter (fun x -> not (PropInfoIsUnseen m x))
  
      let minfoFilter (suppressedMethNames:Zset<_>) (minfo:MethInfo) = 
          let isApplicableMeth =
              match completionTargets with
              | ResolveCompletionTargets.All x -> x
  