add ImplementedAbstractSignatures on FSharpMemberOrFunctionOrValue

Author: Jand42

src/fsharp/infos.fs

@@ -375,6 +375,9 @@ type ValRef with
          | TSlotSig(_,oty,_,_,_,_) :: _ -> isInterfaceTy g oty
          | [] -> false)
 
+    member vref.ImplementedSlotSignatures =
+        vref.MemberInfo.Value.ImplementedSlotSigs
+
 //-------------------------------------------------------------------------
 // Helper methods associated with using TAST metadata (F# members, values etc.) 
 // as backing data for MethInfo, PropInfo etc.
@@ -1090,6 +1093,11 @@ type MethInfo =
         | ProvidedMeth _ -> false 
 #endif
 
+    member x.ImplementedSlotSignatures =
+        match x with 
+        | FSMeth(_,_,vref,_) -> vref.ImplementedSlotSignatures
+        | _ -> failwith "not supported"
+
     /// Indicates if this is an extension member. 
     member x.IsExtensionMember = x.IsCSharpStyleExtensionMember || x.IsFSharpStyleExtensionMember
 
@@ -1796,6 +1804,9 @@ type PropInfo =
         | Some vref -> vref.IsDefiniteFSharpOverrideMember
         | None -> false
 
+    member x.ImplementedSlotSignatures =
+        x.ArbitraryValRef.Value.ImplementedSlotSignatures  
+
     member x.IsFSharpExplicitInterfaceImplementation = 
         match x.ArbitraryValRef with 
         | Some vref -> vref.IsFSharpExplicitInterfaceImplementation x.TcGlobals

src/fsharp/vs/Symbols.fs

@@ -855,6 +855,57 @@ and FSharpDelegateSignature(cenv, info : SlotSig) =
         | Some ty -> FSharpType(cenv,  ty)
     override x.ToString() = "<delegate signature>"
 
+and FSharpAbstractParameter(cenv, info : SlotParam) =
+
+    member __.Name =    
+        let (TSlotParam(name, _, _, _, _, _)) = info
+        name
+
+    member __.Type = FSharpType(cenv, info.Type)
+
+    member __.IsInArg =
+        let (TSlotParam(_, _, isIn, _, _, _)) = info
+        isIn
+
+    member __.IsOutArg =
+        let (TSlotParam(_, _, _, isOut, _, _)) = info
+        isOut
+
+    member __.IsOptionalArg =
+        let (TSlotParam(_, _, _, _, isOptional, _)) = info
+        isOptional
+
+    member __.Attributes =
+        let (TSlotParam(_, _, _, _, _, attribs)) = info
+        attribs |> List.map (fun a -> FSharpAttribute(cenv, AttribInfo.FSAttribInfo(cenv.g, a)))
+        |> makeReadOnlyCollection
+
+and FSharpAbstractSignature(cenv, info : SlotSig) =
+
+    member __.AbstractArguments = 
+        info.FormalParams
+        |> List.map (List.map (fun p -> FSharpAbstractParameter(cenv, p)) >> makeReadOnlyCollection)
+        |> makeReadOnlyCollection
+
+    member __.AbstractReturnType = 
+        match info.FormalReturnType with
+        | None -> FSharpType(cenv,  cenv.g.unit_ty)
+        | Some ty -> FSharpType(cenv,  ty)
+
+    member __.DeclaringTypeGenericParameters =
+        info.ClassTypars 
+        |> List.map (fun t -> FSharpGenericParameter(cenv, t))
+        |> makeReadOnlyCollection
+        
+    member __.MethodGenericParameters =
+        info.MethodTypars 
+        |> List.map (fun t -> FSharpGenericParameter(cenv, t))
+        |> makeReadOnlyCollection
+
+    member __.Name = info.Name 
+    
+    member __.DeclaringType = FSharpType(cenv, info.ImplementedType)
+
 and FSharpGenericParameterMemberConstraint(cenv, info : TraitConstraintInfo) = 
     let (TTrait(tys,nm,flags,atys,rty,_)) = info 
     member __.MemberSources = 
@@ -1338,6 +1389,17 @@ and FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
         | M m -> m.IsFSharpExplicitInterfaceImplementation
         | V v -> v.IsFSharpExplicitInterfaceImplementation cenv.g
 
+    member __.ImplementedAbstractSignatures =
+        checkIsResolved()
+        let sigs =
+            match d with
+            | E e -> e.GetAddMethod().ImplementedSlotSignatures
+            | P p -> p.ImplementedSlotSignatures
+            | M m -> m.ImplementedSlotSignatures
+            | V v -> v.ImplementedSlotSignatures
+        sigs |> List.map (fun s -> FSharpAbstractSignature (cenv, s))
+        |> makeReadOnlyCollection
+
     member __.IsImplicitConstructor = 
         if isUnresolved() then false else 
         match fsharpInfo() with 

src/fsharp/vs/Symbols.fsi

@@ -289,6 +289,48 @@ and [<Class>] FSharpDelegateSignature =
     /// Get the return type of the delegate signature
     member DelegateReturnType : FSharpType
 
+/// Represents a parameter in an abstract method of a class or interface
+and [<Class>] FSharpAbstractParameter =
+
+    /// The optional name of the parameter
+    member Name : string option
+    
+    /// The declared or inferred type of the parameter
+    member Type : FSharpType
+
+    /// Indicate this is an in argument
+    member IsInArg : bool
+
+    /// Indicate this is an out argument
+    member IsOutArg : bool
+
+    /// Indicate this is an optional argument
+    member IsOptionalArg : bool
+
+    /// The declared attributes of the parameter 
+    member Attributes : IList<FSharpAttribute>     
+
+/// Represents the signature of an abstract slot of a class or interface 
+and [<Class>] FSharpAbstractSignature =
+
+    /// Get the arguments of the abstract slot
+    member AbstractArguments : IList<IList<FSharpAbstractParameter>>
+
+    /// Get the return type of the abstract slot
+    member AbstractReturnType : FSharpType
+
+    /// Get the generic arguments of the type defining the abstract slot
+    member DeclaringTypeGenericParameters : IList<FSharpGenericParameter>
+        
+    /// Get the generic arguments of the abstract slot
+    member MethodGenericParameters : IList<FSharpGenericParameter>
+
+    /// Get the name of the abstract slot
+    member Name : string
+    
+    /// Get the declaring type of the abstract slot
+    member DeclaringType : FSharpType
+
 /// A subtype of FSharpSymbol that represents a union case as seen by the F# language
 and [<Class>] FSharpUnionCase =
     inherit FSharpSymbol
@@ -617,6 +659,9 @@ and [<Class>] FSharpMemberOrFunctionOrValue =
     /// Indicates if this is an explicit implementation of an interface member
     member IsExplicitInterfaceImplementation : bool
 
+    /// Gets the list of the abstract slot signatures implemented by the member
+    member ImplementedAbstractSignatures : IList<FSharpAbstractSignature>
+
     /// Indicates if this is a member, including extension members?
     member IsMember : bool