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

@@ -493,3 +493,17 @@ module Asynchronous =
             | Some ident when ident.idText = "Task" -> ReturnsTask
             | _ -> ReturnsNonAsync
         | _ -> ReturnsNonAsync
+    
+    let (|FSharpTypeAsync|FSharpTypeTask|FSharpTypeTaskNonGeneric|FSharpTypeNonAsync|) (fSharpType: FSharpType) =
+        try
+            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,32 @@
 module FSharpLint.Rules.Utilities
 
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Syntax
+
+module TypedTree =
+    let getFunctionReturnType
+        (checkInfo: FSharpCheckFileResults)
+        (lines: array<string>)
+        (funcIdent: SynLongIdent) : Option<FSharpType> =
+        let maybeSymbolUse =
+            checkInfo.GetSymbolUseAtLocation(
+                funcIdent.Range.EndLine,
+                funcIdent.Range.EndColumn,
+                lines.[funcIdent.Range.EndLine],
+                funcIdent.LongIdent |> List.map (fun ident -> ident.idText))
+        match maybeSymbolUse with
+        | Some symbolUse ->
+            match symbolUse.Symbol with
+            | :? FSharpMemberOrFunctionOrValue as func when func.IsFunction ->
+                let lastGenericArg = func.FullType.GenericArguments[func.FullType.GenericArguments.Count - 1]
+                if func.IsMember then
+                    Some <| lastGenericArg.GenericArguments[lastGenericArg.GenericArguments.Count - 1]
+                else
+                    Some lastGenericArg
+            | _ -> None
+        | _ -> None
+
 module LibraryHeuristics =
     type LibraryHeuristicResultByProjectName =
         | Likely