Java CompletionProvider类代码示例

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
/**
 * Complete the "visibility" and "stricthtml" keywords in template definition open tags.
 */
private void extendWithTemplateDefinitionLevelKeywords() {
  extend(
      CompletionType.BASIC,
      psiElement().andOr(psiElement().inside(SoyBeginTemplate.class)),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            @NotNull CompletionParameters completionParameters,
            ProcessingContext processingContext,
            @NotNull CompletionResultSet completionResultSet) {
          if (isPrecededBy(completionParameters.getPosition(),
              elt -> elt instanceof SoyTemplateDefinitionIdentifier)) {
            completionResultSet.addElement(
                LookupElementBuilder.create("visibility=\"private\""));
            completionResultSet.addElement(
                LookupElementBuilder.create("stricthtml=\"true\""));
          }
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
/**
 * Complete types in {@param ...} .
 */
private void extendWithParameterTypes() {
  // Complete types in @param.
  extend(
      CompletionType.BASIC,
      psiElement()
          .andOr(
              psiElement().inside(SoyAtParamSingle.class).afterLeaf(":"),
              psiElement().inside(SoyAtInjectSingle.class).afterLeaf(":"),

              // List type literal.
              psiElement().inside(SoyListType.class).afterLeaf("<"),

              // Map type literal.
              psiElement().inside(SoyMapType.class).afterLeaf("<"),
              psiElement().inside(SoyMapType.class).afterLeaf(",")),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            @NotNull CompletionParameters completionParameters,
            ProcessingContext processingContext,
            @NotNull CompletionResultSet completionResultSet) {
          completionResultSet.addAllElements(soyTypeLiterals);
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public EmojiResourceCompletionContributor() {
	extend(CompletionType.BASIC, PlatformPatterns.psiElement(PsiElement.class), new CompletionProvider<CompletionParameters>() {
		@Override
		protected void addCompletions(@NotNull CompletionParameters completionParameters,
									  ProcessingContext processingContext,
									  @NotNull CompletionResultSet completionResultSet) {
			Document document = completionParameters.getEditor().getDocument();
			int lineStart = document.getLineStartOffset(document.getLineNumber(completionParameters.getOffset()));
			String lineText = document.getText(new TextRange(lineStart, completionParameters.getOffset()));
			if (includeCount(lineText) == 1) {
				for (Map.Entry<String, Icon> iconEntry : EmojiUtil.getEmojiMap().entrySet()) {
					completionResultSet.addElement(LookupElementBuilder.create(iconEntry.getKey(), ":" + iconEntry.getKey() + ":")
							.withIcon(iconEntry.getValue())
							.withInsertHandler((insertionContext, lookupElement) -> {
								int startOffset = insertionContext.getStartOffset();
								Document insertDocument = insertionContext.getDocument();
								if (startOffset > 0 && insertDocument.getCharsSequence().charAt(startOffset - 1) == ':') {
									insertDocument.deleteString(startOffset - 1, startOffset);
								}
							}));
				}
			}
		}
	});
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public ExtensionsNameContributor() {
    extend(
        CompletionType.BASIC,
        tagAttributePattern("extension", "name", null),
        new CompletionProvider<CompletionParameters>() {

            @Override
            protected void addCompletions(
                @NotNull final CompletionParameters parameters,
                final ProcessingContext context,
                @NotNull final CompletionResultSet result
            ) {
                final HybrisProjectSettings hybrisProjectSettings
                    = HybrisProjectSettingsComponent.getInstance(parameters.getOriginalFile().getProject())
                                                    .getState();
                final Set<String> extensions = hybrisProjectSettings.getCompleteSetOfAvailableExtensionsInHybris();

                extensions.forEach(name -> result.addElement(LookupElementBuilder.create(name)));
            }
        }
    );

}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public WorkspaceTypeCompletionContributor() {
  extend(
      CompletionType.BASIC,
      psiElement()
          .withLanguage(ProjectViewLanguage.INSTANCE)
          .inside(ProjectViewPsiScalarSection.class)
          .afterLeaf(psiElement().withText(":").afterLeaf(WorkspaceTypeSection.KEY.getName())),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            CompletionParameters parameters,
            ProcessingContext context,
            CompletionResultSet result) {
          for (WorkspaceType type : WorkspaceType.values()) {
            result.addElement(LookupElementBuilder.create(type.getName()));
          }
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public AdditionalLanguagesCompletionContributor() {
  extend(
      CompletionType.BASIC,
      psiElement()
          .withLanguage(ProjectViewLanguage.INSTANCE)
          .inside(
              psiElement(ProjectViewPsiListSection.class)
                  .withText(
                      StandardPatterns.string()
                          .startsWith(AdditionalLanguagesSection.KEY.getName()))),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            CompletionParameters parameters,
            ProcessingContext context,
            CompletionResultSet result) {
          for (LanguageClass type :
              availableAdditionalLanguages(parameters.getEditor().getProject())) {
            result.addElement(LookupElementBuilder.create(type.getName()));
          }
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public ProjectViewKeywordCompletionContributor() {
  extend(
      CompletionType.BASIC,
      psiElement()
          .withLanguage(ProjectViewLanguage.INSTANCE)
          .withElementType(ProjectViewTokenType.IDENTIFIERS)
          .andOr(psiElement().afterLeaf("\n"), psiElement().afterLeaf(psiElement().isNull())),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            CompletionParameters parameters,
            ProcessingContext context,
            CompletionResultSet result) {
          result.addAllElements(keywordLookups);
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public BuiltInSymbolCompletionContributor() {
  extend(
      CompletionType.BASIC,
      psiElement()
          .withLanguage(BuildFileLanguage.INSTANCE)
          .andNot(psiComment())
          .withParent(ReferenceExpression.class)
          .andNot(psiElement().inside(FuncallExpression.class))
          .andNot(psiElement().afterLeaf(psiElement().withText("."))),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            CompletionParameters parameters,
            ProcessingContext context,
            CompletionResultSet result) {
          for (String symbol : BuiltInNamesProvider.GLOBALS) {
            result.addElement(LookupElementBuilder.create(symbol));
          }
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
private void extendForVariablesAndFunctions() {
    extend(CompletionType.BASIC, referencePattern(XQueryTypes.NCNAME).withReferenceOfAnyOfTypes
                    (XQueryFunctionReference.class),
            new CompletionProvider<CompletionParameters>() {
                @Override
                protected void addCompletions(@NotNull CompletionParameters parameters, ProcessingContext context,
                                              @NotNull CompletionResultSet result) {
                    XQueryFile originalFile = (XQueryFile) parameters.getOriginalFile();
                    VariableCollector variableCollector = new VariableCollector(parameters
                            .getPosition());

                    result.addAllElements(FunctionCollector.getLookUpItems(originalFile));
                    result.addAllElements(variableCollector.getProposedLookUpItems());
                }
            });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
@Override
protected void addCompletions(@NotNull CompletionParameters parameters,
                              ProcessingContext context,
                              @NotNull CompletionResultSet result) {
    for (CompletionProvider<CompletionParameters> provider : providers) {
        provider.addCompletionVariants(parameters, context, result);
    }
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
/**
 * Complete variable names that are in lang when in an expression.
 */
private void extendWithVariableNamesInScope() {
  extend(
      CompletionType.BASIC,
      psiElement().andOr(
          psiElement().inside(SoyExpr.class),
          psiElement().inside(SoyBeginIf.class),
          psiElement().inside(SoyBeginElseIf.class),
          psiElement().inside(SoyBeginFor.class),
          psiElement().inside(SoyBeginForeach.class),
          psiElement().inside(SoyPrintStatement.class),
          psiElement().inside(SoyBeginParamTag.class).and(
              psiElement().afterLeafSkipping(psiElement(PsiWhiteSpace.class),
                  psiElement(SoyTypes.COLON)))
      ),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            @NotNull CompletionParameters completionParameters,
            ProcessingContext processingContext,
            @NotNull CompletionResultSet completionResultSet) {
          Collection<Variable> params =
              Scope.getScopeOrEmpty(completionParameters.getPosition()).getVariables();
          completionResultSet.addAllElements(
              params
                  .stream()
                  .map(param -> "$" + param.name)
                  .map(LookupElementBuilder::create)
                  .collect(Collectors.toList()));
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
/**
 * Complete fully qualified namespace fragments for alias declaration.
 */
private void extendWithIdentifierFragmentsForAlias() {
  extend(
      CompletionType.BASIC,
      psiElement().inside(SoyAliasBlock.class),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            @NotNull CompletionParameters completionParameters,
            ProcessingContext processingContext,
            @NotNull CompletionResultSet completionResultSet) {
          PsiElement identifierElement =
              PsiTreeUtil.getParentOfType(
                  completionParameters.getPosition(), SoyNamespaceIdentifier.class);
          String identifier = identifierElement == null ? "" : identifierElement.getText();

          String prefix = identifier.replaceFirst("IntellijIdeaRulezzz", "");
          Collection<TemplateNameUtils.Fragment> completions =
              TemplateNameUtils.getTemplateNamespaceFragments(
                  completionParameters.getPosition().getProject(), prefix);

          completionResultSet.addAllElements(
              completions
                  .stream()
                  .map(
                      (fragment) ->
                          LookupElementBuilder.create(fragment.text)
                              .withTypeText(
                                  fragment.isFinalFragment ? "Namespace" : "Partial namespace"))
                  .collect(Collectors.toList()));
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public CloudSlangCompletionContributor() {
    extend(CompletionType.BASIC,
            PlatformPatterns.psiElement().withLanguage(YAMLLanguage.INSTANCE),
            new CompletionProvider<CompletionParameters>() {
                public void addCompletions(@NotNull CompletionParameters parameters, ProcessingContext context, @NotNull CompletionResultSet resultSet) {
                    addSlangKeywords(resultSet);
                    addYamlKeywordsUsedByCloudSlang(resultSet);
                }
            }
    );
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public ArgumentCompletionContributor() {
  extend(
      CompletionType.BASIC,
      psiElement()
          .withLanguage(BuildFileLanguage.INSTANCE)
          .withElementType(BuildToken.fromKind(TokenKind.IDENTIFIER))
          .withParents(ReferenceExpression.class, Argument.Positional.class)
          .andNot(psiComment())
          .andNot(psiElement().afterLeaf("="))
          .andNot(psiElement().afterLeaf(psiElement(BuildToken.fromKind(TokenKind.IDENTIFIER)))),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            CompletionParameters parameters,
            ProcessingContext context,
            CompletionResultSet result) {
          Argument.Positional arg =
              PsiTreeUtil.getParentOfType(parameters.getPosition(), Argument.Positional.class);
          if (arg != null) {
            Object[] lookups = arg.getReference().getVariants();
            for (Object lookup : lookups) {
              if (lookup instanceof LookupElement) {
                result.addElement((LookupElement) lookup);
              }
            }
          }
        }
      });
}
 

import com.intellij.codeInsight.completion.CompletionProvider; //导入依赖的package包/类
public BuiltInFunctionCompletionContributor() {
  extend(
      CompletionType.BASIC,
      psiElement()
          .withLanguage(BuildFileLanguage.INSTANCE)
          .andNot(psiComment())
          .andOr(
              // Handles only top-level rules, and rules inside a function statement.
              // There are several other possibilities (e.g. inside top-level list comprehension),
              // but leaving out less common cases to avoid cluttering the autocomplete
              // suggestions when it's not valid to enter a rule.
              psiElement()
                  .withParents(
                      ReferenceExpression.class,
                      BuildFile.class), // leaf node => BuildReference => BuildFile
              psiElement()
                  .inside(
                      psiElement(StatementList.class).inside(psiElement(FunctionStatement.class)))
                  .afterLeaf(
                      psiElement().withText(".").afterLeaf(psiElement().withText("native")))),
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(
            CompletionParameters parameters,
            ProcessingContext context,
            CompletionResultSet result) {
          ImmutableSet<String> builtInNames =
              BuiltInNamesProvider.getBuiltInFunctionNames(parameters.getPosition().getProject());
          for (String ruleName : builtInNames) {
            result.addElement(
                LookupElementBuilder.create(ruleName)
                    .withIcon(BlazeIcons.BuildRule)
                    .withInsertHandler(ParenthesesInsertHandler.getInstance(true)));
          }
        }
      });
}