InlayHints: add option to show hints even if expression type is clear : IDEA-190611

java/java-impl/src/com/intellij/codeInsight/hints/JavaHintUtils.kt

@@ -258,8 +258,9 @@ fun inlayOffset(callArgument: PsiExpression, atEnd: Boolean): Int {
   return if (atEnd) callArgument.textRange.endOffset else callArgument.textRange.startOffset
 }
 
-private fun isUnclearExpression(callArgument: PsiElement): Boolean {
-  val isShowHint = when (callArgument) {
+private fun shouldShowHintsForExpression(callArgument: PsiElement): Boolean {
+  if (JavaInlayParameterHintsProvider.getInstance().isShowHintWhenExpressionTypeIsClear.get()) return true
+  return when (callArgument) {
     is PsiLiteralExpression -> true
     is PsiThisExpression -> true
     is PsiBinaryExpression -> true
@@ -271,8 +272,6 @@ private fun isUnclearExpression(callArgument: PsiElement): Boolean {
     }
     else -> false
   }
-
-  return isShowHint
 }
 
 
@@ -285,7 +284,7 @@ private class CallInfo(val regularArgs: List<CallArgumentInfo>, val varArg: PsiP
     for (callInfo in regularArgs) {
       val inlay = when {
         isErroneousArg(callInfo) -> null
-        isUnclearExpression(callInfo.argument) -> inlayInfo(callInfo)
+        shouldShowHintsForExpression(callInfo.argument) -> inlayInfo(callInfo)
         !callInfo.isAssignable(substitutor) -> inlayInfo(callInfo, showOnlyIfExistedBefore = true)
         else -> null
       }
@@ -320,7 +319,7 @@ private class CallInfo(val regularArgs: List<CallArgumentInfo>, val varArg: PsiP
 
     var hasUnassignable = false
     for (expr in varArgExpressions) {
-      if (isUnclearExpression(expr)) {
+      if (shouldShowHintsForExpression(expr)) {
         return inlayInfo(varArgExpressions.first(), varArg)
       }
       hasUnassignable = hasUnassignable || !varArg.isAssignable(expr, substitutor)

java/java-impl/src/com/intellij/codeInsight/hints/JavaInlayParameterHintsProvider.kt

@@ -113,12 +113,17 @@ class JavaInlayParameterHintsProvider : InlayParameterHintsProvider {
                                                   "Do not show for methods with same-named numbered parameters",
                                                   true)
 
+  val isShowHintWhenExpressionTypeIsClear: Option = Option("java.clear.expression.type",
+                                                           "Show hints even when type of expression is clear",
+                                                           false)
+
   override fun getSupportedOptions(): List<Option> {
     return listOf(
       isDoNotShowIfMethodNameContainsParameterName,
       isShowForParamsWithSameType,
       isDoNotShowForBuilderLikeMethods,
-      ignoreOneCharOneDigitHints
+      ignoreOneCharOneDigitHints,
+      isShowHintWhenExpressionTypeIsClear
     )
   }
 }

java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/inlays/JavaParameterNameHintsTest.kt

@@ -1037,6 +1037,35 @@ class Test {
 """)
   }
 
+  fun `test unclear expression type setting true`() {
+    JavaInlayParameterHintsProvider.getInstance().isShowHintWhenExpressionTypeIsClear.set(true)
+    check("""
+class Test {
+  void main() {
+        String data = "asdad";
+        foo(<hint text="info:"/>data);
+  }
+
+  void foo(String info) {}
+}
+""")
+  }
+
+
+  fun `test unclear expression type setting false`() {
+    JavaInlayParameterHintsProvider.getInstance().isShowHintWhenExpressionTypeIsClear.set(false)
+    check("""
+class Test {
+  void main() {
+        String data = "asdad";
+        foo(data);
+  }
+
+  void foo(String info) {}
+}
+""")
+  }
+
   fun getHints(): List<String> {
     val document = myFixture.getDocument(myFixture.file)
     val manager = ParameterHintsPresentationManager.getInstance()