don't show some java keywords in some java places, but show some keywords in some other places (e.g. IDEA-58589)

java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionData.java

@@ -20,7 +20,11 @@ import com.intellij.codeInsight.TailTypes;
 import com.intellij.codeInsight.completion.util.ParenthesesInsertHandler;
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.codeInsight.lookup.LookupItem;
-import com.intellij.patterns.*;
+import com.intellij.codeInsight.lookup.TailTypeDecorator;
+import com.intellij.patterns.ElementPattern;
+import com.intellij.patterns.PsiElementPattern;
+import com.intellij.patterns.PsiJavaElementPattern;
+import com.intellij.patterns.PsiJavaPatterns;
 import com.intellij.psi.*;
 import com.intellij.psi.filters.*;
 import com.intellij.psi.filters.classes.EnumOrAnnotationTypeFilter;
@@ -36,7 +40,6 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NonNls;
 
 import static com.intellij.patterns.PsiJavaPatterns.*;
-import static com.intellij.patterns.PsiJavaPatterns.psiElement;
 import static com.intellij.patterns.StandardPatterns.not;
 
 public class JavaCompletionData extends JavaAwareCompletionData{
@@ -511,25 +514,6 @@ public class JavaCompletionData extends JavaAwareCompletionData{
       registerVariant(variant);
     }
 
-    {
-      // null completion !!!!!!
-      final CompletionVariant variant = new CompletionVariant(and(
-          psiElement().inside(or(
-              psiElement(PsiExpressionList.class),
-              psiElement(PsiExpression.class).withParent(or(psiElement(PsiIfStatement.class), psiElement(PsiLocalVariable.class))),
-              psiElement(PsiAssignmentExpression.class))
-          ),
-          not(psiElement().afterLeaf(".", PsiKeyword.RETURN)),
-          not(psiElement().withParent(psiElement(PsiReferenceExpression.class).withParent(PsiTypeCastExpression.class)))
-      ));
-      variant.addCompletion(PsiKeyword.NULL, TailType.NONE);
-      variant.addCompletion(PsiKeyword.TRUE, TailType.NONE);
-      variant.addCompletion(PsiKeyword.FALSE, TailType.NONE);
-      variant.addCompletion(PsiKeyword.NEW, TailType.SPACE);
-      variant.includeScopeClass(PsiExpressionList.class);
-      variant.includeScopeClass(PsiStatement.class);
-      registerVariant(variant);
-    }
   }
 
   private static void addPrimitiveTypes(CompletionVariant variant){
@@ -564,9 +548,9 @@ public class JavaCompletionData extends JavaAwareCompletionData{
     if (SUPER_OR_THIS_PATTERN.accepts(position)) {
       if (AFTER_DOT.accepts(position) && !isInsideQualifierClass(position)) return;
 
-      result.addElement(BasicExpressionCompletionContributor.createKeywordLookupItem(position, PsiKeyword.THIS));
+      result.addElement(createKeyword(position, PsiKeyword.THIS));
 
-      final LookupItem superItem = (LookupItem)BasicExpressionCompletionContributor.createKeywordLookupItem(position, PsiKeyword.SUPER);
+      final LookupItem superItem = (LookupItem)createKeyword(position, PsiKeyword.SUPER);
       if (psiElement().afterLeaf(psiElement().withText("{").withSuperParent(2, psiMethod().constructor(true))).accepts(position)) {
         final PsiMethod method = PsiTreeUtil.getParentOfType(position, PsiMethod.class, false, PsiClass.class);
         assert method != null;
@@ -587,6 +571,31 @@ public class JavaCompletionData extends JavaAwareCompletionData{
 
       result.addElement(superItem);
     }
+
+    final ElementPattern<PsiElement> exprKeywords = and(
+      psiElement().withParent(psiElement(PsiReferenceExpression.class).withParent(
+        not(
+          or(psiElement(PsiTypeCastExpression.class),
+             psiElement(PsiSwitchLabelStatement.class),
+             psiElement(PsiExpressionStatement.class).withParent(psiElement(PsiCodeBlock.class).withParent(PsiSwitchStatement.class))
+          )
+        )
+      )),
+      not(psiElement().afterLeaf("."))
+    );
+    if (exprKeywords.accepts(position)) {
+      result.addElement(TailTypeDecorator.withTail(createKeyword(position, PsiKeyword.NEW), TailType.SPACE));
+
+      if (!psiElement().withParent(psiElement(PsiReferenceExpression.class).withParent(PsiExpressionStatement.class)).accepts(position)) {
+        result.addElement(createKeyword(position, PsiKeyword.NULL));
+        result.addElement(createKeyword(position, PsiKeyword.TRUE));
+        result.addElement(createKeyword(position, PsiKeyword.FALSE));
+      }
+    }
+  }
+
+  private static LookupElement createKeyword(PsiElement position, String keyword) {
+    return BasicExpressionCompletionContributor.createKeywordLookupItem(position, keyword);
   }
 
   private static boolean isInsideQualifierClass(PsiElement position) {

java/java-tests/testData/codeInsight/completion/keywords/NullInReturn-out.java

@@ -0,0 +1,8 @@
+
+public class Main {
+
+    public static Object main() {
+        return null<caret>
+
+    }
+}

java/java-tests/testData/codeInsight/completion/keywords/NullInReturn.java

@@ -0,0 +1,8 @@
+
+public class Main {
+
+    public static Object main() {
+        return nu<caret>
+
+    }
+}

java/java-tests/testData/codeInsight/completion/variables/NoKeywordsInForLoopVariableName.java

@@ -0,0 +1,15 @@
+import java.util.ArrayList;
+
+public class Test {
+  {
+
+    Runnable runnable = new Runnable() {
+      public void run() {
+        for (StringBuffer <caret> : new ArrayList<StringBuffer>()) {
+
+        }
+      }
+    };
+  }
+
+}

java/java-tests/testSrc/com/intellij/codeInsight/completion/KeywordCompletionTest.java

@@ -164,6 +164,7 @@ public class KeywordCompletionTest extends LightCompletionTestCase {
 
   public void testTrueInVariableDeclaration() throws Throwable { doTest(); }
   public void testNullInIf() throws Throwable { doTest(); }
+  public void testNullInReturn() throws Throwable { doTest(); }
 
   public void testExtendsInMethodParameters() throws Throwable { doTest(); }
 

java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionTest.groovy

@@ -103,14 +103,13 @@ public class NormalCompletionTest extends LightFixtureCompletionTestCase {
   }
 
   public void testKeywordsInName() throws Exception {
-    configureByFile("KeywordsInName.java");
-    checkResultByFile("KeywordsInName_after.java");
+    myFixture.configureByFile(getTestName(false) + ".java");
+    myFixture.completeBasic()
+    myFixture.type 'a\n'
+    checkResultByFile(getTestName(false) + "_after.java");
   }
 
-  public void testSimpleVariable() throws Exception {
-    configureByFile("SimpleVariable.java");
-    checkResultByFile("SimpleVariable_after.java");
-  }
+  public void testSimpleVariable() throws Exception { doTest() }
 
   public void testPreferLongerNamesOption() throws Exception {
     configureByFile("PreferLongerNamesOption.java");

java/java-tests/testSrc/com/intellij/codeInsight/completion/VariablesCompletionTest.java

@@ -129,18 +129,24 @@ public class VariablesCompletionTest extends CompletionTestCase {
     checkResultByFile(FILE_PREFIX + "locals/" + "ArrayMethodName-result.java");
   }
 
+  public void testNoKeywordsInForLoopVariableName() throws Throwable {
+    configureByFile(FILE_PREFIX + getTestName(false) + ".java");
+    assertStringItems("stringBuffer", "buffer");
+  }
+
   protected void compareLookup(String fileName) throws IOException{
     String fullPath = getTestDataPath() + fileName;
     VirtualFile result = LocalFileSystem.getInstance().findFileByPath(fullPath);
     assertNotNull("file " + fullPath + " not found", result);
 
 
-    String[] strings = LineTokenizer.tokenize(FileDocumentManager.getInstance().getDocument(result).getCharsSequence(), false);
+    assertStringItems(LineTokenizer.tokenize(FileDocumentManager.getInstance().getDocument(result).getCharsSequence(), false));
+  }
 
+  private void assertStringItems(String... strings) {
     assertNotNull(myItems);
     for (int i = 0; i < myItems.length; i++) {
       assertEquals(strings[i], myItems[i].toString());
     }
   }
-
 }