Java StubElement.getPsi方法代码示例

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
public static int calcStubIndex(@NotNull StubBasedPsiElement psi) {
  if (psi instanceof PsiFile) {
    return 0;
  }

  final StubElement liveStub = psi.getStub();
  if (liveStub != null) {
    return ((StubBase)liveStub).id;
  }

  PsiFileImpl file = (PsiFileImpl)psi.getContainingFile();
  final StubTree stubTree = file.calcStubTree();
  for (StubElement<?> stb : stubTree.getPlainList()) {
    if (stb.getPsi() == psi) {
      return ((StubBase)stb).id;
    }
  }

  return -1; // it is possible via custom stub builder intentionally not producing stubs for stubbed elements
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@Override
public PsiFile getContainingFile() {
  StubElement p = myStub;
  while (!(p instanceof PsiFileStub)) {
    p = p.getParentStub();
  }
  return (PsiFile)p.getPsi();
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@Override
public PsiElement getParent() {
  final PsiClassStub stub = getStub();
  if (stub != null) {
    final StubElement parentStub = stub.getParentStub();
    if (parentStub instanceof PsiFileStub || parentStub instanceof PsiClassStub
      ) {
      return parentStub.getPsi();
    }
  }

  return SharedImplUtil.getParent(getNode());
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@Nullable
@Contract("null -> null")
public static PsiElement getStubOrPsiParent(@Nullable PsiElement element) {
  if (element instanceof StubBasedPsiElement) {
    StubBase stub = (StubBase)((StubBasedPsiElement)element).getStub();
    if (stub != null) {
      //noinspection unchecked
      final StubElement parentStub = stub.getParentStub();
      return parentStub != null ? parentStub.getPsi() : null;
    }
  }
  return element != null ? element.getParent() : null;
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@Nullable
private static PsiElement getContainerByStub(@NotNull StubBasedPsiElement element) {
  final StubElement stub = element.getStub();
  if (stub != null) {
    final StubElement parentStub = stub.getParentStub();
    if (parentStub != null) {
      return parentStub.getPsi();
    }
  }
  return null;
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
public static boolean isTopLevel(@NotNull PsiElement element) {
  if (element instanceof StubBasedPsiElement) {
    final StubElement stub = ((StubBasedPsiElement)element).getStub();
    if (stub != null) {
      final StubElement parentStub = stub.getParentStub();
      if (parentStub != null) {
        return parentStub.getPsi() instanceof PsiFile;
      }
    }
  }
  return ScopeUtil.getScopeOwner(element) instanceof PsiFile;
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@Override
public GrPackageDefinition getPackageDefinition() {
  final StubElement<?> stub = getStub();
  if (stub != null) {
    for (StubElement element : stub.getChildrenStubs()) {
      if (element instanceof GrPackageDefinitionStub) return (GrPackageDefinition)element.getPsi();
    }
    return null;
  }

  ASTNode node = calcTreeElement().findChildByType(GroovyElementTypes.PACKAGE_DEFINITION);
  return node != null ? (GrPackageDefinition)node.getPsi() : null;
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
private static void getStubsTreeImpl(StubElement element, StringBuffer buffer, String offset) {
  PsiElement psi = element.getPsi();
  buffer.append(offset).append("[").append(psi.toString()).
          append(element instanceof NamedStub ? " : " + ((NamedStub) element).getName() : "").
          append("]\n");
  for (StubElement stubElement : ((List<StubElement>) element.getChildrenStubs())) {
    getStubsTreeImpl(stubElement, buffer, offset + "  ");
  }
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@Nullable
private static PsiElement calcBasesResolveContext(PsiClass aClass,
                                                  String className,
                                                  boolean isInitialClass,
                                                  final PsiElement defaultResolveContext) {
  final PsiClassStub stub = ((PsiClassImpl)aClass).getStub();
  if (stub == null || stub.isAnonymousInQualifiedNew()) {
    return aClass.getParent();
  }

  boolean isAnonOrLocal = isAnonymousOrLocal(aClass);

  if (!isAnonOrLocal) {
    return isInitialClass ? defaultResolveContext : aClass;
  }

  if (!isInitialClass) {
    if (aClass.findInnerClassByName(className, true) != null) return aClass;
  }

  final StubElement parentStub = stub.getParentStub();

  final StubBasedPsiElementBase<?> context = (StubBasedPsiElementBase)parentStub.getPsi();
  @SuppressWarnings("unchecked")
  PsiClass[] classesInScope = (PsiClass[])parentStub.getChildrenByType(Constants.CLASS_BIT_SET, PsiClass.ARRAY_FACTORY);

  boolean needPreciseContext = false;
  if (classesInScope.length > 1) {
    for (PsiClass scopeClass : classesInScope) {
      if (scopeClass == aClass) continue;
      String className1 = scopeClass.getName();
      if (className.equals(className1)) {
        needPreciseContext = true;
        break;
      }
    }
  }
  else {
    if (classesInScope.length != 1) {
      LOG.assertTrue(classesInScope.length == 1, "Parent stub: "+parentStub.getStubType() +"; children: "+parentStub.getChildrenStubs()+"; \ntext:"+context.getText());
    }
    LOG.assertTrue(classesInScope[0] == aClass);
  }

  if (needPreciseContext) {
    return aClass.getParent();
  }
  else {
    if (context instanceof PsiClass) {
      return calcBasesResolveContext((PsiClass)context, className, false, defaultResolveContext);
    }
    else if (context instanceof PsiMember) {
      return calcBasesResolveContext(((PsiMember)context).getContainingClass(), className, false, defaultResolveContext);
    }
    else {
      LOG.assertTrue(false);
      return context;
    }
  }
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@NonNls
@NotNull
private static String reason(@NotNull PsiElement root) {
  if (root == PsiUtilCore.NULL_PSI_ELEMENT) return "NULL_PSI_ELEMENT";

  PsiElement element = root instanceof PsiFile ? root : root.getParent();
  if (element == null) {
    String m = "parent is null";
    if (root instanceof StubBasedPsiElement) {
      StubElement stub = ((StubBasedPsiElement)root).getStub();
      while (stub != null) {
        m += "\n  each stub=" + stub;
        if (stub instanceof PsiFileStub) {
          m += "; fileStub.psi=" + stub.getPsi() + "; reason=" + ((PsiFileStub)stub).getInvalidationReason();
        }
        stub = stub.getParentStub();
      }
    }
    return m;
  }

  while (element != null && !(element instanceof PsiFile)) element = element.getParent();
  PsiFile file = (PsiFile)element;
  if (file == null) return "containing file is null";

  FileViewProvider provider = file.getViewProvider();
  VirtualFile vFile = provider.getVirtualFile();
  if (!vFile.isValid()) return vFile + " is invalid";
  if (!provider.isPhysical()) {
    PsiElement context = file.getContext();
    if (context != null && !context.isValid()) {
      return "invalid context: " + reason(context);
    }
  }

  PsiManager manager = file.getManager();
  if (manager.getProject().isDisposed()) return "project is disposed";

  Language language = file.getLanguage();
  if (language != provider.getBaseLanguage()) return "File language:" + language + " != Provider base language:" + provider.getBaseLanguage();

  FileViewProvider p = manager.findViewProvider(vFile);
  if (provider != p) return "different providers: " + provider + "(" + id(provider) + "); " + p + "(" + id(p) + ")";

  if (!provider.isPhysical()) return "non-physical provider: " + provider; // "dummy" file?

  return "psi is outdated";
}
 

import com.intellij.psi.stubs.StubElement; //导入方法依赖的package包/类
@Nullable
public static PsiElement restoreFromStubIndex(PsiFileWithStubSupport fileImpl,
                                              int index,
                                              @NotNull IStubElementType elementType, boolean throwIfNull) {
  if (fileImpl == null) {
    if (throwIfNull) throw new AssertionError("Null file");
    return null;
  }
  StubTree tree = fileImpl.getStubTree();

  boolean foreign = tree == null;
  if (foreign) {
    if (fileImpl instanceof PsiFileImpl) {
      // Note: as far as this is a realization of StubIndexReference fileImpl#getContentElementType() must be instance of IStubFileElementType
      tree = ((PsiFileImpl)fileImpl).calcStubTree();
    }
    else {
      if (throwIfNull) throw new AssertionError("Not PsiFileImpl: " + fileImpl.getClass());
      return null;
    }
  }

  List<StubElement<?>> list = tree.getPlainList();
  if (index >= list.size()) {
    if (throwIfNull) throw new AssertionError("Too large index: " + index + ">=" + list.size());
    return null;
  }
  StubElement stub = list.get(index);

  if (stub.getStubType() != elementType) {
    if (throwIfNull) throw new AssertionError("Element type mismatch: " + stub.getStubType() + "!=" + elementType);
    return null;
  }

  if (foreign) {
    final PsiElement cachedPsi = ((StubBase)stub).getCachedPsi();
    if (cachedPsi != null) return cachedPsi;

    final ASTNode ast = fileImpl.findTreeForStub(tree, stub);
    if (ast != null) {
      return ast.getPsi();
    }

    if (throwIfNull) throw new AssertionError("No AST for stub");
    return null;
  }
  return stub.getPsi();
}