private static void addDefaultConstructor(
JavaChangeInfo changeInfo, PsiClass aClass, final UsageInfo[] usages)
throws IncorrectOperationException {
if (!(aClass instanceof PsiAnonymousClass)) {
PsiElementFactory factory = JavaPsiFacade.getElementFactory(aClass.getProject());
PsiMethod defaultConstructor =
factory.createMethodFromText(aClass.getName() + "(){}", aClass);
defaultConstructor =
(PsiMethod)
CodeStyleManager.getInstance(aClass.getProject()).reformat(defaultConstructor);
defaultConstructor = (PsiMethod) aClass.add(defaultConstructor);
PsiUtil.setModifierProperty(
defaultConstructor, VisibilityUtil.getVisibilityModifier(aClass.getModifierList()), true);
addSuperCall(changeInfo, defaultConstructor, null, usages);
} else {
final PsiElement parent = aClass.getParent();
if (parent instanceof PsiNewExpression) {
final PsiExpressionList argumentList = ((PsiNewExpression) parent).getArgumentList();
final PsiClass baseClass = changeInfo.getMethod().getContainingClass();
final PsiSubstitutor substitutor =
TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY);
fixActualArgumentsList(argumentList, changeInfo, true, substitutor);
}
}
}
private static PsiSubstitutor obtainFinalSubstitutor(
PsiClass superClass,
PsiSubstitutor superSubstitutor,
PsiSubstitutor derivedSubstitutor,
boolean inRawContext) {
if (inRawContext) {
Set<PsiTypeParameter> typeParams = superSubstitutor.getSubstitutionMap().keySet();
PsiElementFactory factory = JavaPsiFacade.getElementFactory(superClass.getProject());
superSubstitutor =
factory.createRawSubstitutor(
derivedSubstitutor, typeParams.toArray(new PsiTypeParameter[typeParams.size()]));
}
Map<PsiTypeParameter, PsiType> map = null;
for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(superClass)) {
PsiType type = superSubstitutor.substitute(typeParameter);
final PsiType t = derivedSubstitutor.substitute(type);
if (map == null) {
map = new THashMap<PsiTypeParameter, PsiType>();
}
map.put(typeParameter, t);
}
return map == null
? PsiSubstitutor.EMPTY
: JavaPsiFacade.getInstance(superClass.getProject())
.getElementFactory()
.createSubstitutor(map);
}
@NotNull
private static PsiClass[] getSupersInner(@NotNull PsiClass psiClass) {
PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes();
if (psiClass.isInterface()) {
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), true);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiAnonymousClass psiAnonymousClass = (PsiAnonymousClass) psiClass;
PsiClassType baseClassReference = psiAnonymousClass.getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass != null) {
if (baseClass.isInterface()) {
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null
? new PsiClass[] {objectClass, baseClass}
: new PsiClass[] {baseClass};
}
return new PsiClass[] {baseClass};
}
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
if (psiClass instanceof PsiTypeParameter) {
if (extendsListTypes.length == 0) {
final PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
}
PsiClass[] interfaces =
resolveClassReferenceList(
implementsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
PsiClass superClass = getSuperClass(psiClass);
if (superClass == null) return interfaces;
PsiClass[] types = new PsiClass[interfaces.length + 1];
types[0] = superClass;
System.arraycopy(interfaces, 0, types, 1, interfaces.length);
return types;
}
public static void register(
final HighlightInfo highlightInfo, PsiExpression expression, final PsiType lType) {
expression = PsiUtil.deparenthesizeExpression(expression);
if (!(expression instanceof PsiNewExpression)) return;
final PsiType rType = expression.getType();
PsiType newType = lType;
if (rType instanceof PsiClassType && newType instanceof PsiClassType) {
final PsiClassType.ClassResolveResult rResolveResult =
((PsiClassType) rType).resolveGenerics();
final PsiClass rClass = rResolveResult.getElement();
if (rClass != null) {
final PsiClassType.ClassResolveResult lResolveResult =
((PsiClassType) newType).resolveGenerics();
final PsiClass lClass = lResolveResult.getElement();
if (lClass != null) {
PsiSubstitutor substitutor =
getInheritorSubstitutorForNewExpression(
lClass, rClass, lResolveResult.getSubstitutor(), expression);
if (substitutor != null) {
newType =
JavaPsiFacade.getInstance(lClass.getProject())
.getElementFactory()
.createType(rClass, substitutor);
}
}
}
}
PsiNewExpression newExpression = (PsiNewExpression) expression;
QuickFixAction.registerQuickFixAction(
highlightInfo, new ChangeNewOperatorTypeFix(newType, newExpression));
}
public String calcGenerics(@NotNull PsiElement context, InsertionContext insertionContext) {
if (insertionContext.getCompletionChar() == '<') {
return "";
}
assert context.isValid();
if (myDiamond) {
return "<>";
}
if (getObject() instanceof PsiClass) {
PsiClass psiClass = (PsiClass) getObject();
PsiResolveHelper resolveHelper =
JavaPsiFacade.getInstance(psiClass.getProject()).getResolveHelper();
PsiSubstitutor substitutor = getSubstitutor();
StringBuilder builder = new StringBuilder();
for (PsiTypeParameter parameter : psiClass.getTypeParameters()) {
PsiType substitute = substitutor.substitute(parameter);
if (substitute == null
|| (PsiUtil.resolveClassInType(substitute) == parameter
&& resolveHelper.resolveReferencedClass(parameter.getName(), context)
!= CompletionUtil.getOriginalOrSelf(parameter))) {
return "";
}
if (builder.length() > 0) {
builder.append(", ");
}
builder.append(substitute.getCanonicalText());
}
if (builder.length() > 0) {
return "<" + builder + ">";
}
}
return "";
}
/* Guesswork
*/
@Nullable
private static PsiSubstitutor getInheritorSubstitutorForNewExpression(
final PsiClass baseClass,
final PsiClass inheritor,
final PsiSubstitutor baseSubstitutor,
final PsiElement context) {
final Project project = baseClass.getProject();
JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
PsiSubstitutor superSubstitutor =
TypeConversionUtil.getClassSubstitutor(baseClass, inheritor, PsiSubstitutor.EMPTY);
if (superSubstitutor == null) return null;
PsiSubstitutor inheritorSubstitutor = PsiSubstitutor.EMPTY;
for (PsiTypeParameter inheritorParameter : PsiUtil.typeParametersIterable(inheritor)) {
for (PsiTypeParameter baseParameter : PsiUtil.typeParametersIterable(baseClass)) {
final PsiType substituted = superSubstitutor.substitute(baseParameter);
PsiType arg = baseSubstitutor.substitute(baseParameter);
if (arg instanceof PsiWildcardType) arg = ((PsiWildcardType) arg).getBound();
PsiType substitution =
resolveHelper.getSubstitutionForTypeParameter(
inheritorParameter, substituted, arg, true, PsiUtil.getLanguageLevel(context));
if (PsiType.NULL.equals(substitution)) continue;
if (substitution == null) {
return facade.getElementFactory().createRawSubstitutor(inheritor);
}
inheritorSubstitutor = inheritorSubstitutor.put(inheritorParameter, substitution);
break;
}
}
return inheritorSubstitutor;
}
@NotNull
@Override
public List<LightRef> getHierarchyRestrictedToLibraryScope(
@NotNull LightRef baseRef,
@NotNull PsiElement basePsi,
@NotNull ByteArrayEnumerator names,
@NotNull GlobalSearchScope libraryScope) {
final PsiClass baseClass =
ObjectUtils.notNull(
basePsi instanceof PsiClass
? (PsiClass) basePsi
: ReadAction.compute(() -> (PsiMember) basePsi).getContainingClass());
final List<LightRef> overridden = new ArrayList<>();
Processor<PsiClass> processor =
c -> {
if (c.hasModifierProperty(PsiModifier.PRIVATE)) return true;
String qName = ReadAction.compute(() -> c.getQualifiedName());
if (qName == null) return true;
overridden.add(baseRef.override(id(qName, names)));
return true;
};
ClassInheritorsSearch.search(
baseClass,
LibraryScopeCache.getInstance(baseClass.getProject()).getLibrariesOnlyScope(),
true)
.forEach(processor);
return overridden;
}
private static void putInMap(
PsiClass aClass,
Map<MethodSignature, HierarchicalMethodSignature> result,
Map<MethodSignature, HierarchicalMethodSignatureImpl> map,
HierarchicalMethodSignature hierarchicalMethodSignature,
MethodSignature signature) {
if (!PsiUtil.isAccessible(
aClass.getProject(), hierarchicalMethodSignature.getMethod(), aClass, aClass)) return;
HierarchicalMethodSignatureImpl existing = map.get(signature);
if (existing == null) {
HierarchicalMethodSignatureImpl copy = copy(hierarchicalMethodSignature);
LOG.assertTrue(copy.getMethod().isValid());
map.put(signature, copy);
} else if (isReturnTypeIsMoreSpecificThan(hierarchicalMethodSignature, existing)
&& isSuperMethod(aClass, hierarchicalMethodSignature, existing)) {
HierarchicalMethodSignatureImpl newSuper = copy(hierarchicalMethodSignature);
mergeSupers(newSuper, existing);
LOG.assertTrue(newSuper.getMethod().isValid());
map.put(signature, newSuper);
} else if (isSuperMethod(aClass, existing, hierarchicalMethodSignature)) {
mergeSupers(existing, hierarchicalMethodSignature);
}
// just drop an invalid method declaration there - to highlight accordingly
else if (!result.containsKey(signature)) {
LOG.assertTrue(hierarchicalMethodSignature.getMethod().isValid());
result.put(signature, hierarchicalMethodSignature);
}
}
@Override
public PsiType visitClassType(PsiClassType classType) {
final PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics();
final PsiClass aClass = resolveResult.getElement();
if (aClass == null) return classType;
PsiUtilCore.ensureValid(aClass);
if (aClass instanceof PsiTypeParameter) {
final PsiTypeParameter typeParameter = (PsiTypeParameter) aClass;
if (containsInMap(typeParameter)) {
PsiType result = substituteTypeParameter(typeParameter);
if (result != null) {
PsiUtil.ensureValidType(result);
}
return result;
}
return classType;
}
final Map<PsiTypeParameter, PsiType> hashMap = new HashMap<PsiTypeParameter, PsiType>(2);
if (!processClass(aClass, resolveResult.getSubstitutor(), hashMap)) {
return null;
}
PsiClassType result =
JavaPsiFacade.getElementFactory(aClass.getProject())
.createType(aClass, createSubstitutor(hashMap), classType.getLanguageLevel());
PsiUtil.ensureValidType(result);
return result;
}
public ClassUsageGroup(@NotNull PsiClass aClass) {
myQName = aClass.getQualifiedName();
myText = createText(aClass);
myClassPointer =
SmartPointerManager.getInstance(aClass.getProject()).createSmartPsiElementPointer(aClass);
myIcon = aClass.getIcon(Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS);
}
public static GdkMethodHolder getHolderForClass(
final PsiClass categoryClass, final boolean isStatic, final GlobalSearchScope scope) {
final Project project = categoryClass.getProject();
Key<CachedValue<GdkMethodHolder>> key = isStatic ? CACHED_STATIC : CACHED_NON_STATIC;
return CachedValuesManager.getManager(project)
.getCachedValue(
categoryClass,
key,
new CachedValueProvider<GdkMethodHolder>() {
@Override
public Result<GdkMethodHolder> compute() {
GdkMethodHolder result = new GdkMethodHolder(categoryClass, isStatic, scope);
final ProjectRootManager rootManager = ProjectRootManager.getInstance(project);
final VirtualFile vfile = categoryClass.getContainingFile().getVirtualFile();
if (vfile != null
&& (rootManager.getFileIndex().isInLibraryClasses(vfile)
|| rootManager.getFileIndex().isInLibrarySource(vfile))) {
return Result.create(result, rootManager);
}
return Result.create(
result, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT, rootManager);
}
},
false);
}
public static boolean inheritsITestListener(@NotNull PsiClass psiClass) {
final Project project = psiClass.getProject();
final PsiClass aListenerClass =
JavaPsiFacade.getInstance(project)
.findClass(ITestNGListener.class.getName(), GlobalSearchScope.allScope(project));
return aListenerClass != null && psiClass.isInheritor(aListenerClass, true);
}
@Nullable
private PsiClass mapClass(@NotNull PsiClass psiClass) {
String qualifiedName = psiClass.getQualifiedName();
if (qualifiedName == null) {
return psiClass;
}
PsiFile file = psiClass.getContainingFile();
if (file == null || !file.getViewProvider().isPhysical()) {
return psiClass;
}
final VirtualFile vFile = file.getVirtualFile();
if (vFile == null) {
return psiClass;
}
final FileIndexFacade index = FileIndexFacade.getInstance(file.getProject());
if (!index.isInSource(vFile)
&& !index.isInLibrarySource(vFile)
&& !index.isInLibraryClasses(vFile)) {
return psiClass;
}
return JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(qualifiedName, myResolveScope);
}
@NotNull
@Override
public PsiClassType rawType() {
PsiClass psiClass = resolve();
PsiElementFactory factory = JavaPsiFacade.getElementFactory(psiClass.getProject());
return factory.createType(psiClass, factory.createRawSubstitutor(psiClass));
}
@Nullable
public static PsiQualifiedReference getClassReferenceToShorten(
@NotNull final PsiClass refClass,
final boolean addImports,
@NotNull final PsiQualifiedReference reference) {
PsiClass parentClass = refClass.getContainingClass();
if (parentClass != null) {
JavaPsiFacade facade = JavaPsiFacade.getInstance(parentClass.getProject());
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
if (resolveHelper.isAccessible(refClass, reference, null)
&& isSafeToShortenReference(reference.getReferenceName(), reference, refClass)) {
return reference;
}
if (!CodeStyleSettingsManager.getSettings(reference.getProject())
.INSERT_INNER_CLASS_IMPORTS) {
final PsiElement qualifier = reference.getQualifier();
if (qualifier instanceof PsiQualifiedReference) {
return getClassReferenceToShorten(
parentClass, addImports, (PsiQualifiedReference) qualifier);
}
return null;
}
}
if (addImports && !((PsiImportHolder) reference.getContainingFile()).importClass(refClass))
return null;
if (!isSafeToShortenReference(reference, refClass)) return null;
return reference;
}
public CodeWriter(
PsiFile psiFile,
PsiClass clazz,
List<ViewPart> viewPartList,
boolean isViewHolder,
boolean isAddRootView,
String rootViewStr) {
super(clazz.getProject(), "");
this.psiFile = psiFile;
mProject = clazz.getProject();
mClass = clazz;
mFactory = JavaPsiFacade.getElementFactory(mProject);
this.viewPartList = viewPartList;
this.isAddRootView = isAddRootView;
this.isViewHolder = isViewHolder;
this.rootViewStr = rootViewStr;
}
public static boolean isProduction(PsiClass aClass) {
final PsiFile file = PsiTreeUtil.getParentOfType(aClass, PsiFile.class);
if (file == null) {
return false;
}
final VirtualFile virtualFile = file.getVirtualFile();
return isProduction(virtualFile, aClass.getProject());
}
public GrPullUpHelper(
PsiClass aClass, PsiClass superClass, GrMemberInfo[] infos, DocCommentPolicy policy) {
super(aClass.getProject());
mySourceClass = aClass;
myTargetSuperClass = (GrTypeDefinition) superClass;
myMembersToMove = infos;
myDocCommentPolicy = policy;
}
private static PsiType createType(PsiClass cls, PsiSubstitutor currentSubstitutor, int arrayDim) {
final PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(cls.getProject()).getElementFactory();
PsiType newType = elementFactory.createType(cls, currentSubstitutor);
for (int i = 0; i < arrayDim; i++) {
newType = newType.createArrayType();
}
return newType;
}
private static PsiMethod createMethod(final String methodText, final PsiClass implClass) {
try {
return JavaPsiFacade.getInstance(implClass.getProject())
.getElementFactory()
.createMethodFromText(methodText, implClass);
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
public LayoutCreator(
PsiFile file,
PsiClass clazz,
String command,
ArrayList<Element> elements,
String layoutFileName,
String fieldNamePrefix,
boolean createHolder) {
super(clazz.getProject(), command);
mFile = file;
mProject = clazz.getProject();
mClass = clazz;
mElements = elements;
mFactory = JavaPsiFacade.getElementFactory(mProject);
mLayoutFileName = layoutFileName;
mFieldNamePrefix = fieldNamePrefix;
mCreateHolder = createHolder;
}
public ExtractClassProcessor(
PsiClass sourceClass,
List<PsiField> fields,
List<PsiMethod> methods,
List<PsiClass> classes,
String packageName,
MoveDestination moveDestination,
String newClassName,
String newVisibility,
boolean generateAccessors,
List<MemberInfo> enumConstants) {
super(sourceClass.getProject());
this.sourceClass = sourceClass;
this.newPackageName = packageName;
myMoveDestination = moveDestination;
myNewVisibility = newVisibility;
myGenerateAccessors = generateAccessors;
this.enumConstants = new ArrayList<PsiField>();
for (MemberInfo constant : enumConstants) {
if (constant.isChecked()) {
this.enumConstants.add((PsiField) constant.getMember());
}
}
this.fields = new ArrayList<PsiField>(fields);
this.methods = new ArrayList<PsiMethod>(methods);
this.innerClasses = new ArrayList<PsiClass>(classes);
this.newClassName = newClassName;
delegateFieldName = calculateDelegateFieldName();
requiresBackpointer =
new BackpointerUsageVisitor(fields, innerClasses, methods, sourceClass)
.backpointerRequired();
if (requiresBackpointer) {
ContainerUtil.addAll(typeParams, sourceClass.getTypeParameters());
} else {
final Set<PsiTypeParameter> typeParamSet = new HashSet<PsiTypeParameter>();
final TypeParametersVisitor visitor = new TypeParametersVisitor(typeParamSet);
for (PsiField field : fields) {
field.accept(visitor);
}
for (PsiMethod method : methods) {
method.accept(visitor);
// do not include method's type parameters in class signature
typeParamSet.removeAll(Arrays.asList(method.getTypeParameters()));
}
typeParams.addAll(typeParamSet);
}
myClass =
new WriteCommandAction<PsiClass>(myProject, getCommandName()) {
@Override
protected void run(@NotNull Result<PsiClass> result) throws Throwable {
result.setResult(buildClass());
}
}.execute().getResultObject();
myExtractEnumProcessor = new ExtractEnumProcessor(myProject, this.enumConstants, myClass);
}
// todo: inline
private static void generateBean(
final PsiClass aClass,
final String[] properties,
final HashMap<String, String> property2fqClassName)
throws MyException {
final StringBuffer membersBuffer = new StringBuffer();
final StringBuffer methodsBuffer = new StringBuffer();
final CodeStyleManager formatter = CodeStyleManager.getInstance(aClass.getProject());
final JavaCodeStyleManager styler = JavaCodeStyleManager.getInstance(aClass.getProject());
for (final String property : properties) {
LOG.assertTrue(property != null);
final String type = property2fqClassName.get(property);
LOG.assertTrue(type != null);
generateProperty(styler, property, type, membersBuffer, methodsBuffer);
}
final PsiClass fakeClass;
try {
fakeClass =
JavaPsiFacade.getInstance(aClass.getProject())
.getElementFactory()
.createClassFromText(membersBuffer.toString() + methodsBuffer.toString(), null);
final PsiField[] fields = fakeClass.getFields();
for (final PsiField field : fields) {
aClass.add(field);
}
final PsiMethod[] methods = fakeClass.getMethods();
for (final PsiMethod method : methods) {
aClass.add(method);
}
styler.shortenClassReferences(aClass);
formatter.reformat(aClass);
} catch (IncorrectOperationException e) {
throw new MyException(e.getMessage());
}
}
@NotNull
public static PsiClassType[] getExtendsListTypes(@NotNull PsiClass psiClass) {
if (psiClass.isEnum()) {
PsiClassType enumSuperType =
getEnumSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory());
return enumSuperType == null ? PsiClassType.EMPTY_ARRAY : new PsiClassType[] {enumSuperType};
}
if (psiClass.isAnnotationType()) {
return new PsiClassType[] {
getAnnotationSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory())
};
}
final PsiReferenceList extendsList = psiClass.getExtendsList();
if (extendsList != null) {
return extendsList.getReferencedTypes();
}
return PsiClassType.EMPTY_ARRAY;
}
static List<? extends LookupElement> wrap(
@NotNull JavaPsiClassReferenceElement classItem, @NotNull PsiElement position) {
PsiClass psiClass = classItem.getObject();
return wrap(
classItem,
psiClass,
position,
() ->
JavaPsiFacade.getElementFactory(psiClass.getProject())
.createType(psiClass, PsiSubstitutor.EMPTY));
}
public PullUpProcessor(
PsiClass sourceClass,
PsiClass targetSuperClass,
MemberInfo[] membersToMove,
DocCommentPolicy javaDocPolicy) {
super(sourceClass.getProject());
mySourceClass = sourceClass;
myTargetSuperClass = targetSuperClass;
myMembersToMove = membersToMove;
myJavaDocPolicy = javaDocPolicy;
}
@NotNull
public static PsiClassType createListType(@NotNull PsiClass elements) {
JavaPsiFacade facade = JavaPsiFacade.getInstance(elements.getProject());
GlobalSearchScope resolveScope = elements.getResolveScope();
PsiClass listClass = facade.findClass(JAVA_UTIL_LIST, resolveScope);
if (listClass == null) {
return facade.getElementFactory().createTypeByFQClassName(JAVA_UTIL_LIST, resolveScope);
}
return facade
.getElementFactory()
.createType(listClass, facade.getElementFactory().createType(elements));
}
private static void generateDelegate(JavaChangeInfo changeInfo)
throws IncorrectOperationException {
final PsiMethod delegate = (PsiMethod) changeInfo.getMethod().copy();
final PsiClass targetClass = changeInfo.getMethod().getContainingClass();
LOG.assertTrue(!targetClass.isInterface());
PsiElementFactory factory = JavaPsiFacade.getElementFactory(targetClass.getProject());
ChangeSignatureProcessor.makeEmptyBody(factory, delegate);
final PsiCallExpression callExpression =
ChangeSignatureProcessor.addDelegatingCallTemplate(delegate, changeInfo.getNewName());
addDelegateArguments(changeInfo, factory, callExpression);
targetClass.addBefore(delegate, changeInfo.getMethod());
}
private static void generateMethod(
TestIntegrationUtils.MethodKind methodKind,
TestFramework descriptor,
PsiClass targetClass,
Editor editor,
@Nullable String name) {
PsiMethod method =
(PsiMethod) targetClass.add(TestIntegrationUtils.createDummyMethod(targetClass));
PsiDocumentManager.getInstance(targetClass.getProject())
.doPostponedOperationsAndUnblockDocument(editor.getDocument());
TestIntegrationUtils.runTestMethodTemplate(
methodKind, descriptor, editor, targetClass, method, name, true);
}
@Nullable
public static List<String> findTestDataFiles(@NotNull DataContext context) {
final PsiMethod method = findTargetMethod(context);
if (method == null) {
return null;
}
final String name = method.getName();
if (name.startsWith("test")) {
String testDataPath =
TestDataLineMarkerProvider.getTestDataBasePath(method.getContainingClass());
final TestDataReferenceCollector collector =
new TestDataReferenceCollector(testDataPath, name.substring(4));
return collector.collectTestDataReferences(method);
}
final Location<?> location = Location.DATA_KEY.getData(context);
if (location instanceof PsiMemberParameterizedLocation) {
PsiClass containingClass = ((PsiMemberParameterizedLocation) location).getContainingClass();
if (containingClass == null) {
containingClass =
PsiTreeUtil.getParentOfType(location.getPsiElement(), PsiClass.class, false);
}
if (containingClass != null) {
final PsiAnnotation annotation =
AnnotationUtil.findAnnotationInHierarchy(
containingClass, Collections.singleton(JUnitUtil.RUN_WITH));
if (annotation != null) {
final PsiAnnotationMemberValue memberValue = annotation.findAttributeValue("value");
if (memberValue instanceof PsiClassObjectAccessExpression) {
final PsiTypeElement operand =
((PsiClassObjectAccessExpression) memberValue).getOperand();
if (operand.getType().equalsToText(Parameterized.class.getName())) {
final String testDataPath =
TestDataLineMarkerProvider.getTestDataBasePath(containingClass);
final String paramSetName =
((PsiMemberParameterizedLocation) location).getParamSetName();
final String baseFileName =
StringUtil.trimEnd(StringUtil.trimStart(paramSetName, "["), "]");
final ProjectFileIndex fileIndex =
ProjectRootManager.getInstance(containingClass.getProject()).getFileIndex();
return TestDataGuessByExistingFilesUtil.suggestTestDataFiles(
fileIndex, baseFileName, testDataPath, containingClass);
}
}
}
}
}
return null;
}
