Emit not-null assertions for enhanced types

compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.jvm
+
+import com.intellij.openapi.util.text.StringUtil
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
+import org.jetbrains.kotlin.jvm.bindingContextSlices.RUNTIME_ASSERTION_INFO
+import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
+import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
+import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.upperIfFlexible
+import kotlin.platform.platformStatic
+
+public class RuntimeAssertionInfo(public val needNotNullAssertion: Boolean, public val message: String) {
+    public interface DataFlowExtras {
+        class OnlyMessage(message: String) : DataFlowExtras {
+            override val canBeNull: Boolean get() = true
+            override val possibleTypes: Set<JetType> get() = setOf()
+            override val presentableText: String = message
+        }
+
+        val canBeNull: Boolean
+        val possibleTypes: Set<JetType>
+        val presentableText: String
+    }
+
+    companion object {
+        platformStatic public fun create(
+                expectedType: JetType,
+                expressionType: JetType,
+                dataFlowExtras: DataFlowExtras
+        ): RuntimeAssertionInfo? {
+            fun assertNotNull(): Boolean {
+                if (expectedType.isError() || expressionType.isError()) return false
+
+                // T : Any, T! = T..T?
+                // Let T$ will be copy of T! with enhanced nullability.
+                // Cases when nullability assertion needed: T! -> T, T$ -> T
+
+                // Expected type either T?, T! or T$
+                if (TypeUtils.isNullableType(expectedType) || expectedType.hasEnhancedNullability()) return false
+
+                // Expression type is not nullable and not enhanced (neither T?, T! or T$)
+                val isExpressionTypeNullable = TypeUtils.isNullableType(expressionType)
+                if (!isExpressionTypeNullable && !expressionType.hasEnhancedNullability()) return false
+
+                // Smart-cast T! or T?
+                if (!dataFlowExtras.canBeNull && isExpressionTypeNullable) return false
+
+                return true
+            }
+
+            return if (assertNotNull())
+                RuntimeAssertionInfo(needNotNullAssertion = true, message = dataFlowExtras.presentableText)
+            else
+                null
+        }
+
+        private fun JetType.hasEnhancedNullability()
+                = getAnnotations().findAnnotation(JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION) != null
+    }
+}
+
+public object RuntimeAssertionsTypeChecker : AdditionalTypeChecker {
+    override fun checkType(expression: JetExpression, expressionType: JetType, c: ResolutionContext<*>) {
+        if (TypeUtils.noExpectedType(c.expectedType)) return
+
+        val assertionInfo = RuntimeAssertionInfo.create(
+                c.expectedType,
+                expressionType,
+                object : RuntimeAssertionInfo.DataFlowExtras {
+                    override val canBeNull: Boolean
+                        get() = c.dataFlowInfo.getNullability(dataFlowValue).canBeNull()
+                    override val possibleTypes: Set<JetType>
+                        get() = c.dataFlowInfo.getPossibleTypes(dataFlowValue)
+                    override val presentableText: String
+                        get() = StringUtil.trimMiddle(expression.getText(), 50)
+
+                    private val dataFlowValue = DataFlowValueFactory.createDataFlowValue(expression, expressionType, c)
+                }
+        )
+
+        if (assertionInfo != null) {
+            c.trace.record(RUNTIME_ASSERTION_INFO, expression, assertionInfo)
+        }
+    }
+
+    override fun checkReceiver(
+            receiverParameter: ReceiverParameterDescriptor,
+            receiverArgument: ReceiverValue,
+            safeAccess: Boolean,
+            c: CallResolutionContext<*>
+    ) { }
+}

compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.jvm.bindingContextSlices
+
+import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo
+import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice
+import org.jetbrains.kotlin.util.slicedMap.RewritePolicy
+import org.jetbrains.kotlin.util.slicedMap.WritableSlice
+import org.jetbrains.kotlin.utils.DO_NOTHING
+
+public val RUNTIME_ASSERTION_INFO: WritableSlice<JetExpression, RuntimeAssertionInfo> = BasicWritableSlice(RewritePolicy.DO_NOTHING)

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.cfg.WhenChecker
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.jvm.RuntimeAssertionsTypeChecker
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNotNull
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNullable
@@ -63,7 +64,7 @@ public class KotlinJvmCheckerProvider(private val module: ModuleDescriptor) : Ad
                                         JavaAnnotationMethodCallChecker(), TraitDefaultMethodCallChecker(),
                                         ReflectionAPICallChecker(module)),
 
-        additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker()),
+        additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker(), RuntimeAssertionsTypeChecker),
         additionalSymbolUsageValidators = listOf()
 )