private void completeArgumentName()

in src/main/com/intellij/lang/jsgraphql/ide/completion/GraphQLCompletionContributor.java [673:750]
73 lines of code
16 McCabe index (conditional complexity)

  private void completeArgumentName() {
    CompletionProvider<CompletionParameters> provider = new CompletionProvider<>() {
      @Override
      protected void addCompletions(final @NotNull CompletionParameters parameters,
                                    @NotNull ProcessingContext context,
                                    @NotNull CompletionResultSet result) {
        final PsiElement completionElement = Optional.ofNullable(parameters.getOriginalPosition()).orElse(parameters.getPosition());
        final GraphQLNamedElement element =
          PsiTreeUtil.getParentOfType(completionElement, GraphQLField.class, GraphQLDirective.class);
        if (element == null || element.getName() == null) {
          return;
        }

        if (element instanceof GraphQLDirective) {
          addDirectiveArguments(result, completionElement, ((GraphQLDirective)element));
        }
        else if (element instanceof GraphQLField) {
          addFieldArguments(result, ((GraphQLField)element));
        }
      }

      private void addDirectiveArguments(@NotNull CompletionResultSet result,
                                         @NotNull PsiElement completionElement,
                                         @NotNull GraphQLDirective directive) {
        final GraphQLSchema schema = GraphQLSchemaProvider.getInstance(completionElement.getProject())
          .getSchemaInfo(completionElement).getSchema();
        com.intellij.lang.jsgraphql.types.schema.GraphQLDirective directiveDefinition =
          schema.getFirstDirective(directive.getName());
        if (directiveDefinition == null) {
          return;
        }
        final Set<String> existingArgumentNames = Sets.newHashSet();
        GraphQLArguments arguments = directive.getArguments();
        if (arguments != null) {
          for (GraphQLArgument directiveArgument : arguments.getArgumentList()) {
            ContainerUtil.addIfNotNull(existingArgumentNames, directiveArgument.getName());
          }
        }
        addArgumentResults(result, directiveDefinition.getArguments(), existingArgumentNames);
      }

      private void addFieldArguments(@NotNull CompletionResultSet result, @NotNull GraphQLField field) {
        final GraphQLTypeScopeProvider typeScopeProvider = PsiTreeUtil.getParentOfType(field, GraphQLTypeScopeProvider.class);
        if (typeScopeProvider == null) {
          return;
        }
        GraphQLType typeScope = typeScopeProvider.getTypeScope();
        if (typeScope != null) {
          // we need the raw type to get the fields
          typeScope = GraphQLSchemaUtil.getUnmodified(typeScope);
        }
        if (!(typeScope instanceof GraphQLFieldsContainer)) {
          return;
        }
        final com.intellij.lang.jsgraphql.types.schema.GraphQLFieldDefinition fieldDefinition =
          ((GraphQLFieldsContainer)typeScope).getFieldDefinition(field.getName());
        if (fieldDefinition == null || field.getArguments() == null) {
          return;
        }
        final Set<String> existingArgumentNames = field.getArguments().getArgumentList().stream()
          .map(PsiNamedElement::getName).filter(Objects::nonNull).collect(Collectors.toSet());
        addArgumentResults(result, fieldDefinition.getArguments(), existingArgumentNames);
      }

      private void addArgumentResults(@NotNull CompletionResultSet result,
                                      @NotNull List<com.intellij.lang.jsgraphql.types.schema.GraphQLArgument> arguments,
                                      @NotNull Set<String> existingArgumentNames) {
        for (com.intellij.lang.jsgraphql.types.schema.GraphQLArgument graphQLArgument : arguments) {
          String name = graphQLArgument.getName();
          if (name != null && !existingArgumentNames.contains(name)) {
            String typeText = GraphQLSchemaUtil.formatAsTypeReference(graphQLArgument.getType());
            result.addElement(GraphQLCompletionUtil.createArgumentNameLookupElement(name, typeText));
          }
        }
      }
    };
    extend(CompletionType.BASIC, psiElement(GraphQLElementTypes.NAME).withSuperParent(2, GraphQLArgument.class), provider);
  }