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"); } } }