SynchronousFunctionNames: check typed tree

If there is no explicit return type.

Author: webwarrior-ws

src/FSharpLint.Core/Rules/Conventions/Naming/SynchronousFunctionNames.fs

@@ -5,11 +5,9 @@ open FSharpLint.Framework
 open FSharpLint.Framework.Suggestion
 open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
-open Helper.Naming.Asynchronous
 open FSharp.Compiler.Syntax
-open FSharp.Compiler.Symbols
-
-let asyncSuffixOrPrefix = "Async"
+open Helper.Naming.Asynchronous
+open Utilities.TypedTree
 
 let runner (args: AstNodeRuleParams) =
     let emitWarning range (newFunctionName: string) =
@@ -21,28 +19,38 @@ let runner (args: AstNodeRuleParams) =
                 TypeChecks = List.empty
             }
 
+    let checkIdentifier (funcIdent: SynLongIdent) identRange =
+        match funcIdent with
+        | HasAsyncPrefix name ->
+            let startsWithLowercase = Char.IsLower name.[0]
+            let nameWithoutAsync = name.Substring asyncSuffixOrPrefix.Length
+            let suggestedName = 
+                if startsWithLowercase then
+                    sprintf "%c%s" (Char.ToLowerInvariant nameWithoutAsync.[0]) (nameWithoutAsync.Substring 1)
+                else
+                    nameWithoutAsync
+            emitWarning identRange suggestedName
+        | HasAsyncSuffix name ->
+            let nameWithoutAsync = name.Substring(0, name.Length - asyncSuffixOrPrefix.Length)
+            emitWarning identRange nameWithoutAsync
+        | HasNoAsyncPrefixOrSuffix _ -> Array.empty
+
     match args.AstNode with
     | AstNode.Binding (SynBinding (_, _, _, _, attributes, _, _, SynPat.LongIdent(funcIdent, _, _, _, _, identRange), returnInfo, _, _, _, _))
         when not <| Helper.Naming.isAttribute "Obsolete" attributes ->
         match returnInfo with
         | Some ReturnsNonAsync ->
-            match funcIdent with
-            | HasAsyncPrefix name ->
-                let startsWithLowercase = Char.IsLower name.[0]
-                let nameWithoutAsync = name.Substring asyncSuffixOrPrefix.Length
-                let suggestedName = 
-                    if startsWithLowercase then
-                        sprintf "%c%s" (Char.ToLowerInvariant nameWithoutAsync.[0]) (nameWithoutAsync.Substring 1)
-                    else
-                        nameWithoutAsync
-                emitWarning identRange suggestedName
-            | HasAsyncSuffix name ->
-                let nameWithoutAsync = name.Substring(0, name.Length - asyncSuffixOrPrefix.Length)
-                emitWarning identRange nameWithoutAsync
-            | HasNoAsyncPrefixOrSuffix _ -> Array.empty
+            checkIdentifier funcIdent identRange
         | None -> 
-            // TODO: get type using typed tree in args.CheckInfo
-            Array.empty
+            match args.CheckInfo with
+            | Some checkInfo ->
+                match getFunctionReturnType checkInfo args.Lines funcIdent with
+                | Some returnType ->
+                    match returnType with
+                    | FSharpTypeNonAsync -> checkIdentifier funcIdent identRange
+                    | _ -> Array.empty
+                | None -> Array.empty
+            | None -> Array.empty
         | _ ->
             Array.empty
     | _ -> Array.empty

src/FSharpLint.Core/Rules/NamingHelper.fs

@@ -476,7 +476,11 @@ module Asynchronous =
     let (|HasAsyncPrefix|HasAsyncSuffix|HasNoAsyncPrefixOrSuffix|) (pattern: SynLongIdent) =
         match List.tryLast pattern.LongIdent with
         | Some name ->
-            if name.idText.StartsWith(asyncSuffixOrPrefix, StringComparison.InvariantCultureIgnoreCase) then
+            if not (isNotDoubleBackTickedIdent name) then
+                // Consider any identifier surrounded by double backticks (usually used as test names)
+                // to not have Async prefix or suffix.
+                HasNoAsyncPrefixOrSuffix name.idText
+            elif name.idText.StartsWith(asyncSuffixOrPrefix, StringComparison.InvariantCultureIgnoreCase) then
                 HasAsyncPrefix name.idText
             elif name.idText.EndsWith asyncSuffixOrPrefix then
                 HasAsyncSuffix name.idText
@@ -493,3 +497,19 @@ module Asynchronous =
             | Some ident when ident.idText = "Task" -> ReturnsTask
             | _ -> ReturnsNonAsync
         | _ -> ReturnsNonAsync
+    
+    let (|FSharpTypeAsync|FSharpTypeTask|FSharpTypeTaskNonGeneric|FSharpTypeNonAsync|) (fSharpType: FSharpType) =
+        try
+            // BasicQualifiedName may throw InvalidOperationException for some types
+            // e.g. arrays, but not for Async<'T> or Task<'T>, so assume non-async type.
+            match fSharpType.BasicQualifiedName with
+            | "Microsoft.FSharp.Control.FSharpAsync`1" -> FSharpTypeAsync
+            | name when name.StartsWith "System.Threading.Tasks.Task" ->
+                if fSharpType.GenericArguments.Count > 0 then
+                    FSharpTypeTask
+                else
+                    FSharpTypeTaskNonGeneric
+            | _ -> FSharpTypeNonAsync
+        with
+        | :? InvalidOperationException ->
+            FSharpTypeNonAsync

src/FSharpLint.Core/Rules/Utilities.fs

@@ -1,5 +1,43 @@
 module FSharpLint.Rules.Utilities
 
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Syntax
+
+module TypedTree =
+    let tryGetLastGenericArg (fSharpType: FSharpType) =
+        Seq.tryLast fSharpType.GenericArguments
+
+    [<TailCall>]
+    let rec private getReturnType (fSharpType: FSharpType) =
+        if fSharpType.IsFunctionType then
+            match tryGetLastGenericArg fSharpType with
+            | Some argType -> getReturnType argType
+            | None -> fSharpType
+        else
+            fSharpType
+
+    let getFunctionReturnType
+        (checkInfo: FSharpCheckFileResults)
+        (lines: array<string>)
+        (funcIdent: SynLongIdent) : Option<FSharpType> =
+        let maybeSymbolUse =
+            match List.tryLast funcIdent.LongIdent with
+            | Some ident ->
+                checkInfo.GetSymbolUseAtLocation(
+                    ident.idRange.EndLine,
+                    ident.idRange.EndColumn,
+                    lines.[ident.idRange.EndLine - 1],
+                    List.singleton ident.idText)
+            | None -> None
+        match maybeSymbolUse with
+        | Some symbolUse ->
+            match symbolUse.Symbol with
+            | :? FSharpMemberOrFunctionOrValue as func when func.IsFunction ->
+                Some <| getReturnType func.FullType
+            | _ -> None
+        | _ -> None
+
 module LibraryHeuristics =
     type LibraryHeuristicResultByProjectName =
         | Likely