Add NoAsyncRunSynchronouslyInLibrary rule

docs/content/how-tos/rule-configuration.md

@@ -128,3 +128,4 @@ The following rules can be specified for linting.
 - [EnsureTailCallDiagnosticsInRecursiveFunctions (FL0085)](rules/FL0085.html)
 - [FavourAsKeyword (FL0086)](rules/FL0086.html)
 - [InterpolatedStringWithNoSubstitution (FL0087)](rules/FL0087.html)
+- [NoAsyncRunSynchronouslyInLibrary (FL0088)](rules/FL0088.html)

docs/content/how-tos/rules/FL0088.md

@@ -0,0 +1,68 @@
+---
+title: FL0088
+category: how-to
+hide_menu: true
+---
+
+# NoAsyncRunSynchronouslyInLibrary (FL0088)
+
+*Introduced in `0.26.8`*
+
+## Cause
+
+`Async.RunSynchronously` method is used to run async computation in library code.
+
+The rule assumes the code is in the library if none of the following is true:
+- The code is inside NUnit or MSTest test.
+- Namespace or project name contains "test" or "console".
+- Assembly has `[<EntryPoint>]` attribute one one of the functions/methods.
+
+## Rationale
+
+Using `Async.RunSynchronously` outside of scripts, tests, and console projects can lead to program becoming non-responsive.
+
+## How To Fix
+
+Remove `Async.RunSynchronously` and wrap the code that uses `async` computations in `async` computation, using `let!`, `use!`, `match!`, or `return!` keyword to get the result.
+
+Example:
+
+```fsharp
+type SomeType() =
+    member self.SomeMethod someParam =
+        let foo =
+            asyncSomeFunc someParam
+            |> Async.RunSynchronously
+        processFoo foo
+```
+
+The function can be modified to be asynchronous. In that case it might be better to prefix its name with Async:
+
+```fsharp
+type SomeType() =
+    member self.AsyncSomeMethod someParam = async {
+        let! foo = asyncSomeFunc someParam
+        return processFoo foo
+    }
+```
+
+In case the method/function is public, a nice C#-friendly overload that returns `Task<'T>` could be provided, suffixed with Async, that just calls the previous method with `Async.StartAsTask`:
+
+```fsharp
+type SomeType() =
+    member self.AsyncSomeMethod someParam = async {
+        let! foo = asyncSomeFunc someParam
+        return processFoo foo
+    }
+    member self.SomeMethodsync someParam =
+        self.AsyncSomeMethod someParam
+        |> Async.StartAsTask
+```
+
+## Rule Settings
+
+    {
+        "noAsyncRunSynchronouslyInLibrary": {
+            "enabled": true
+        }
+    }

src/FSharpLint.Console/Program.fs

@@ -165,9 +165,9 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
         try
             let lintResult =
                 match fileType with
-                | FileType.File -> Lint.lintFile lintParams target
-                | FileType.Source -> Lint.lintSource lintParams target
-                | FileType.Solution -> Lint.lintSolution lintParams target toolsPath
+                | FileType.File -> Lint.asyncLintFile lintParams target |> Async.RunSynchronously
+                | FileType.Source -> Lint.asyncLintSource lintParams target |> Async.RunSynchronously
+                | FileType.Solution -> Lint.asyncLintSolution lintParams target toolsPath |> Async.RunSynchronously
                 | FileType.Wildcard ->
                     output.WriteInfo "Wildcard detected, but not recommended. Using a project (slnx/sln/fsproj) can detect more issues."
                     let files = expandWildcard target
@@ -176,9 +176,9 @@ let private start (arguments:ParseResults<ToolArgs>) (toolsPath:Ionide.ProjInfo.
                         LintResult.Success List.empty
                     else
                         output.WriteInfo $"Found %d{List.length files} file(s) matching pattern '%s{target}'."
-                        Lint.lintFiles lintParams files
+                        Lint.asyncLintFiles lintParams files |> Async.RunSynchronously
                 | FileType.Project
-                | _ -> Lint.lintProject lintParams target toolsPath
+                | _ -> Lint.asyncLintProject lintParams target toolsPath |> Async.RunSynchronously
             handleLintResult lintResult
         with
         | exn ->

src/FSharpLint.Core/Application/Configuration.fs

@@ -474,7 +474,8 @@ type Configuration =
       SuggestUseAutoProperty:EnabledConfig option
       EnsureTailCallDiagnosticsInRecursiveFunctions:EnabledConfig option
       FavourAsKeyword:EnabledConfig option 
-      InterpolatedStringWithNoSubstitution:EnabledConfig option }
+      InterpolatedStringWithNoSubstitution:EnabledConfig option
+      NoAsyncRunSynchronouslyInLibrary:EnabledConfig option}
 with
     static member Zero = {
         Global = None
@@ -570,6 +571,7 @@ with
         EnsureTailCallDiagnosticsInRecursiveFunctions = None
         FavourAsKeyword = None
         InterpolatedStringWithNoSubstitution = None
+        NoAsyncRunSynchronouslyInLibrary = None
     }
 
 // fsharplint:enable RecordFieldNames
@@ -766,6 +768,7 @@ let flattenConfig (config:Configuration) =
                 config.EnsureTailCallDiagnosticsInRecursiveFunctions |> Option.bind (constructRuleIfEnabled EnsureTailCallDiagnosticsInRecursiveFunctions.rule)
                 config.FavourAsKeyword |> Option.bind (constructRuleIfEnabled FavourAsKeyword.rule)
                 config.InterpolatedStringWithNoSubstitution |> Option.bind (constructRuleIfEnabled InterpolatedStringWithNoSubstitution.rule)
+                config.NoAsyncRunSynchronouslyInLibrary |> Option.bind (constructRuleIfEnabled NoAsyncRunSynchronouslyInLibrary.rule)
             |]
 
     findDeprecation config deprecatedAllRules allRules