import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public static Query<PsiClass> search(final PsiClass aClass,
                                     SearchScope scope,
                                     boolean includeAnonymous,
                                     final boolean checkInheritance) {
  final Query<PsiClass> raw = INSTANCE.createUniqueResultsQuery(new SearchParameters(aClass, scope, includeAnonymous, checkInheritance));

  if (!includeAnonymous) {
    return new FilteredQuery<PsiClass>(raw, new Condition<PsiClass>() {
      @Override
      public boolean value(final PsiClass psiClass) {
        return !(psiClass instanceof PsiAnonymousClass);
      }
    });
  }

  return raw;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
/**
 * Override in case if your JVMNames slightly different then it can be provided by getJvmSignature method.
 *
 * @param stepTarget
 * @return SmartStepFilter
 */
@Nullable
protected MethodFilter createMethodFilter(SmartStepTarget stepTarget) {
  if (stepTarget instanceof MethodSmartStepTarget) {
    final PsiMethod method = ((MethodSmartStepTarget)stepTarget).getMethod();
    if (stepTarget.needsBreakpointRequest()) {
      return Registry.is("debugger.async.smart.step.into") && method.getContainingClass() instanceof PsiAnonymousClass
             ? new ClassInstanceMethodFilter(method, stepTarget.getCallingExpressionLines())
             : new AnonymousClassMethodFilter(method, stepTarget.getCallingExpressionLines());
    }
    else {
      return new BasicStepMethodFilter(method, stepTarget.getCallingExpressionLines());
    }
  }
  if (stepTarget instanceof LambdaSmartStepTarget) {
    final LambdaSmartStepTarget lambdaTarget = (LambdaSmartStepTarget)stepTarget;
    return new LambdaMethodFilter(lambdaTarget.getLambda(), lambdaTarget.getOrdinal(), stepTarget.getCallingExpressionLines());
  }
  return null;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
@NotNull
@Override
public Collection<JavaAnonymousClassTreeElement> provideNodes(@NotNull TreeElement node) {
  if (node instanceof PsiMethodTreeElement || node instanceof PsiFieldTreeElement || node instanceof ClassInitializerTreeElement) {
    final PsiElement el = ((PsiTreeElementBase)node).getElement();
    if (el != null) {
      for (AnonymousElementProvider provider : Extensions.getExtensions(AnonymousElementProvider.EP_NAME)) {
        final PsiElement[] elements = provider.getAnonymousElements(el);
        if (elements.length > 0) {
          List<JavaAnonymousClassTreeElement> result = new ArrayList<JavaAnonymousClassTreeElement>(elements.length);
          for (PsiElement element : elements) {
            result.add(new JavaAnonymousClassTreeElement((PsiAnonymousClass)element, new HashSet<PsiClass>()));
          }
          return result;
        }
      }
    }
  }
  return Collections.emptyList();
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
  int offset = editor.getCaretModel().getOffset();
  editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
  PsiElement element = file.findElementAt(offset);
  while (true) {
    if (element == null || element instanceof PsiFile) {
      String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("error.wrong.caret.position.class"));
      CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.TURN_REFS_TO_SUPER);
      return;
    }
    if (element instanceof PsiClass && !(element instanceof PsiAnonymousClass)) {
      invoke(project, new PsiElement[]{element}, dataContext);
      return;
    }
    element = element.getParent();
  }
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
@Override
public void doFix(@NotNull final Project project, ProblemDescriptor descriptor) {
  final PsiElement nameElement = descriptor.getPsiElement();
  final PsiAnonymousClass aClass =
    (PsiAnonymousClass)nameElement.getParent();
  final JavaRefactoringActionHandlerFactory factory =
    JavaRefactoringActionHandlerFactory.getInstance();
  final RefactoringActionHandler anonymousToInner =
    factory.createAnonymousToInnerHandler();
  final DataManager dataManager = DataManager.getInstance();
  final DataContext dataContext = dataManager.getDataContext();
  final Runnable runnable = new Runnable() {
    @Override
    public void run() {
      anonymousToInner.invoke(project, new PsiElement[]{aClass}, dataContext);
    }
  };
  if (ApplicationManager.getApplication().isUnitTestMode()) {
    runnable.run();
  }
  else {
    ApplicationManager.getApplication().invokeLater(runnable, project.getDisposed());
  }
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
@Override
@NotNull
public String buildErrorString(Object... infos) {
  final PsiClass aClass = (PsiClass)infos[0];
  if (aClass.isAnnotationType()) {
    return InspectionGadgetsBundle.message(
      "[email protected]ptor");
  }
  else if (aClass.isInterface()) {
    return InspectionGadgetsBundle.message(
      "non.serializable.interface.with.serialversionuid.problem.descriptor");
  }
  else if (aClass instanceof PsiAnonymousClass) {
    return InspectionGadgetsBundle.message(
      "non.serializable.anonymous.with.serialversionuid.problem.descriptor");
  }
  else {
    return InspectionGadgetsBundle.message(
      "non.serializable.class.with.serialversionuid.problem.descriptor");
  }
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
@Override
public Collection<JavaAnonymousClassTreeElement> provideNodes(TreeElement node) {
  if (node instanceof PsiMethodTreeElement || node instanceof PsiFieldTreeElement || node instanceof ClassInitializerTreeElement) {
    final PsiElement el = ((PsiTreeElementBase)node).getElement();
    for (AnonymousElementProvider provider : Extensions.getExtensions(AnonymousElementProvider.EP_NAME)) {
      final PsiElement[] elements = provider.getAnonymousElements(el);
      if (elements != null && elements.length > 0) {
        List<JavaAnonymousClassTreeElement> result = new ArrayList<JavaAnonymousClassTreeElement>(elements.length);
        for (PsiElement element : elements) {
          result.add(new JavaAnonymousClassTreeElement((PsiAnonymousClass)element, new HashSet<PsiClass>()));
        }
        return result;
      }
    }
  }
  return Collections.emptyList();
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
@Nullable
@Override
protected PsiClass getCustomTopLevelParentClass(PsiClass psiClass) {
  if (!(psiClass instanceof GrTypeDefinition)) return null;

  PsiClass enclosing = PsiTreeUtil.getParentOfType(psiClass, PsiClass.class, true);
  while (enclosing != null) {
    psiClass = enclosing;
    enclosing = PsiTreeUtil.getParentOfType(enclosing, PsiClass.class, true);
  }

  if (psiClass instanceof PsiAnonymousClass) {
    final PsiFile file = psiClass.getContainingFile();
    if (file instanceof GroovyFile) {
      return ((GroovyFile)file).getScriptClass();
    }
  }

  return psiClass;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public boolean validateBaseClassConstructor(@NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) {
  if (psiClass instanceof PsiAnonymousClass || psiClass.isEnum()) {
    return true;
  }
  PsiClass baseClass = psiClass.getSuperClass();
  if (baseClass == null) {
    return true;
  }
  PsiMethod[] constructors = baseClass.getConstructors();
  if (constructors.length == 0) {
    return true;
  }

  for (PsiMethod constructor : constructors) {
    final int parametersCount = constructor.getParameterList().getParametersCount();
    if (parametersCount == 0 || parametersCount == 1 && constructor.isVarArgs()) {
      return true;
    }
  }
  builder.addError("Lombok needs a default constructor in the base class");
  return false;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public static String getLambdaPrefix(@NotNull PsiLambdaExpression lambdaExpression)
{
	PsiMember member = PsiTreeUtil.getParentOfType(lambdaExpression, PsiMethod.class, PsiClass.class, PsiField.class);
	final String methodPrefix;
	if(member instanceof PsiMethod)
	{
		methodPrefix = member.getContainingClass() instanceof PsiAnonymousClass ? "" : "$" + member.getName();
	}
	else if(member instanceof PsiField && member.getContainingClass() instanceof PsiAnonymousClass)
	{
		methodPrefix = "";
	}
	else
	{
		//inside class initializer everywhere or field in a named class
		methodPrefix = "$new";
	}
	return methodPrefix;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
private static boolean isUnusedInAnonymousClass(@NotNull PsiMethod method)
{
	PsiClass containingClass = method.getContainingClass();
	if(!(containingClass instanceof PsiAnonymousClass))
	{
		return false;
	}

	if(containingClass.getParent() instanceof PsiNewExpression && containingClass.getParent().getParent() instanceof PsiVariable && !method.getHierarchicalMethodSignature().getSuperSignatures()
			.isEmpty())
	{
		// references outside anonymous class can still resolve to this method, see com.intellij.psi.scope.util.PsiScopesUtil.setupAndRunProcessor()
		return false;
	}

	return MethodReferencesSearch.search(method, new LocalSearchScope(containingClass), false).findFirst() == null;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
private static Set<String> getContainingClassNames(PsiElement position)
{
	Set<String> result = ContainerUtil.newLinkedHashSet();
	boolean add = false;
	while(position != null)
	{
		if(position instanceof PsiAnonymousClass)
		{
			add = true;
		}
		else if(add && position instanceof PsiClass)
		{
			ContainerUtil.addIfNotNull(result, ((PsiClass) position).getName());
		}
		position = position.getParent();
	}
	return result;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public static boolean isAvailableForElement(PsiElement element) {
  if (Extensions.getExtensions(TestFramework.EXTENSION_NAME).length == 0) return false;

  if (element == null) return false;

  PsiClass psiClass = getContainingClass(element);

  if (psiClass == null) return false;

  Module srcModule = ModuleUtilCore.findModuleForPsiElement(psiClass);
  if (srcModule == null) return false;

  if (psiClass.isAnnotationType() ||
      psiClass instanceof PsiAnonymousClass ||
      PsiTreeUtil.getParentOfType(psiClass, PsiClass.class) != null || // inner
      isUnderTestSources(psiClass)) {
    return false;
  }
  return true;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
  editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
  int offset = editor.getCaretModel().getOffset();
  PsiElement element = file.findElementAt(offset);
  while (true) {
    if (element == null || element instanceof PsiFile) {
      String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("error.wrong.caret.position.class"));
      CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INHERITANCE_TO_DELEGATION);
      return;
    }

    if (element instanceof PsiClass && !(element instanceof PsiAnonymousClass)) {
      invoke(project, new PsiElement[]{element}, dataContext);
      return;
    }
    element = element.getParent();
  }
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public void doFix(@NotNull final Project project, ProblemDescriptor descriptor) {
  final PsiElement nameElement = descriptor.getPsiElement();
  final PsiAnonymousClass aClass =
    (PsiAnonymousClass)nameElement.getParent();
  final JavaRefactoringActionHandlerFactory factory =
    JavaRefactoringActionHandlerFactory.getInstance();
  final RefactoringActionHandler anonymousToInner =
    factory.createAnonymousToInnerHandler();
  final DataManager dataManager = DataManager.getInstance();
  final DataContext dataContext = dataManager.getDataContext();
  final Runnable runnable = new Runnable() {
    public void run() {
      anonymousToInner.invoke(project, new PsiElement[]{aClass}, dataContext);
    }
  };
  if (ApplicationManager.getApplication().isUnitTestMode()) {
    runnable.run();
  }
  else {
    ApplicationManager.getApplication().invokeLater(runnable, project.getDisposed());
  }
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
/**
 * Override in case if your JVMNames slightly different then it can be provided by getJvmSignature method.
 *
 * @param stepTarget
 * @return SmartStepFilter
 */
@Nullable
protected MethodFilter createMethodFilter(SmartStepTarget stepTarget)
{
	if(stepTarget instanceof MethodSmartStepTarget)
	{
		final PsiMethod method = ((MethodSmartStepTarget) stepTarget).getMethod();
		if(stepTarget.needsBreakpointRequest())
		{
			return method.getContainingClass() instanceof PsiAnonymousClass ? new ClassInstanceMethodFilter(method, stepTarget.getCallingExpressionLines()) : new AnonymousClassMethodFilter
					(method, stepTarget.getCallingExpressionLines());
		}
		else
		{
			return new BasicStepMethodFilter(method, stepTarget.getCallingExpressionLines());
		}
	}
	if(stepTarget instanceof LambdaSmartStepTarget)
	{
		final LambdaSmartStepTarget lambdaTarget = (LambdaSmartStepTarget) stepTarget;
		return new LambdaMethodFilter(lambdaTarget.getLambda(), lambdaTarget.getOrdinal(), stepTarget.getCallingExpressionLines());
	}
	return null;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public static PsiMethod findMethod(PsiElement element) {
    PsiMethod method = (element instanceof PsiMethod) ? (PsiMethod) element :
            PsiTreeUtil.getParentOfType(element, PsiMethod.class);
    if (method != null && method.getContainingClass() instanceof PsiAnonymousClass) {
        return findMethod(method.getParent());
    }
    return method;
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
private static boolean cannotBeOverriden(final PsiMethod method) {
  final PsiClass parentClass = method.getContainingClass();
  return parentClass == null
         || method.isConstructor()
         || method.hasModifierProperty(PsiModifier.STATIC)
         || method.hasModifierProperty(PsiModifier.FINAL)
         || method.hasModifierProperty(PsiModifier.PRIVATE)
         || parentClass instanceof PsiAnonymousClass
         || parentClass.hasModifierProperty(PsiModifier.FINAL);
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public static boolean isRunnableClass(final PsiClass aClass, final boolean mustBePublic, boolean mustNotBeAbstract) {
  if (aClass instanceof PsiAnonymousClass) return false;
  if (aClass.isInterface()) return false;
  if (mustBePublic && !aClass.hasModifierProperty(PsiModifier.PUBLIC)) return false;
  if (aClass.hasModifierProperty(PsiModifier.PRIVATE)) return false;
  if (mustNotBeAbstract && aClass.hasModifierProperty(PsiModifier.ABSTRACT)) return false;
  return aClass.getContainingClass() == null || aClass.hasModifierProperty(PsiModifier.STATIC);
}
 

import com.intellij.psi.PsiAnonymousClass; //导入依赖的package包/类
public static TargetClassFilter createClassFilter(PsiClass psiClass) {
  if (psiClass instanceof PsiAnonymousClass) {
    return TargetClassFilter.ALL;
  }
  if (PsiUtil.isLocalClass(psiClass)) {
    return new LocalClassFilter(psiClass.getName());
  }
  final String name = JVMNameUtil.getNonAnonymousClassName(psiClass);
  return name != null? new FQNameClassFilter(name) : TargetClassFilter.ALL;
}