anchor.diff:      let mkEventSym einfo = FSharpMemberOrFunctionOrValue(cenv, E einfo, Item.Event einfo)
   
       new (cenv, vref) = FSharpMemberFunctionOrValue(cenv, V vref, Item.Value vref)
  -    new (cenv, minfo) =  FSharpMemberFunctionOrValue(cenv, M minfo, Item.MethodGroup(minfo.LogicalName, [minfo], None))
  +
  +    new (cenv, minfo: MethInfo) =
  +        if minfo.IsConstructor || minfo.IsClassConstructor then
  +            FSharpMemberFunctionOrValue(cenv, C minfo, Item.CtorGroup(minfo.LogicalName, [minfo]))
  +        else
  +            FSharpMemberFunctionOrValue(cenv, M minfo, Item.MethodGroup(minfo.LogicalName, [minfo], None))
   
       member __.IsUnresolved = 
           isUnresolved()
  
positive.code:             match d, other.Data with 
              | E evt1, E evt2 -> EventInfo.EventInfosUseIdenticalDefintions evt1 evt2 
              | P p1, P p2 ->  PropInfo.PropInfosUseIdenticalDefinitions p1 p2
              | M m1, M m2 ->  MethInfo.MethInfosUseIdenticalDefinitions m1 m2
              | V v1, V v2 -> valRefEq cenv.g v1 v2
              | _ -> false
          |   _ -> false
  
negative.code:     member x.Overloads matchParameterNumber =
          checkIsResolved()
          match d with
          | M m | C m ->
              match item with
              | Item.MethodGroup (_, methodInfos, _)
              | Item.CtorGroup (_, methodInfos) ->
                  let isConstructor = x.IsConstructor
                  let methods =
                      if matchParameterNumber then
                          methodInfos
                          |> List.filter (fun methodInfo -> not (methodInfo.NumArgs = m.NumArgs) )
                      else methodInfos
                  methods
                  |> List.map (fun mi ->
                      if isConstructor then
                          FSharpMemberOrFunctionOrValue(cenv, C mi, item)
                      else
                          FSharpMemberOrFunctionOrValue(cenv, M mi, item))
                  |> makeReadOnlyCollection
                  |> Some
              | _ -> None
  