Parameter name hints

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

@@ -74,7 +74,7 @@ let unitTypeName = clrTypeName "Microsoft.FSharp.Core.Unit"
 
 
 let predefinedFunctionTypes =
-    [| operatorsModuleTypeName, [| "not"; "id"; "ignore"; "|>"; "<|"; "<>"; "=" |]
+    [| operatorsModuleTypeName, [| "not"; "id"; "ignore"; "|>"; "<|"; "<>"; "="; "typeof" |]
        intrinsicOperatorsTypeName, [| "||"; "&&" |] |]
     |> Array.collect (fun (typeName, names) -> [| for name in names -> name, typeName |])
     |> dict

ReSharper.FSharp/src/FSharp.Psi.Features/FSharp.Psi.Features.fsproj

@@ -64,6 +64,7 @@
     <Compile Include="src\Daemon\Stages\PipeChainTypeHintStage.fs" />
     <Compile Include="src\Daemon\Stages\InferredTypeCodeVisionProvider.fs" />
     <Compile Include="src\Daemon\Stages\FSharpSyntaxHighlightingStage.fs" />
+    <Compile Include="src\Daemon\Stages\ParameterNameHintStage.fs" />
     <Compile Include="src\Daemon\UsageChecking\FSharpUsageCheckingService.fs" />
     <Compile Include="src\Daemon\Analyzers\ReSpellerHelper.fs" />
     <Compile Include="src\Daemon\Analyzers\StringProblemsAnalyzer.fs" />

ReSharper.FSharp/src/FSharp.Psi.Features/src/Daemon/Stages/ParameterNameHintStage.fs

@@ -0,0 +1,217 @@
+namespace JetBrains.ReSharper.Plugins.FSharp.Psi.Features.Daemon.Stages
+
+open System
+open FSharp.Compiler.SourceCodeServices
+open JetBrains.ProjectModel
+open JetBrains.ReSharper.Daemon.Stages
+open JetBrains.ReSharper.Feature.Services.InlayHints
+open JetBrains.ReSharper.Feature.Services.ParameterNameHints
+open JetBrains.ReSharper.Feature.Services.ParameterNameHints.BlackList
+open JetBrains.ReSharper.Feature.Services.ParameterNameHints.ManagedLanguage
+open JetBrains.ReSharper.Plugins.FSharp
+open JetBrains.ReSharper.Plugins.FSharp.Psi
+open JetBrains.ReSharper.Plugins.FSharp.Psi.Features.Util
+open JetBrains.ReSharper.Plugins.FSharp.Psi.Impl
+open JetBrains.ReSharper.Plugins.FSharp.Psi.Resolve
+open JetBrains.ReSharper.Plugins.FSharp.Psi.Tree
+open JetBrains.ReSharper.Psi
+open JetBrains.ReSharper.Feature.Services.Daemon
+open JetBrains.ReSharper.Psi.Naming
+open JetBrains.ReSharper.Psi.Naming.Impl
+open JetBrains.ReSharper.Psi.Naming.Settings
+open JetBrains.ReSharper.Psi.Tree
+open JetBrains.UI.RichText
+open JetBrains.Util.Logging
+
+[<Language(typeof<FSharpLanguage>)>]
+type FSharpParameterNameHintsOptionStore(optionsStore: ManagedLanguageParameterNameHintsOptionsStore) =
+    interface ILanguageSpecificParameterNameHintsOptionsStore with
+        // todo: should we have our own cache key?
+        override x.GetBlackListCacheKey() = optionsStore.GetBlackListCacheKey()
+        override x.GetCategory() = optionsStore.GetCategory()
+        override x.GetLanguageSpecificSettingsEntries(context) = optionsStore.GetLanguageSpecificSettingsEntries(context)
+        override x.GetGlobalSettingsEntries(context) = optionsStore.GetGlobalSettingsEntries(context)
+        override x.GetBlackList(settingsStore) = optionsStore.GetBlackList(settingsStore)
+        override x.PersistBlackList(settingsStore, value) = optionsStore.PersistBlackList(settingsStore, value)
+
+[<Language(typeof<FSharpLanguage>)>]
+type ParameterNameHintsHighlightingStrategy() =
+    inherit ManagedLanguageParameterNameHintsHighlightingStrategy()
+
+    override x.GetShortDescription(parameter, argument) = RichText parameter.ShortName
+
+    override x.IsShouldBeIgnored(argument: IArgument) =
+        match argument with
+        | :? IFSharpExpression as expr -> isNotNull (FSharpMethodInvocationUtil.tryGetNamedArg expr)
+        | _ -> false
+
+    override x.IsShouldBeIgnored(expression: IExpression) = false
+    override x.IsLast(parameter) = parameter.IsParameterArray || parameter.IsVarArg
+    override x.CanBeConsideredAsLiteral(argument, expression) =
+        match expression with
+        | :? ILiteralExpr -> true
+        | _ -> isNull argument.MatchingParameter
+
+    override x.IsLambdaExpression(context, expression) =
+        context.ShowForLambdaExpressions && x.IsLambdaExpression expression
+    override x.IsLambdaExpression(expression) =
+        match expression with
+        | :? ILambdaExpr -> true
+        | _ -> false
+
+    override x.IsConstOrEnumMemberReference(context, parameter, expression) =
+        if not context.ShowForConstantsAndEnumMembers then false else
+
+        let refExpr = expression.As<IReferenceExpr>()
+        if isNull refExpr then false else
+
+        let field = refExpr.Reference.Resolve().DeclaredElement.As<IField>()
+        if isNull field then false else
+
+        field.IsStatic && field.IsReadonly || field.IsConstant || field.IsEnumMember
+
+    override x.IsUnclearCreationExpression(context, expression) = false
+    override x.IsMethodInvocation(context, expression) =
+        match expression with
+        | :? IAppExpr -> true
+        | _ -> false
+
+    override x.IsIntentionOfArgumentClearFromReferencedElement(context, parameter, uniqueParameterParts, expression) =
+        if not context.HideIfIntentionOfArgumentIsClearFromUsage then false else
+
+        match expression with
+        | :? IReferenceExpr as refExpr ->
+            let namingRule = x.GetTypeNamingRule(context, refExpr.GetSourceFile())
+            NamesHelper.IsLike(context.NameParser, context.NamingPolicyProvider, namingRule, parameter, uniqueParameterParts, refExpr.ShortName)
+        | _ -> false
+
+    override x.IsDefaultExpression(expression) = false
+
+    override x.GetExpression(expression, getThroughInvocation, getThroughCast) =
+        let expr = expression.As<IFSharpExpression>()
+        if isNull expr then null else
+
+        match expr.IgnoreInnerParens() with
+        | :? ICastExpr as castExpr when getThroughCast ->
+            x.GetExpression(castExpr.Expression, getThroughInvocation, getThroughCast)
+        | :? IAppExpr as appExpr ->
+            x.GetExpression(appExpr.FunctionExpression, getThroughInvocation, getThroughCast)
+        | expr ->
+            // todo: unary ops
+            expr :> _
+
+    override x.IsIntentionOfArgumentClearFromInvocation(context, parameter, uniqueParameterParts, expression) =
+        if not context.HideIfIntentionOfArgumentIsClearFromUsage then false else
+
+        // todo: nameof
+        // todo: invocation e.g. foo.|GetBar|() ?
+
+        match expression with
+        | :? IReferenceExpr as refExpr when FSharpExpressionUtil.isPredefinedFunctionRef "typeof" refExpr ->
+            let namingRule = x.GetTypeNamingRule(context, refExpr.GetSourceFile())
+            NamesHelper.IsLike(context.NameParser, context.NamingPolicyProvider, namingRule, parameter, uniqueParameterParts, "type")
+        | _ -> false
+
+    override x.GetTypeNamingRule(context, sourceFile) =
+        context.NamingRulesCache.GetNamingRule(NamedElementKinds.TypesAndNamespaces, FSharpLanguage.Instance, sourceFile)
+
+    override x.GetParametersNamingRule(context, sourceFile) =
+        context.NamingRulesCache.GetNamingRule(NamedElementKinds.Parameters, FSharpLanguage.Instance, sourceFile)
+
+    override x.GetParameterOwnerNamingRule(context, sourceFile) =
+        context.NamingRulesCache.GetNamingRule(NamedElementKinds.Method, FSharpLanguage.Instance, sourceFile)
+
+    override x.IsIntentionOfArgumentClearFromExplicitConversion(context, parameter, uniqueParameterParts, expression) =
+        if not context.HideIfIntentionOfArgumentIsClearFromUsage then false else
+
+        match expression with
+        | :? ICastExpr as castExpr when isNotNull castExpr.TypeUsage ->
+            // todo: check type cast expr
+            false
+        | _ -> false
+
+type ParameterNameHintHighlightingProcess
+        (logger: ILogger, fsFile, settings, daemonProcess, namingManager: NamingManager,
+         nameParser: NameParser, blackListMatcher: IParameterNameHintsBlackListMatcher,
+         strategy: ManagedLanguageParameterNameHintsHighlightingStrategy,
+         parameterNameHintsHighlightingProvider: IManagedLanguageParameterNameHintsHighlightingProvider,
+         customProviders: ICustomManagedLanguageParameterNameHintsHighlightingProvider seq) =
+    inherit FSharpDaemonStageProcessBase(fsFile, daemonProcess)
+
+    let policyProvider = fsFile.GetPsiServices().Naming.Policy.GetPolicyProvider(FSharpLanguage.Instance, fsFile.GetSourceFile(), settings)
+    let context = ParameterNameHintsHighlightingContext(settings, namingManager, nameParser, policyProvider, blackListMatcher, strategy, customProviders)
+
+    let resolveParamOwner (reference: FSharpSymbolReference) =
+        use compilationContextCookie = CompilationContextCookie.OverrideOrCreate(fsFile.GetResolveContext())
+        reference.Resolve().DeclaredElement.As<IParametersOwner>()
+
+    let resolveMethod (appExpr: IAppExpr) =
+        let refExpr = appExpr.FunctionExpression.As<IReferenceExpr>()
+        if isNull refExpr then null else resolveParamOwner refExpr.Reference
+
+    override x.Execute(committer) =
+        use _swc = logger.StopwatchCookie("Adorning parameter name hints", sprintf "sourceFile=%s" daemonProcess.SourceFile.Name)
+        let consumer = FilteringHighlightingConsumer(daemonProcess.SourceFile, fsFile, settings)
+        fsFile.ProcessThisAndDescendants(Processor(x, consumer))
+        committer.Invoke(DaemonStageResult(consumer.Highlightings))
+
+    override x.VisitPrefixAppExpr(prefixAppExpr, consumer) =
+        let mfv =
+            prefixAppExpr.Reference.TryGetFSharpSymbol()
+            |> Option.bind (function
+                | :? FSharpMemberOrFunctionOrValue as mfv -> Some mfv
+                | _ -> None)
+
+        match mfv with
+        | None -> ()
+        | Some mfv ->
+
+        let method = resolveMethod prefixAppExpr
+
+        let invokingExtensionMethod = mfv.IsExtensionMember && Some mfv.ApparentEnclosingEntity <> mfv.DeclaringEntity
+        let parametersOffset = if invokingExtensionMethod then 1 else 0
+
+        let highlightingRange = prefixAppExpr.ArgumentExpression.GetHighlightingRange()
+        let highlightings =
+            // todo: is this necessary/does it make a difference?
+            match method with
+            | :? IConstructor as constructor ->
+                parameterNameHintsHighlightingProvider.GetHighlightingsForConstructor(context, prefixAppExpr, constructor, highlightingRange, Action x.CheckForInterrupt)
+            | _ ->
+                parameterNameHintsHighlightingProvider.GetHighlightingsForMethod(context, prefixAppExpr, method, parametersOffset, highlightingRange, Action x.CheckForInterrupt)
+
+        for highlighting in highlightings do
+            consumer.AddHighlighting(highlighting)
+
+    override x.VisitAttribute(attribute, consumer) =
+        let constructor = resolveParamOwner(attribute.Reference).As<IConstructor>()
+        if isNull constructor then () else
+
+        let argumentsOwner = attribute :> IArgumentsOwner
+
+        let highlightingRange = attribute.ArgExpression.GetHighlightingRange()
+        let highlightings = parameterNameHintsHighlightingProvider.GetHighlightingsForConstructor(context, argumentsOwner, constructor, highlightingRange, Action x.CheckForInterrupt)
+
+        for highlighting in highlightings do
+            consumer.AddHighlighting(highlighting)
+
+[<DaemonStage(StagesBefore = [| typeof<GlobalFileStructureCollectorStage> |])>]
+type ParameterNameHintStage
+        (logger: ILogger, languageManager: ILanguageManager, namingManager: NamingManager,
+         nameParser: NameParser, parameterNameHintsOptionsStore: IParameterNameHintsOptionsStore,
+         blackListManager: IParameterNameHintsBlackListManager,
+         parameterNameHintsHighlightingProvider: IManagedLanguageParameterNameHintsHighlightingProvider,
+         customProviders: ICustomManagedLanguageParameterNameHintsHighlightingProvider seq) =
+    inherit FSharpDaemonStageBase()
+
+    override x.IsSupported(sourceFile, processKind) =
+        processKind = DaemonProcessKind.VISIBLE_DOCUMENT &&
+        base.IsSupported(sourceFile, processKind) &&
+        not (sourceFile.LanguageType.Is<FSharpSignatureProjectFileType>())
+
+    override x.CreateStageProcess(fsFile, settings, daemonProcess) =
+        if not (parameterNameHintsOptionsStore.IsEnabled settings) then null else
+
+        let blackListMatcher = blackListManager.GetMatcher(FSharpLanguage.Instance, settings)
+        let strategy = languageManager.GetService<ManagedLanguageParameterNameHintsHighlightingStrategy>(FSharpLanguage.Instance)
+        ParameterNameHintHighlightingProcess(logger, fsFile, settings, daemonProcess, namingManager, nameParser, blackListMatcher, strategy, parameterNameHintsHighlightingProvider, customProviders) :> _

ReSharper.FSharp/src/FSharp.Psi/src/Features/Daemon/Stages/FSharpDaemonStageProcessBase.cs

@@ -26,6 +26,12 @@ protected FSharpDaemonStageProcessBase(IFSharpFile fsFile, IDaemonProcess daemon
       SeldomInterruptChecker = new SeldomInterruptCheckerWithCheckTime(InterruptCheckTime);
     }
 
+    public void CheckForInterrupt()
+    {
+      if (DaemonProcess.InterruptFlag)
+        throw new OperationCanceledException();
+    }
+
     public IDaemonProcess DaemonProcess { get; }
     public abstract void Execute(Action<DaemonStageResult> committer);
   }

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 01 - Multiple literals.fs

@@ -0,0 +1,5 @@
+open System.Drawing
+
+Color.FromArgb(123, 150, 234) |> ignore
+Color.FromArgb(123, blue = 234, green = 150) |> ignore
+Color.FromArgb(green = 150, blue = 234, red = 123) |> ignore

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 01 - Multiple literals.fs.gold

@@ -0,0 +1,11 @@
+open System.Drawing
+
+Color.FromArgb(||(0)123, ||(1)150, ||(2)234) |> ignore
+Color.FromArgb(||(3)123, blue = 234, green = 150) |> ignore
+Color.FromArgb(green = 150, blue = 234, red = 123) |> ignore
+
+---------------------------------------------------------
+(0): ReSharper Parameter Name Hint: red, System.Drawing.Color.FromArgb
+(1): ReSharper Parameter Name Hint: green, System.Drawing.Color.FromArgb
+(2): ReSharper Parameter Name Hint: blue, System.Drawing.Color.FromArgb
+(3): ReSharper Parameter Name Hint: red, System.Drawing.Color.FromArgb

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 02 - Some literals.fs

@@ -0,0 +1,4 @@
+open System.Drawing
+
+let green = 234
+Color.FromArgb(123, green, 100) |> ignore

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 02 - Some literals.fs.gold

@@ -0,0 +1,8 @@
+open System.Drawing
+
+let green = 234
+Color.FromArgb(||(0)123, green, ||(1)100) |> ignore
+
+---------------------------------------------------------
+(0): ReSharper Parameter Name Hint: red, System.Drawing.Color.FromArgb
+(1): ReSharper Parameter Name Hint: blue, System.Drawing.Color.FromArgb

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 03 - Parentheses.fs

@@ -0,0 +1,7 @@
+open System.Drawing
+
+let green = 234
+
+Color.FromArgb((123), green, blue=100) |> ignore
+Color.FromArgb(123, (green), blue=100) |> ignore
+Color.FromArgb(123, green, blue=(100)) |> ignore

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 03 - Parentheses.fs.gold

@@ -0,0 +1,12 @@
+open System.Drawing
+
+let green = 234
+
+Color.FromArgb(||(0)(123), green, blue=100) |> ignore
+Color.FromArgb(||(1)123, (green), blue=100) |> ignore
+Color.FromArgb(||(2)123, green, blue=(100)) |> ignore
+
+---------------------------------------------------------
+(0): ReSharper Parameter Name Hint: red, System.Drawing.Color.FromArgb
+(1): ReSharper Parameter Name Hint: red, System.Drawing.Color.FromArgb
+(2): ReSharper Parameter Name Hint: red, System.Drawing.Color.FromArgb

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 04 - Ignore binary eq.fs

@@ -0,0 +1,4 @@
+open System.IO
+
+let recursive = false
+Directory.Delete("", (recursive=false))

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 04 - Ignore binary eq.fs.gold

@@ -0,0 +1,7 @@
+open System.IO
+
+let recursive = false
+Directory.Delete(||(0)"", (recursive=false))
+
+---------------------------------------------------------
+(0): ReSharper Parameter Name Hint: path, System.IO.Directory.Delete

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 05 - After constructor.fs

@@ -0,0 +1,7 @@
+open System.IO
+
+DirectoryInfo("").Delete()
+DirectoryInfo("").Delete ()
+DirectoryInfo("").Delete true
+DirectoryInfo("").Delete(true)
+DirectoryInfo("").Delete (true)

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 05 - After constructor.fs.gold

@@ -0,0 +1,17 @@
+open System.IO
+
+DirectoryInfo(||(0)"").Delete()
+DirectoryInfo(||(1)"").Delete ()
+DirectoryInfo(||(2)"").Delete ||(3)true
+DirectoryInfo(||(4)"").Delete(||(5)true)
+DirectoryInfo(||(6)"").Delete (||(7)true)
+
+---------------------------------------------------------
+(0): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(1): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(2): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(3): ReSharper Parameter Name Hint: recursive, System.IO.DirectoryInfo.Delete
+(4): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(5): ReSharper Parameter Name Hint: recursive, System.IO.DirectoryInfo.Delete
+(6): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(7): ReSharper Parameter Name Hint: recursive, System.IO.DirectoryInfo.Delete

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 06 - Ignored.fs

@@ -0,0 +1,5 @@
+open System.IO
+
+DirectoryInfo(path="") |> ignore
+DirectoryInfo("").Delete(recursive=true)
+DirectoryInfo("").Delete (recursive=true)

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/App 06 - Ignored.fs.gold

@@ -0,0 +1,9 @@
+open System.IO
+
+DirectoryInfo(path="") |> ignore
+DirectoryInfo(||(0)"").Delete(recursive=true)
+DirectoryInfo(||(1)"").Delete (recursive=true)
+
+---------------------------------------------------------
+(0): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(1): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/Constructor 01.fs

@@ -0,0 +1,6 @@
+open System.IO
+
+DirectoryInfo "" |> ignore
+DirectoryInfo("") |> ignore
+DirectoryInfo ("") |> ignore
+(DirectoryInfo "") |> ignore

ReSharper.FSharp/test/data/features/daemon/parameterNameHints/Constructor 01.fs.gold

@@ -0,0 +1,12 @@
+open System.IO
+
+DirectoryInfo ||(0)"" |> ignore
+DirectoryInfo(||(1)"") |> ignore
+DirectoryInfo (||(2)"") |> ignore
+(DirectoryInfo ||(3)"") |> ignore
+
+---------------------------------------------------------
+(0): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(1): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(2): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo
+(3): ReSharper Parameter Name Hint: path, System.IO.DirectoryInfo.DirectoryInfo