RFC FS-1124 - Interfaces with static abstract methods

src/Compiler/Checking/CheckExpressions.fs

@@ -1314,13 +1314,16 @@ let MakeMemberDataAndMangledNameForMemberVal(g, tcref, isExtrinsic, attrs, implS
 
     let isInstance = MemberIsCompiledAsInstance g tcref isExtrinsic memberInfo attrs
 
-    if (memberFlags.IsDispatchSlot || not (isNil intfSlotTys)) then
-        if not isInstance then
-          errorR(VirtualAugmentationOnNullValuedType(id.idRange))
+    let hasUseNullAsTrueAttr = TyconHasUseNullAsTrueValueAttribute g tcref.Deref
 
-    elif not memberFlags.IsOverrideOrExplicitImpl && memberFlags.IsInstance then
-        if not isExtrinsic && not isInstance then
-            warning(NonVirtualAugmentationOnNullValuedType(id.idRange))
+    if hasUseNullAsTrueAttr then
+        if (memberFlags.IsDispatchSlot || not (isNil intfSlotTys)) then
+            if not isInstance then
+              errorR(VirtualAugmentationOnNullValuedType(id.idRange))
+
+        elif not memberFlags.IsOverrideOrExplicitImpl && memberFlags.IsInstance then
+            if not isExtrinsic && not isInstance then
+                warning(NonVirtualAugmentationOnNullValuedType(id.idRange))
 
     let compiledName =
         if isExtrinsic then
@@ -10909,7 +10912,7 @@ and ApplyAbstractSlotInference (cenv: cenv) (envinner: TcEnv) (bindingTy, m, syn
         match memberFlags.MemberKind with
         | SynMemberKind.Member ->
              let dispatchSlots, dispatchSlotsArityMatch =
-                 GetAbstractMethInfosForSynMethodDecl(cenv.infoReader, ad, memberId, m, typToSearchForAbstractMembers, valSynData)
+                 GetAbstractMethInfosForSynMethodDecl(cenv.infoReader, ad, memberId, m, typToSearchForAbstractMembers, valSynData, memberFlags)
 
              let uniqueAbstractMethSigs =
                  match dispatchSlots with
@@ -11051,14 +11054,15 @@ and AnalyzeRecursiveStaticMemberOrValDecl
         envinner: TcEnv,
         tpenv,
         declKind,
+        synTyparDecls,
         newslotsOK,
         overridesOK,
         tcrefContainerInfo,
         vis1,
         id: Ident,
         vis2,
         declaredTypars,
-        memberFlagsOpt,
+        memberFlagsOpt: SynMemberFlags option,
         thisIdOpt,
         bindingAttribs,
         valSynInfo,
@@ -11074,6 +11078,32 @@ and AnalyzeRecursiveStaticMemberOrValDecl
     // name for the member and the information about which type it is augmenting
 
     match tcrefContainerInfo, memberFlagsOpt with
+    | Some(MemberOrValContainerInfo(tcref, intfSlotTyOpt, _, _, declaredTyconTypars)), Some memberFlags 
+        when memberFlags.MemberKind = SynMemberKind.Member &&
+             memberFlags.IsInstance = false &&
+             memberFlags.IsOverrideOrExplicitImpl = true  ->
+
+           CheckMemberFlags intfSlotTyOpt newslotsOK overridesOK memberFlags id.idRange
+           CheckForNonAbstractInterface declKind tcref memberFlags id.idRange
+
+           let isExtrinsic = (declKind = ExtrinsicExtensionBinding)
+           let tcrefObjTy, enclosingDeclaredTypars, renaming, objTy, _ = FreshenObjectArgType cenv mBinding TyparRigidity.WillBeRigid tcref isExtrinsic declaredTyconTypars
+           let envinner = AddDeclaredTypars CheckForDuplicateTypars enclosingDeclaredTypars envinner
+           let envinner = MakeInnerEnvForTyconRef envinner tcref isExtrinsic
+
+           let (ExplicitTyparInfo(_, declaredTypars, infer)) = explicitTyparInfo
+
+           let domainTy = NewInferenceType g
+
+           let optInferredImplSlotTys, declaredTypars =
+               ApplyAbstractSlotInference cenv envinner (domainTy, mBinding, synTyparDecls, declaredTypars, id, tcrefObjTy, renaming, objTy, intfSlotTyOpt, valSynInfo, memberFlags, bindingAttribs)
+
+           let explicitTyparInfo = ExplicitTyparInfo(declaredTypars, declaredTypars, infer)
+
+           let memberInfo = MakeMemberDataAndMangledNameForMemberVal(g, tcref, isExtrinsic, bindingAttribs, optInferredImplSlotTys, memberFlags, valSynInfo, id, false)
+
+           envinner, tpenv, id, None, Some memberInfo, vis, vis2, None, enclosingDeclaredTypars, None, explicitTyparInfo, bindingRhs, declaredTypars
+
     | Some(MemberOrValContainerInfo(tcref, intfSlotTyOpt, baseValOpt, _safeInitInfo, declaredTyconTypars)), Some memberFlags ->
         assert (Option.isNone intfSlotTyOpt)
 
@@ -11260,7 +11290,7 @@ and AnalyzeRecursiveDecl
 
         | SynPat.Named (SynIdent(id,_), _, vis2, _) ->
             AnalyzeRecursiveStaticMemberOrValDecl
-                (cenv, envinner, tpenv, declKind,
+                (cenv, envinner, tpenv, declKind, synTyparDecls,
                  newslotsOK, overridesOK, tcrefContainerInfo,
                  vis1, id, vis2, declaredTypars,
                  memberFlagsOpt, thisIdOpt, bindingAttribs,

src/Compiler/Checking/MethodOverrides.fs

@@ -767,9 +767,10 @@ module DispatchSlotChecking =
         // Find the methods relevant to implementing the abstract slots listed under the reqdType being checked.
         let allImmediateMembersThatMightImplementDispatchSlots = 
             allImmediateMembers |> List.filter (fun overrideBy -> 
-                overrideBy.IsInstanceMember   &&  // exclude static
-                overrideBy.IsVirtualMember &&  // exclude non virtual (e.g. keep override/default). [4469]
-                not overrideBy.IsDispatchSlotMember)
+                (overrideBy.IsInstanceMember // Not static OR
+                 || ((not overrideBy.IsInstanceMember) && overrideBy.IsOverrideOrExplicitImpl) // Static in the interface
+                && overrideBy.IsVirtualMember   // exclude non virtual (e.g. keep override/default). [4469]
+                && not overrideBy.IsDispatchSlotMember))
 
         let mustOverrideSomething reqdTy (overrideBy: ValRef) =
            let memberInfo = overrideBy.MemberInfo.Value
@@ -919,7 +920,7 @@ let FinalTypeDefinitionChecksAtEndOfInferenceScope (infoReader: InfoReader, nenv
 
 /// Get the methods relevant to determining if a uniquely-identified-override exists based on the syntactic information 
 /// at the member signature prior to type inference. This is used to pre-assign type information if it does 
-let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, valSynData) =
+let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, valSynData, memberFlags: SynMemberFlags) =
     let minfos = 
         match typToSearchForAbstractMembers with 
         | _, Some(SlotImplSet(_, dispatchSlotsKeyed, _, _)) -> 
@@ -928,7 +929,14 @@ let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName:
             GetIntrinsicMethInfosOfType infoReader (Some memberName.idText) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides bindm ty
     let dispatchSlots = minfos |> List.filter (fun minfo -> minfo.IsDispatchSlot)
     let topValSynArities = SynInfo.AritiesOfArgs valSynData
-    let topValSynArities = if List.isEmpty topValSynArities then topValSynArities else topValSynArities.Tail
+
+    // We only return everything if it's empty or if it's a non-instance member.
+    // If it's an instance member, we are getting rid of `this` (by only taking tail).
+    let topValSynArities =
+        if List.isEmpty topValSynArities || (not memberFlags.IsInstance) then
+            topValSynArities
+        else
+            topValSynArities.Tail
     let dispatchSlotsArityMatch = dispatchSlots |> List.filter (fun minfo -> minfo.NumArgs = topValSynArities) 
     dispatchSlots, dispatchSlotsArityMatch 
 

src/Compiler/Checking/MethodOverrides.fsi

@@ -155,7 +155,8 @@ val GetAbstractMethInfosForSynMethodDecl:
     memberName: Ident *
     bindm: range *
     typToSearchForAbstractMembers: (TType * SlotImplSet option) *
-    valSynData: SynValInfo ->
+    valSynData: SynValInfo *
+    memberFlags: SynMemberFlags ->
         MethInfo list * MethInfo list
 
 /// Get the properties relevant to determining if a uniquely-identified-override exists based on the syntactic information

src/Compiler/CodeGen/IlxGen.fs

@@ -4644,11 +4644,17 @@ and GenFormalSlotsig m cenv eenv slotsig =
     let ilRet = GenFormalReturnType m cenv eenvForSlotSig returnTy
     ilTy, ilParams, ilRet
 
-and GenOverridesSpec cenv eenv slotsig m =
+and GenOverridesSpec cenv eenv slotsig m isInstance =
     let (TSlotSig(nameOfOverridenMethod, _, _, methodTypars, _, _)) = slotsig
     let ilOverrideTy, ilOverrideParams, ilOverrideRet = GenFormalSlotsig m cenv eenv slotsig
     let ilOverrideTyRef = ilOverrideTy.TypeRef
-    let ilOverrideMethRef = mkILMethRef(ilOverrideTyRef, ILCallingConv.Instance, nameOfOverridenMethod, List.length (DropErasedTypars methodTypars), typesOfILParams ilOverrideParams, ilOverrideRet.Type)
+    let callingConv =
+        if isInstance then
+            ILCallingConv.Instance
+        else
+            ILCallingConv.Static
+
+    let ilOverrideMethRef = mkILMethRef(ilOverrideTyRef, callingConv, nameOfOverridenMethod, List.length (DropErasedTypars methodTypars), typesOfILParams ilOverrideParams, ilOverrideRet.Type)
     OverridesSpec(ilOverrideMethRef, ilOverrideTy)
 
 and GenFormalReturnType m cenv eenvFormal returnTy : ILReturn =
@@ -4686,8 +4692,8 @@ and GenNameOfOverridingMethod cenv (useMethodImpl, slotsig) =
     else
         nameOfOverridenMethod
 
-and GenMethodImpl cenv eenv (useMethodImpl, slotsig) m =
-    let ilOverridesSpec = GenOverridesSpec cenv eenv slotsig m
+and GenMethodImpl cenv eenv (useMethodImpl, slotsig) m isInstance =
+    let ilOverridesSpec = GenOverridesSpec cenv eenv slotsig m isInstance
 
     let nameOfOverridingMethod = GenNameOfOverridingMethod cenv (useMethodImpl, slotsig)
     nameOfOverridingMethod,
@@ -4696,7 +4702,12 @@ and GenMethodImpl cenv eenv (useMethodImpl, slotsig) m =
         let ilParamsOfOverridingMethod, ilReturnOfOverridingMethod = GenActualSlotsig m cenv eenvForOverrideBy slotsig methTyparsOfOverridingMethod []
         let ilOverrideMethGenericParams = GenGenericParams cenv eenvForOverrideBy methTyparsOfOverridingMethod
         let ilOverrideMethGenericArgs = mkILFormalGenericArgs 0 ilOverrideMethGenericParams
-        let ilOverrideBy = mkILInstanceMethSpecInTy(ilTyForOverriding, nameOfOverridingMethod, typesOfILParams ilParamsOfOverridingMethod, ilReturnOfOverridingMethod.Type, ilOverrideMethGenericArgs)
+        let ilOverrideBy =
+            if isInstance then
+                mkILInstanceMethSpecInTy(ilTyForOverriding, nameOfOverridingMethod, typesOfILParams ilParamsOfOverridingMethod, ilReturnOfOverridingMethod.Type, ilOverrideMethGenericArgs)
+            else
+                mkILStaticMethSpecInTy(ilTyForOverriding, nameOfOverridingMethod, typesOfILParams ilParamsOfOverridingMethod, ilReturnOfOverridingMethod.Type, ilOverrideMethGenericArgs)
+
         { Overrides = ilOverridesSpec
           OverrideBy = ilOverrideBy })
 
@@ -4714,6 +4725,9 @@ and renameMethodDef nameOfOverridingMethod (mdef: ILMethodDef) =
 and fixupMethodImplFlags (mdef: ILMethodDef) =
     mdef.WithAccess(ILMemberAccess.Private).WithHideBySig().WithFinal(true).WithNewSlot
 
+and fixupStaticAbstractSlotFlags (mdef: ILMethodDef) =
+    mdef.WithHideBySig(true)
+
 and GenObjectMethod cenv eenvinner (cgbuf: CodeGenBuffer) useMethodImpl tmethod =
     let g = cenv.g
 
@@ -4745,7 +4759,7 @@ and GenObjectMethod cenv eenvinner (cgbuf: CodeGenBuffer) useMethodImpl tmethod
 
         let ilMethodBody = CodeGenMethodForExpr cenv cgbuf.mgbuf ([], nameOfOverridenMethod, eenvForMeth, 0, selfArgOpt, methBodyExpr, sequel)
 
-        let nameOfOverridingMethod, methodImplGenerator = GenMethodImpl cenv eenvinner (useMethodImpl, slotsig) methBodyExpr.Range
+        let nameOfOverridingMethod, methodImplGenerator = GenMethodImpl cenv eenvinner (useMethodImpl, slotsig) methBodyExpr.Range true
 
         let mdef =
             mkILGenericVirtualMethod
@@ -4868,7 +4882,7 @@ and GenStructStateMachine cenv cgbuf eenvouter (res: LoweredStateMachine) sequel
                 | _ -> error(InternalError(sprintf "expected method %s not found" imethName, m))
 
             let slotsig = implementedMeth.GetSlotSig(amap, m)
-            let ilOverridesSpec = GenOverridesSpec cenv eenvinner slotsig m
+            let ilOverridesSpec = GenOverridesSpec cenv eenvinner slotsig m mdef.CallingConv.IsInstance
             let ilOverrideBy = mkILInstanceMethSpecInTy(ilCloTy, imethName, mdef.ParameterTypes, mdef.Return.Type, [])
             { Overrides = ilOverridesSpec
               OverrideBy = ilOverrideBy } ]
@@ -6632,6 +6646,22 @@ and ComputeFlagFixupsForMemberBinding cenv (v: Val) =
        | Some nm -> renameMethodDef nm
        | None -> () ]
 
+and ComputeMethodImplNameFixupForStaticMemberBinding cenv (v: Val) =
+    if isNil v.ImplementedSlotSigs then
+        None
+    else
+        let slotsig = v.ImplementedSlotSigs |> List.last
+        let nameOfOverridingMethod = GenNameOfOverridingMethod cenv (false, slotsig)
+        Some nameOfOverridingMethod
+
+and ComputeFlagFixupsForStaticMemberBinding cenv (v: Val) =
+    [ 
+      fixupStaticAbstractSlotFlags
+      match ComputeMethodImplNameFixupForStaticMemberBinding cenv v with
+      | Some nm -> renameMethodDef nm
+      | None -> ()
+    ]
+
 and ComputeMethodImplAttribs cenv (_v: Val) attrs =
     let g = cenv.g
     let implflags =
@@ -6864,8 +6894,16 @@ and GenMethodForBinding
            else
                let mdef =
                    if not compileAsInstance then
-                       mkILStaticMethod (ilMethTypars, mspec.Name, access, ilParams, ilReturn, ilMethodBody)
-
+                       if not memberInfo.MemberFlags.IsOverrideOrExplicitImpl then
+                           mkILStaticMethod (ilMethTypars, mspec.Name, access, ilParams, ilReturn, ilMethodBody)
+                       else // We want to get potential fixups and hidebysig for abstract statics:
+                           let flagFixups = ComputeFlagFixupsForStaticMemberBinding cenv v
+                           let mdef = mkILStaticMethod (ilMethTypars, mspec.Name, access, ilParams, ilReturn, ilMethodBody)
+                           let mdef = List.fold (fun mdef f -> f mdef) mdef flagFixups
+
+                           // fixup can potentially change name of reflected definition that was already recorded - patch it if necessary
+                           mgbuf.ReplaceNameOfReflectedDefinition(v, mdef.Name)
+                           mdef
                    elif (memberInfo.MemberFlags.IsDispatchSlot && memberInfo.IsImplemented) ||
                         memberInfo.MemberFlags.IsOverrideOrExplicitImpl then
 
@@ -7934,10 +7972,12 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
                                      | Some(_, memberParentTypars, memberMethodTypars, _, _) -> memberParentTypars, memberMethodTypars
                                      | None -> [], []
 
-                                 let useMethodImpl = true
+                                 // Don't use method impl for static abstract implementation (IsInstance <> true && IsOverrideOrExplicitImpl = true):
+                                 let isStaticAbstractImpl = (not memberInfo.MemberFlags.IsInstance) && memberInfo.MemberFlags.IsOverrideOrExplicitImpl
+                                 let useMethodImpl =  not isStaticAbstractImpl
                                  let eenvUnderTypars = EnvForTypars memberParentTypars eenv
-                                 let _, methodImplGenerator = GenMethodImpl cenv eenvUnderTypars (useMethodImpl, slotsig) m
-                                 if useMethodImpl then
+                                 let _, methodImplGenerator = GenMethodImpl cenv eenvUnderTypars (useMethodImpl, slotsig) m memberInfo.MemberFlags.IsInstance
+                                 if useMethodImpl || isStaticAbstractImpl then
                                      yield methodImplGenerator (ilThisTy, memberMethodTypars)
 
                              | _ -> () ]

src/Compiler/SyntaxTree/SyntaxTreeOps.fs

@@ -698,6 +698,14 @@ let StaticMemberFlags trivia k : SynMemberFlags =
       IsFinal=false
       Trivia=trivia }
 
+let ImplementStaticMemberFlags trivia k : SynMemberFlags =
+    { MemberKind=k
+      IsInstance=false
+      IsDispatchSlot=false
+      IsOverrideOrExplicitImpl=true
+      IsFinal=false
+      Trivia=trivia }
+
 let MemberSynMemberFlagsTrivia (mMember: range) : SynMemberFlagsTrivia =
     { MemberRange = Some mMember
       OverrideRange = None

src/Compiler/SyntaxTree/SyntaxTreeOps.fsi

@@ -300,6 +300,8 @@ val AbstractMemberFlags: trivia: SynMemberFlagsTrivia -> k: SynMemberKind -> Syn
 
 val StaticMemberFlags: trivia: SynMemberFlagsTrivia -> k: SynMemberKind -> SynMemberFlags
 
+val ImplementStaticMemberFlags: SynMemberFlagsTrivia -> k: SynMemberKind -> SynMemberFlags
+
 val MemberSynMemberFlagsTrivia: mMember: range -> SynMemberFlagsTrivia
 
 val OverrideSynMemberFlagsTrivia: mOverride: range -> SynMemberFlagsTrivia

src/Compiler/TypedTree/TypedTree.fs

@@ -300,8 +300,8 @@ type TyparFlags(flags: int32) =
         TyparFlags((if isFromError then                0b00000000000000010 else 0) |||
                    (if isCompGen   then                0b00000000000000100 else 0) |||
                    (match staticReq with
-                     | TyparStaticReq.None                  -> 0b00000000000000000
-                     | TyparStaticReq.HeadType            -> 0b00000000000001000) |||
+                     | TyparStaticReq.None          -> 0b00000000000000000
+                     | TyparStaticReq.HeadType      -> 0b00000000000001000) |||
                    (match rigidity with
                      | TyparRigidity.Rigid          -> 0b00000000000000000
                      | TyparRigidity.WillBeRigid    -> 0b00000000000100000

src/Compiler/TypedTree/TypedTreeOps.fs

@@ -8841,7 +8841,9 @@ let CompileAsEvent g attrs = HasFSharpAttribute g g.attrib_CLIEventAttribute att
 let MemberIsCompiledAsInstance g parent isExtensionMember (membInfo: ValMemberInfo) attrs =
     // All extension members are compiled as static members
     if isExtensionMember then false
-    // Anything implementing a dispatch slot is compiled as an instance member
+    // Members implementing a dispatch slot is compiled as an instance member
+    // Exception is static interface members:
+    elif not membInfo.MemberFlags.IsInstance && membInfo.MemberFlags.IsOverrideOrExplicitImpl then false
     elif membInfo.MemberFlags.IsOverrideOrExplicitImpl then true
     elif not (isNil membInfo.ImplementedSlotSigs) then true
     else 

src/Compiler/pars.fsy

@@ -2325,28 +2325,32 @@ objectImplementationMembers:
 
 /* One member in an object expression or interface implementation */
 objectImplementationMember: 
-  | opt_attributes memberOrOverride memberCore opt_ODECLEND
+  | opt_attributes staticMemberOrMemberOrOverride memberCore opt_ODECLEND
      { let rangeStart = rhs parseState 1
-       $3 None (OverrideMemberFlags $2) $1 rangeStart }
+       $3 None $2 $1 rangeStart }
 
-  | opt_attributes memberOrOverride autoPropsDefnDecl opt_ODECLEND
+  | opt_attributes staticMemberOrMemberOrOverride autoPropsDefnDecl opt_ODECLEND
      { let rangeStart = rhs parseState 1
-       $3 $1 false (OverrideMemberFlags $2) rangeStart }
+       $3 $1 false $2 rangeStart }
 
-  | opt_attributes memberOrOverride error 
+  | opt_attributes staticMemberOrMemberOrOverride error 
       { [] } 
 
   | opt_attributes error memberCore opt_ODECLEND 
       { [] }
 
 
-memberOrOverride: 
+staticMemberOrMemberOrOverride:
+  | STATIC MEMBER
+      { let mStatic = rhs parseState 1
+        let mMember = rhs parseState 2
+        ImplementStaticMemberFlags(StaticMemberSynMemberFlagsTrivia mStatic mMember) }  
   | MEMBER 
       { let mMember = rhs parseState 1
-        MemberSynMemberFlagsTrivia mMember } 
+        OverrideMemberFlags(MemberSynMemberFlagsTrivia mMember) }
   | OVERRIDE 
       { let mOverride = rhs parseState 1
-        OverrideSynMemberFlagsTrivia mOverride }
+        OverrideMemberFlags(OverrideSynMemberFlagsTrivia mOverride) }
 
 
 /* The core of the right-hand-side of a simple type definition */