private boolean startProcessing() {
    LOG.assertTrue(Thread.holdsLock(myQueue));

    if (isProcessing || !myStarted) {
      return false;
    }
    isProcessing = true;
    final T item = myQueue.removeFirst();
    final Runnable runnable =
        () -> {
          if (myDeathCondition.value(null)) return;
          runSafely(() -> myProcessor.consume(item, myContinuationContext));
        };
    final Application application = ApplicationManager.getApplication();
    if (myThreadToUse == ThreadToUse.AWT) {
      final ModalityState state = myModalityState.remove(new MyOverrideEquals(item));
      if (state != null) {
        application.invokeLater(runnable, state);
      } else {
        application.invokeLater(runnable);
      }
    } else {
      application.executeOnPooledThread(runnable);
    }
    return true;
  }
  public static boolean isValidName(
      final Project project, final PsiElement psiElement, final String newName) {
    if (newName == null || newName.length() == 0) {
      return false;
    }
    final Condition<String> inputValidator =
        RenameInputValidatorRegistry.getInputValidator(psiElement);
    if (inputValidator != null) {
      return inputValidator.value(newName);
    }
    if (psiElement instanceof PsiFile || psiElement instanceof PsiDirectory) {
      return newName.indexOf('\\') < 0 && newName.indexOf('/') < 0;
    }
    if (psiElement instanceof PomTargetPsiElement) {
      return !StringUtil.isEmptyOrSpaces(newName);
    }

    final PsiFile file = psiElement.getContainingFile();
    final Language elementLanguage = psiElement.getLanguage();

    final Language fileLanguage = file == null ? null : file.getLanguage();
    Language language =
        fileLanguage == null
            ? elementLanguage
            : fileLanguage.isKindOf(elementLanguage) ? fileLanguage : elementLanguage;

    return LanguageNamesValidation.INSTANCE
        .forLanguage(language)
        .isIdentifier(newName.trim(), project);
  }
  private static Condition<PsiElement> findFieldUsages(
      final PsiField psiField,
      final List<UsageInfo> usages,
      final PsiElement[] allElementsToDelete) {
    final Condition<PsiElement> isInsideDeleted = getUsageInsideDeletedFilter(allElementsToDelete);
    ReferencesSearch.search(psiField)
        .forEach(
            reference -> {
              if (!isInsideDeleted.value(reference.getElement())) {
                final PsiElement element = reference.getElement();
                final PsiElement parent = element.getParent();
                if (parent instanceof PsiAssignmentExpression
                    && element == ((PsiAssignmentExpression) parent).getLExpression()) {
                  usages.add(
                      new SafeDeleteFieldWriteReference(
                          (PsiAssignmentExpression) parent, psiField));
                } else {
                  TextRange range = reference.getRangeInElement();
                  usages.add(
                      new SafeDeleteReferenceJavaDeleteUsageInfo(
                          reference.getElement(),
                          psiField,
                          range.getStartOffset(),
                          range.getEndOffset(),
                          false,
                          PsiTreeUtil.getParentOfType(element, PsiImportStaticStatement.class)
                              != null));
                }
              }

              return true;
            });

    return isInsideDeleted;
  }
  @Override
  public boolean processDeclarations(
      @NotNull PsiScopeProcessor processor,
      @NotNull ResolveState state,
      PsiElement lastParent,
      @NotNull PsiElement place) {
    GlobalSearchScope scope = place.getResolveScope();

    processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this);
    ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);

    final JavaPsiFacade facade = getFacade();
    final Condition<String> prefixMatcher = processor.getHint(JavaCompletionHints.NAME_FILTER);

    if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
      NameHint nameHint = processor.getHint(NameHint.KEY);
      if (nameHint != null) {
        final String shortName = nameHint.getName(state);
        if (containsClassNamed(shortName)
            && processClassesByName(processor, state, scope, shortName)) return false;
      } else if (prefixMatcher != null) {
        for (String className : getClassNamesCache()) {
          if (prefixMatcher.value(className)) {
            if (processClassesByName(processor, state, scope, className)) return false;
          }
        }
      } else {
        PsiClass[] classes = getClasses(scope);
        if (!processClasses(processor, state, classes)) return false;
      }
    }
    if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.PACKAGE)) {
      NameHint nameHint = processor.getHint(NameHint.KEY);
      if (nameHint != null) {
        PsiPackage aPackage = findSubPackageByName(nameHint.getName(state));
        if (aPackage != null) {
          if (!processor.execute(aPackage, state)) return false;
        }
      } else {
        PsiPackage[] packs = getSubPackages(scope);
        for (PsiPackage pack : packs) {
          final String packageName = pack.getName();
          if (packageName == null) continue;
          if (!facade.getNameHelper().isIdentifier(packageName, PsiUtil.getLanguageLevel(this))) {
            continue;
          }
          if (!processor.execute(pack, state)) {
            return false;
          }
        }
      }
    }
    return true;
  }
    private Alignment getAlignment(ASTNode node) {
      IElementType elementType = node.getElementType();

      Condition<ASTNode> noneAlignmentCondition = myNoneAlignmentCondition.get(elementType);
      if (noneAlignmentCondition != null && noneAlignmentCondition.value(node)) {
        return null;
      }

      Alignment alignment = myAlignments.get(elementType);
      if (alignment == null) {
        return myDefaultAlignment;
      }
      return alignment == NO_ALIGNMENT ? null : alignment;
    }
  private static boolean checkDependants(
      final IdeaPluginDescriptor pluginDescriptor,
      final Function<PluginId, IdeaPluginDescriptor> pluginId2Descriptor,
      final Condition<PluginId> check,
      final Set<PluginId> processed) {
    processed.add(pluginDescriptor.getPluginId());
    final PluginId[] dependentPluginIds = pluginDescriptor.getDependentPluginIds();
    final Set<PluginId> optionalDependencies =
        new HashSet<PluginId>(Arrays.asList(pluginDescriptor.getOptionalDependentPluginIds()));
    for (final PluginId dependentPluginId : dependentPluginIds) {
      if (processed.contains(dependentPluginId)) continue;

      // TODO[yole] should this condition be a parameter?
      if (isModuleDependency(dependentPluginId)
          && (ourAvailableModules.isEmpty()
              || ourAvailableModules.contains(dependentPluginId.getIdString()))) {
        continue;
      }
      if (!optionalDependencies.contains(dependentPluginId)) {
        if (!check.value(dependentPluginId)) {
          return false;
        }
        final IdeaPluginDescriptor dependantPluginDescriptor =
            pluginId2Descriptor.fun(dependentPluginId);
        if (dependantPluginDescriptor != null
            && !checkDependants(dependantPluginDescriptor, pluginId2Descriptor, check, processed)) {
          return false;
        }
      }
    }
    return true;
  }
  public static void showDiffForChange(
      final Iterable<Change> changes,
      final Condition<Change> selectionChecker,
      final Project project,
      @NotNull ShowDiffUIContext context) {
    int newIndex = -1;
    ChangeForDiffConvertor convertor = new ChangeForDiffConvertor(project, true);
    final List<DiffRequestPresentable> changeList = ContainerUtil.newArrayList();
    for (Change change : changes) {
      if (!directoryOrBinary(change)) { // todo
        DiffRequestPresentable presentable = convertor.convert(change);
        if (presentable != null) {
          if ((newIndex == -1) && selectionChecker.value(change)) {
            newIndex = changeList.size();
          }
          changeList.add(presentable);
        }
      }
    }
    if (changeList.isEmpty()) {
      return;
    }
    if (newIndex < 0) {
      newIndex = 0;
    }

    showDiffImpl(project, changeList, newIndex, context);
  }
 public Fragment getSubfragmentAt(int offset, FragmentSide side, Condition<Fragment> condition) {
   LOG.assertTrue(
       getRange(side).getStartOffset() <= offset
           && offset < getRange(side).getEndOffset()
           && condition.value(this));
   return this;
 }
  public static void showDiffForChange(
      final Iterable<Change> changes,
      final Condition<Change> selectionChecker,
      final Project project,
      @NotNull ShowDiffUIContext context) {
    int cnt = 0;
    int newIndex = -1;
    final List<Change> changeList = new ArrayList<Change>();
    for (Change change : changes) {
      if (!directoryOrBinary(change)) { // todo
        changeList.add(change);
        if ((newIndex == -1) && selectionChecker.value(change)) {
          newIndex = cnt;
        }
        ++cnt;
      }
    }
    if (changeList.isEmpty()) {
      return;
    }
    if (newIndex < 0) {
      newIndex = 0;
    }

    showDiffImpl(
        project,
        ObjectsConvertor.convert(
            changeList, new ChangeForDiffConvertor(project, true), ObjectsConvertor.NOT_NULL),
        newIndex,
        context);
  }
Beispiel #10
0
  // TODO: Make it work for properties
  public Collection<DeclarationDescriptor> getJetCallableExtensions(
      @NotNull Condition<String> acceptedNameCondition,
      @NotNull JetSimpleNameExpression expression,
      @NotNull ResolveSession resolveSession,
      @NotNull GlobalSearchScope searchScope) {
    Collection<DeclarationDescriptor> resultDescriptors = new ArrayList<DeclarationDescriptor>();

    BindingContext context = ResolveSessionUtils.resolveToExpression(resolveSession, expression);
    JetExpression receiverExpression = expression.getReceiverExpression();

    if (receiverExpression != null) {
      JetType expressionType = context.get(BindingContext.EXPRESSION_TYPE, receiverExpression);
      JetScope scope = context.get(BindingContext.RESOLUTION_SCOPE, receiverExpression);

      if (expressionType != null && scope != null) {
        Collection<String> extensionFunctionsNames = getAllJetExtensionFunctionsNames(searchScope);

        Set<FqName> functionFQNs = new java.util.HashSet<FqName>();

        // Collect all possible extension function qualified names
        for (String name : extensionFunctionsNames) {
          if (acceptedNameCondition.value(name)) {
            Collection<PsiElement> extensionFunctions =
                getJetExtensionFunctionsByName(name, searchScope);

            for (PsiElement extensionFunction : extensionFunctions) {
              if (extensionFunction instanceof JetNamedFunction) {
                functionFQNs.add(JetPsiUtil.getFQName((JetNamedFunction) extensionFunction));
              } else if (extensionFunction instanceof PsiMethod) {
                FqName functionFQN =
                    JetFromJavaDescriptorHelper.getJetTopLevelDeclarationFQN(
                        (PsiMethod) extensionFunction);
                if (functionFQN != null) {
                  functionFQNs.add(functionFQN);
                }
              }
            }
          }
        }

        // Iterate through the function with attempt to resolve found functions
        for (FqName functionFQN : functionFQNs) {
          for (CallableDescriptor functionDescriptor :
              ExpressionTypingUtils.canFindSuitableCall(
                  functionFQN,
                  project,
                  receiverExpression,
                  expressionType,
                  scope,
                  resolveSession.getModuleConfiguration())) {

            resultDescriptors.add(functionDescriptor);
          }
        }
      }
    }

    return resultDescriptors;
  }
 public static void copyChildren(Element from, Element to, Condition<Element> filter) {
   final List<Element> list = from.getChildren();
   for (Element element : list) {
     if (filter.value(element)) {
       to.addContent((Element) element.clone());
     }
   }
 }
 public void unregisterQuickFix(@NotNull Condition<IntentionAction> condition) {
   for (Iterator<Pair<IntentionActionDescriptor, TextRange>> it = quickFixActionRanges.iterator();
       it.hasNext(); ) {
     Pair<IntentionActionDescriptor, TextRange> pair = it.next();
     if (condition.value(pair.first.getAction())) {
       it.remove();
     }
   }
 }
 @Nullable
 public static Element findChild(Element parent, final Condition<Element> filter) {
   final List<Element> list = parent.getChildren();
   for (Element e : list) {
     if (filter.value(e)) {
       return e;
     }
   }
   return null;
 }
 @Override
 @NonNls
 public String toString() {
   return "[runnable: "
       + runnable
       + "; state="
       + modalityState
       + (expired.value(null) ? "; expired" : "")
       + "] ";
 }
 @NotNull
 private static <T> Set<T> packCollection(
     @NotNull Collection<T> set, @NotNull Condition<T> condition) {
   final Set<T> result = new LinkedHashSet<T>();
   for (T t : set) {
     if (condition.value(t)) {
       result.add(t);
     }
   }
   return result;
 }
  private static void printImpl(
      JTree tree,
      Object root,
      Collection<String> strings,
      int level,
      boolean withSelection,
      @Nullable Condition<String> nodePrintCondition) {
    DefaultMutableTreeNode defaultMutableTreeNode = (DefaultMutableTreeNode) root;

    final Object userObject = defaultMutableTreeNode.getUserObject();
    String nodeText;
    if (userObject != null) {
      nodeText = toString(userObject, null);
    } else {
      nodeText = "null";
    }

    if (nodePrintCondition != null && !nodePrintCondition.value(nodeText)) return;

    final StringBuilder buff = new StringBuilder();
    StringUtil.repeatSymbol(buff, ' ', level);

    final boolean expanded = tree.isExpanded(new TreePath(defaultMutableTreeNode.getPath()));
    if (!defaultMutableTreeNode.isLeaf()) {
      buff.append(expanded ? "-" : "+");
    }

    final boolean selected =
        tree.getSelectionModel().isPathSelected(new TreePath(defaultMutableTreeNode.getPath()));
    if (withSelection && selected) {
      buff.append("[");
    }

    buff.append(nodeText);

    if (withSelection && selected) {
      buff.append("]");
    }

    strings.add(buff.toString());

    int childCount = tree.getModel().getChildCount(root);
    if (expanded) {
      for (int i = 0; i < childCount; i++) {
        printImpl(
            tree,
            tree.getModel().getChild(root, i),
            strings,
            level + 1,
            withSelection,
            nodePrintCondition);
      }
    }
  }
 public boolean satisfies(@NotNull PsiElement element, @NotNull ResolveState state) {
   final String name = PsiUtilCore.getName(element);
   if (StringUtil.isNotEmpty(name) && (myMatcher == null || myMatcher.value(name))) {
     if (myFilter.isClassAcceptable(element.getClass())
         && myFilter.isAcceptable(
             new CandidateInfo(element, state.get(PsiSubstitutor.KEY)), myElement)) {
       return true;
     }
   }
   return false;
 }
Beispiel #18
0
 private static boolean processClasses(
     @NotNull PsiScopeProcessor processor,
     @NotNull ResolveState state,
     @NotNull PsiClass[] classes,
     @NotNull Condition<String> nameCondition) {
   for (PsiClass aClass : classes) {
     String name = aClass.getName();
     if (name != null && nameCondition.value(name) && !processor.execute(aClass, state))
       return false;
   }
   return true;
 }
 private static void addSomeItems(
     LinkedHashSet<LookupElement> model,
     Iterator<LookupElement> iterator,
     Condition<LookupElement> stopWhen) {
   while (iterator.hasNext()) {
     LookupElement item = iterator.next();
     model.add(item);
     if (stopWhen.value(item)) {
       break;
     }
   }
 }
 public static void updateDependenciesOnDartPackagesLibrary(
     @NotNull final Project project,
     @NotNull final Condition<Module> moduleFilter,
     @NotNull final Library library) {
   for (Module module : ModuleManager.getInstance(project).getModules()) {
     if (moduleFilter.value(module)) {
       addDependencyOnDartPackagesLibrary(module, library);
     } else {
       removeDependencyOnDartPackagesLibrary(module);
     }
   }
 }
Beispiel #21
0
 @NotNull
 private IDevice[] getFilteredDevices(AndroidDebugBridge bridge) {
   final List<IDevice> filteredDevices = new ArrayList<IDevice>();
   for (IDevice device : bridge.getDevices()) {
     if (myFilter == null || myFilter.value(device)) {
       filteredDevices.add(device);
     }
   }
   // Do not filter launching cloud devices as they are just unselectable progress markers
   // that are replaced with the actual cloud devices as soon as they are up and the actual cloud
   // devices will be filtered above.
   return filteredDevices.toArray(new IDevice[filteredDevices.size()]);
 }
 public static void processFilesToRecompile(
     final CompileContext context,
     final ModuleChunk chunk,
     final Condition<JpsModule> moduleFilter,
     final FileProcessor processor)
     throws IOException {
   final BuildFSState fsState = context.getProjectDescriptor().fsState;
   for (ModuleBuildTarget target : chunk.getTargets()) {
     if (moduleFilter.value(target.getModule())) {
       fsState.processFilesToRecompile(context, target, processor);
     }
   }
 }
 private static int getDefaultOptionIndexFromSelectCondition(
     @Nullable Condition<AnAction> preselectActionCondition, @NotNull List<ActionItem> items) {
   int defaultOptionIndex = 0;
   if (preselectActionCondition != null) {
     for (int i = 0; i < items.size(); i++) {
       final AnAction action = items.get(i).getAction();
       if (preselectActionCondition.value(action)) {
         defaultOptionIndex = i;
         break;
       }
     }
   }
   return defaultOptionIndex;
 }
 public static List<Element> removeChildren(
     final Element element, final Condition<Element> filter) {
   List<Element> toRemove = new ArrayList<Element>();
   final List<Element> list = element.getChildren();
   for (Element e : list) {
     if (filter.value(e)) {
       toRemove.add(e);
     }
   }
   for (Element e : toRemove) {
     element.removeContent(e);
   }
   return toRemove;
 }
Beispiel #25
0
  public Collection<ClassDescriptor> getJetClassesDescriptors(
      @NotNull Condition<String> acceptedShortNameCondition, @NotNull KotlinCodeAnalyzer analyzer) {
    Collection<ClassDescriptor> classDescriptors = new ArrayList<ClassDescriptor>();

    for (String fqName : JetFullClassNameIndex.getInstance().getAllKeys(project)) {
      FqName classFQName = new FqName(fqName);
      if (acceptedShortNameCondition.value(classFQName.shortName().getName())) {
        classDescriptors.addAll(
            ResolveSessionUtils.getClassDescriptorsByFqName(analyzer, classFQName));
      }
    }

    return classDescriptors;
  }
Beispiel #26
0
 @NotNull
 @Override
 public Collection<? extends CustomLiveTemplateLookupElement> getLookupElements(
     @NotNull PsiFile file, @NotNull Editor editor, int offset) {
   String key =
       computeTemplateKeyWithoutContextChecking(editor.getDocument().getCharsSequence(), offset);
   if (key != null) {
     Map<String, CustomLiveTemplateLookupElement> result = ContainerUtil.newHashMap();
     Condition<PostfixTemplate> isApplicationTemplateFunction =
         createIsApplicationTemplateFunction(key, file, editor);
     for (Map.Entry<String, PostfixTemplate> entry : myTemplates.entrySet()) {
       PostfixTemplate postfixTemplate = entry.getValue();
       if (entry.getKey().startsWith(key)
           && isApplicationTemplateFunction.value(postfixTemplate)) {
         result.put(
             postfixTemplate.getKey(),
             new PostfixTemplateLookupElement(
                 this, postfixTemplate, postfixTemplate.getKey(), false));
       }
     }
     return result.values();
   }
   return super.getLookupElements(file, editor, offset);
 }
 @NotNull
 public List<RunContentDescriptor> getRunningDescriptors(
     @NotNull Condition<RunnerAndConfigurationSettings> condition) {
   List<RunContentDescriptor> result = new SmartList<>();
   for (Trinity<RunContentDescriptor, RunnerAndConfigurationSettings, Executor> trinity :
       myRunningConfigurations) {
     if (trinity.getSecond() != null && condition.value(trinity.getSecond())) {
       ProcessHandler processHandler = trinity.getFirst().getProcessHandler();
       if (processHandler != null /*&& !processHandler.isProcessTerminating()*/
           && !processHandler.isProcessTerminated()) {
         result.add(trinity.getFirst());
       }
     }
   }
   return result;
 }
 public void update(AnActionEvent e) {
   final Presentation presentation = e.getPresentation();
   presentation.setEnabled(false);
   final TreePath[] selectionPath = myTree.getSelectionPaths();
   if (selectionPath != null) {
     Object[] nodes =
         ContainerUtil.map2Array(
             selectionPath,
             new Function<TreePath, Object>() {
               @Override
               public Object fun(TreePath treePath) {
                 return treePath.getLastPathComponent();
               }
             });
     if (!myCondition.value(nodes)) return;
     presentation.setEnabled(true);
   }
 }
 @Override
 public void run() {
   boolean b = invokeLaterScheduled.compareAndSet(true, false);
   assert b;
   if (stopped || myShutUpCondition.value(null)) {
     stop();
     return;
   }
   long start = System.currentTimeMillis();
   int processed = 0;
   while (processNext()) {
     processed++;
     long finish = System.currentTimeMillis();
     if (myMaxUnitOfWorkThresholdMs != -1 && finish - start > myMaxUnitOfWorkThresholdMs)
       break;
   }
   if (!isEmpty()) {
     scheduleUpdate();
   }
 }
 public static void addChildAfter(
     final Element parent,
     final Element child,
     final Condition<Element> filter,
     boolean addFirstIfNotFound) {
   List list = parent.getContent();
   for (int i = 0; i < list.size(); i++) {
     Object o = list.get(i);
     if (o instanceof Element && filter.value((Element) o)) {
       if (i < list.size() - 1) {
         parent.addContent(i + 1, child);
       } else {
         parent.addContent(child);
       }
       return;
     }
   }
   if (addFirstIfNotFound) {
     parent.addContent(0, child);
   }
 }