Add NoAsyncRunSynchronouslyInLibrary rule

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

@@ -130,3 +130,4 @@ The following rules can be specified for linting.
 - [InterpolatedStringWithNoSubstitution (FL0087)](rules/FL0087.html)
 - [IndexerAccessorStyleConsistency (FL0088)](rules/FL0088.html)
 - [FavourSingleton (FL0089)](rules/FL0089.html)
+- [NoAsyncRunSynchronouslyInLibrary (FL0090)](rules/FL0090.html)

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

@@ -0,0 +1,68 @@
+---
+title: FL0090
+category: how-to
+hide_menu: true
+---
+
+# NoAsyncRunSynchronouslyInLibrary (FL0090)
+
+*Introduced in `0.26.10`*
+
+## 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
+
+Your library code might be consumed by certain type of programs which have strict threading requirements (e.g. a long running operation shouldn't be run on the main thread of a desktop app, or it will make the app look like it's hanging for a while), so it's better to expose asynchronous code with `Async<'TResult>` or `Task`/`Task<'TResult>` return types, so that the consumer of your library can decide how/when to start the operation.
+
+## 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.SomeMethodAsync someParam =
+        self.AsyncSomeMethod someParam
+        |> Async.StartAsTask
+```
+
+## Rule Settings
+
+    {
+        "noAsyncRunSynchronouslyInLibrary": {
+            "enabled": true
+        }
+    }

src/FSharpLint.Console/Program.fs

@@ -158,9 +158,9 @@ let private lint
     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
@@ -169,9 +169,9 @@ let private lint
                     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

@@ -554,7 +554,8 @@ type Configuration =
       EnsureTailCallDiagnosticsInRecursiveFunctions:EnabledConfig option
       FavourAsKeyword:EnabledConfig option 
       InterpolatedStringWithNoSubstitution:EnabledConfig option
-      FavourSingleton:EnabledConfig option }
+      FavourSingleton:EnabledConfig option
+      NoAsyncRunSynchronouslyInLibrary:EnabledConfig option}
 with
     static member Zero = {
         Global = None
@@ -656,6 +657,7 @@ with
         FavourAsKeyword = None
         InterpolatedStringWithNoSubstitution = None
         FavourSingleton = None
+        NoAsyncRunSynchronouslyInLibrary = None
     }
 
 // fsharplint:enable RecordFieldNames
@@ -859,6 +861,7 @@ let flattenConfig (config:Configuration) =
                 config.FavourAsKeyword |> Option.bind (constructRuleIfEnabled FavourAsKeyword.rule)
                 config.InterpolatedStringWithNoSubstitution |> Option.bind (constructRuleIfEnabled InterpolatedStringWithNoSubstitution.rule)
                 config.FavourSingleton |> Option.bind (constructRuleIfEnabled FavourSingleton.rule)
+                config.NoAsyncRunSynchronouslyInLibrary |> Option.bind (constructRuleIfEnabled NoAsyncRunSynchronouslyInLibrary.rule)
             |]
 
     findDeprecation config deprecatedAllRules allRules