Java AutoCompletionPolicy类代码示例

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private static void addEnumSuggestions(Editor editor, String val, String suffix, List<LookupElement> answer,
                                       String deprecated, String enums, String defaultValue, boolean xmlMode) {
    String[] parts = enums.split(",");
    for (String part : parts) {
        String lookup = val + part;
        LookupElementBuilder builder = LookupElementBuilder.create(lookup);
        builder = addInsertHandler(editor, suffix, builder, xmlMode);

        // only show the option in the UI
        builder = builder.withPresentableText(part);
        builder = builder.withBoldness(true);
        if ("true".equals(deprecated)) {
            // mark as deprecated
            builder = builder.withStrikeoutness(true);
        }
        boolean isDefaultValue = defaultValue != null && part.equals(defaultValue);
        if (isDefaultValue) {
            builder = builder.withTailText(" (default value)");
            // add default value first in the list
            answer.add(0, builder.withAutoCompletionPolicy(AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE));
        } else {
            answer.add(builder.withAutoCompletionPolicy(AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE));
        }
    }
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
public static List<LookupElement> addSmartCompletionSuggestionsContextPath(String val, ComponentModel component,
                                                                           Map<String, String> existing, boolean xmlMode, PsiElement psiElement) {
    List<LookupElement> answer = new ArrayList<>();

    // show the syntax as the only choice for now
    LookupElementBuilder builder = LookupElementBuilder.create(val);
    builder = builder.withIcon(getCamelPreferenceService().getCamelIcon());
    builder = builder.withBoldness(true);
    builder = builder.withPresentableText(component.getSyntax());

    LookupElement element = builder.withAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE);
    answer.add(element);
    val = removeUnknownEnum(val, psiElement);
    List<LookupElement> old = addSmartCompletionContextPathEnumSuggestions(val, component, existing);
    if (!old.isEmpty()) {
        answer.addAll(old);
    }

    return answer;
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private static void suggestNonImportedClasses(final CompletionParameters parameters, final CompletionResultSet result, @Nullable final InheritorsHolder inheritorsHolder) {
  JavaClassNameCompletionContributor.addAllClasses(parameters,
                                                   true, result.getPrefixMatcher(), new Consumer<LookupElement>() {
    @Override
    public void consume(LookupElement element) {
      if (inheritorsHolder != null && inheritorsHolder.alreadyProcessed(element)) {
        return;
      }
      JavaPsiClassReferenceElement classElement = element.as(JavaPsiClassReferenceElement.CLASS_CONDITION_KEY);
      if (classElement != null) {
        classElement.setAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE);
        element = JavaClassNameCompletionContributor.highlightIfNeeded(classElement, parameters);
      }

      result.addElement(element);
    }
  });
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
@NotNull
@Override
protected LookupElement createLookupElement(@NotNull PsiMember member, @NotNull final PsiClass containingClass, boolean shouldImport) {
  shouldImport |= myOriginalPosition != null && PsiTreeUtil.isAncestor(containingClass, myOriginalPosition, false);

  if (member instanceof PsiMethod) {
    return AutoCompletionPolicy.NEVER_AUTOCOMPLETE.applyPolicy(new GlobalMethodCallElement((PsiMethod)member, shouldImport, false));
  }
  return AutoCompletionPolicy.NEVER_AUTOCOMPLETE.applyPolicy(new VariableLookupItem((PsiField)member, shouldImport) {
    @Override
    public void handleInsert(InsertionContext context) {
      FeatureUsageTracker.getInstance().triggerFeatureUsed(JavaCompletionFeatures.GLOBAL_MEMBER_NAME);

      super.handleInsert(context);
    }
  });
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private void doProcessMembers(boolean acceptMethods,
                              Consumer<LookupElement> results,
                              boolean isExpectedTypeMember, Collection<? extends PsiElement> declarations) {
  for (final PsiElement result : declarations) {
    if (result instanceof PsiMember && !(result instanceof PsiClass)) {
      final PsiMember member = (PsiMember)result;
      if (!member.hasModifierProperty(PsiModifier.STATIC)) continue;
      if (result instanceof PsiField && !member.hasModifierProperty(PsiModifier.FINAL)) continue;
      if (result instanceof PsiMethod && (!acceptMethods || myPlaceMethods.contains(result))) continue;
      if (JavaCompletionUtil.isInExcludedPackage(member, false) || myImportedStatically.contains(member)) continue;

      if (!JavaPsiFacade.getInstance(myPlace.getProject()).getResolveHelper().isAccessible(member, myPlace, null)) {
        continue;
      }

      final LookupElement item = result instanceof PsiMethod ? createMethodElement((PsiMethod)result) : createFieldElement((PsiField)result);
      if (item != null) {
        item.putUserData(EXPECTED_TYPE_MEMBER, isExpectedTypeMember);
        results.consume(AutoCompletionPolicy.NEVER_AUTOCOMPLETE.applyPolicy(item));
      }
    }
  }
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private static <T> void addCompletionElements(final CompletionResultSet result,
                                              final TextFieldWithAutoCompletionListProvider<T> listProvider,
                                              final Collection<T> items,
                                              final int index) {
  final AutoCompletionPolicy completionPolicy = ApplicationManager.getApplication().isUnitTestMode()
                                                ? AutoCompletionPolicy.ALWAYS_AUTOCOMPLETE
                                                : AutoCompletionPolicy.NEVER_AUTOCOMPLETE;
  int grouping = index;
  for (final T item : items) {
    if (item == null) {
      LOG.error("Null item from " + listProvider);
      continue;
    }

    LookupElementBuilder builder = listProvider.createLookupBuilder(item);

    result.addElement(PrioritizedLookupElement.withGrouping(builder.withAutoCompletionPolicy(completionPolicy), grouping--));
  }
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
@NotNull
public Object[] getVariants() {
  final TargetResolver.Result result = doResolve(getCanonicalText());
  if (result == null) {
    return EMPTY_ARRAY;
  }
  final Map<String, AntDomTarget> variants = result.getVariants();                                                                          
  final List resVariants = new ArrayList();
  final Set<String> existing = getExistingNames();
  for (String s : variants.keySet()) {
    if (existing.contains(s)){
      continue;
    }
    final LookupElementBuilder builder = LookupElementBuilder.create(s).withCaseSensitivity(false);
    final LookupElement element = AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE.applyPolicy(builder);
    resVariants.add(element);
  }
  return ContainerUtil.toArray(resVariants, new Object[resVariants.size()]);
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
@NotNull
@Override
public Object[] getVariants() {
  final AntDomProject project = myInvocationContextElement.getParentOfType(AntDomProject.class, true);
  if (project != null) {
    final Collection<String> variants = PropertyResolver.resolve(project.getContextAntProject(), getCanonicalText(), myInvocationContextElement).getSecond();
    Object[] result = new Object[variants.size()];
    int idx = 0;
    for (String variant : variants) {
      final LookupElementBuilder builder = LookupElementBuilder.create(variant).withCaseSensitivity(false);
      final LookupElement element = AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE.applyPolicy(builder);
      result[idx++] = element;
    }
    return result;
  }
  return EMPTY_ARRAY;
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
@NotNull 
public Object[] getVariants() {
  final AntDomMacroDef parentMacrodef = getParentMacrodef();
  if (parentMacrodef != null) {
    final List variants = new ArrayList();
    for (AntDomMacrodefAttribute attribute : parentMacrodef.getMacroAttributes()) {
      final String attribName = attribute.getName().getStringValue();
      if (attribName != null && attribName.length() > 0) {
        final LookupElementBuilder builder = LookupElementBuilder.create(attribName);
        final LookupElement element = AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE.applyPolicy(builder);
        variants.add(element);
      }
    }
    return ContainerUtil.toArray(variants, new Object[variants.size()]);
  }
  return EMPTY_ARRAY;
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private void doProcessMembers(boolean acceptMethods,
                              Consumer<LookupElement> results,
                              boolean isInheritor, Collection<? extends PsiElement> declarations) {
  for (final PsiElement result : declarations) {
    if (result instanceof PsiMember && !(result instanceof PsiClass)) {
      final PsiMember member = (PsiMember)result;
      if (!member.hasModifierProperty(PsiModifier.STATIC)) continue;
      if (result instanceof PsiField && !member.hasModifierProperty(PsiModifier.FINAL)) continue;
      if (result instanceof PsiMethod && (!acceptMethods || myPlaceMethods.contains(result))) continue;
      if (JavaCompletionUtil.isInExcludedPackage(member, false) || myImportedStatically.contains(member)) continue;

      if (!JavaPsiFacade.getInstance(myPlace.getProject()).getResolveHelper().isAccessible(member, myPlace, null)) {
        continue;
      }

      final LookupElement item = result instanceof PsiMethod ? createMethodElement((PsiMethod)result) : createFieldElement((PsiField)result);
      if (item != null) {
        item.putUserData(EXPECTED_TYPE_INHERITOR_MEMBER, isInheritor);
        results.consume(AutoCompletionPolicy.NEVER_AUTOCOMPLETE.applyPolicy(item));
      }
    }
  }
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private static void suggestNonImportedClasses(CompletionParameters parameters, CompletionResultSet result, @Nullable JavaCompletionSession session)
{
	JavaClassNameCompletionContributor.addAllClasses(parameters, true, result.getPrefixMatcher(), element ->
	{
		if(session != null && session.alreadyProcessed(element))
		{
			return;
		}
		JavaPsiClassReferenceElement classElement = element.as(JavaPsiClassReferenceElement.CLASS_CONDITION_KEY);
		if(classElement != null)
		{
			classElement.setAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE);
			element = JavaClassNameCompletionContributor.highlightIfNeeded(classElement, parameters);
		}

		result.addElement(element);
	});
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private static void addBooleanSuggestions(Editor editor, String val, String suffix, List<LookupElement> answer,
                                          String deprecated, String defaultValue, boolean xmlMode) {
    // for boolean types then give a choice between true|false
    String lookup = val + "true";
    LookupElementBuilder builder = LookupElementBuilder.create(lookup);
    builder = addInsertHandler(editor, suffix, builder, xmlMode);
    // only show the option in the UI
    builder = builder.withPresentableText("true");
    if ("true".equals(deprecated)) {
        // mark as deprecated
        builder = builder.withStrikeoutness(true);
    }
    boolean isDefaultValue = defaultValue != null && "true".equals(defaultValue);
    if (isDefaultValue) {
        builder = builder.withTailText(" (default value)");
        // add default value first in the list
        answer.add(0, builder.withAutoCompletionPolicy(AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE));
    } else {
        answer.add(builder.withAutoCompletionPolicy(AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE));
    }

    lookup = val + "false";
    builder = LookupElementBuilder.create(lookup);
    builder = addInsertHandler(editor, suffix, builder, xmlMode);
    // only show the option in the UI
    builder = builder.withPresentableText("false");
    if ("true".equals(deprecated)) {
        // mark as deprecated
        builder = builder.withStrikeoutness(true);
    }
    isDefaultValue = defaultValue != null && "false".equals(defaultValue);
    if (isDefaultValue) {
        builder = builder.withTailText(" (default value)");
        // add default value first in the list
        answer.add(0, builder.withAutoCompletionPolicy(AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE));
    } else {
        answer.add(builder.withAutoCompletionPolicy(AutoCompletionPolicy.GIVE_CHANCE_TO_OVERWRITE));
    }
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private static void addDefaultValueSuggestions(Editor editor, String val, String suffix, List<LookupElement> answer,
                                               String deprecated, String defaultValue, boolean xmlMode) {
    String lookup = val + defaultValue;
    LookupElementBuilder builder = LookupElementBuilder.create(lookup);
    builder = addInsertHandler(editor, suffix, builder, xmlMode);
    // only show the option in the UI
    builder = builder.withPresentableText(defaultValue);
    if ("true".equals(deprecated)) {
        // mark as deprecated
        builder = builder.withStrikeoutness(true);
    }
    builder = builder.withTailText(" (default value)");
    // there is only one value in the list and its the default value, so never auto complete it but show as suggestion
    answer.add(0, builder.withAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE));
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
@Override
public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull final CompletionResultSet result) {
  PsiElement position = parameters.getPosition();
  PsiFile file = position.getContainingFile();
  if (parameters.getCompletionType() != CompletionType.BASIC ||
      !JavaCompletionContributor.mayStartClassName(result) ||
      !file.getLanguage().isKindOf(StdLanguages.XML)) {
    return;
  }

  final boolean empty = result.runRemainingContributors(parameters, true).isEmpty();

  if (!empty && parameters.getInvocationCount() == 0) {
    result.restartCompletionWhenNothingMatches();
  }

  if (empty && JavaClassReferenceCompletionContributor.findJavaClassReference(file, parameters.getOffset()) != null ||
      parameters.isExtendedCompletion()) {
    CompletionService.getCompletionService().getVariantsFromContributors(parameters.delegateToClassName(), null, new Consumer<CompletionResult>() {
      @Override
      public void consume(final CompletionResult completionResult) {
        LookupElement lookupElement = completionResult.getLookupElement();
        JavaPsiClassReferenceElement classElement = lookupElement.as(JavaPsiClassReferenceElement.CLASS_CONDITION_KEY);
        if (classElement != null) {
          classElement.setAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE);
        }
        lookupElement.putUserData(XmlCompletionContributor.WORD_COMPLETION_COMPATIBLE, Boolean.TRUE); //todo think of a less dirty interaction
        result.passResult(completionResult);
      }
    });
  }
}
 

import com.intellij.codeInsight.lookup.AutoCompletionPolicy; //导入依赖的package包/类
private static LookupElement createConstructorReferenceLookup(PsiType functionalInterfaceType, PsiType expectedReturnType) {
  return LookupElementBuilder
                    .create(expectedReturnType.getPresentableText() + "::new")
                    .withTypeText(functionalInterfaceType.getPresentableText())
                    .withIcon(AllIcons.Nodes.MethodReference)
                    .withAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE);
}