index groovy package annotations

2026-09-27 10:03:11 +07:00 · 2010-07-28 23:49:46 +01:00
parent 5f49355390
commit 61e2575c87
14 changed files with 182 additions and 229 deletions
@@ -21,25 +21,49 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.LocalSearchScope;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.search.searches.AnnotatedElementsSearch;
+import com.intellij.psi.stubs.StubIndex;
 import com.intellij.util.Processor;
 import com.intellij.util.QueryExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyRecursiveElementVisitor;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMember;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
-import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GroovyScriptClass;
-import org.jetbrains.plugins.groovy.lang.stubs.GroovyCacheUtil;
+import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnnotatedMemberIndex;

 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;

 /**
 * @author ven
 */
-public class AnnotatedMembersSearcher implements QueryExecutor<PsiMember, AnnotatedElementsSearch.Parameters> {
+public class AnnotatedMembersSearcher implements QueryExecutor<PsiModifierListOwner, AnnotatedElementsSearch.Parameters> {

-  public boolean execute(final AnnotatedElementsSearch.Parameters p, final Processor<PsiMember> consumer) {
+  @NotNull
+  private static List<PsiModifierListOwner> getAnnotatedMemberCandidates(PsiClass clazz, GlobalSearchScope scope) {
+    final String name = clazz.getName();
+    if (name == null) return Collections.emptyList();
+    final Collection<PsiElement> members = StubIndex.getInstance().get(GrAnnotatedMemberIndex.KEY, name, clazz.getProject(), scope);
+    if (members.isEmpty()) {
+      return Collections.emptyList();
+    }
+
+    final ArrayList<PsiModifierListOwner> result = new ArrayList<PsiModifierListOwner>();
+    for (PsiElement element : members) {
+      if (element instanceof GroovyFile) {
+        element = ((GroovyFile)element).getPackageDefinition();
+      }
+      if (element instanceof PsiModifierListOwner) {
+        result.add((PsiModifierListOwner)element);
+      }
+    }
+    return result;
+  }
+
+  public boolean execute(final AnnotatedElementsSearch.Parameters p, final Processor<PsiModifierListOwner> consumer) {
    final PsiClass annClass = p.getAnnotationClass();
    assert annClass.isAnnotationType() : "Annotation type should be passed to annotated members search";

@@ -48,29 +72,27 @@ public class AnnotatedMembersSearcher implements QueryExecutor<PsiMember, Annota

    final SearchScope scope = p.getScope();

-    PsiMember[] candidates;
+    final List<PsiModifierListOwner> candidates;
    if (scope instanceof GlobalSearchScope) {
-      candidates = GroovyCacheUtil.getAnnotatedMemberCandidates(annClass, ((GlobalSearchScope)scope));
+      candidates = getAnnotatedMemberCandidates(annClass, ((GlobalSearchScope)scope));
    } else {
-      PsiElement[] elements = ((LocalSearchScope)scope).getScope();
-      final List<GrMember> collector = new ArrayList<GrMember>();
-      for (PsiElement element : elements) {
+      candidates = new ArrayList<PsiModifierListOwner>();
+      for (PsiElement element : ((LocalSearchScope)scope).getScope()) {
        if (element instanceof GroovyPsiElement) {
          ((GroovyPsiElement)element).accept(new GroovyRecursiveElementVisitor() {
            public void visitMethod(GrMethod method) {
-              collector.add(method);
+              candidates.add(method);
            }

            public void visitField(GrField field) {
-              collector.add(field);
+              candidates.add(field);
            }
          });
        }
      }
-      candidates = collector.toArray(new PsiMember[collector.size()]);
    }

-    for (PsiMember candidate : candidates) {
+    for (PsiModifierListOwner candidate : candidates) {
      if (!AnnotatedElementsSearcher.isInstanceof(candidate, p.getTypes())) {
        continue;
      }
@@ -78,10 +100,8 @@ public class AnnotatedMembersSearcher implements QueryExecutor<PsiMember, Annota
      PsiModifierList list = candidate.getModifierList();
      if (list != null) {
        for (PsiAnnotation annotation : list.getAnnotations()) {
-          if (annotationFQN.equals(annotation.getQualifiedName())) {
-            PsiClass clazz = candidate.getContainingClass();
-            if (clazz instanceof GroovyScriptClass) continue;
-            if (!consumer.process(candidate)) return false;
+          if (annotationFQN.equals(annotation.getQualifiedName()) && !consumer.process(candidate)) {
+            return false;
          }
        }
      }
@@ -16,10 +16,7 @@

 package org.jetbrains.plugins.groovy.lang.psi.api.toplevel.packaging;

-import com.intellij.navigation.NavigationItem;
-import com.intellij.openapi.util.Iconable;
-import com.intellij.openapi.util.UserDataHolderEx;
-import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiModifierListOwner;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
 import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.GrTopStatement;
@@ -28,10 +25,11 @@ import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
 /**
 * @author ilyas
 */
-public interface GrPackageDefinition
-  extends UserDataHolderEx, Cloneable, Iconable, PsiElement, NavigationItem, GrTopStatement {
+public interface GrPackageDefinition extends GrTopStatement, PsiModifierListOwner {
+  @Nullable
  String getPackageName();

+  @Nullable
  GrCodeReferenceElement getPackageReference();

  @Nullable
@@ -18,12 +18,23 @@ package org.jetbrains.plugins.groovy.lang.psi.impl;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.util.Computable;
 import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.search.searches.DirectClassInheritorsSearch;
+import com.intellij.psi.stubs.StubIndex;
 import com.intellij.util.Processor;
 import com.intellij.util.QueryExecutor;
-import org.jetbrains.plugins.groovy.lang.stubs.GroovyCacheUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.groovy.lang.psi.GrClassSubstitutor;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrAnonymousClassDefinition;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrReferenceList;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
+import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnonymousClassIndex;
+import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrDirectInheritorsIndex;
+
+import java.util.ArrayList;
+import java.util.Collection;

 /**
 * @author ven
@@ -32,6 +43,26 @@ class GroovyDirectInheritorsSearcher implements QueryExecutor<PsiClass, DirectCl
  public GroovyDirectInheritorsSearcher() {
  }

+  @NotNull
+  private static PsiClass[] getDeriverCandidates(PsiClass clazz, GlobalSearchScope scope) {
+    final String name = clazz.getName();
+    if (name == null) return GrTypeDefinition.EMPTY_ARRAY;
+    final ArrayList<PsiClass> inheritors = new ArrayList<PsiClass>();
+    final Collection<GrReferenceList> refLists = StubIndex.getInstance().get(GrDirectInheritorsIndex.KEY, name, clazz.getProject(), scope);
+    for (GrReferenceList list : refLists) {
+      final PsiElement parent = list.getParent();
+      if (parent instanceof GrTypeDefinition) {
+        inheritors.add(GrClassSubstitutor.getSubstitutedClass(((GrTypeDefinition)parent)));
+      }
+    }
+    final Collection<GrAnonymousClassDefinition> classes =
+      StubIndex.getInstance().get(GrAnonymousClassIndex.KEY, name, clazz.getProject(), scope);
+    for (GrAnonymousClassDefinition aClass : classes) {
+      inheritors.add(aClass);
+    }
+    return inheritors.toArray(new PsiClass[inheritors.size()]);
+  }
+
  public boolean execute(DirectClassInheritorsSearch.SearchParameters queryParameters, final Processor<PsiClass> consumer) {
    final PsiClass clazz = queryParameters.getClassToProcess();
    final SearchScope scope = queryParameters.getScope();
@@ -39,7 +70,7 @@ class GroovyDirectInheritorsSearcher implements QueryExecutor<PsiClass, DirectCl
      final PsiClass[] candidates = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass[]>() {
        public PsiClass[] compute() {
          if (!clazz.isValid()) return PsiClass.EMPTY_ARRAY;
-          return GroovyCacheUtil.getDeriverCandidates(clazz, (GlobalSearchScope)scope);
+          return getDeriverCandidates(clazz, (GlobalSearchScope)scope);
        }
      });
      for (final PsiClass candidate : candidates) {
@@ -17,6 +17,9 @@
 package org.jetbrains.plugins.groovy.lang.psi.impl.toplevel.packaging;

 import com.intellij.lang.ASTNode;
+import com.intellij.psi.Modifier;
+import com.intellij.psi.PsiModifierList;
+import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.plugins.groovy.lang.parser.GroovyElementTypes;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
@@ -56,4 +59,15 @@ public class GrPackageDefinitionImpl extends GroovyPsiElementImpl implements GrP
  public GrModifierList getAnnotationList() {
    return (GrModifierList)findChildByType(GroovyElementTypes.MODIFIERS);
  }
+
+  @Override
+  public PsiModifierList getModifierList() {
+    return getAnnotationList();
+  }
+
+  @Override
+  public boolean hasModifierProperty(@Modifier @NonNls @NotNull String name) {
+    final PsiModifierList list = getModifierList();
+    return list != null && list.hasExplicitModifier(name);
+  }
 }
@@ -15,17 +15,63 @@
 */
 package org.jetbrains.plugins.groovy.lang.psi.stubs;

-import com.intellij.psi.stubs.PsiFileStub;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.stubs.PsiFileStubImpl;
+import com.intellij.psi.tree.IStubFileElementType;
+import com.intellij.util.ArrayUtil;
 import com.intellij.util.io.StringRef;
+import org.jetbrains.plugins.groovy.lang.parser.GroovyParserDefinition;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
+import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.packaging.GrPackageDefinition;
+import org.jetbrains.plugins.groovy.lang.psi.stubs.elements.GrTypeDefinitionElementType;

 /**
 * @author ilyas
 */
-public interface GrFileStub extends PsiFileStub<GroovyFile> {
-  StringRef getPackageName();
+public class GrFileStub extends PsiFileStubImpl<GroovyFile> {
+  private final String[] myAnnotations;
+  private final StringRef myPackageName;
+  private final StringRef myName;
+  private final boolean isScript;

-  StringRef getName();
+  public GrFileStub(GroovyFile file) {
+    super(file);
+    myPackageName = StringRef.fromString(file.getPackageName());
+    myName = StringRef.fromString(StringUtil.trimEnd(file.getName(), ".groovy"));
+    isScript = file.isScript();
+    final GrPackageDefinition definition = file.getPackageDefinition();
+    if (definition != null) {
+      myAnnotations = GrTypeDefinitionElementType.getAnnotationNames(definition);
+    } else {
+      myAnnotations = ArrayUtil.EMPTY_STRING_ARRAY;
+    }
+  }

-  boolean isScript();
+  public GrFileStub(StringRef packName, StringRef name, boolean isScript, String[] annotations) {
+    super(null);
+    myPackageName = packName;
+    myName = name;
+    this.isScript = isScript;
+    myAnnotations = annotations;
+  }
+
+  public IStubFileElementType getType() {
+    return GroovyParserDefinition.GROOVY_FILE;
+  }
+
+  public StringRef getPackageName() {
+    return myPackageName;
+  }
+
+  public StringRef getName() {
+    return myName;
+  }
+
+  public boolean isScript() {
+    return isScript;
+  }
+
+  public String[] getAnnotations() {
+    return myAnnotations;
+  }
 }
@@ -58,5 +58,21 @@ public class GrStubUtils {
        dataStream.writeUTF(namepParameter);
      }
    }
-  }  
+  }
+
+  public static void writeStringArray(StubOutputStream dataStream, String[] array) throws IOException {
+    dataStream.writeByte(array.length);
+    for (String s : array) {
+      dataStream.writeName(s);
+    }
+  }
+
+  public static String[] readStringArray(StubInputStream dataStream) throws IOException {
+    final byte b = dataStream.readByte();
+    final String[] annNames = new String[b];
+    for (int i = 0; i < b; i++) {
+      annNames[i] = dataStream.readName().toString();
+    }
+    return annNames;
+  }
 }
@@ -19,7 +19,6 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.stubs.DefaultStubBuilder;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
-import org.jetbrains.plugins.groovy.lang.psi.stubs.impl.GrFileStubImpl;

 /**
 * @author ilyas
@@ -27,7 +26,7 @@ import org.jetbrains.plugins.groovy.lang.psi.stubs.impl.GrFileStubImpl;
 public class GroovyFileStubBuilder extends DefaultStubBuilder {
  protected StubElement createStubForFile(final PsiFile file) {
    if (file instanceof GroovyFile && ((GroovyFile) file).isScript()) {
-      return new GrFileStubImpl((GroovyFile)file);
+      return new GrFileStub((GroovyFile)file);
    }

    return super.createStubForFile(file);
@@ -21,16 +21,10 @@ import com.intellij.psi.stubs.IndexSink;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
-import com.intellij.util.ArrayUtil;
-import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.io.StringRef;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.psi.GrStubElementType;
-import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
-import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField;
-import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.GrFieldImpl;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.GrFieldStub;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.impl.GrFieldStubImpl;
@@ -64,22 +58,7 @@ public class GrFieldElementType extends GrStubElementType<GrFieldStub, GrField>
  }

  public GrFieldStub createStub(GrField psi, StubElement parentStub) {
-    final GrModifierList modifiers = psi.getModifierList();
-    String[] annNames;
-    if (modifiers == null) {
-      annNames = ArrayUtil.EMPTY_STRING_ARRAY;
-    }
-    else {
-      final GrAnnotation[] annotations = modifiers.getAnnotations();
-      annNames = ContainerUtil.map(annotations, new Function<GrAnnotation, String>() {
-        @Nullable
-        public String fun(final GrAnnotation grAnnotation) {
-          final GrCodeReferenceElement element = grAnnotation.getClassReference();
-          if (element == null) return null;
-          return element.getReferenceName();
-        }
-      }, new String[annotations.length]);
-    }
+    String[] annNames = GrTypeDefinitionElementType.getAnnotationNames(psi);

    Set<String>[] namedParametersArray = new Set[0];
    if (psi instanceof GrFieldImpl){
@@ -20,15 +20,9 @@ import com.intellij.psi.stubs.IndexSink;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
-import com.intellij.util.Function;
-import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.io.StringRef;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.psi.GrStubElementType;
-import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
-import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
-import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.typedef.members.GrMethodImpl;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.GrMethodStub;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.GrStubUtils;
@@ -37,7 +31,9 @@ import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnnotatedMemberIndex;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrMethodNameIndex;

 import java.io.IOException;
-import java.util.*;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;

 /**
 * @author ilyas
@@ -57,42 +53,22 @@ public class GrMethodElementType extends GrStubElementType<GrMethodStub, GrMetho
  }

  public GrMethodStub createStub(GrMethod psi, StubElement parentStub) {
-    final GrModifierList modifiers = psi.getModifierList();
-    final GrAnnotation[] annotations = modifiers.getAnnotations();
-    String[] annNames = ContainerUtil.map(annotations, new Function<GrAnnotation, String>() {
-      @Nullable
-      public String fun(final GrAnnotation grAnnotation) {
-        final GrCodeReferenceElement element = grAnnotation.getClassReference();
-        if (element == null) return null;
-        return element.getReferenceName();
-      }
-    }, new String[annotations.length]);

-    Set<String>[] namedParametersArray;
-    namedParametersArray = psi.getNamedParametersArray();
-
-    return new GrMethodStubImpl(parentStub, StringRef.fromString(psi.getName()), annNames, namedParametersArray);
+    return new GrMethodStubImpl(parentStub, StringRef.fromString(psi.getName()), GrTypeDefinitionElementType.getAnnotationNames(psi),
+                                psi.getNamedParametersArray());
  }

  public void serialize(GrMethodStub stub, StubOutputStream dataStream) throws IOException {
    dataStream.writeName(stub.getName());
-    final String[] annotations = stub.getAnnotations();
-    dataStream.writeByte(annotations.length);
-    for (String s : annotations) {
-      dataStream.writeName(s);
-    }
+    GrStubUtils.writeStringArray(dataStream, stub.getAnnotations());
    final Set<String>[] namedParameters = stub.getNamedParameters();

    GrStubUtils.serializeCollectionsArray(dataStream, namedParameters);
  }
-    
+
  public GrMethodStub deserialize(StubInputStream dataStream, StubElement parentStub) throws IOException {
    StringRef ref = dataStream.readName();
-    final byte b = dataStream.readByte();
-    final String[] annNames = new String[b];
-    for (int i = 0; i < b; i++) {
-      annNames[i] = dataStream.readName().toString();
-    }
+    final String[] annNames = GrStubUtils.readStringArray(dataStream);
    final List<Set<String>> namedParametersSets = GrStubUtils.deserializeCollectionsArray(dataStream);

    return new GrMethodStubImpl(parentStub, ref, annNames, namedParametersSets.toArray(new HashSet[0]));
@@ -21,8 +21,9 @@ import com.intellij.psi.stubs.*;
 import com.intellij.psi.tree.IStubFileElementType;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.GrFileStub;
+import org.jetbrains.plugins.groovy.lang.psi.stubs.GrStubUtils;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.GroovyFileStubBuilder;
-import org.jetbrains.plugins.groovy.lang.psi.stubs.impl.GrFileStubImpl;
+import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnnotatedMemberIndex;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrFullScriptNameIndex;
 import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrScriptClassNameIndex;

@@ -43,7 +44,7 @@ public class GrStubFileElementType extends IStubFileElementType<GrFileStub> {

  @Override
  public int getStubVersion() {
-    return super.getStubVersion() + 5;
+    return super.getStubVersion() + 6;
  }

  public String getExternalId() {
@@ -60,6 +61,7 @@ public class GrStubFileElementType extends IStubFileElementType<GrFileStub> {
    dataStream.writeName(stub.getPackageName().toString());
    dataStream.writeName(stub.getName().toString());
    dataStream.writeBoolean(stub.isScript());
+    GrStubUtils.writeStringArray(dataStream, stub.getAnnotations());
  }

  @Override
@@ -67,7 +69,7 @@ public class GrStubFileElementType extends IStubFileElementType<GrFileStub> {
    StringRef packName = dataStream.readName();
    StringRef name = dataStream.readName();
    boolean isScript = dataStream.readBoolean();
-    return new GrFileStubImpl(packName, name, isScript);
+    return new GrFileStub(packName, name, isScript, GrStubUtils.readStringArray(dataStream));
  }

  public void indexStub(GrFileStub stub, IndexSink sink) {
@@ -78,6 +80,10 @@ public class GrStubFileElementType extends IStubFileElementType<GrFileStub> {
      final String fqn = pName == null || pName.length() == 0 ? name : pName + "." + name;
      sink.occurrence(GrFullScriptNameIndex.KEY, fqn.hashCode());
    }
+
+    for (String anno : stub.getAnnotations()) {
+      sink.occurrence(GrAnnotatedMemberIndex.KEY, anno);
+    }
  }

 }
@@ -17,6 +17,7 @@ package org.jetbrains.plugins.groovy.lang.psi.stubs.elements;

 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiModifierList;
+import com.intellij.psi.PsiModifierListOwner;
 import com.intellij.psi.PsiNameHelper;
 import com.intellij.psi.impl.java.stubs.index.JavaFullClassNameIndex;
 import com.intellij.psi.impl.java.stubs.index.JavaShortClassNameIndex;
@@ -59,7 +60,7 @@ public abstract class GrTypeDefinitionElementType<TypeDef extends GrTypeDefiniti
                                        flags);
  }

-  private static String[] getAnnotationNames(GrTypeDefinition psi) {
+  public static String[] getAnnotationNames(PsiModifierListOwner psi) {
    List<String> annoNames = CollectionFactory.arrayList();
    final PsiModifierList modifierList = psi.getModifierList();
    if (modifierList instanceof GrModifierList) {
@@ -1,63 +0,0 @@
-/*
- * Copyright 2000-2009 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.jetbrains.plugins.groovy.lang.psi.stubs.impl;
-
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.stubs.PsiFileStubImpl;
-import com.intellij.psi.tree.IStubFileElementType;
-import com.intellij.util.io.StringRef;
-import org.jetbrains.plugins.groovy.lang.parser.GroovyParserDefinition;
-import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
-import org.jetbrains.plugins.groovy.lang.psi.stubs.GrFileStub;
-
-/**
- * @author ilyas
- */
-public class GrFileStubImpl extends PsiFileStubImpl<GroovyFile> implements GrFileStub {
-  private final StringRef myPackageName;
-  private final StringRef myName;
-  private final boolean isScript;
-
-  public GrFileStubImpl(GroovyFile file) {
-    super(file);
-    myPackageName = StringRef.fromString(file.getPackageName());
-    myName = StringRef.fromString(StringUtil.trimEnd(file.getName(), ".groovy"));
-    isScript = file.isScript();
-  }
-
-  public GrFileStubImpl(StringRef packName, StringRef name, boolean isScript) {
-    super(null);
-    myPackageName = packName;
-    myName = name;
-    this.isScript = isScript;
-  }
-
-  public IStubFileElementType getType() {
-    return GroovyParserDefinition.GROOVY_FILE;
-  }
-
-  public StringRef getPackageName() {
-    return myPackageName;
-  }
-
-  public StringRef getName() {
-    return myName;
-  }
-
-  public boolean isScript() {
-    return isScript;
-  }
-}
@@ -15,17 +15,17 @@
 */
 package org.jetbrains.plugins.groovy.lang.psi.stubs.index;

-import com.intellij.psi.PsiMember;
+import com.intellij.psi.PsiElement;
 import com.intellij.psi.stubs.StringStubIndexExtension;
 import com.intellij.psi.stubs.StubIndexKey;

 /**
 * @author ilyas
 */
-public class GrAnnotatedMemberIndex extends StringStubIndexExtension<PsiMember> {
-  public static final StubIndexKey<String, PsiMember> KEY = StubIndexKey.createIndexKey("gr.annot.members");
+public class GrAnnotatedMemberIndex extends StringStubIndexExtension<PsiElement> {
+  public static final StubIndexKey<String, PsiElement> KEY = StubIndexKey.createIndexKey("gr.annot.members");

-  public StubIndexKey<String, PsiMember> getKey() {
+  public StubIndexKey<String, PsiElement> getKey() {
    return KEY;
  }
 }
@@ -1,70 +0,0 @@
-/*
- * Copyright 2000-2009 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.jetbrains.plugins.groovy.lang.stubs;
-
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiMember;
-import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.stubs.StubIndex;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.plugins.groovy.lang.psi.GrClassSubstitutor;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrAnonymousClassDefinition;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrReferenceList;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMember;
-import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnnotatedMemberIndex;
-import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnonymousClassIndex;
-import org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrDirectInheritorsIndex;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-/**
- * @author ilyas
- */
-public abstract class GroovyCacheUtil {
-
-  @NotNull
-  public static PsiMember[] getAnnotatedMemberCandidates(PsiClass clazz, GlobalSearchScope scope) {
-    final String name = clazz.getName();
-    if (name == null) return GrMember.EMPTY_ARRAY;
-    final Collection<PsiMember> members = StubIndex.getInstance().get(GrAnnotatedMemberIndex.KEY, name, clazz.getProject(), scope);
-    return members.toArray(new PsiMember[members.size()]);
-  }
-
-  @NotNull
-  public static PsiClass[] getDeriverCandidates(PsiClass clazz, GlobalSearchScope scope) {
-    final String name = clazz.getName();
-    if (name == null) return GrTypeDefinition.EMPTY_ARRAY;
-    final ArrayList<PsiClass> inheritors = new ArrayList<PsiClass>();
-    final Collection<GrReferenceList> refLists = StubIndex.getInstance().get(GrDirectInheritorsIndex.KEY, name, clazz.getProject(), scope);
-    for (GrReferenceList list : refLists) {
-      final PsiElement parent = list.getParent();
-      if (parent instanceof GrTypeDefinition) {
-        inheritors.add(GrClassSubstitutor.getSubstitutedClass(((GrTypeDefinition)parent)));
-      }
-    }
-    final Collection<GrAnonymousClassDefinition> classes =
-      StubIndex.getInstance().get(GrAnonymousClassIndex.KEY, name, clazz.getProject(), scope);
-    for (GrAnonymousClassDefinition aClass : classes) {
-      inheritors.add(aClass);
-    }
-    return inheritors.toArray(new PsiClass[inheritors.size()]);
-  }
-
-
-}