Added stub indexes, fixed exceptions during parsing

Author: mesour

.gitignore

@@ -6,16 +6,13 @@ local.properties
 /src/main/java/src/cz/juzna/intellij/neon/parser/_NeonLexer.flex
 
 intellij-neon.iws
-out/
 src/main/java/src/cz/juzna/intellij/neon/lexer/_NeonLexer.java
 src/main/java/src/cz/juzna/intellij/neon/lexer/_NeonTokenTypes.java
 src/main/java/src/cz/juzna/intellij/neon/parser/_NeonLexer.flex
 src/main/java/src/cz/juzna/intellij/neon/parser/NeonParser.java
 src/main/java/src/cz/juzna/intellij/neon/psi/generated/*
 src/main/java/src/cz/juzna/intellij/neon/psi/impl/generated/*
-gen/
 
 /.idea
 /.gradle
-/build
-/out
+/build

build.gradle

@@ -1,8 +1,8 @@
 import org.jetbrains.grammarkit.tasks.*
 
 plugins {
-    id 'org.jetbrains.intellij' version "0.4.20"
-    id "org.jetbrains.grammarkit" version "2020.2"
+    id 'org.jetbrains.intellij' version "0.6.5"
+    id "org.jetbrains.grammarkit" version "2020.3"
 }
 
 sourceSets {
@@ -19,7 +19,7 @@ properties.load(project.rootProject.file("local.properties").newDataInputStream(
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
 
-version '1.0.0-RC1'
+version '1.0.0-alfa2'
 group 'cz.juzna.intellij.neon'
 
 jar {

gradle.properties

@@ -1,4 +1,2 @@
-ideaVersion = 2020.2
-phpPluginVersion = 202.6397.115
-toolboxPluginVersion = 0.4.6
-annotationPluginVersion = 5.3
+ideaVersion = 2020.3
+phpPluginVersion = 203.5981.155

src/main/java/cz/juzna/intellij/neon/completion/NeonCompletionContributor.java

@@ -11,7 +11,7 @@
  */
 public class NeonCompletionContributor extends CompletionContributor {
 	public NeonCompletionContributor() {
-		extend(CompletionType.BASIC, StandardPatterns.instanceOf(PsiElement.class), new MethodCompletionProvider());
+		extend(CompletionType.BASIC, StandardPatterns.instanceOf(PsiElement.class), new PhpCompletionProvider());
 		extend(CompletionType.BASIC, StandardPatterns.instanceOf(PsiElement.class), new ParameterCompletionProvider());
 		extend(CompletionType.BASIC, StandardPatterns.instanceOf(PsiElement.class), new ServiceCompletionProvider());
 		extend(CompletionType.BASIC, StandardPatterns.instanceOf(PsiElement.class), new KeywordCompletionProvider());

src/main/java/cz/juzna/intellij/neon/completion/insert/PhpReferenceInsertHandler.java

@@ -46,17 +46,19 @@ public void handleInsert(InsertionContext context, LookupElement lookupElement)
 			}
 
 			String fqn = classNamespace;
-			if (!existingNamespace.startsWith("\\") && fqn.startsWith("\\")) {
+			if (!classNamespace.equals("\\") && !existingNamespace.startsWith("\\") && fqn.startsWith("\\")) {
 				fqn = fqn.substring(1);
+			} else if (classNamespace.equals("\\") && existingNamespace.length() == 0) {
+				fqn = "\\";
 			}
 
-			if (fqn.contains(existingNamespace)) {
+			if (existingNamespace.length() > 0 && fqn.contains(existingNamespace)) {
 				fqn = fqn.replace(existingNamespace, "");
 			}
 
 			if (incompleteKey) {
-				context.getDocument().insertString(context.getTailOffset(), ": ");
-				context.getEditor().getCaretModel().moveToOffset(context.getEditor().getCaretModel().getOffset() + 2);
+				//context.getDocument().insertString(context.getTailOffset(), ": ");
+				//context.getEditor().getCaretModel().moveToOffset(context.getEditor().getCaretModel().getOffset() + 2);
 			}
 			context.getDocument().insertString(context.getStartOffset(), fqn);
 			PsiDocumentManager.getInstance(context.getProject()).commitDocument(context.getDocument());

src/main/java/cz/juzna/intellij/neon/completion/insert/PhpVariableInsertHandler.java

@@ -0,0 +1,43 @@
+package cz.juzna.intellij.neon.completion.insert;
+
+import com.intellij.codeInsight.completion.*;
+import com.intellij.codeInsight.lookup.LookupElement;
+import com.intellij.openapi.editor.CaretModel;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.EditorModificationUtil;
+import com.intellij.psi.PsiDocumentManager;
+import com.intellij.psi.PsiElement;
+import com.jetbrains.php.lang.parser.PhpElementTypes;
+import com.jetbrains.php.lang.psi.PhpPsiUtil;
+import com.jetbrains.php.lang.psi.elements.Variable;
+import cz.juzna.intellij.neon.NeonLanguage;
+import org.jetbrains.annotations.NotNull;
+
+public class PhpVariableInsertHandler implements InsertHandler<LookupElement> {
+
+	private static final PhpVariableInsertHandler instance = new PhpVariableInsertHandler();
+
+	public PhpVariableInsertHandler() {
+		super();
+	}
+
+	public void handleInsert(@NotNull InsertionContext context, @NotNull LookupElement lookupElement) {
+		PsiElement element = context.getFile().findElementAt(context.getStartOffset());
+		if (element != null && element.getLanguage() == NeonLanguage.INSTANCE) {
+			PsiElement parent = element.getParent();
+			if (!(parent instanceof Variable) && !element.getText().startsWith("$")) {
+				Editor editor = context.getEditor();
+				CaretModel caretModel = editor.getCaretModel();
+				int offset = caretModel.getOffset();
+				caretModel.moveToOffset(element.getTextOffset() + (PhpPsiUtil.isOfType(parent, PhpElementTypes.CAST_EXPRESSION) ? 1 : 0));
+				EditorModificationUtil.insertStringAtCaret(editor, "$");
+				caretModel.moveToOffset(offset + 1);
+				PsiDocumentManager.getInstance(context.getProject()).commitDocument(editor.getDocument());
+			}
+		}
+	}
+
+	public static PhpVariableInsertHandler getInstance() {
+		return instance;
+	}
+}

src/main/java/cz/juzna/intellij/neon/completion/providers/ClassCompletionProvider.java

@@ -3,16 +3,10 @@
 import com.intellij.codeInsight.completion.CompletionParameters;
 import com.intellij.codeInsight.completion.CompletionProvider;
 import com.intellij.codeInsight.completion.CompletionResultSet;
-import com.intellij.codeInsight.completion.PrefixMatcher;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.ProcessingContext;
-import com.jetbrains.php.PhpIndex;
-import com.jetbrains.php.completion.PhpCompletionUtil;
 import com.jetbrains.php.completion.PhpLookupElement;
-import com.jetbrains.php.completion.insert.PhpClassStaticInsertHandler;
-import com.jetbrains.php.completion.insert.PhpNamespaceInsertHandler;
 import com.jetbrains.php.lang.psi.elements.PhpClass;
 import com.jetbrains.php.lang.psi.elements.PhpNamedElement;
 import cz.juzna.intellij.neon.completion.CompletionUtil;
@@ -22,10 +16,8 @@
 import cz.juzna.intellij.neon.psi.NeonNamespaceReference;
 import cz.juzna.intellij.neon.psi.NeonValue;
 import cz.juzna.intellij.neon.util.NeonPhpUtil;
-import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
@@ -72,15 +64,15 @@ protected void addCompletions(
 
 		Project project = params.getPosition().getProject();
 		Collection<String> classNames = NeonPhpUtil.getAllExistingClassNames(project, results.getPrefixMatcher());
-		Collection<PhpNamedElement> variants = NeonPhpUtil.getAllClassNamesAndInterfaces(project, classNames, namespace);
+		Collection<PhpClass> variants = NeonPhpUtil.getAllClassNamesAndInterfaces(project, classNames, namespace);
 
 		// Add variants
 		for (PhpNamedElement item : variants) {
 			PhpLookupElement lookupItem = new PhpLookupElement(item) {
 				@Override
 				public Set<String> getAllLookupStrings() {
 					Set<String> original = super.getAllLookupStrings();
-					Set<String> strings = new HashSet<String>(original.size() + 1);
+					Set<String> strings = new HashSet<>(original.size() + 1);
 					strings.addAll(original);
 					strings.add(this.getNamedElement().getFQN().substring(1));
 					return strings;

src/main/java/cz/juzna/intellij/neon/completion/providers/MethodCompletionProvider.java renamed to src/main/java/cz/juzna/intellij/neon/completion/providers/PhpCompletionProvider.java

@@ -6,10 +6,13 @@
 import com.intellij.psi.PsiElement;
 import com.intellij.util.ProcessingContext;
 import com.jetbrains.php.completion.PhpLookupElement;
+import com.jetbrains.php.completion.insert.PhpFieldInsertHandler;
 import com.jetbrains.php.completion.insert.PhpMethodInsertHandler;
+import com.jetbrains.php.lang.psi.elements.Field;
 import com.jetbrains.php.lang.psi.elements.Method;
 import com.jetbrains.php.lang.psi.elements.PhpClass;
 import cz.juzna.intellij.neon.completion.CompletionUtil;
+import cz.juzna.intellij.neon.completion.insert.PhpVariableInsertHandler;
 import cz.juzna.intellij.neon.config.NeonConfiguration;
 import cz.juzna.intellij.neon.config.NeonService;
 import cz.juzna.intellij.neon.psi.*;
@@ -20,13 +23,13 @@
 /**
  * Complete parameters
  */
-public class MethodCompletionProvider extends CompletionProvider<CompletionParameters> {
+public class PhpCompletionProvider extends CompletionProvider<CompletionParameters> {
 	// current element
 	PsiElement curr;
 
 	boolean isMagicPrefixed;
 
-	public MethodCompletionProvider() {
+	public PhpCompletionProvider() {
 		super();
 	}
 
@@ -43,68 +46,83 @@ protected void addCompletions(
 
 		isMagicPrefixed = results.getPrefixMatcher().getPrefix().startsWith("__");
 
-		boolean hasSomething = false;
+		boolean isValid = false;
 		String serviceName = NeonPsiImplUtil.getServiceName(curr);
-		if (serviceName.length() > 0) {
-			hasSomething = findServiceByName(serviceName, params, results);
-
-		} else if (curr.getParent() instanceof NeonPhpElementUsage) {
+		if (curr.getParent() instanceof NeonPhpElementUsage) {
 			NeonPhpStatementElement statement = ((NeonPhpElementUsage) curr.getParent()).getPhpStatement();
 			if (statement != null) {
-				hasSomething = findServiceInStatement((NeonPhpElementUsage) curr.getParent(), params, results);
+				findServiceInStatement(statement.isStatic(), (NeonPhpElementUsage) curr.getParent(), params, results);
+				isValid = true;
 			}
 
+		} else if (serviceName.length() > 0) {
+			findServiceByName(serviceName, params, results);
+			isValid = true;
 		}
 
-		if (hasSomething && params.getInvocationCount() <= 1) {
+		if (isValid && params.getInvocationCount() <= 1) {
 			results.stopHere();
 		}
 	}
 
-	private boolean findServiceInStatement(
+	private void findServiceInStatement(
+			boolean isStatic,
 			@NotNull NeonPhpElementUsage usageElement,
 			@NotNull CompletionParameters params,
 			@NotNull CompletionResultSet results
 	) {
-		boolean hasSomething = false;
 		for (PhpClass phpClass : usageElement.getPhpType().getPhpClasses(curr.getProject())) {
 			for (Method method : phpClass.getMethods()) {
-				if (method.getModifier().isPublic()) {
-					if (attachMethod(method, params, results)) {
-						hasSomething = true;
-					}
+				if (method.getModifier().isPublic() && ((isStatic && method.getModifier().isStatic()) || (!isStatic && !method.getModifier().isStatic()))) {
+					attachMethod(method, params, results);
+				}
+			}
+
+			for (Field field : phpClass.getFields()) {
+				if (!field.getModifier().isPublic()) {
+					continue;
+				}
+
+				if (isStatic && (field.isConstant() || field.getModifier().isStatic())) {
+					attachField(field, results);
+				} else if (!isStatic && !field.getModifier().isStatic()) {
+					attachField(field, results);
 				}
 			}
 		}
-		return hasSomething;
 	}
 
-	private boolean findServiceByName(@NotNull String serviceName, @NotNull CompletionParameters params, @NotNull CompletionResultSet results) {
-		boolean hasSomething = false;
+	private void findServiceByName(@NotNull String serviceName, @NotNull CompletionParameters params, @NotNull CompletionResultSet results) {
 		NeonService service = NeonConfiguration.INSTANCE.findService(serviceName, curr.getProject());
 		if (service != null && service.getPhpType().containsClasses()) {
 			for (PhpClass phpClass : service.getPhpType().getPhpClasses(curr.getProject())) {
 				for (Method method : phpClass.getMethods()) {
 					if (!method.isStatic() && method.getModifier().isPublic()) {
-						if (attachMethod(method, params, results)) {
-							hasSomething = true;
-						}
+						attachMethod(method, params, results);
 					}
 				}
 			}
 		}
-		return hasSomething;
 	}
 
-	private boolean attachMethod(@NotNull Method method, @NotNull CompletionParameters params, @NotNull CompletionResultSet results) {
+	private void attachMethod(@NotNull Method method, @NotNull CompletionParameters params, @NotNull CompletionResultSet results) {
 		if (!isMagicPrefixed && params.getInvocationCount() <= 1 && NeonTypesUtil.isExcludedCompletion(method.getName())) {
-			return false;
+			return;
 		}
 
 		PhpLookupElement lookupItem = new PhpLookupElement(method);
 		lookupItem.handler = PhpMethodInsertHandler.getInstance();
 		results.addElement(lookupItem);
-		return true;
+	}
+
+	private void attachField(@NotNull Field field, @NotNull CompletionResultSet results) {
+		PhpLookupElement lookupItem = new PhpLookupElement(field);
+		if (!field.isConstant() && field.getModifier().isStatic()) {
+			lookupItem.handler = PhpVariableInsertHandler.getInstance();
+		} else {
+			lookupItem.handler = PhpFieldInsertHandler.getInstance();
+		}
+		results.addElement(lookupItem);
 	}
 
 	private boolean isValidTarget() {

src/main/java/cz/juzna/intellij/neon/indexes/NeonIndexUtil.java

@@ -0,0 +1,45 @@
+package cz.juzna.intellij.neon.indexes;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.search.GlobalSearchScope;
+import cz.juzna.intellij.neon.indexes.extensions.*;
+import cz.juzna.intellij.neon.psi.*;
+import cz.juzna.intellij.neon.util.NeonPhpUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+public class NeonIndexUtil {
+    public static Collection<NeonConstantUsage> findConstantsByName(@NotNull Project project, String name) {
+        return NeonPhpConstantIndex.getInstance().get(name, project, GlobalSearchScope.allScope(project));
+    }
+
+    public static Collection<NeonStaticVariable> findStaticVariablesByName(@NotNull Project project, String name) {
+        return NeonPhpStaticVariableIndex.getInstance().get(
+                NeonPhpUtil.normalizePhpVariable(name),
+                project,
+                GlobalSearchScope.allScope(project)
+        );
+    }
+
+    public static Collection<NeonNamespaceReference> findNamespacesByFqn(@NotNull Project project, String fqn) {
+        return NeonPhpNamespaceIndex.getInstance().get(
+                NeonPhpUtil.normalizeClassName(fqn),
+                project,
+                GlobalSearchScope.allScope(project)
+        );
+    }
+
+    public static Collection<NeonMethodUsage> findMethodsByName(@NotNull Project project, String name) {
+        return NeonPhpMethodIndex.getInstance().get(name, project, GlobalSearchScope.allScope(project));
+    }
+
+    public static Collection<NeonClassReference> getClassesByFqn(@NotNull Project project, String fqn) {
+        return NeonPhpClassIndex.getInstance().get(
+                NeonPhpUtil.normalizeClassName(fqn),
+                project,
+                GlobalSearchScope.allScope(project)
+        );
+    }
+
+}

src/main/java/cz/juzna/intellij/neon/indexes/extensions/NeonPhpClassIndex.java

@@ -0,0 +1,37 @@
+package cz.juzna.intellij.neon.indexes.extensions;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.stubs.StringStubIndexExtension;
+import com.intellij.psi.stubs.StubIndex;
+import com.intellij.psi.stubs.StubIndexKey;
+import cz.juzna.intellij.neon.psi.NeonClassReference;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+public class NeonPhpClassIndex extends StringStubIndexExtension<NeonClassReference> {
+    public static final StubIndexKey<String, NeonClassReference> KEY = StubIndexKey.createIndexKey("neon.phpClass.index");
+
+    private static final NeonPhpClassIndex ourInstance = new NeonPhpClassIndex();
+
+    public static NeonPhpClassIndex getInstance() {
+        return ourInstance;
+    }
+
+    @Override
+    public int getVersion() {
+        return super.getVersion() + 1;
+    }
+
+    @Override
+    @NotNull
+    public StubIndexKey<String, NeonClassReference> getKey() {
+        return KEY;
+    }
+
+    @Override
+    public Collection<NeonClassReference> get(@NotNull String key, @NotNull Project project, @NotNull GlobalSearchScope scope) {
+        return StubIndex.getElements(getKey(), key, project, scope, NeonClassReference.class);
+    }
+}