Remove NotNull annotation

annotations/com/intellij/psi/annotations.xml

@@ -17,9 +17,6 @@
   <item name='com.intellij.psi.PsiElementVisitor void visitElement(com.intellij.psi.PsiElement) 0'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
-  <item name='com.intellij.psi.PsiElement java.lang.String getText()'>
-    <annotation name='org.jetbrains.annotations.NotNull'/>
-  </item>
   <item name='com.intellij.psi.PsiReference com.intellij.psi.PsiElement getElement()'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -223,7 +223,9 @@ private fun createFileForDebugger(codeFragment: JetCodeFragment,
                                             .split(JetCodeFragment.IMPORT_SEPARATOR)
                                             .makeString("\n"))
 
-    fileText = fileText.replace("!FUNCTION!", extractedFunction.getText())
+    val extractedFunctionText = extractedFunction.getText()
+    assert(extractedFunctionText != null, "Text of extracted function shouldn't be null")
+    fileText = fileText.replace("!FUNCTION!", extractedFunction.getText()!!)
 
     val virtualFile = LightVirtualFile("debugFile.kt", JetLanguage.INSTANCE, fileText)
     virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET)

idea/src/org/jetbrains/jet/plugin/intentions/ConvertToForEachFunctionCallIntention.kt

@@ -33,7 +33,7 @@ public class ConvertToForEachFunctionCallIntention : JetSelfTargetingIntention<J
         fun buildStatements(statements: List<JetElement>): String {
             return when {
                 statements.isEmpty() -> ""
-                statements.size() == 1 -> statements[0].getText()
+                statements.size() == 1 -> statements[0].getText() ?: throw AssertionError("Statements in ForExpression shouldn't be empty: expressionText = ${element.getText()}")
                 else -> statements.fold(StringBuilder(), { acc, h -> acc.append("${h.getText()}\n") }).toString()
             }
         }
@@ -50,7 +50,7 @@ public class ConvertToForEachFunctionCallIntention : JetSelfTargetingIntention<J
 
             return when (loopRange) {
                 is JetOperationExpression -> "(${loopRange.getText()})"
-                else -> loopRange.getText()
+                else -> loopRange.getText() ?: throw AssertionError("LoopRange in ForExpression shouldn't be empty: expressionText = ${element.getText()}")
             }
         }
 
@@ -59,7 +59,7 @@ public class ConvertToForEachFunctionCallIntention : JetSelfTargetingIntention<J
 
         val bodyText = buildReplacementBodyText(loopParameter, when (body) {
             is JetBlockExpression -> buildStatements(body.getStatements())
-            else -> body.getText()
+            else -> body.getText() ?: throw AssertionError("Body of ForExpression shouldn't be empty: expressionText = ${element.getText()}")
         })
 
         element.replace(JetPsiFactory.createExpression(element.getProject(), "${buildReceiverText(element)}.forEach { $bodyText }"))

idea/src/org/jetbrains/jet/plugin/intentions/InsertExplicitTypeArguments.kt

@@ -34,6 +34,7 @@ public class InsertExplicitTypeArguments : JetSelfTargetingIntention<JetCallExpr
 
     override fun isApplicableTo(element: JetCallExpression, editor: Editor): Boolean {
         if (!element.getTypeArguments().isEmpty()) return false
+        if (element.getText() == null) return false
 
         val textRange = element.getCalleeExpression()?.getTextRange()
         if (textRange == null || !textRange.contains(editor.getCaretModel().getOffset())) return false
@@ -65,7 +66,7 @@ public class InsertExplicitTypeArguments : JetSelfTargetingIntention<JetCallExpr
         val name = element.getCalleeExpression()?.getText()
         if (name == null) return
 
-        val valueAndFunctionArguments = element.getText().substring(name.size)
+        val valueAndFunctionArguments = element.getText()?.substring(name.size) ?: throw AssertionError("InsertExplicitTypeArguments intention shouldn't be applicable for empty call expression")
         val expr = JetPsiFactory.createExpression(element.getProject(), "$name$typeArgs${valueAndFunctionArguments}")
         element.replace(expr)
     }

idea/src/org/jetbrains/jet/plugin/intentions/MakeTypeExplicitInLambdaIntention.kt

@@ -71,7 +71,7 @@ public class MakeTypeExplicitInLambdaIntention : JetSelfTargetingIntention<JetFu
         else {
             val openBraceElement = functionLiteral.getOpenBraceNode().getPsi()
             val nextSibling = openBraceElement?.getNextSibling()
-            val addNewline = nextSibling is PsiWhiteSpace && "\n" in nextSibling.getText()
+            val addNewline = nextSibling is PsiWhiteSpace && nextSibling.getText()?.contains("\n") ?: false
             val (whitespace, arrow) = JetPsiFactory.createWhitespaceAndArrow(element.getProject())
             functionLiteral.addRangeAfter(whitespace, arrow, openBraceElement)
             functionLiteral.addAfter(newParameterList, openBraceElement)

idea/src/org/jetbrains/jet/plugin/intentions/OperatorToFunctionIntention.kt

@@ -165,7 +165,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
         val parent = element.getParent()
         val array = element.getArrayExpression()!!.getText()
         val indices = element.getIndicesNode()
-        val indicesText = indices.getText().trim("[","]")
+        val indicesText = indices.getText()?.trim("[","]") ?: throw AssertionError("Indices node of ArrayExpression shouldn't be null: JetArrayAccessExpression = ${element.getText()}")
 
         val transformation : String
         val replaced : JetElement

idea/src/org/jetbrains/jet/plugin/quickfix/CreateFunctionFromUsageFix.kt

@@ -753,7 +753,7 @@ public class CreateFunctionFromUsageFix internal (
             returnTypeExpression!!
             val returnTypeRef = func.getReturnTypeRef()
             if (returnTypeRef != null) {
-                val returnType = returnTypeExpression.getTypeFromSelection(returnTypeRef.getText())
+                val returnType = returnTypeExpression.getTypeFromSelection(returnTypeRef.getText() ?: throw AssertionError("Expression for function return type shouldn't be empty: function = ${func.getText()}"))
                 if (returnType != null) {
                     // user selected a given type
                     replaceWithLongerName(returnTypeRef, returnType)
@@ -768,7 +768,7 @@ public class CreateFunctionFromUsageFix internal (
         for ((i, parameter) in valueParameters.stream().withIndices()) {
             val parameterTypeRef = parameter.getTypeReference()
             if (parameterTypeRef != null) {
-                val parameterType = parameterTypeExpressions[i].getTypeFromSelection(parameterTypeRef.getText())
+                val parameterType = parameterTypeExpressions[i].getTypeFromSelection(parameterTypeRef.getText() ?: throw AssertionError("Expression for function parameter type shouldn't be empty: function = ${func.getText()}"))
                 if (parameterType != null) {
                     replaceWithLongerName(parameterTypeRef, parameterType)
                     parameterIndicesToShorten.add(i)

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionData.kt

@@ -78,7 +78,7 @@ class ExtractionData(
     }
 
     fun getCodeFragmentText(): String =
-            getCodeFragmentTextRange()?.let { originalFile.getText().substring(it.getStartOffset(), it.getEndOffset()) } ?: ""
+            getCodeFragmentTextRange()?.let { originalFile.getText()?.substring(it.getStartOffset(), it.getEndOffset()) } ?: ""
 
     val originalStartOffset = originalElements.first?.let { e -> e.getTextRange()!!.getStartOffset() }
 

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt

@@ -412,7 +412,7 @@ private fun ExtractionData.inferParametersInfo(
                                     if (hasThisReceiver && extractThis)
                                         "this@${parameterType.getConstructor().getDeclarationDescriptor()!!.getName().asString()}"
                                     else
-                                        (thisExpr ?: ref).getText()
+                                        (thisExpr ?: ref).getText() ?: throw AssertionError("'this' reference shouldn't be empty: code fragment = ${getCodeFragmentText()}")
 
                             val parameter = Parameter(argumentText, parameterName, mirrorVarName, parameterType, extractThis)
 
@@ -623,7 +623,7 @@ fun ExtractionDescriptor.getFunctionText(
     return FunctionBuilder().let { builder ->
         builder.modifier(visibility)
 
-        builder.typeParams(typeParameters.map { it.originalDeclaration.getText() })
+        builder.typeParams(typeParameters.map { it.originalDeclaration.getText()!! })
 
         receiverParameter?.let { builder.receiver(descriptorRenderer.renderType(it.parameterType)) }
 
@@ -637,7 +637,7 @@ fun ExtractionDescriptor.getFunctionText(
             if (isDefault()) builder.noReturnType() else builder.returnType(descriptorRenderer.renderType(this))
         }
 
-        builder.typeConstraints(typeParameters.flatMap { it.originalConstraints }.map { it.getText() })
+        builder.typeConstraints(typeParameters.flatMap { it.originalConstraints }.map { it.getText()!! })
 
         if (withBody) {
             builder.blockBody(extractionData.getCodeFragmentText())
@@ -756,7 +756,7 @@ fun ExtractionDescriptor.generateFunction(
 
             is ExpressionEvaluation ->
                 body.getStatements().last?.let {
-                    val newExpr = it.replaced(JetPsiFactory.createReturn(project, it.getText())).getReturnedExpression()!!
+                    val newExpr = it.replaced(JetPsiFactory.createReturn(project, it.getText() ?: throw AssertionError("Return expression shouldn't be empty: code fragment = ${body.getText()}"))).getReturnedExpression()!!
                     val counterpartMap = createNameCounterpartMap(it, newExpr)
                     nameByOffset.entrySet().forEach { it.setValue(counterpartMap[it.getValue()]!!) }
                 }