Make project compilable after types enhancement

compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.types.JetType
 import java.util.*
 
 public class AccessorForConstructorDescriptor(
@@ -38,6 +39,8 @@ public class AccessorForConstructorDescriptor(
 
     override fun isPrimary(): Boolean = false
 
+    override fun getReturnType(): JetType = super<AbstractAccessorForFunctionDescriptor>.getReturnType()!!
+
     init {
         initialize(
                 DescriptorUtils.getReceiverParameterType(getExtensionReceiverParameter()),

compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt

@@ -49,7 +49,7 @@ open class BranchedValue(
     open fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
         if (arg1 is CondJump) arg1.condJump(jumpLabel, v, jumpIfFalse) else arg1.put(operandType, v)
         arg2?.put(operandType, v)
-        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode], v), jumpLabel);
+        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode]!!, v), jumpLabel);
     }
 
     open fun loopJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt

@@ -284,7 +284,7 @@ class RawFileMapping(val name: String, val path: String) {
             if (rangeMappings.isNotEmpty() && isLastMapped && couldFoldInRange(lastMappedWithNewIndex, source)) {
                 rangeMapping = rangeMappings.last()
                 rangeMapping.range += source - lastMappedWithNewIndex
-                dest = lineMappings[lastMappedWithNewIndex] + source - lastMappedWithNewIndex
+                dest = lineMappings[lastMappedWithNewIndex]!! + source - lastMappedWithNewIndex
             }
             else {
                 dest = currentIndex + 1

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt

@@ -139,7 +139,7 @@ public object LabelNormalizationMethodTransformer : MethodTransformer() {
     }
 
     private fun isRemoved(labelNode: LabelNode): Boolean = removedLabelNodes.contains(labelNode)
-    private fun getNew(oldLabelNode: LabelNode): LabelNode = newLabelNodes[oldLabelNode]
+    private fun getNew(oldLabelNode: LabelNode): LabelNode = newLabelNodes[oldLabelNode]!!
 }
 
 private fun InsnList.replaceNodeGetNext(oldNode: AbstractInsnNode, newNode: AbstractInsnNode): AbstractInsnNode? {

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt

@@ -134,19 +134,19 @@ public class FixStackAnalyzer(
             val returnValue = pop()
             clearStack()
             val savedValues = savedStacks[beforeInlineMarker]
-            pushAll(savedValues)
+            pushAll(savedValues!!)
             push(returnValue)
         }
         else {
             val savedValues = savedStacks[beforeInlineMarker]
-            pushAll(savedValues)
+            pushAll(savedValues!!)
         }
     }
 
     private fun FixStackFrame.executeRestoreStackInTryCatch(insn: AbstractInsnNode) {
         val saveNode = context.saveStackMarkerForRestoreMarker[insn]
         val savedValues = savedStacks.getOrElse(saveNode) {
-            throw AssertionError("${indexOf(insn)}: Restore stack is unavailable for ${indexOf(saveNode)}")
+            throw AssertionError("${indexOf(insn)}: Restore stack is unavailable for ${indexOf(saveNode!!)}")
         }
         pushAll(savedValues)
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/LocalVariablesManager.kt

@@ -39,7 +39,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
     }
 
     fun allocateVariablesForSaveStackMarker(saveStackMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
-        val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker].size()
+        val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker]!!.size()
         return allocateNewHandle(numRestoreStackMarkers, saveStackMarker, savedStackValues)
     }
 
@@ -54,7 +54,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
 
     fun getSavedStackDescriptorOrNull(restoreStackMarker: AbstractInsnNode): SavedStackDescriptor {
         val saveStackMarker = context.saveStackMarkerForRestoreMarker[restoreStackMarker]
-        return allocatedHandles[saveStackMarker].savedStackDescriptor
+        return allocatedHandles[saveStackMarker]!!.savedStackDescriptor
     }
 
     private fun getFirstUnusedLocalVariableIndex(): Int =
@@ -64,7 +64,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
 
     fun markRestoreStackMarkerEmitted(restoreStackMarker: AbstractInsnNode) {
         val saveStackMarker = context.saveStackMarkerForRestoreMarker[restoreStackMarker]
-        markEmitted(saveStackMarker)
+        markEmitted(saveStackMarker!!)
     }
 
     fun allocateVariablesForBeforeInlineMarker(beforeInlineMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
@@ -73,16 +73,16 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
 
     fun getBeforeInlineDescriptor(afterInlineMarker: AbstractInsnNode): SavedStackDescriptor {
         val beforeInlineMarker = context.openingInlineMethodMarker[afterInlineMarker]
-        return allocatedHandles[beforeInlineMarker].savedStackDescriptor
+        return allocatedHandles[beforeInlineMarker]!!.savedStackDescriptor
     }
 
     fun markAfterInlineMarkerEmitted(afterInlineMarker: AbstractInsnNode) {
         val beforeInlineMarker = context.openingInlineMethodMarker[afterInlineMarker]
-        markEmitted(beforeInlineMarker)
+        markEmitted(beforeInlineMarker!!)
     }
 
     private fun markEmitted(saveStackMarker: AbstractInsnNode) {
-        val allocatedHandle = allocatedHandles[saveStackMarker]
+        val allocatedHandle = allocatedHandles[saveStackMarker]!!
         allocatedHandle.markRestoreNodeEmitted()
         if (allocatedHandle.isFullyEmitted()) {
             allocatedHandles.remove(saveStackMarker)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -94,7 +94,7 @@ public open class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             return INTERNAL_ERROR
         }
         catch (e: CliOptionProcessingException) {
-            messageSeverityCollector.report(CompilerMessageSeverity.ERROR, e.getMessage(), CompilerMessageLocation.NO_LOCATION)
+            messageSeverityCollector.report(CompilerMessageSeverity.ERROR, e.getMessage()!!, CompilerMessageLocation.NO_LOCATION)
             return INTERNAL_ERROR
         }
         catch (t: Throwable) {

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

@@ -61,7 +61,7 @@ public class JavaAnnotationCallChecker : CallChecker {
             if (it.getArgumentExpression() != null) {
                 context.trace.report(
                         diagnostic.on(
-                                it.getArgumentExpression()
+                                it.getArgumentExpression()!!
                         )
                 )
             }

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

@@ -172,7 +172,7 @@ public class PublicFieldAnnotationChecker: DeclarationChecker {
         if (descriptor !is PropertyDescriptor) {
             report()
         }
-        else if (!bindingContext.get<PropertyDescriptor, Boolean>(BindingContext.BACKING_FIELD_REQUIRED, descriptor)) {
+        else if (!bindingContext.get<PropertyDescriptor, Boolean>(BindingContext.BACKING_FIELD_REQUIRED, descriptor)!!) {
             report()
         }
     }
@@ -301,7 +301,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
                         val baseExpression = expression.getLeft()
                         val baseExpressionType = baseExpression?.let{ c.trace.getType(it) } ?: return
                         doIfNotNull(
-                                DataFlowValueFactory.createDataFlowValue(baseExpression, baseExpressionType, c),
+                                DataFlowValueFactory.createDataFlowValue(baseExpression!!, baseExpressionType, c),
                                 c
                         ) {
                             c.trace.report(Errors.USELESS_ELVIS.on(expression, baseExpressionType))
@@ -364,7 +364,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
         }
         else {
             doIfNotNull(dataFlowValue, c) {
-                c.trace.report(Errors.UNNECESSARY_SAFE_CALL.on(c.call.getCallOperationNode().getPsi(), receiverArgument.getType()))
+                c.trace.report(Errors.UNNECESSARY_SAFE_CALL.on(c.call.getCallOperationNode()!!.getPsi(), receiverArgument.getType()))
             }
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt

@@ -289,7 +289,7 @@ public object PositioningStrategies {
 
     public val VARIANCE_IN_PROJECTION: PositioningStrategy<JetTypeProjection> = object : PositioningStrategy<JetTypeProjection>() {
         override fun mark(element: JetTypeProjection): List<TextRange> {
-            return markNode(element.getProjectionNode())
+            return markNode(element.getProjectionNode()!!)
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt

@@ -43,6 +43,6 @@ public class KDocLink(node: ASTNode) : JetElementImpl(node) {
         return if (tag != null && tag.getSubjectLink() == this) tag else null
     }
 
-    override fun getReferences(): Array<out PsiReference>? =
+    override fun getReferences(): Array<out PsiReference> =
         ReferenceProvidersRegistry.getReferencesFromProviders(this)
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.lexer.JetTokens
 public abstract class JetDoubleColonExpression(node: ASTNode) : JetExpressionImpl(node) {
     public fun getTypeReference(): JetTypeReference? = findChildByType(JetNodeTypes.TYPE_REFERENCE)
 
-    public fun getDoubleColonTokenReference(): PsiElement = findChildByType(JetTokens.COLONCOLON)
+    public fun getDoubleColonTokenReference(): PsiElement = findChildByType(JetTokens.COLONCOLON)!!
 
     override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
         return visitor.visitDoubleColonExpression(this, data)

compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt

@@ -75,5 +75,5 @@ public class JetObjectDeclaration : JetClassOrObject {
 
     public fun isObjectLiteral(): Boolean = getStub()?.isObjectLiteral() ?: (getParent() is JetObjectLiteralExpression)
 
-    public fun getObjectKeyword(): PsiElement = findChildByType(JetTokens.OBJECT_KEYWORD)
+    public fun getObjectKeyword(): PsiElement = findChildByType(JetTokens.OBJECT_KEYWORD)!!
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt

@@ -251,7 +251,7 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createFunctionLiteralParameterList(text: String): JetParameterList {
-        return (createExpression("{ $text -> 0}") as JetFunctionLiteralExpression).getFunctionLiteral().getValueParameterList()
+        return (createExpression("{ $text -> 0}") as JetFunctionLiteralExpression).getFunctionLiteral().getValueParameterList()!!
     }
 
     public fun createEnumEntry(text: String): JetEnumEntry {
@@ -284,7 +284,7 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createPackageDirective(fqName: FqName): JetPackageDirective {
-        return createFile("package ${fqName.asString()}").getPackageDirective()
+        return createFile("package ${fqName.asString()}").getPackageDirective()!!
     }
 
     public fun createPackageDirectiveIfNeeded(fqName: FqName): JetPackageDirective? {

compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt

@@ -39,7 +39,7 @@ public class KotlinStringLiteralTextEscaper(host: JetStringTemplateExpression):
             }
             when (child) {
                 is JetLiteralStringTemplateEntry -> {
-                    val textRange = rangeInsideHost.intersection(childRange).shiftRight(-childRange.getStartOffset())
+                    val textRange = rangeInsideHost.intersection(childRange)!!.shiftRight(-childRange.getStartOffset())
                     outChars.append(child.getText(), textRange.getStartOffset(), textRange.getEndOffset())
                     textRange.getLength().times {
                         sourceOffsetsList.add(sourceOffset++)

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt

@@ -144,9 +144,9 @@ public fun JetElement.getCalleeHighlightingRange(): TextRange {
             ) ?: return getTextRange()
 
     val startOffset = annotationEntry.getAtSymbol()?.getTextRange()?.getStartOffset()
-                      ?: annotationEntry.getCalleeExpression().startOffset
+                      ?: annotationEntry.getCalleeExpression()!!.startOffset
 
-    return TextRange(startOffset, annotationEntry.getCalleeExpression().endOffset)
+    return TextRange(startOffset, annotationEntry.getCalleeExpression()!!.endOffset)
 }
 
 // ---------- Block expression -------------------------------------------------------------------------------------------------------------

compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt

@@ -210,7 +210,7 @@ public class LazyTopDownAnalyzer {
                 }
 
                 override fun visitAnonymousInitializer(initializer: JetClassInitializer) {
-                    val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(initializer, javaClass<JetClassOrObject>())
+                    val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(initializer, javaClass<JetClassOrObject>())!!
                     c.getAnonymousInitializers().put(initializer, lazyDeclarationResolver!!.resolveToDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes)
                 }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -226,7 +226,7 @@ public class TypeResolver(
                 val receiverTypeRef = type.getReceiverTypeReference()
                 val receiverType = if (receiverTypeRef == null) null else resolveType(c.noBareTypes(), receiverTypeRef)
 
-                val parameterTypes = type.getParameters().map { resolveType(c.noBareTypes(), it.getTypeReference()) }
+                val parameterTypes = type.getParameters().map { resolveType(c.noBareTypes(), it.getTypeReference()!!) }
 
                 val returnTypeRef = type.getReturnTypeReference()
                 val returnType = if (returnTypeRef != null)

compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt

@@ -176,7 +176,7 @@ class VarianceChecker(private val trace: BindingTrace) {
             for (argumentBinding in getArgumentBindings()) {
                 if (argumentBinding == null || argumentBinding.typeParameterDescriptor == null) continue
 
-                val projectionKind = getEffectiveProjectionKind(argumentBinding.typeParameterDescriptor, argumentBinding.typeProjection)!!
+                val projectionKind = getEffectiveProjectionKind(argumentBinding.typeParameterDescriptor!!, argumentBinding.typeProjection)!!
                 val newPosition = when (projectionKind) {
                     OUT -> position
                     IN -> position.opposite()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt

@@ -77,7 +77,7 @@ public class CallCompleter(
                 resolvedCall.variableCall.getCall().getCalleeExpression()
             else
                 resolvedCall.getCall().getCalleeExpression()
-            context.symbolUsageValidator.validateCall(resolvedCall.getResultingDescriptor(), context.trace, element)
+            context.symbolUsageValidator.validateCall(resolvedCall.getResultingDescriptor(), context.trace, element!!)
         }
 
         if (results.isSingleResult() && results.getResultingCall().getStatus().isSuccess()) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt

@@ -74,7 +74,7 @@ class CapturingInClosureChecker : CallChecker {
         if (InlineUtil.isInlinedArgument(scopeDeclaration as JetFunction, context, false)) {
             val scopeContainerParent = scopeContainer.getContainingDeclaration()
             assert(scopeContainerParent != null) { "parent is null for " + scopeContainer }
-            return !isCapturedVariable(variableParent, scopeContainerParent) || isCapturedInInline(context, scopeContainerParent, variableParent)
+            return !isCapturedVariable(variableParent, scopeContainerParent!!) || isCapturedInInline(context, scopeContainerParent, variableParent)
         }
         return false
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -226,7 +226,7 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
             if (argumentForParameter == null) return null
 
             if (isDivisionByZero(resultingDescriptorName.asString(), argumentForParameter.value)) {
-                val parentExpression: JetExpression = PsiTreeUtil.getParentOfType(receiverExpression, javaClass())
+                val parentExpression: JetExpression = PsiTreeUtil.getParentOfType(receiverExpression, javaClass())!!
                 trace.report(Errors.DIVISION_BY_ZERO.on(parentExpression))
                 return ErrorValue.create("Division by zero")
             }
@@ -406,7 +406,7 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
     }
 
     override fun visitClassLiteralExpression(expression: JetClassLiteralExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val jetType = trace.getType(expression)
+        val jetType = trace.getType(expression)!!
         if (jetType.isError()) return null
         return KClassValue(jetType)
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt

@@ -97,6 +97,7 @@ public class LazyScriptClassMemberScope protected constructor(
 
         val returnType = scriptDescriptor.getScriptCodeDescriptor().getReturnType()
         assert(returnType != null) { "Return type not initialized for " + scriptDescriptor }
+        returnType!!
 
         propertyDescriptor.setType(
                 returnType,

compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt

@@ -47,7 +47,7 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
     override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
         // Do not check types in annotation entries to prevent cycles in resolve, rely on call message
         val annotationEntry = JetStubbedPsiUtil.getPsiOrStubParent(element, javaClass<JetAnnotationEntry>(), true)
-        if (annotationEntry != null && annotationEntry.getCalleeExpression().getConstructorReferenceExpression() == element)
+        if (annotationEntry != null && annotationEntry.getCalleeExpression()!!.getConstructorReferenceExpression() == element)
             return
 
         // Do not check types in calls to super constructor in extends list, rely on call message

compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt

@@ -74,7 +74,7 @@ public class LockBasedLazyResolveStorageManager(private val storageManager: Stor
             storageManager.compute { trace.record<K>(slice, key) }
         }
 
-        override fun <K, V> get(slice: ReadOnlySlice<K, V>, key: K): V = storageManager.compute { trace.get<K, V>(slice, key) }
+        override fun <K, V> get(slice: ReadOnlySlice<K, V>, key: K): V? = storageManager.compute { trace.get<K, V>(slice, key) }
 
         override fun <K, V> getKeys(slice: WritableSlice<K, V>): Collection<K> = storageManager.compute { trace.getKeys<K, V>(slice) }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt

@@ -214,7 +214,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
         // This is needed for ControlStructureTypingVisitor#visitReturnExpression() to properly type-check returned expressions
         context.trace.record(EXPECTED_RETURN_TYPE, functionLiteral, expectedType)
         val typeOfBodyExpression = // Type-check the body
-                components.expressionTypingServices.getBlockReturnedType(functionLiteral.getBodyExpression(), COERCION_TO_UNIT, newContext).type
+                components.expressionTypingServices.getBlockReturnedType(functionLiteral.getBodyExpression()!!, COERCION_TO_UNIT, newContext).type
 
         return declaredReturnType ?: computeReturnTypeBasedOnReturnExpressions(functionLiteral, context, typeOfBodyExpression)
     }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt

@@ -33,6 +33,6 @@ public class KotlinLightMethodForTraitFakeOverride(
     override fun getOrigin(): JetDeclaration = origin
 
     override fun copy(): PsiElement {
-        return KotlinLightMethodForTraitFakeOverride(getManager(), delegate, origin.copy() as JetDeclaration, getContainingClass())
+        return KotlinLightMethodForTraitFakeOverride(getManager(), delegate, origin.copy() as JetDeclaration, getContainingClass()!!)
     }
 }

compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt

@@ -64,22 +64,22 @@ public object AnnotationSerializer {
 
             override fun visitBooleanValue(value: BooleanValue, data: Unit) {
                 setType(Type.BOOLEAN)
-                setIntValue(if (value.getValue()) 1 else 0)
+                setIntValue(if (value.getValue()!!) 1 else 0)
             }
 
             override fun visitByteValue(value: ByteValue, data: Unit) {
                 setType(Type.BYTE)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.getValue()!!.toLong())
             }
 
             override fun visitCharValue(value: CharValue, data: Unit) {
                 setType(Type.CHAR)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.getValue()!!.toLong())
             }
 
             override fun visitDoubleValue(value: DoubleValue, data: Unit) {
                 setType(Type.DOUBLE)
-                setDoubleValue(value.getValue())
+                setDoubleValue(value.getValue()!!)
             }
 
             override fun visitEnumValue(value: EnumValue, data: Unit) {
@@ -95,12 +95,12 @@ public object AnnotationSerializer {
 
             override fun visitFloatValue(value: FloatValue, data: Unit) {
                 setType(Type.FLOAT)
-                setFloatValue(value.getValue())
+                setFloatValue(value.getValue()!!)
             }
 
             override fun visitIntValue(value: IntValue, data: Unit) {
                 setType(Type.INT)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.getValue()!!.toLong())
             }
 
             override fun visitKClassValue(value: KClassValue?, data: Unit?) {
@@ -110,7 +110,7 @@ public object AnnotationSerializer {
 
             override fun visitLongValue(value: LongValue, data: Unit) {
                 setType(Type.LONG)
-                setIntValue(value.getValue())
+                setIntValue(value.getValue()!!)
             }
 
             override fun visitNullValue(value: NullValue, data: Unit) {
@@ -135,12 +135,12 @@ public object AnnotationSerializer {
 
             override fun visitShortValue(value: ShortValue, data: Unit) {
                 setType(Type.SHORT)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.getValue()!!.toLong())
             }
 
             override fun visitStringValue(value: StringValue, data: Unit) {
                 setType(Type.STRING)
-                setStringValue(nameTable.getStringIndex(value.getValue()))
+                setStringValue(nameTable.getStringIndex(value.getValue()!!))
             }
         }, Unit)
 

compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt

@@ -152,7 +152,7 @@ class LazyOperationsLog(
             }
             o.javaClass.getSimpleName() == "LazyJavaClassTypeConstructor" -> {
                 val javaClass = o.field<Any>("this\$0").field<JavaClassImpl>("jClass")
-                javaClass.getPsi().getName().appendQuoted()
+                javaClass.getPsi().getName()!!.appendQuoted()
             }
             o.javaClass.getSimpleName() == "DeserializedType" -> {
                 val typeDeserializer = o.field<TypeDeserializer>("typeDeserializer")
@@ -161,7 +161,7 @@ class LazyOperationsLog(
                 val text = when (typeProto.getConstructor().getKind()) {
                     ProtoBuf.Type.Constructor.Kind.CLASS -> context.nameResolver.getFqName(typeProto.getConstructor().getId()).asString()
                     ProtoBuf.Type.Constructor.Kind.TYPE_PARAMETER -> {
-                        val classifier = (o as JetType).getConstructor().getDeclarationDescriptor()
+                        val classifier = (o as JetType).getConstructor().getDeclarationDescriptor()!!
                         "" + classifier.getName() + " in " + DescriptorUtils.getFqName(classifier.getContainingDeclaration())
                     }
                     else -> "???"

compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt

@@ -143,6 +143,7 @@ public class KotlinCliJavaFileManagerTest : PsiTestCase() {
         val pkg = root.createChildDirectory(this, "foo")
         val dir = myPsiManager.findDirectory(pkg)
         TestCase.assertNotNull(dir)
+        dir!!
         dir.add(PsiFileFactory.getInstance(getProject()).createFileFromText(className + ".java", JavaFileType.INSTANCE, text))
         val coreJavaFileManagerExt = KotlinCliJavaFileManagerImpl(myPsiManager)
         coreJavaFileManagerExt.initIndex(JvmDependenciesIndex(listOf(JavaRoot(root, JavaRoot.RootType.SOURCE))))

compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt

@@ -194,9 +194,9 @@ public object InlineTestUtil {
                 override fun getFileContents(): ByteArray = throw UnsupportedOperationException()
                 override fun hashCode(): Int = throw UnsupportedOperationException()
                 override fun equals(other: Any?): Boolean = throw UnsupportedOperationException()
-                override fun toString(): String? = throw UnsupportedOperationException()
+                override fun toString(): String = throw UnsupportedOperationException()
             }
-        }.getClassHeader()
+        }!!.getClassHeader()
     }
 
     private class InlineInfo(val inlineMethods: Set<MethodInfo>, val classHeaders: Map<String, KotlinClassHeader>)

compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -79,7 +79,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                     is JetPrimaryConstructor -> {
                         val jetClassOrObject: JetClassOrObject = declaringElement.getContainingClassOrObject()
                         val classDescriptor = getDescriptor(jetClassOrObject, resolveSession) as ClassDescriptor
-                        addCorrespondingParameterDescriptor(classDescriptor.getUnsubstitutedPrimaryConstructor(), parameter)
+                        addCorrespondingParameterDescriptor(classDescriptor.getUnsubstitutedPrimaryConstructor()!!, parameter)
                     }
                     else ->  super.visitParameter(parameter)
                 }

compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt

@@ -66,7 +66,7 @@ public abstract class AbstractResolvedCallsTest : JetLiteFixture() {
     open protected fun buildCachedCall(
             bindingContext: BindingContext, jetFile: JetFile, text: String
     ): Pair<PsiElement?, ResolvedCall<out CallableDescriptor>?> {
-        val element = jetFile.findElementAt(text.indexOf("<caret>"))
+        val element = jetFile.findElementAt(text.indexOf("<caret>"))!!
         val expression = element.getStrictParentOfType<JetExpression>()
 
         val cachedCall = expression?.getParentResolvedCall(bindingContext, strict = false)

compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt

@@ -106,7 +106,7 @@ public class CapturedTypeApproximationTest() : JetLiteFixture() {
                 val testSubstitutions = createTestSubstitutions(typeParameters)
                 for (testSubstitution in testSubstitutions) {
                     val typeSubstitutor = createTestSubstitutor(testSubstitution)
-                    val typeWithCapturedType = typeSubstitutor.substituteWithoutApproximation(TypeProjectionImpl(INVARIANT, type))!!.getType()
+                    val typeWithCapturedType = typeSubstitutor.substituteWithoutApproximation(TypeProjectionImpl(INVARIANT, type!!))!!.getType()
 
                     val (lower, upper) = approximateCapturedTypes(typeWithCapturedType)
                     val substitution = approximateCapturedTypesIfNecessary(TypeProjectionImpl(INVARIANT, typeWithCapturedType))