public Pair<List<RepositoryLocationGroup>, List<RepositoryLocation>> groupLocations(
final List<RepositoryLocation> in) {
final List<RepositoryLocationGroup> groups = new ArrayList<RepositoryLocationGroup>();
final List<RepositoryLocation> singles = new ArrayList<RepositoryLocation>();
final MultiMap<SVNURL, RepositoryLocation> map = new MultiMap<SVNURL, RepositoryLocation>();
for (RepositoryLocation location : in) {
final SvnRepositoryLocation svnLocation = (SvnRepositoryLocation) location;
final String url = svnLocation.getURL();
final SVNURL root = SvnUtil.getRepositoryRoot(myVcs, url);
if (root == null) {
// should not occur
LOG.info("repository root not found for location:" + location.toPresentableString());
singles.add(location);
} else {
map.putValue(root, svnLocation);
}
}
final Set<SVNURL> keys = map.keySet();
for (SVNURL key : keys) {
final Collection<RepositoryLocation> repositoryLocations = map.get(key);
if (repositoryLocations.size() == 1) {
singles.add(repositoryLocations.iterator().next());
} else {
final SvnRepositoryLocationGroup group =
new SvnRepositoryLocationGroup(key, repositoryLocations);
groups.add(group);
}
}
return new Pair<List<RepositoryLocationGroup>, List<RepositoryLocation>>(groups, singles);
}
private void analyzeDfaWithNestedClosures(
PsiElement scope,
ProblemsHolder holder,
StandardDataFlowRunner dfaRunner,
Collection<DfaMemoryState> initialStates) {
final DataFlowInstructionVisitor visitor = new DataFlowInstructionVisitor(dfaRunner);
final RunnerResult rc =
dfaRunner.analyzeMethod(scope, visitor, IGNORE_ASSERT_STATEMENTS, initialStates);
if (rc == RunnerResult.OK) {
createDescription(dfaRunner, holder, visitor);
MultiMap<PsiElement, DfaMemoryState> nestedClosures = dfaRunner.getNestedClosures();
for (PsiElement closure : nestedClosures.keySet()) {
analyzeDfaWithNestedClosures(closure, holder, dfaRunner, nestedClosures.get(closure));
}
} else if (rc == RunnerResult.TOO_COMPLEX) {
if (scope.getParent() instanceof PsiMethod) {
PsiMethod method = (PsiMethod) scope.getParent();
final PsiIdentifier name = method.getNameIdentifier();
if (name != null) { // Might be null for synthetic methods like JSP page.
holder.registerProblem(
name,
InspectionsBundle.message("dataflow.too.complex"),
ProblemHighlightType.WEAK_WARNING);
}
}
}
}
public Object deserializeInto(@NotNull Object result, @NotNull Element element) {
Set<Binding> bindings = myPropertyBindings.keySet();
MultiMap<Binding, Object> data = MultiMap.createSmartList();
nextNode:
for (Object child : ContainerUtil.concat(element.getContent(), element.getAttributes())) {
if (XmlSerializerImpl.isIgnoredNode(child)) {
continue;
}
for (Binding binding : bindings) {
if (binding.isBoundTo(child)) {
data.putValue(binding, child);
continue nextNode;
}
}
final String message = "Format error: no binding for " + child + " inside " + this;
LOG.debug(message);
Logger.getInstance(myBeanClass.getName()).debug(message);
Logger.getInstance("#" + myBeanClass.getName()).debug(message);
}
for (Binding binding : data.keySet()) {
binding.deserialize(result, ArrayUtil.toObjectArray(data.get(binding)));
}
return result;
}
public synchronized MultiMap<String, VirtualFile> getBranchToFileMap() {
final MultiMap<String, VirtualFile> result = new MultiMap<String, VirtualFile>();
for (final VirtualFile vf : myMap.keySet()) {
result.putValue(myMap.get(vf).getSecond(), vf);
}
return result;
}
protected boolean preprocessUsages(Ref<UsageInfo[]> refUsages) {
final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
checkExistingMethods(conflicts, true);
checkExistingMethods(conflicts, false);
final Collection<PsiClass> classes = ClassInheritorsSearch.search(myClass).findAll();
for (FieldDescriptor fieldDescriptor : myFieldDescriptors) {
final Set<PsiMethod> setters = new HashSet<PsiMethod>();
final Set<PsiMethod> getters = new HashSet<PsiMethod>();
for (PsiClass aClass : classes) {
final PsiMethod getterOverrider =
myDescriptor.isToEncapsulateGet()
? aClass.findMethodBySignature(fieldDescriptor.getGetterPrototype(), false)
: null;
if (getterOverrider != null) {
getters.add(getterOverrider);
}
final PsiMethod setterOverrider =
myDescriptor.isToEncapsulateSet()
? aClass.findMethodBySignature(fieldDescriptor.getSetterPrototype(), false)
: null;
if (setterOverrider != null) {
setters.add(setterOverrider);
}
}
if (!getters.isEmpty() || !setters.isEmpty()) {
final PsiField field = fieldDescriptor.getField();
for (PsiReference reference : ReferencesSearch.search(field)) {
final PsiElement place = reference.getElement();
if (place instanceof PsiReferenceExpression) {
final PsiExpression qualifierExpression =
((PsiReferenceExpression) place).getQualifierExpression();
final PsiClass ancestor;
if (qualifierExpression == null) {
ancestor = PsiTreeUtil.getParentOfType(place, PsiClass.class, false);
} else {
ancestor = PsiUtil.resolveClassInType(qualifierExpression.getType());
}
final boolean isGetter = !PsiUtil.isAccessedForWriting((PsiExpression) place);
for (PsiMethod overridden : isGetter ? getters : setters) {
if (InheritanceUtil.isInheritorOrSelf(myClass, ancestor, true)) {
conflicts.putValue(
overridden,
"There is already a "
+ RefactoringUIUtil.getDescription(overridden, true)
+ " which would hide generated "
+ (isGetter ? "getter" : "setter")
+ " for "
+ place.getText());
break;
}
}
}
}
}
}
return showConflicts(conflicts, refUsages.get());
}
public MultiMap<PsiElement, String> findConflicts(Ref<UsageInfo[]> refUsages) {
MultiMap<PsiElement, String> conflictDescriptions = new MultiMap<PsiElement, String>();
addMethodConflicts(conflictDescriptions);
Set<UsageInfo> usagesSet = new HashSet<UsageInfo>(Arrays.asList(refUsages.get()));
RenameUtil.removeConflictUsages(usagesSet);
if (myChangeInfo.isVisibilityChanged()) {
try {
addInaccessibilityDescriptions(usagesSet, conflictDescriptions);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
for (UsageInfo usageInfo : usagesSet) {
if (usageInfo instanceof OverriderUsageInfo) {
final PsiMethod method = (PsiMethod) usageInfo.getElement();
final PsiMethod baseMethod = ((OverriderUsageInfo) usageInfo).getBaseMethod();
final int delta =
baseMethod.getParameterList().getParametersCount()
- method.getParameterList().getParametersCount();
if (delta > 0) {
final boolean[] toRemove = myChangeInfo.toRemoveParm();
if (toRemove[
toRemove.length - 1]) { // todo check if implicit parameter is not the last one
conflictDescriptions.putValue(
baseMethod, "Implicit last parameter should not be deleted");
}
}
}
}
return conflictDescriptions;
}
public static MultiMap<PsiElement, UsageInfo> classifyUsages(
Collection<? extends PsiElement> elements, UsageInfo[] usages) {
final MultiMap<PsiElement, UsageInfo> result = new MultiMap<PsiElement, UsageInfo>();
for (UsageInfo usage : usages) {
LOG.assertTrue(usage instanceof MoveRenameUsageInfo);
if (usage.getReference() instanceof LightElement) {
continue; // filter out implicit references (e.g. from derived class to super class' default
// constructor)
}
MoveRenameUsageInfo usageInfo = (MoveRenameUsageInfo) usage;
if (usage instanceof RelatedUsageInfo) {
final PsiElement relatedElement = ((RelatedUsageInfo) usage).getRelatedElement();
if (elements.contains(relatedElement)) {
result.putValue(relatedElement, usage);
}
} else {
PsiElement referenced = usageInfo.getReferencedElement();
if (elements.contains(referenced)) {
result.putValue(referenced, usage);
} else if (referenced != null) {
PsiElement indirect = referenced.getNavigationElement();
if (elements.contains(indirect)) {
result.putValue(indirect, usage);
}
}
}
}
return result;
}
protected boolean showConflicts(
@NotNull MultiMap<PsiElement, String> conflicts, @Nullable final UsageInfo[] usages) {
if (!conflicts.isEmpty() && ApplicationManager.getApplication().isUnitTestMode()) {
if (!ConflictsInTestsException.isTestIgnore())
throw new ConflictsInTestsException(conflicts.values());
return true;
}
if (myPrepareSuccessfulSwingThreadCallback != null && !conflicts.isEmpty()) {
final String refactoringId = getRefactoringId();
if (refactoringId != null) {
RefactoringEventData conflictUsages = new RefactoringEventData();
conflictUsages.putUserData(RefactoringEventData.CONFLICTS_KEY, conflicts.values());
myProject
.getMessageBus()
.syncPublisher(RefactoringEventListener.REFACTORING_EVENT_TOPIC)
.conflictsDetected(refactoringId, conflictUsages);
}
final ConflictsDialog conflictsDialog = prepareConflictsDialog(conflicts, usages);
if (!conflictsDialog.showAndGet()) {
if (conflictsDialog.isShowConflicts()) prepareSuccessful();
return false;
}
}
prepareSuccessful();
return true;
}
private static VcsTaskHandler.TaskInfo fromBranches(List<BranchInfo> branches) {
MultiMap<String, String> map = new MultiMap<String, String>();
for (BranchInfo branch : branches) {
map.putValue(branch.name, branch.repository);
}
return new VcsTaskHandler.TaskInfo(map);
}
private static void checkInterfaceTarget(
MemberInfoBase<? extends PsiMember>[] infos, MultiMap<PsiElement, String> conflictsList) {
for (MemberInfoBase<? extends PsiMember> info : infos) {
PsiElement member = info.getMember();
if (member instanceof PsiField || member instanceof PsiClass) {
if (!((PsiModifierListOwner) member).hasModifierProperty(PsiModifier.STATIC)
&& !(member instanceof PsiClass && ((PsiClass) member).isInterface())) {
String message =
RefactoringBundle.message(
"0.is.not.static.it.cannot.be.moved.to.the.interface",
RefactoringUIUtil.getDescription(member, false));
message = CommonRefactoringUtil.capitalize(message);
conflictsList.putValue(member, message);
}
}
if (member instanceof PsiField && ((PsiField) member).getInitializer() == null) {
String message =
RefactoringBundle.message(
"0.is.not.initialized.in.declaration.such.fields.are.not.allowed.in.interfaces",
RefactoringUIUtil.getDescription(member, false));
conflictsList.putValue(member, CommonRefactoringUtil.capitalize(message));
}
}
}
// made public for Upsource
public RootIndex(@NotNull Project project, @NotNull InfoCache cache) {
myProject = project;
myInfoCache = cache;
final RootInfo info = buildRootInfo(project);
MultiMap<String, VirtualFile> rootsByPackagePrefix = MultiMap.create();
Set<VirtualFile> allRoots = info.getAllRoots();
for (VirtualFile root : allRoots) {
List<VirtualFile> hierarchy = getHierarchy(root, allRoots, info);
Pair<DirectoryInfo, String> pair =
hierarchy != null
? calcDirectoryInfo(root, hierarchy, info)
: new Pair<DirectoryInfo, String>(NonProjectDirectoryInfo.IGNORED, null);
cacheInfos(root, root, pair.first);
rootsByPackagePrefix.putValue(pair.second, root);
myPackagePrefixByRoot.put(root, pair.second);
}
myPackageDirectoryCache =
new PackageDirectoryCache(rootsByPackagePrefix) {
@Override
protected boolean isPackageDirectory(
@NotNull VirtualFile dir, @NotNull String packageName) {
return getInfoForFile(dir).isInProject() && packageName.equals(getPackageName(dir));
}
};
}
@Override
protected void addFolderGroupComponents() {
super.addFolderGroupComponents();
for (PyRootTypeProvider provider : myRootTypeProviders) {
MultiMap<ContentEntry, VirtualFilePointer> roots = provider.getRoots();
if (!roots.get(getContentEntry()).isEmpty()) {
final JComponent sourcesComponent =
createFolderGroupComponent(
provider.getName() + " Folders",
provider.createFolders(getContentEntry()),
provider.getColor(),
null);
this.add(
sourcesComponent,
new GridBagConstraints(
0,
GridBagConstraints.RELATIVE,
1,
1,
1.0,
0.0,
GridBagConstraints.NORTH,
GridBagConstraints.HORIZONTAL,
new Insets(0, 0, 10, 0),
0,
0));
}
}
}
@Override
public Map<LookupElement, StringBuilder> getRelevanceStrings() {
final LinkedHashMap<LookupElement, StringBuilder> map =
new LinkedHashMap<LookupElement, StringBuilder>();
for (LookupElement item : myItems) {
map.put(item, new StringBuilder());
}
final MultiMap<CompletionSorterImpl, LookupElement> inputBySorter =
groupItemsBySorter(new ArrayList<LookupElement>(map.keySet()));
if (inputBySorter.size() > 1) {
for (LookupElement element : map.keySet()) {
map.get(element).append(obtainSorter(element)).append(": ");
}
}
for (CompletionSorterImpl sorter : inputBySorter.keySet()) {
final LinkedHashMap<LookupElement, StringBuilder> subMap =
new LinkedHashMap<LookupElement, StringBuilder>();
for (LookupElement element : inputBySorter.get(sorter)) {
subMap.put(element, map.get(element));
}
Classifier<LookupElement> classifier = myClassifiers.get(sorter);
if (classifier != null) {
classifier.describeItems(subMap, createContext(false));
}
}
return map;
}
@NotNull
public Collection<VcsRef> refsToCommit(@NotNull Hash hash) {
if (myRefsToHashes.containsKey(hash)) {
return myRefsToHashes.get(hash);
}
return Collections.emptyList();
}
@NotNull
public TIntObjectHashMap<T> preLoadCommitData(@NotNull TIntHashSet commits) throws VcsException {
TIntObjectHashMap<T> result = new TIntObjectHashMap<>();
final MultiMap<VirtualFile, String> rootsAndHashes = MultiMap.create();
commits.forEach(
commit -> {
CommitId commitId = myHashMap.getCommitId(commit);
if (commitId != null) {
rootsAndHashes.putValue(commitId.getRoot(), commitId.getHash().asString());
}
return true;
});
for (Map.Entry<VirtualFile, Collection<String>> entry : rootsAndHashes.entrySet()) {
VcsLogProvider logProvider = myLogProviders.get(entry.getKey());
if (logProvider != null) {
List<? extends T> details =
readDetails(logProvider, entry.getKey(), ContainerUtil.newArrayList(entry.getValue()));
for (T data : details) {
int index = myHashMap.getCommitIndex(data.getId(), data.getRoot());
result.put(index, data);
}
saveInCache(result);
} else {
LOG.error(
"No log provider for root "
+ entry.getKey().getPath()
+ ". All known log providers "
+ myLogProviders);
}
}
return result;
}
@NotNull
private static MultiMap<Hash, VcsRef> prepareRefsMap(@NotNull Collection<VcsRef> refs) {
MultiMap<Hash, VcsRef> map = MultiMap.createSmartList();
for (VcsRef ref : refs) {
map.putValue(ref.getCommitHash(), ref);
}
return map;
}
private void performAction(
String from,
String to,
final int docCommentPolicy,
String[] expectedConflicts,
final String[] toPullUp) {
final JSClassResolver resolver =
JSDialectSpecificHandlersFactory.forLanguage(JavaScriptSupportLoader.ECMA_SCRIPT_L4)
.getClassResolver();
final JSClass sourceClass =
(JSClass) resolver.findClassByQName(from, GlobalSearchScope.projectScope(getProject()));
assertNotNull("source class not found: " + sourceClass, sourceClass);
final JSClass targetClass =
(JSClass) resolver.findClassByQName(to, GlobalSearchScope.projectScope(getProject()));
assertNotNull("target class not found: " + targetClass, targetClass);
assertTrue(
"Source should be a subclass of target",
JSInheritanceUtil.isParentClass(sourceClass, targetClass));
final List<JSMemberInfo> memberInfos = getMemberInfos(toPullUp, sourceClass, false);
final JSMemberInfo[] infosArray =
JSMemberInfo.getSelected(memberInfos, sourceClass, Conditions.<JSMemberInfo>alwaysTrue());
MultiMap<PsiElement, String> conflicts =
JSPullUpConflictsUtil.checkConflicts(
infosArray,
sourceClass,
targetClass,
new JSInterfaceContainmentVerifier() {
@Override
public boolean checkedInterfacesContain(JSFunction psiMethod) {
return JSPullUpHelper.checkedInterfacesContain(memberInfos, psiMethod);
}
},
JSVisibilityUtil.DEFAULT_OPTIONS);
ArrayList<String> messages = new ArrayList<String>(conflicts.values());
for (int i = 0; i < messages.size(); i++) {
messages.set(i, messages.get(i).replaceAll("<[^>]+>", ""));
}
assertSameElements(messages, expectedConflicts);
if (conflicts.isEmpty()) {
WriteCommandAction.runWriteCommandAction(
null,
new Runnable() {
public void run() {
new JSPullUpHelper(sourceClass, targetClass, infosArray, docCommentPolicy)
.moveMembersToBase();
myProject.getComponent(PostprocessReformattingAspect.class).doPostponedFormatting();
}
});
FileDocumentManager.getInstance().saveAllDocuments();
}
}
@NotNull
private Map<VirtualFile, OrderEntry[]> getOrderEntries() {
Map<VirtualFile, OrderEntry[]> result = myOrderEntries;
if (result != null) return result;
MultiMap<VirtualFile, OrderEntry> libClassRootEntries = MultiMap.createSmart();
MultiMap<VirtualFile, OrderEntry> libSourceRootEntries = MultiMap.createSmart();
MultiMap<VirtualFile, OrderEntry> depEntries = MultiMap.createSmart();
for (final Module module : ModuleManager.getInstance(myProject).getModules()) {
final ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
for (OrderEntry orderEntry : moduleRootManager.getOrderEntries()) {
if (orderEntry instanceof ModuleOrderEntry) {
final Module depModule = ((ModuleOrderEntry) orderEntry).getModule();
if (depModule != null) {
VirtualFile[] importedClassRoots =
OrderEnumerator.orderEntries(depModule)
.exportedOnly()
.recursively()
.classes()
.usingCache()
.getRoots();
for (VirtualFile importedClassRoot : importedClassRoots) {
depEntries.putValue(importedClassRoot, orderEntry);
}
}
for (VirtualFile sourceRoot : orderEntry.getFiles(OrderRootType.SOURCES)) {
depEntries.putValue(sourceRoot, orderEntry);
}
} else if (orderEntry instanceof LibraryOrSdkOrderEntry) {
final LibraryOrSdkOrderEntry entry = (LibraryOrSdkOrderEntry) orderEntry;
for (final VirtualFile sourceRoot : entry.getRootFiles(OrderRootType.SOURCES)) {
libSourceRootEntries.putValue(sourceRoot, orderEntry);
}
for (final VirtualFile classRoot : entry.getRootFiles(OrderRootType.CLASSES)) {
libClassRootEntries.putValue(classRoot, orderEntry);
}
}
}
}
RootInfo rootInfo = buildRootInfo(myProject);
result = ContainerUtil.newHashMap();
Set<VirtualFile> allRoots = rootInfo.getAllRoots();
for (VirtualFile file : allRoots) {
List<VirtualFile> hierarchy = getHierarchy(file, allRoots, rootInfo);
result.put(
file,
hierarchy == null
? OrderEntry.EMPTY_ARRAY
: calcOrderEntries(
rootInfo, depEntries, libClassRootEntries, libSourceRootEntries, hierarchy));
}
myOrderEntries = result;
return result;
}
public static void checkMethodConflicts(
@Nullable PsiClass aClass,
PsiMethod refactoredMethod,
PsiMethod prototype,
final MultiMap<PsiElement, String> conflicts) {
if (prototype == null) return;
PsiMethod method = aClass != null ? aClass.findMethodBySignature(prototype, true) : null;
if (method != null && method != refactoredMethod) {
if (aClass.equals(method.getContainingClass())) {
final String classDescr =
aClass instanceof PsiAnonymousClass
? RefactoringBundle.message("current.class")
: RefactoringUIUtil.getDescription(aClass, false);
conflicts.putValue(
method,
RefactoringBundle.message(
"method.0.is.already.defined.in.the.1",
getMethodPrototypeString(prototype),
classDescr));
} else { // method somewhere in base class
if (JavaPsiFacade.getInstance(method.getProject())
.getResolveHelper()
.isAccessible(method, aClass, null)) {
String protoMethodInfo = getMethodPrototypeString(prototype);
String className =
CommonRefactoringUtil.htmlEmphasize(
UsageViewUtil.getDescriptiveName(method.getContainingClass()));
if (PsiUtil.getAccessLevel(prototype.getModifierList())
>= PsiUtil.getAccessLevel(method.getModifierList())) {
boolean isMethodAbstract = method.hasModifierProperty(PsiModifier.ABSTRACT);
boolean isMyMethodAbstract =
refactoredMethod != null
&& refactoredMethod.hasModifierProperty(PsiModifier.ABSTRACT);
final String conflict =
isMethodAbstract != isMyMethodAbstract
? RefactoringBundle.message(
"method.0.will.implement.method.of.the.base.class",
protoMethodInfo,
className)
: RefactoringBundle.message(
"method.0.will.override.a.method.of.the.base.class",
protoMethodInfo,
className);
conflicts.putValue(method, conflict);
} else { // prototype is private, will be compile-error
conflicts.putValue(
method,
RefactoringBundle.message(
"method.0.will.hide.method.of.the.base.class", protoMethodInfo, className));
}
}
}
}
}
private void refreshLogOnVcsEvents(@NotNull Map<VirtualFile, VcsLogProvider> logProviders) {
MultiMap<VcsLogProvider, VirtualFile> providers2roots = MultiMap.create();
for (Map.Entry<VirtualFile, VcsLogProvider> entry : logProviders.entrySet()) {
providers2roots.putValue(entry.getValue(), entry.getKey());
}
for (Map.Entry<VcsLogProvider, Collection<VirtualFile>> entry : providers2roots.entrySet()) {
entry.getKey().subscribeToRootRefreshEvents(entry.getValue(), myLogRefresher);
}
}
protected boolean preprocessUsages(Ref<UsageInfo[]> refUsages) {
final UsageInfo[] usages = refUsages.get();
MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
final Set<PsiMember> members = new HashSet<PsiMember>();
members.add(myMethod);
if (myTargetVariable instanceof PsiField) members.add((PsiMember) myTargetVariable);
if (!myTargetClass.isInterface()) {
RefactoringConflictsUtil.analyzeAccessibilityConflicts(
members, myTargetClass, conflicts, myNewVisibility);
} else {
for (final UsageInfo usage : usages) {
if (usage instanceof InheritorUsageInfo) {
RefactoringConflictsUtil.analyzeAccessibilityConflicts(
members, ((InheritorUsageInfo) usage).getInheritor(), conflicts, myNewVisibility);
}
}
}
if (myTargetVariable instanceof PsiParameter) {
PsiParameter parameter = (PsiParameter) myTargetVariable;
for (final UsageInfo usageInfo : usages) {
if (usageInfo instanceof MethodCallUsageInfo) {
final PsiElement methodCall = ((MethodCallUsageInfo) usageInfo).getMethodCallExpression();
if (methodCall instanceof PsiMethodCallExpression) {
final PsiExpression[] expressions =
((PsiMethodCallExpression) methodCall).getArgumentList().getExpressions();
final int index = myMethod.getParameterList().getParameterIndex(parameter);
if (index < expressions.length) {
PsiExpression instanceValue = expressions[index];
instanceValue = RefactoringUtil.unparenthesizeExpression(instanceValue);
if (instanceValue instanceof PsiLiteralExpression
&& ((PsiLiteralExpression) instanceValue).getValue() == null) {
String message =
RefactoringBundle.message(
"0.contains.call.with.null.argument.for.parameter.1",
RefactoringUIUtil.getDescription(
ConflictsUtil.getContainer(methodCall), true),
CommonRefactoringUtil.htmlEmphasize(parameter.getName()));
conflicts.putValue(instanceValue, message);
}
}
} else if (methodCall instanceof PsiMethodReferenceExpression) {
conflicts.putValue(methodCall, "Method reference would be broken after move");
}
}
}
}
try {
ConflictsUtil.checkMethodConflicts(myTargetClass, myMethod, getPatternMethod(), conflicts);
} catch (IncorrectOperationException e) {
}
return showConflicts(conflicts, usages);
}
public void minus(Pair<String, AbstractVcs> pair) {
final VirtualFile root = getRootForPath(pair.getFirst());
if (root == null) return;
synchronized (myLock) {
final VcsRoot key = new VcsRoot(pair.getSecond(), root);
if (myQueries.containsKey(key)) {
myQueries.remove(key, pair.getFirst());
}
myChanged.remove(pair.getFirst());
}
}
private static void removeFromMap(
LookupElement key,
MultiMap<LookupElement, LookupElement> mainMap,
MultiMap<LookupElement, LookupElement> inverseMap) {
Collection<LookupElement> removed = mainMap.remove(key);
if (removed == null) return;
for (LookupElement reference : ContainerUtil.newArrayList(removed)) {
inverseMap.remove(reference, key);
}
}
@NotNull
private static MultiMap<String, GoImportSpec> collectImportsWithSameString(
@NotNull Collection<GoImportSpec> importsWithSameName) {
MultiMap<String, GoImportSpec> importsWithSameString = MultiMap.create();
for (PsiElement duplicateCandidate : importsWithSameName) {
GoImportSpec importSpec = getImportSpec(duplicateCandidate);
if (importSpec != null) {
importsWithSameString.putValue(importSpec.getPath(), importSpec);
}
}
return importsWithSameString;
}
/** Return class names form jet sources in given scope which should be visible as Java classes. */
@NotNull
@Override
public PsiClass[] getClassesByName(
@NotNull @NonNls String name, @NotNull GlobalSearchScope scope) {
List<PsiClass> result = new ArrayList<PsiClass>();
IDELightClassGenerationSupport lightClassGenerationSupport =
IDELightClassGenerationSupport.getInstanceForIDE(project);
MultiMap<String, FqName> packageClasses =
lightClassGenerationSupport.getAllPackageClasses(scope);
// .namespace classes can not be indexed, since they have no explicit declarations
Collection<FqName> fqNames = packageClasses.get(name);
if (!fqNames.isEmpty()) {
for (FqName fqName : fqNames) {
PsiClass psiClass =
JavaElementFinder.getInstance(project).findClass(fqName.getFqName(), scope);
if (psiClass != null) {
result.add(psiClass);
}
}
}
// Quick check for classes from getAllClassNames()
Collection<JetClassOrObject> classOrObjects =
JetShortClassNameIndex.getInstance().get(name, project, scope);
if (classOrObjects.isEmpty()) {
return result.toArray(new PsiClass[result.size()]);
}
for (JetClassOrObject classOrObject : classOrObjects) {
FqName fqName = JetPsiUtil.getFQName(classOrObject);
if (fqName != null) {
assert fqName.shortName().getName().equals(name)
: "A declaration obtained from index has non-matching name:\n"
+ "in index: "
+ name
+ "\n"
+ "declared: "
+ fqName.shortName()
+ "("
+ fqName
+ ")";
PsiClass psiClass =
JavaElementFinder.getInstance(project).findClass(fqName.getFqName(), scope);
if (psiClass != null) {
result.add(psiClass);
}
}
}
return result.toArray(new PsiClass[result.size()]);
}
private void handleStepOutOfLoop(
@NotNull final Instruction prevInstruction,
@NotNull Instruction nextInstruction,
@NotNull final int[] loopNumber,
@NotNull MultiMap<BranchingInstruction, DfaMemoryState> processedStates,
@NotNull MultiMap<BranchingInstruction, DfaMemoryState> incomingStates,
@NotNull List<DfaInstructionState> inFlightStates,
@NotNull DfaInstructionState[] afterStates,
@NotNull StateQueue queue) {
if (loopNumber[prevInstruction.getIndex()] == 0
|| inSameLoop(prevInstruction, nextInstruction, loopNumber)) {
return;
}
// stepped out of loop. destroy all memory states from the loop, we don't need them anymore
// but do not touch yet states being handled right now
for (DfaInstructionState state : inFlightStates) {
Instruction instruction = state.getInstruction();
if (inSameLoop(prevInstruction, instruction, loopNumber)) {
return;
}
}
for (DfaInstructionState state : afterStates) {
Instruction instruction = state.getInstruction();
if (inSameLoop(prevInstruction, instruction, loopNumber)) {
return;
}
}
// and still in queue
if (!queue.processAll(
new Processor<DfaInstructionState>() {
@Override
public boolean process(DfaInstructionState state) {
Instruction instruction = state.getInstruction();
return !inSameLoop(prevInstruction, instruction, loopNumber);
}
})) return;
// now remove obsolete memory states
final Set<BranchingInstruction> mayRemoveStatesFor = new THashSet<BranchingInstruction>();
for (Instruction instruction : myInstructions) {
if (inSameLoop(prevInstruction, instruction, loopNumber)
&& instruction instanceof BranchingInstruction) {
mayRemoveStatesFor.add((BranchingInstruction) instruction);
}
}
for (Instruction instruction : mayRemoveStatesFor) {
processedStates.remove((BranchingInstruction) instruction);
incomingStates.remove((BranchingInstruction) instruction);
}
}
/**
* delete file or directory (both 'undo' and 'do' modes) unversioned: do nothing, return false
* obstructed: do nothing, return false external or wc root: do nothing, return false missing: do
* nothing, return false
*
* <p>versioned: schedule for deletion, return true added: schedule for deletion (make
* unversioned), return true copied, but not scheduled: schedule for deletion, return true
* replaced: schedule for deletion, return true
*
* <p>deleted: do nothing, return true (strange)
*/
public boolean delete(VirtualFile file) throws IOException {
final SvnVcs vcs = getVCS(file);
if (vcs != null && SvnUtil.isAdminDirectory(file)) {
return true;
}
if (vcs == null) return false;
final VcsShowConfirmationOption.Value value = vcs.getDeleteConfirmation().getValue();
if (VcsShowConfirmationOption.Value.DO_NOTHING_SILENTLY.equals(value)) return false;
final File ioFile = getIOFile(file);
if (!SvnUtil.isSvnVersioned(vcs.getProject(), ioFile.getParentFile())) {
return false;
}
if (SvnUtil.isWorkingCopyRoot(ioFile)) {
return false;
}
SVNStatus status = getFileStatus(vcs, ioFile);
if (status == null
|| SvnVcs.svnStatusIsUnversioned(status)
|| SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_OBSTRUCTED)
|| SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_MISSING)
|| SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_EXTERNAL)
|| SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_IGNORED)) {
return false;
} else if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_DELETED)) {
if (isUndo(vcs)) {
moveToUndoStorage(file);
}
return true;
} else {
if (vcs != null) {
if (isAboveSourceOfCopyOrMove(vcs.getProject(), ioFile)) {
myDeletedFiles.putValue(vcs.getProject(), ioFile);
return true;
}
if (SvnVcs.svnStatusIs(status, SVNStatusType.STATUS_ADDED)) {
try {
createRevertAction(vcs, ioFile, false).execute();
} catch (SVNException e) {
// ignore
}
} else {
myDeletedFiles.putValue(vcs.getProject(), ioFile);
// packages deleted from disk should not be deleted from svn (IDEADEV-16066)
if (file.isDirectory() || isUndo(vcs)) return true;
}
}
return false;
}
}
@Override
protected MultiMap<PsiElement, String> getConflictDescriptions(UsageInfo[] usages) {
MultiMap<PsiElement, String> descriptions = super.getConflictDescriptions(usages);
if (mySettings.isMakeClassParameter() || mySettings.isMakeFieldParameters()) {
for (UsageInfo usage : usages) {
PsiElement element = usage.getElement();
if (element instanceof PsiMethodReferenceExpression) {
descriptions.putValue(element, "Method reference will be corrupted");
}
}
}
return descriptions;
}
private void calculateToLift(LookupElement element) {
for (String string : CompletionUtil.iterateLookupStrings(element)) {
for (int len = 1; len < string.length(); len++) {
String prefix = string.substring(0, len);
for (LookupElement shorterElement : myElements.get(prefix)) {
if (myCondition.shouldLift(shorterElement, element)) {
myToLift.putValue(element, shorterElement);
myReversedToLift.putValue(shorterElement, element);
}
}
}
}
}
private void calculateInitializersConflicts(MultiMap<PsiElement, String> conflicts) {
final PsiClassInitializer[] initializers = sourceClass.getInitializers();
for (PsiClassInitializer initializer : initializers) {
if (initializerDependsOnMoved(initializer)) {
conflicts.putValue(initializer, "Class initializer requires moved members");
}
}
for (PsiMethod constructor : sourceClass.getConstructors()) {
if (initializerDependsOnMoved(constructor.getBody())) {
conflicts.putValue(constructor, "Constructor requires moved members");
}
}
}
