Fix return hints with incomplete defs

Author: WhiteMemory99

src/main/kotlin/space/whitememory/pythoninlayparams/types/functions/PythonFunctionInlayTypeHintsCollector.kt

@@ -3,8 +3,10 @@ package space.whitememory.pythoninlayparams.types.functions
 import com.intellij.codeInsight.hints.InlayHintsSink
 import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiElement
+import com.intellij.psi.tree.TokenSet
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.refactoring.suggested.endOffset
+import com.jetbrains.python.PyTokenTypes
 import com.jetbrains.python.psi.PyElement
 import com.jetbrains.python.psi.PyFunction
 import com.jetbrains.python.psi.PyParameterList
@@ -18,7 +20,13 @@ class PythonFunctionInlayTypeHintsCollector(editor: Editor, settings: Any) :
     override val textBeforeTypeHint = "->"
 
     override fun validateExpression(element: PsiElement): Boolean {
-        return element is PyFunction
+        // Not a function or has only def keyword
+        if (element !is PyFunction || element.nameNode == null) {
+            return false
+        }
+
+        val colonToken = TokenSet.create(PyTokenTypes.COLON)
+        return element.node.getChildren(colonToken).isNotEmpty()
     }
 
     override fun collect(element: PsiElement, editor: Editor, sink: InlayHintsSink): Boolean {

src/main/kotlin/space/whitememory/pythoninlayparams/types/hints/HintResolver.kt

@@ -132,7 +132,8 @@ enum class HintResolver {
     },
 
     CLASS_ATTRIBUTE_HINT {
-        override fun isApplicable(settings: PythonVariablesInlayTypeHintsProvider.Settings): Boolean = !settings.showClassAttributeHints
+        override fun isApplicable(settings: PythonVariablesInlayTypeHintsProvider.Settings): Boolean =
+            !settings.showClassAttributeHints
 
         override fun shouldShowTypeHint(
             element: PyTargetExpression,
@@ -321,7 +322,9 @@ enum class HintResolver {
             if (isLiteralExpression(assignedValue)) {
                 if ((typeAnnotation is PyTypedDictType || (typeAnnotation is PyClassType && typeAnnotation.pyClass.qualifiedName == PyNames.DICT)) && assignedValue is PySequenceExpression) {
                     // Handle case when dict contains all literal expressions
-                    if (assignedValue.elements.isNotEmpty() && assignedValue.elements.all { it is PyKeyValueExpression && isLiteralExpression(it.value) }) {
+                    if (assignedValue.elements.isNotEmpty() && assignedValue.elements.all {
+                            it is PyKeyValueExpression && isLiteralExpression(it.value)
+                        }) {
                         return false
                     }
 
@@ -408,7 +411,12 @@ enum class HintResolver {
 
     companion object {
         val builtinMethods = setOf("globals", "locals")
-        fun resolve(element: PyTargetExpression, typeEvalContext: TypeEvalContext, settings: PythonVariablesInlayTypeHintsProvider.Settings): Boolean {
+
+        fun resolve(
+            element: PyTargetExpression,
+            typeEvalContext: TypeEvalContext,
+            settings: PythonVariablesInlayTypeHintsProvider.Settings
+        ): Boolean {
             val typeAnnotation = getExpressionAnnotationType(element, typeEvalContext)
 
             return resolveEnabled(settings).any {
@@ -454,13 +462,14 @@ enum class HintResolver {
                 || (element is PyFunction && typeAnnotation is PyNoneType)
                 || ((element is PyFunction || element is PyTargetExpression) && (element as PyTypeCommentOwner).typeCommentAnnotation != null)
                 || (element is PyAnnotationOwner && element.annotation != null)
-                || (element is PyFunction && !element.textContains(":".single()))
             ) {
                 return false
             }
 
             if (typeAnnotation is PyUnionType) {
-                return !typeAnnotation.members.all { PyTypeChecker.isUnknown(it, false, typeEvalContext) || (it is PyNoneType || it == null) }
+                return !typeAnnotation.members.all {
+                    PyTypeChecker.isUnknown(it, false, typeEvalContext) || (it is PyNoneType || it == null)
+                }
             }
 
             if (PyTypeChecker.isUnknown(typeAnnotation, false, typeEvalContext)) {