RegExp: completion for POSIX bracket expressions

RegExpSupport/src/org/intellij/lang/regexp/DefaultRegExpPropertiesProvider.java

@@ -113,6 +113,23 @@ public final class DefaultRegExpPropertiesProvider {
     {"e", "escape character ('\\u001B')"}
   };
 
+  private final String[][] myPosixCharacterClasses = {
+    {"alnum", "Alphanumeric characters"},
+    {"alpha", "Alphabetic characters"},
+    {"ascii", "ASCII characters"},
+    {"blank", "Space and tab"},
+    {"cntrl", "Control characters"},
+    {"digit", "Digits"},
+    {"graph", "Visible characters"},
+    {"lower", "Lowercase letters"},
+    {"print", "Visible characters and spaces"},
+    {"punct", "Punctuation and symbols"},
+    {"space", "All whitespace characters, including line breaks"},
+    {"upper", "Uppercase letters"},
+    {"word",  "Word characters (letters, numbers and underscores)"},
+    {"xdigit","Hexadecimal digits"},
+  };
+
   private DefaultRegExpPropertiesProvider() {
   }
 
@@ -157,4 +174,9 @@ public final class DefaultRegExpPropertiesProvider {
   public String[][] getKnownCharacterClasses() {
     return myCharacterClasses;
   }
+
+  @NotNull
+  public String[][] getPosixCharacterClasses() {
+    return myPosixCharacterClasses;
+  }
 }

RegExpSupport/src/org/intellij/lang/regexp/RegExpCompletionContributor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2014 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.
@@ -20,11 +20,15 @@ import com.intellij.codeInsight.completion.*;
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.codeInsight.lookup.LookupElementBuilder;
 import com.intellij.codeInsight.lookup.TailTypeDecorator;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.util.TextRange;
 import com.intellij.patterns.ElementPattern;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.PlatformIcons;
 import com.intellij.util.ProcessingContext;
 import com.intellij.util.ui.EmptyIcon;
+import org.intellij.lang.regexp.psi.RegExpClass;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
@@ -47,6 +51,9 @@ public final class RegExpCompletionContributor extends CompletionContributor {
 
       final ElementPattern<PsiElement> propertyNamePattern = psiElement().afterLeaf(psiElement().withText("{").afterLeaf(propertyPattern));
       extend(CompletionType.BASIC, propertyNamePattern, new PropertyNameCompletionProvider());
+
+      final ElementPattern<PsiElement> bracketExpressionPattern = psiElement().inside(RegExpClass.class);
+      extend(CompletionType.BASIC, bracketExpressionPattern, new BracketExpressionCompletionProvider());
     }
 
     {
@@ -85,6 +92,34 @@ public final class RegExpCompletionContributor extends CompletionContributor {
     return LookupElementBuilder.create(name).withTypeText(type).withIcon(icon);
   }
 
+  private static class BracketExpressionCompletionProvider extends CompletionProvider<CompletionParameters> {
+
+    @Override
+    protected void addCompletions(@NotNull CompletionParameters parameters,
+                                  ProcessingContext context,
+                                  @NotNull CompletionResultSet result) {
+
+      for (String[] completion : RegExpLanguageHosts.getInstance().getPosixCharacterClasses(parameters.getPosition())) {
+        result.addElement(
+          LookupElementBuilder.create(completion[0]).withTypeText((completion.length > 1) ? completion[1] : null).withIcon(emptyIcon)
+            .withInsertHandler(new InsertHandler<LookupElement>() {
+              @Override
+              public void handleInsert(InsertionContext context, LookupElement item) {
+                context.setAddCompletionChar(false);
+                final Editor editor = context.getEditor();
+                final Document document = editor.getDocument();
+                final int tailOffset = context.getTailOffset();
+                if (document.getTextLength() < tailOffset + 2 ||
+                    !document.getText(new TextRange(tailOffset, tailOffset + 2)).equals(":]")) {
+                  document.insertString(tailOffset, ":]");
+                }
+                editor.getCaretModel().moveCaretRelatively(2, 0, false, false, true);
+              }
+            }));
+      }
+    }
+  }
+
   private static class PropertyNameCompletionProvider extends CompletionProvider<CompletionParameters> {
 
     public void addCompletions(@NotNull final CompletionParameters parameters,

RegExpSupport/src/org/intellij/lang/regexp/RegExpLanguageHosts.java

@@ -143,4 +143,8 @@ public final class RegExpLanguageHosts extends ClassExtension<RegExpLanguageHost
     final RegExpLanguageHost host = findRegExpHost(element);
     return host != null ? host.getKnownCharacterClasses() : myDefaultProvider.getKnownCharacterClasses();
   }
+
+  String[][] getPosixCharacterClasses(@NotNull final PsiElement element) {
+    return myDefaultProvider.getPosixCharacterClasses();
+  }
 }

RegExpSupport/testData/RETest.xml

@@ -549,6 +549,10 @@
       <pattern>(?&lt;asdf&gt;[a-c])\1</pattern>
       <expected>OK</expected>
     </test>
+    <test host="com.intellij.psi.impl.JavaRegExpHost">
+      <pattern>(?&lt;asdf&gt;[a-c])\2</pattern>
+      <expected>ERR</expected>
+    </test>
     <test host="com.intellij.psi.impl.JavaRegExpHost">
       <pattern>(?&lt;asdf&gt;[a-c])\k&lt;asdf&gt;</pattern>
       <expected>OK</expected>