Initial generation signature feature toggle.

Author: nojaf

ReSharper.FSharp/src/FSharp.Common/src/Settings/FSharpOptions.fs

@@ -86,7 +86,7 @@ module FSharpExperimentalFeatures =
     let [<Literal>] outOfProcessTypeProviders = "Host type providers out-of-process"
     let [<Literal>] generativeTypeProvidersInMemoryAnalysis = "Enable generative type providers analysis in C#/VB.NET projects"
     let [<Literal>] tryRecoverFcsProjects = "Try to reuse FCS results on project changes"
-
+    let [<Literal>] generateSignatureFile = "Generate signature file"
 
 [<SettingsKey(typeof<FSharpOptions>, "F# experimental features")>]
 type FSharpExperimentalFeatures =
@@ -109,8 +109,10 @@ type FSharpExperimentalFeatures =
       mutable GenerativeTypeProvidersInMemoryAnalysis: bool
 
       [<SettingsEntry(false, FSharpExperimentalFeatures.tryRecoverFcsProjects); DefaultValue>]
-      mutable TryRecoverFcsProjects: bool }
+      mutable TryRecoverFcsProjects: bool
 
+      [<SettingsEntry(false, FSharpExperimentalFeatures.generateSignatureFile); DefaultValue>]
+      mutable GenerateSignatureFile: bool }
 
 [<AllowNullLiteral>]
 type FSharpSettingsProviderBase<'T>(lifetime: Lifetime, settings: IContextBoundSettingsStoreLive,
@@ -146,6 +148,7 @@ type FSharpExperimentalFeaturesProvider(lifetime, solution, settings, settingsSc
     member val OutOfProcessTypeProviders = base.GetValueProperty<bool>("OutOfProcessTypeProviders")
     member val GenerativeTypeProvidersInMemoryAnalysis = base.GetValueProperty<bool>("GenerativeTypeProvidersInMemoryAnalysis")
     member val TryRecoverFcsProjects = base.GetValueProperty<bool>("TryRecoverFcsProjects")
+    member val GenerateSignatureFile = base.GetValueProperty<bool>("GenerateSignatureFile")
 
 
 [<SolutionInstanceComponent>]
@@ -220,6 +223,7 @@ type FSharpOptionsPage(lifetime: Lifetime, optionsPageContext, settings,
             this.AddBoolOption((fun key -> key.RedundantParensAnalysis), RichText(FSharpExperimentalFeatures.redundantParenAnalysis), null) |> ignore
             this.AddBoolOption((fun key -> key.Formatter), RichText(FSharpExperimentalFeatures.formatter), null) |> ignore
             this.AddBoolOptionWithComment((fun key -> key.NonFSharpProjectInMemoryAnalysis), nonFSharpProjectInMemoryAnalysis, "Requires restart") |> ignore
+            this.AddBoolOption((fun key -> key.GenerateSignatureFile), RichText(FSharpExperimentalFeatures.generateSignatureFile)) |> ignore
 
 
 [<ShellComponent>]

ReSharper.FSharp/src/FSharp.Common/src/Util/FSharpExperimentalFeatures.fs

@@ -13,6 +13,7 @@ type ExperimentalFeature =
     | RedundantParenAnalysis = 3
     | AssemblyReaderShim = 4
     | TryRecoverFcsProjects = 5
+    | GenerateSignatureFile = 6
 
 type FSharpExperimentalFeatureCookie(feature: ExperimentalFeature) =
     static let cookies = OneToListMap<ExperimentalFeature, IDisposable>()
@@ -45,6 +46,7 @@ type FSharpExperimentalFeatures() =
         | ExperimentalFeature.PostfixTemplates -> experimentalFeatures.EnablePostfixTemplates.Value
         | ExperimentalFeature.RedundantParenAnalysis -> experimentalFeatures.RedundantParensAnalysis.Value
         | ExperimentalFeature.TryRecoverFcsProjects -> experimentalFeatures.TryRecoverFcsProjects.Value
+        | ExperimentalFeature.GenerateSignatureFile -> experimentalFeatures.GenerateSignatureFile.Value
         | _ -> failwith $"Unexpected feature: {feature}"
 
     [<Extension>]

ReSharper.FSharp/src/FSharp.Psi.Features/src/LanguageService/FSharpElementFactory.fs

@@ -395,3 +395,23 @@ type FSharpElementFactory(languageService: IFSharpLanguageService, sourceFile: I
             let source = $"member val P = 3 with {accessors}"
             let t = getTypeDecl source
             t.MemberDeclarations[0].As<IAutoPropertyDeclaration>().AccessorsClause
+
+        member this.CreateEmptyFile() = createFile ""
+        
+        member this.CreateModule(name) =
+            let file = createFile $"module {name}"
+            match file.ModuleDeclarations.[0] with
+            | :? INamedModuleDeclaration as nmd -> nmd
+            | _ -> failwith "Could not get named module"
+
+        member this.CreateNamespace(name) =
+            let file = createFile $"namespace {name}"
+            match file.ModuleDeclarations.[0] with
+            | :? INamedNamespaceDeclaration as nnd -> nnd
+            | _ -> failwith "Could not get namespace"
+
+        member this.CreateNestedModule(name) =
+            let file = createFile $"module {name} = begin end"
+            match file.ModuleDeclarations.[0].Members.[0] with
+            | :? INestedModuleDeclaration as nmd -> nmd
+            | _ ->  failwith "Could not get nested module"

ReSharper.FSharp/src/FSharp.Psi.Intentions/FSharp.Psi.Intentions.fsproj

@@ -25,6 +25,7 @@
     <Compile Include="src\Intentions\SetNameAction.fs" />
     <Compile Include="src\Intentions\LetToUseAction.fs" />
     <Compile Include="src\Intentions\RenameFileToMatchTypeNameAction.fs" />
+    <Compile Include="src\Intentions\GenerateSignatureFileAction.fs" />
     <Compile Include="src\QuickFixes\FSharpQuickFixBase.fs" />
     <Compile Include="src\QuickFixes\RemoveUnusedOpensFix.fs" />
     <Compile Include="src\QuickFixes\ReplaceUseWithLetFix.fs" />

ReSharper.FSharp/src/FSharp.Psi.Intentions/src/Intentions/GenerateSignatureFileAction.fs

@@ -0,0 +1,100 @@
+namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Features.ContextActions
+
+open System.IO
+open JetBrains.ReSharper.Feature.Services.ContextActions
+open JetBrains.ReSharper.Plugins.FSharp.Psi
+open JetBrains.ReSharper.Plugins.FSharp.Psi.Features.Intentions
+open type JetBrains.ReSharper.Psi.PsiSourceFileExtensions
+open JetBrains.ReSharper.Plugins.FSharp
+open  JetBrains.ReSharper.Plugins.FSharp.Psi.Tree
+open JetBrains.ReSharper.Psi
+open JetBrains.ReSharper.Psi.ExtensionsAPI.Tree
+
+type TopLevelModuleOrNamespace =
+    {
+        IsModule: bool
+        Name: string
+        NestedModules: NestedModule list
+    }
+
+and NestedModule =
+    {
+        Name: string
+        NestedModules: NestedModule list
+    }
+
+[<ContextAction(Group = "F#", Name = "Generate signature file for current file", Priority = 1s,
+                Description = "Generate signature file for current file.")>]
+type GenerateSignatureFileAction(dataProvider: FSharpContextActionDataProvider) =
+    inherit FSharpContextActionBase(dataProvider)
+    
+    let mkSignatureFile (fsharpFile: IFSharpFile) : IFSharpFile =
+        let factory : IFSharpElementFactory = fsharpFile.CreateElementFactory()
+        let signatureFile : IFSharpFile = factory.CreateEmptyFile()
+        
+        let rec processModuleMembers (parent: IFSharpTreeNode) (members: IModuleMember seq) =
+            for m in members do
+                match m with
+                | :? INestedModuleDeclaration as nmd ->
+                    let nestedModuleNode = factory.CreateNestedModule(nmd.NameIdentifier.Name)
+                    // TODO: if the nested module has nested modules, clear the content (`begin end`) and process them.
+                    ModificationUtil.AddChild(parent, nestedModuleNode) |> ignore
+                | _ -> ()
+        
+        for decl in fsharpFile.ModuleDeclarations do
+            match decl with
+            | :? INamedModuleDeclaration as nmd ->
+                let moduleNode = factory.CreateModule(nmd.NameIdentifier.Name)
+                processModuleMembers moduleNode nmd.Members
+                ModificationUtil.AddChild(signatureFile, moduleNode) |> ignore
+            | :? INamedNamespaceDeclaration as nnd ->
+                let namespaceNode = factory.CreateModule(nnd.NameIdentifier.Name)
+                processModuleMembers namespaceNode nnd.Members
+                ModificationUtil.AddChild(signatureFile, namespaceNode) |> ignore
+            | _ -> ()
+
+        signatureFile
+
+    override this.Text = "Generate signature file for current file"
+    
+    override this.IsAvailable _ =
+        let solution = dataProvider.Solution
+        let isSettingEnabled = solution.IsFSharpExperimentalFeatureEnabled(ExperimentalFeature.GenerateSignatureFile)
+        if not isSettingEnabled then false else
+        let currentFSharpFile = dataProvider.PsiFile
+        let fcsService = currentFSharpFile.FcsCheckerService
+        let hasSignature = fcsService.FcsProjectProvider.HasPairFile dataProvider.SourceFile
+        not hasSignature
+        
+    override this.ExecutePsiTransaction(solution, _) =
+        let projectFile = dataProvider.SourceFile.ToProjectFile()
+        let fsharpFile = projectFile.GetPrimaryPsiFile().AsFSharpFile()
+        let physicalPath = dataProvider.SourceFile.ToProjectFile().Location.FileAccessPath
+        let fsiFile = Path.ChangeExtension(physicalPath, ".fsi")
+        
+        let signatureFile = mkSignatureFile fsharpFile
+        // try
+        //     let currentFSharpFile = dataProvider.PsiFile
+        //     let fcsService = currentFSharpFile.FcsCheckerService
+        //     let checkResult = fcsService.ParseAndCheckFile(currentFSharpFile.GetSourceFile(), "for signature file", true)
+        //     do
+        //         match checkResult with
+        //         | None -> ()
+        //         | Some { CheckResults = checkResult } ->
+        //         
+        //         match checkResult.GenerateSignature() with
+        //         | None -> ()
+        //         | Some signatureSourceText ->
+        //             let content = string signatureSourceText
+        //             File.WriteAllText(fsiFile, content)
+        // with ex ->
+        //     // TODO: show some balloon thing?
+        //     ()
+
+        // solution.InvokeUnderTransaction(fun transactionCookie ->
+        //     let virtualPath = FileSystemPath.TryParse(fsiFile).ToVirtualFileSystemPath()
+        //     let relativeTo = RelativeTo(projectFile, RelativeToType.Before)
+        //     transactionCookie.AddFile(projectFile.ParentFolder, virtualPath, context = OrderingContext(relativeTo))
+        //     |> ignore)
+
+        null

ReSharper.FSharp/src/FSharp.Psi/src/IFSharpElementFactory.cs

@@ -64,5 +64,10 @@ public interface IFSharpElementFactory
     ITypeParameterDeclarationList CreateTypeParameterOfTypeList(FSharpList<string> names);
 
     IAccessorsNamesClause CreateAccessorsNamesClause(bool withGetter, bool withSetter);
+
+    IFSharpFile CreateEmptyFile();
+    INamedModuleDeclaration CreateModule(string name);
+    INamedNamespaceDeclaration CreateNamespace(string name);
+    INestedModuleDeclaration CreateNestedModule(string name);
   }
 }