Java PsiClassInitializer类代码示例

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
public void collectNodes(PsiClass psiClass) {
    for (PsiMethod psiMethod : psiClass.getMethods()) {
        elementsAddedByUser.put(getFqn(psiMethod), spManager.createSmartPsiElementPointer((PsiElement) psiMethod));
    }

    for (PsiField psiField : psiClass.getFields()) {
        elementsAddedByUser.put(getFqn(psiField), spManager.createSmartPsiElementPointer((PsiElement) psiField));
    }

    for (PsiClassInitializer psiClassInitializer : psiClass.getInitializers()) {
        elementsAddedByUser.put(getFqn(psiClassInitializer), spManager.createSmartPsiElementPointer((PsiElement) psiClassInitializer));
    }

    for (PsiClass innerClass : psiClass.getInnerClasses()) {
        elementsAddedByUser.put(getFqn(innerClass), spManager.createSmartPsiElementPointer((PsiElement) innerClass));
    }
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
public T dispatch(PsiElement psiElement) {
    if (psiElement instanceof PsiClass) {
        if (((PsiClass) psiElement).getContainingClass() == null) {
            return processClass((PsiClass) psiElement);
        } else {
            if (((PsiClass) psiElement).isEnum()) {
                return processEnum((PsiClass) psiElement);
            } else {
                if (((PsiClass) psiElement).hasModifierProperty("static")) {
                    return processStaticInnerClass((PsiClass) psiElement);
                } else {
                    return processInnerClass((PsiClass) psiElement);
                }
            }
        }
    } else if (psiElement instanceof PsiMethod) {
        return processMethod((PsiMethod) psiElement);
    } else if (psiElement instanceof PsiField) {
        return processField((PsiField) psiElement);
    } else if (psiElement instanceof PsiClassInitializer) {
        return processClassInitializer((PsiClassInitializer) psiElement);
    }
    throw new IllegalArgumentException("Type of PsiElement not supported: " + psiElement);
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
private void registerNestedClosures(@NotNull DfaInstructionState instructionState, @NotNull PsiClass nestedClass)
{
	DfaMemoryState state = instructionState.getMemoryState();
	for(PsiMethod method : nestedClass.getMethods())
	{
		PsiCodeBlock body = method.getBody();
		if(body != null)
		{
			createClosureState(body, state);
		}
	}
	for(PsiClassInitializer initializer : nestedClass.getInitializers())
	{
		createClosureState(initializer.getBody(), state);
	}
	for(PsiField field : nestedClass.getFields())
	{
		createClosureState(field, state);
	}
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
private boolean isInitializedInInitializer(@NotNull PsiField field, UninitializedReadCollector uninitializedReadsCollector) {
  final PsiClass aClass = field.getContainingClass();
  if (aClass == null) {
    return false;
  }
  final PsiClassInitializer[] initializers = aClass.getInitializers();
  for (final PsiClassInitializer initializer : initializers) {
    if (!initializer.hasModifierProperty(PsiModifier.STATIC)) {
      final PsiCodeBlock body = initializer.getBody();
      if (uninitializedReadsCollector.blockAssignsVariable(body, field)) {
        return true;
      }
    }
  }
  return false;
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
@Override
@NotNull
public TextRange getDeclarationRange(@NotNull final PsiElement container) {
  PsiClassInitializer initializer = (PsiClassInitializer)container;
  int startOffset = initializer.getModifierList().getTextRange().getStartOffset();
  int endOffset = initializer.getBody().getTextRange().getStartOffset();
  return new TextRange(startOffset, endOffset);
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
@Override
public Result calculateResult(@NotNull Expression[] params, final ExpressionContext context) {
  PsiElement place = context.getPsiElementAtStartOffset();
  while(place != null){
    if (place instanceof PsiMethod){
      return new TextResult(((PsiMethod)place).getName());
    } else if (place instanceof PsiClassInitializer) {
      return ((PsiClassInitializer) place).hasModifierProperty(PsiModifier.STATIC) ?
             new TextResult(LangBundle.message("java.terms.static.initializer")) :
             new TextResult(LangBundle.message("java.terms.instance.initializer"));
    }
    place = place.getParent();
  }
  return null;
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
@Override
public void visitClassInitializer(PsiClassInitializer initializer) {
  if (initializer.hasModifierProperty(PsiModifier.STATIC)) {
    return;
  }
  final PsiClass aClass = initializer.getContainingClass();
  if (!TestUtils.isJUnitTestClass(aClass) && !TestUtils.isJUnit4TestClass(aClass, true)) {
    return;
  }
  if (MethodUtils.isTrivial(initializer)) {
    return;
  }
  registerClassInitializerError(initializer, Boolean.TRUE);
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
@Override
public void visitClassInitializer(
  @NotNull PsiClassInitializer initializer) {
  super.visitClassInitializer(initializer);
  final PsiCodeBlock body = initializer.getBody();
  if (!codeBlockIsEmpty(body)) {
    return;
  }
  registerClassInitializerError(initializer);
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
private int calculateInitializerComplexity(PsiClass aClass) {
  final CyclomaticComplexityVisitor visitor = new CyclomaticComplexityVisitor();
  int complexity = 0;
  final PsiClassInitializer[] initializers = aClass.getInitializers();
  for (final PsiClassInitializer initializer : initializers) {
    visitor.reset();
    initializer.accept(visitor);
    complexity += visitor.getComplexity();
  }
  return complexity;
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
private static PsiElement getRootPsiElementWithStack(PsiClass psiClass, PsiElement psiElement, List<PsiElement> stack) {
    stack.add(psiElement);
    PsiElement parent = psiElement.getParent();
    if (parent == null) {
        return null;
    }
    try {
        if (parent instanceof PsiMethod) {
            if (PsiUtils.classHasMethod(psiClass, (PsiMethod) parent)) {
                return parent;
            }
        } else if (parent instanceof PsiClassInitializer) {
            if (PsiUtils.classHasClassInitializer(psiClass, (PsiClassInitializer) parent)) {
                return parent;
            }
        } else if (parent instanceof PsiField) {
            if (PsiUtils.classHasField(psiClass, (PsiField) parent)) {
                return parent;
            }
        } else if (parent instanceof PsiClass) {
            if (psiClass.equals(((PsiClass) parent).getContainingClass())) {
                return parent;
            }
        } else if (parent instanceof PsiAnonymousClass) {
            if (((PsiAnonymousClass) parent).getContainingClass().equals(psiClass)) {
                return parent;
            }
        }
    } catch (Exception ex) {
        stack.add(parent);
        String preparedStack = prepareStack(stack);
        throw new IllegalStateException("Cannot get root element. Stack: " + preparedStack);
    }

    return getRootPsiElementWithStack(psiClass, parent, stack);
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
private static boolean classHasClassInitializer(PsiClass psiClass, PsiClassInitializer other) {
    for (PsiClassInitializer classInitializer : psiClass.getInitializers()) {
        if (classInitializer.equals(other)) {
            return true;
        }
    }
    return false;
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
public static String getName(PsiClassInitializer psiClassInitializer) {
    if (psiClassInitializer.getModifierList().hasModifierProperty("static")) {
        return "[static init]";
    } else {
        return "[init]";
    }
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
@Override
public void visitClassInitializer(PsiClassInitializer initializer) {
  super.visitClassInitializer(initializer);
  if (initializer.hasModifierProperty(PsiModifier.STATIC)) {
    return;
  }
  registerClassInitializerError(initializer);
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
private int calculateInitializerComplexity(PsiClass aClass) {
  final ComplexityVisitor visitor = new ComplexityVisitor();
  int complexity = 0;
  final PsiClassInitializer[] initializers = aClass.getInitializers();
  for (final PsiClassInitializer initializer : initializers) {
    visitor.reset();
    initializer.accept(visitor);
    complexity += visitor.getComplexity();
  }
  return complexity;
}
 

import com.intellij.psi.PsiClassInitializer; //导入依赖的package包/类
@Override
public void visitClassInitializer(PsiClassInitializer initializer)
{
	if(initializer.hasModifierProperty(PsiModifier.STATIC))
	{
		return;
	}

	final PsiClass containingClass = ClassUtils.getContainingClass(initializer);
	if(containingClass == null)
	{
		return;
	}
	for(Condition<PsiElement> addin : JavaExtensionPoints.CANT_BE_STATIC_EP_NAME.getExtensions())
	{
		if(addin.value(initializer))
		{
			return;
		}
	}
	final PsiElement scope = containingClass.getScope();
	if(!(scope instanceof PsiJavaFile) && !containingClass.hasModifierProperty(PsiModifier.STATIC))
	{
		return;
	}

	final MethodReferenceVisitor visitor = new MethodReferenceVisitor(initializer);
	initializer.accept(visitor);
	if(!visitor.areReferencesStaticallyAccessible())
	{
		return;
	}

	registerClassInitializerError(initializer);
}