Formalised type widening behaviour for overidden fields/methods.

Essentially, an explicit type annotation will always take
precedence over an implicitly inferred type. Thus, if you wish
a sub-class to narrow an overridden type, you ought to do so
explicitly with a type annotation.

The only time the child's type will automatically narrow a
parent's type is if the parent did not provide an explicit type
annotation for the field/method.

src/main/java/com/tang/intellij/lua/codeInsight/LuaParameterInfoHandler.kt

@@ -108,9 +108,10 @@ class LuaParameterInfoHandler : ParameterInfoHandler<LuaArgs, ParameterInfoType>
             o.sig.processParameters(null, o.isColonStyle) { idx, pi ->
                 if (idx > 0) append(", ")
                 if (idx == index) start = length
+                val ty = pi.ty ?: Ty.UNKNOWN
                 append(pi.name)
                 append(": ")
-                append(pi.ty.displayName)
+                append(ty.displayName)
                 if (idx == index) end = length
                 true
             }

src/main/java/com/tang/intellij/lua/codeInsight/inspection/AssignTypeInspection.kt

@@ -21,6 +21,7 @@ import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.util.PsiTreeUtil
 import com.tang.intellij.lua.project.LuaSettings
 import com.tang.intellij.lua.psi.*
 import com.tang.intellij.lua.search.PsiSearchContext
@@ -82,7 +83,7 @@ class AssignTypeInspection : StrictInspection() {
                     }
                 }
 
-                fun inspectAssignment(assignees: List<LuaTypeGuessable>, expressions: List<LuaExpression<*>>?) {
+                fun inspectAssignment(statement: LuaStatement?, assignees: List<LuaTypeGuessable>, expressions: List<LuaExpression<*>>?) {
                     if (expressions == null || expressions.size == 0) {
                         return
                     }
@@ -91,6 +92,7 @@ class AssignTypeInspection : StrictInspection() {
                     var assigneeIndex = 0
                     var variadicTy: ITy? = null
                     var lastExpressionFirstAssigneeIndex = 0
+                    val isClassDeclaration = statement?.comment?.tagClass != null
 
                     for (expressionIndex in 0 until expressions.size) {
                         val isLastExpression = expressionIndex == expressions.size - 1
@@ -157,7 +159,7 @@ class AssignTypeInspection : StrictInspection() {
                                 value = variadicTy
                             }
 
-                            if (assignees.size == 1 && LuaPsiTreeUtil.findAncestorOfType(assignee, LuaStatement::class.java)?.comment?.tagClass != null) {
+                            if (isClassDeclaration) {
                                 if (value !is TyTable) {
                                     myHolder.registerProblem(expression, "Type mismatch. Required: 'table' Found: '%s'".format(value.displayName))
                                 }
@@ -218,12 +220,22 @@ class AssignTypeInspection : StrictInspection() {
 
                 override fun visitAssignStat(o: LuaAssignStat) {
                     super.visitAssignStat(o)
-                    inspectAssignment(o.varExprList.expressionList, o.valueExprList?.expressionList)
+                    inspectAssignment(o, o.varExprList.expressionList, o.valueExprList?.expressionList)
                 }
 
                 override fun visitLocalDefStat(o: LuaLocalDefStat) {
                     super.visitLocalDefStat(o)
-                    inspectAssignment(o.localDefList, o.exprList?.expressionList)
+                    inspectAssignment(o, o.localDefList, o.exprList?.expressionList)
+                }
+
+                override fun visitTableField(o: LuaTableField) {
+                    super.visitTableField(o)
+
+                    o.valueExpr?.let { valueExpr ->
+                        if (o.isExplicitlyTyped) {
+                            inspectAssignment(null, listOf(o), listOf(valueExpr))
+                        }
+                    }
                 }
             }
 }

src/main/java/com/tang/intellij/lua/comment/LuaCommentUtil.kt

@@ -62,27 +62,21 @@ object LuaCommentUtil {
             val parent = element.parent
 
             if (parent is LuaTableField) {
-                val tableFieldComment = parent.comment
-
-                // If we encounter a table field with an EmmyDoc, that isn't a type definition, return that comment.
-                if (tableFieldComment?.findTag(LuaDocTagType::class.java) == null) {
-                    return tableFieldComment
-                }
+                // If the closure is being assigned to table field, use the field's comment
+                return parent.comment
             }
 
             val grandParent = element.parent.parent
-            val assignmentComment = if (grandParent is LuaLocalDefStat && grandParent.localDefList.size == 1) {
+            val assignmentComment = if (grandParent is LuaLocalDefStat) {
                 grandParent.comment
-            } else if (grandParent is LuaAssignStat && grandParent.varExprList.expressionList.size == 1) {
+            } else if (grandParent is LuaAssignStat) {
                 grandParent.comment
             } else {
                 null
             }
 
-            // If we encounter a closure assignment with an EmmyDoc, that isn't a type definition, return that comment.
-            if (assignmentComment?.findTag(LuaDocTagType::class.java) == null) {
-                return assignmentComment
-            }
+            // If the closure is a value of a (single value) assignment statement, use that comment.
+            return assignmentComment
         }
 
         return null