Examples with GrNamedArgument org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument used on opensource projects

Example 31 with GrNamedArgument

use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.

the class GroovyBlockGenerator method generateSubBlocks.

public List<Block> generateSubBlocks() {
    //For binary expressions
    PsiElement blockPsi = myNode.getPsi();
    IElementType elementType = myNode.getElementType();
    if (blockPsi instanceof GrBinaryExpression && !(blockPsi.getParent() instanceof GrBinaryExpression)) {
        return generateForBinaryExpr();
    }
    //For multiline strings
    if ((elementType == GroovyTokenTypes.mSTRING_LITERAL || elementType == GroovyTokenTypes.mGSTRING_LITERAL) && myBlock.getTextRange().equals(myNode.getTextRange())) {
        String text = myNode.getText();
        if (text.length() > 6) {
            if (text.substring(0, 3).equals("'''") && text.substring(text.length() - 3).equals("'''") || text.substring(0, 3).equals("\"\"\"") & text.substring(text.length() - 3).equals("\"\"\"")) {
                return generateForMultiLineString();
            }
        }
    }
    //for gstrings
    if (elementType == GroovyElementTypes.GSTRING || elementType == GroovyElementTypes.REGEX || elementType == GroovyTokenTypes.mREGEX_LITERAL || elementType == GroovyTokenTypes.mDOLLAR_SLASH_REGEX_LITERAL) {
        final FormattingContext context = myNode.getPsi() instanceof GrString && ((GrString) myNode.getPsi()).isPlainString() ? myContext.createContext(true) : myContext;
        final ArrayList<Block> subBlocks = new ArrayList<>();
        ASTNode[] children = getGroovyChildren(myNode);
        for (ASTNode childNode : children) {
            if (childNode.getTextRange().getLength() > 0) {
                subBlocks.add(new GroovyBlock(childNode, getIndent(childNode), Wrap.createWrap(WrapType.NONE, false), context));
            }
        }
        return subBlocks;
    }
    // chained properties, calls, indexing, etc
    if (NESTED.contains(elementType) && blockPsi.getParent() != null && !NESTED.contains(blockPsi.getParent().getNode().getElementType())) {
        final List<Block> subBlocks = new ArrayList<>();
        AlignmentProvider.Aligner dotsAligner = myContext.getSettings().ALIGN_MULTILINE_CHAINED_METHODS ? myAlignmentProvider.createAligner(false) : null;
        final Wrap wrap = myWrappingProcessor.getChainedMethodCallWrap();
        addNestedChildren(myNode.getPsi(), subBlocks, dotsAligner, true, wrap);
        return subBlocks;
    }
    if (blockPsi instanceof GrListOrMap && ((GrListOrMap) blockPsi).isMap() && myContext.getGroovySettings().ALIGN_NAMED_ARGS_IN_MAP) {
        AlignmentProvider.Aligner labels = myAlignmentProvider.createAligner(false);
        AlignmentProvider.Aligner exprs = myAlignmentProvider.createAligner(true);
        GrNamedArgument[] namedArgs = ((GrListOrMap) blockPsi).getNamedArguments();
        for (GrNamedArgument arg : namedArgs) {
            GrArgumentLabel label = arg.getLabel();
            if (label != null)
                labels.append(label);
            PsiElement colon = arg.getColon();
            if (colon == null)
                colon = arg.getExpression();
            if (colon != null)
                exprs.append(colon);
        }
    }
    // For Parameter lists
    if (isListLikeClause(blockPsi)) {
        final ArrayList<Block> subBlocks = new ArrayList<>();
        List<ASTNode> astNodes = visibleChildren(myNode);
        if (mustAlign(blockPsi, astNodes)) {
            final AlignmentProvider.Aligner aligner = myAlignmentProvider.createAligner(false);
            for (ASTNode node : astNodes) {
                if (!isKeyword(node))
                    aligner.append(node.getPsi());
            }
        }
        for (ASTNode childNode : astNodes) {
            subBlocks.add(new GroovyBlock(childNode, getIndent(childNode), getChildWrap(childNode), myContext));
        }
        return subBlocks;
    }
    boolean classLevel = blockPsi instanceof GrTypeDefinitionBody;
    if (blockPsi instanceof GrClosableBlock && ((GrClosableBlock) blockPsi).getArrow() != null && ((GrClosableBlock) blockPsi).getParameters().length > 0 && !getClosureBodyVisibleChildren(myNode).isEmpty()) {
        GrClosableBlock closableBlock = (GrClosableBlock) blockPsi;
        ArrayList<Block> blocks = new ArrayList<>();
        PsiElement lbrace = closableBlock.getLBrace();
        if (lbrace != null) {
            ASTNode node = lbrace.getNode();
            blocks.add(new GroovyBlock(node, getIndent(node), Wrap.createWrap(WrapType.NONE, false), myContext));
        }
        /* {
        Indent indent = GroovyIndentProcessor.getChildIndent(myBlock, parameterListNode);
        GroovyBlock block = new GroovyBlock(parameterListNode, indent, myWrap, mySettings, myGroovySettings, myAlignmentProvider);
        blocks.add(block);
      }

      {
        PsiElement arrow = closableBlock.getArrow();
        ASTNode node = arrow.getNode();
        Indent indent = GroovyIndentProcessor.getChildIndent(myBlock, node);
        GroovyBlock block = new GroovyBlock(node, indent, myWrap, mySettings, myGroovySettings, myAlignmentProvider);
        blocks.add(block);
      }*/
        {
            Indent indent = Indent.getNormalIndent();
            ASTNode parameterListNode = closableBlock.getParameterList().getNode();
            ClosureBodyBlock bodyBlock = new ClosureBodyBlock(parameterListNode, indent, Wrap.createWrap(WrapType.NONE, false), myContext);
            blocks.add(bodyBlock);
        }
        PsiElement rbrace = closableBlock.getRBrace();
        if (rbrace != null) {
            ASTNode node = rbrace.getNode();
            blocks.add(new GroovyBlock(node, getIndent(node), Wrap.createWrap(WrapType.NONE, false), myContext));
        }
        return blocks;
    }
    if (blockPsi instanceof GrCodeBlock || blockPsi instanceof GroovyFile || classLevel) {
        return generateSubBlockForCodeBlocks(classLevel, visibleChildren(myNode), myContext.getGroovySettings().INDENT_LABEL_BLOCKS);
    }
    if (blockPsi instanceof GrMethod) {
        final ArrayList<Block> subBlocks = new ArrayList<>();
        for (ASTNode childNode : getGroovyChildren(myNode)) {
            if (childNode.getElementType() == GroovyTokenTypes.mLPAREN)
                continue;
            if (childNode.getElementType() == GroovyTokenTypes.mRPAREN)
                continue;
            if (childNode.getElementType() == GroovyElementTypes.PARAMETERS_LIST) {
                subBlocks.add(new ParameterListBlock(((GrMethod) blockPsi), Indent.getNoneIndent(), Wrap.createWrap(WrapType.NONE, false), myContext));
            } else if (canBeCorrectBlock(childNode)) {
                subBlocks.add(new GroovyBlock(childNode, getIndent(childNode), getChildWrap(childNode), myContext));
            }
        }
        return subBlocks;
    } else if (blockPsi instanceof GrTraditionalForClause) {
        if (myContext.getSettings().ALIGN_MULTILINE_FOR) {
            final GrTraditionalForClause clause = (GrTraditionalForClause) blockPsi;
            final AlignmentProvider.Aligner parenthesesAligner = myAlignmentProvider.createAligner(false);
            parenthesesAligner.append(clause.getInitialization());
            parenthesesAligner.append(clause.getCondition());
            parenthesesAligner.append(clause.getUpdate());
        }
    } else if (blockPsi instanceof GrBinaryExpression) {
        if (myContext.getSettings().ALIGN_MULTILINE_BINARY_OPERATION) {
            final GrBinaryExpression binary = (GrBinaryExpression) blockPsi;
            final GrExpression left = binary.getLeftOperand();
            final GrExpression right = binary.getRightOperand();
            if (left != null && right != null) {
                myAlignmentProvider.addPair(left, right, false);
            }
        }
    } else if (blockPsi instanceof GrAssignmentExpression) {
        if (myContext.getSettings().ALIGN_MULTILINE_ASSIGNMENT) {
            final GrAssignmentExpression assignment = (GrAssignmentExpression) blockPsi;
            final GrExpression lValue = assignment.getLValue();
            final GrExpression rValue = assignment.getRValue();
            if (lValue != null && rValue != null) {
                myAlignmentProvider.addPair(lValue, rValue, false);
            }
        }
    } else if (blockPsi instanceof GrConditionalExpression) {
        if (myContext.getSettings().ALIGN_MULTILINE_TERNARY_OPERATION) {
            final GrConditionalExpression conditional = (GrConditionalExpression) blockPsi;
            final AlignmentProvider.Aligner exprAligner = myAlignmentProvider.createAligner(false);
            exprAligner.append(conditional.getCondition());
            if (!(conditional instanceof GrElvisExpression)) {
                exprAligner.append(conditional.getThenBranch());
            }
            exprAligner.append(conditional.getElseBranch());
            ASTNode question = conditional.getNode().findChildByType(GroovyTokenTypes.mQUESTION);
            ASTNode colon = conditional.getNode().findChildByType(GroovyTokenTypes.mCOLON);
            if (question != null && colon != null) {
                AlignmentProvider.Aligner questionColonAligner = myAlignmentProvider.createAligner(false);
                questionColonAligner.append(question.getPsi());
                questionColonAligner.append(colon.getPsi());
            }
        }
    }
    // For other cases
    final ArrayList<Block> subBlocks = new ArrayList<>();
    for (ASTNode childNode : visibleChildren(myNode)) {
        subBlocks.add(new GroovyBlock(childNode, getIndent(childNode), getChildWrap(childNode), myContext));
    }
    return subBlocks;
}

Example 32 with GrNamedArgument

use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.

the class GroovyIntroduceParameterUtil method removeParamsFromUnresolvedCall.

public static void removeParamsFromUnresolvedCall(GrCall callExpression, PsiParameter[] parameters, TIntArrayList parametersToRemove) {
    final GrExpression[] arguments = callExpression.getExpressionArguments();
    final GrClosableBlock[] closureArguments = callExpression.getClosureArguments();
    final GrNamedArgument[] namedArguments = callExpression.getNamedArguments();
    final boolean hasNamedArgs;
    if (namedArguments.length > 0) {
        if (parameters.length > 0) {
            final PsiType type = parameters[0].getType();
            hasNamedArgs = InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP);
        } else {
            hasNamedArgs = false;
        }
    } else {
        hasNamedArgs = false;
    }
    parametersToRemove.forEachDescending(new TIntProcedure() {

        @Override
        public boolean execute(int paramNum) {
            try {
                if (paramNum == 0 && hasNamedArgs) {
                    for (GrNamedArgument namedArgument : namedArguments) {
                        namedArgument.delete();
                    }
                } else {
                    if (hasNamedArgs)
                        paramNum--;
                    if (paramNum < arguments.length) {
                        arguments[paramNum].delete();
                    } else if (paramNum < arguments.length + closureArguments.length) {
                        closureArguments[paramNum - arguments.length].delete();
                    }
                }
            } catch (IncorrectOperationException e) {
                LOG.error(e);
            }
            return true;
        }
    });
}

Example 33 with GrNamedArgument

use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.

the class GroovyIntroduceParameterMethodUsagesProcessor method removeParamsFromUnresolvedCall.

private static void removeParamsFromUnresolvedCall(GrCall callExpression, IntroduceParameterData data) {
    final GrExpression[] arguments = callExpression.getExpressionArguments();
    final GrClosableBlock[] closureArguments = callExpression.getClosureArguments();
    final GrNamedArgument[] namedArguments = callExpression.getNamedArguments();
    final boolean hasNamedArgs;
    if (namedArguments.length > 0) {
        final PsiMethod method = data.getMethodToSearchFor();
        final PsiParameter[] parameters = method.getParameterList().getParameters();
        if (parameters.length > 0) {
            final PsiType type = parameters[0].getType();
            hasNamedArgs = InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP);
        } else {
            hasNamedArgs = false;
        }
    } else {
        hasNamedArgs = false;
    }
    data.getParametersToRemove().forEachDescending(new TIntProcedure() {

        @Override
        public boolean execute(int paramNum) {
            try {
                if (paramNum == 0 && hasNamedArgs) {
                    for (GrNamedArgument namedArgument : namedArguments) {
                        namedArgument.delete();
                    }
                } else {
                    if (hasNamedArgs)
                        paramNum--;
                    if (paramNum < arguments.length) {
                        arguments[paramNum].delete();
                    } else if (paramNum < arguments.length + closureArguments.length) {
                        closureArguments[paramNum - arguments.length].delete();
                    }
                }
            } catch (IncorrectOperationException e) {
                LOG.error(e);
            }
            return true;
        }
    });
}

Example 34 with GrNamedArgument

use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.

the class ImportMavenRepositoriesTask method findMavenRemoteRepositories.

@NotNull
private Collection<? extends MavenRemoteRepository> findMavenRemoteRepositories(@Nullable GrClosableBlock repositoriesBlock) {
    Set<MavenRemoteRepository> myRemoteRepositories = ContainerUtil.newHashSet();
    for (GrMethodCall repo : PsiTreeUtil.getChildrenOfTypeAsList(repositoriesBlock, GrMethodCall.class)) {
        final String expressionText = repo.getInvokedExpression().getText();
        if ("mavenCentral".equals(expressionText)) {
            myRemoteRepositories.add(mavenCentralRemoteRepository);
        } else if ("mavenRepo".equals(expressionText)) {
            for (GrNamedArgument namedArgument : repo.getNamedArguments()) {
                if ("url".equals(namedArgument.getLabelName())) {
                    URI urlArgumentValue = resolveUriFromSimpleExpression(namedArgument.getExpression());
                    if (urlArgumentValue != null) {
                        String textUri = urlArgumentValue.toString();
                        myRemoteRepositories.add(new MavenRemoteRepository(textUri, null, textUri, null, null, null));
                    }
                    break;
                }
            }
        } else if ("maven".equals(expressionText) && repo.getClosureArguments().length > 0) {
            List<GrApplicationStatement> applicationStatementList = PsiTreeUtil.getChildrenOfTypeAsList(repo.getClosureArguments()[0], GrApplicationStatement.class);
            if (!applicationStatementList.isEmpty()) {
                GrApplicationStatement statement = applicationStatementList.get(0);
                if (statement == null)
                    continue;
                GrExpression expression = statement.getInvokedExpression();
                if ("url".equals(expression.getText())) {
                    URI urlArgumentValue = resolveUriFromSimpleExpression(statement.getExpressionArguments()[0]);
                    if (urlArgumentValue != null) {
                        String textUri = urlArgumentValue.toString();
                        myRemoteRepositories.add(new MavenRemoteRepository(textUri, null, textUri, null, null, null));
                    }
                }
            }
            List<GrAssignmentExpression> assignmentExpressionList = PsiTreeUtil.getChildrenOfTypeAsList(repo.getClosureArguments()[0], GrAssignmentExpression.class);
            if (!assignmentExpressionList.isEmpty()) {
                GrAssignmentExpression statement = assignmentExpressionList.get(0);
                if (statement == null)
                    continue;
                GrExpression expression = statement.getLValue();
                if ("url".equals(expression.getText())) {
                    URI urlArgumentValue = resolveUriFromSimpleExpression(statement.getRValue());
                    if (urlArgumentValue != null) {
                        String textUri = urlArgumentValue.toString();
                        myRemoteRepositories.add(new MavenRemoteRepository(textUri, null, textUri, null, null, null));
                    }
                }
            }
        }
    }
    return myRemoteRepositories;
}

Example 35 with GrNamedArgument

use of org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument in project intellij-community by JetBrains.

the class ExpressionGenerator method visitNewExpression.

@Override
public void visitNewExpression(@NotNull GrNewExpression newExpression) {
    boolean hasFieldInitialization = hasFieldInitialization(newExpression);
    StringBuilder builder;
    final PsiType type = newExpression.getType();
    final String varName;
    if (hasFieldInitialization) {
        builder = new StringBuilder();
        varName = GenerationUtil.suggestVarName(type, newExpression, context);
        TypeWriter.writeType(builder, type, newExpression);
        builder.append(' ').append(varName).append(" = ");
    } else {
        varName = null;
        builder = this.builder;
    }
    final GrTypeElement typeElement = newExpression.getTypeElement();
    final GrArrayDeclaration arrayDeclaration = newExpression.getArrayDeclaration();
    final GrCodeReferenceElement referenceElement = newExpression.getReferenceElement();
    builder.append("new ");
    if (typeElement != null) {
        final PsiType builtIn = typeElement.getType();
        LOG.assertTrue(builtIn instanceof PsiPrimitiveType);
        final PsiType boxed = TypesUtil.boxPrimitiveType(builtIn, newExpression.getManager(), newExpression.getResolveScope());
        TypeWriter.writeTypeForNew(builder, boxed, newExpression);
    } else if (referenceElement != null) {
        GenerationUtil.writeCodeReferenceElement(builder, referenceElement);
    }
    final GrArgumentList argList = newExpression.getArgumentList();
    if (argList != null) {
        GrClosureSignature signature = null;
        final GroovyResolveResult resolveResult = newExpression.advancedResolve();
        final PsiElement constructor = resolveResult.getElement();
        if (constructor instanceof PsiMethod) {
            signature = GrClosureSignatureUtil.createSignature((PsiMethod) constructor, resolveResult.getSubstitutor());
        } else if (referenceElement != null) {
            final GroovyResolveResult clazzResult = referenceElement.advancedResolve();
            final PsiElement clazz = clazzResult.getElement();
            if (clazz instanceof PsiClass && ((PsiClass) clazz).getConstructors().length == 0) {
                signature = GrClosureSignatureUtil.createSignature(PsiParameter.EMPTY_ARRAY, null);
            }
        }
        final GrNamedArgument[] namedArgs = hasFieldInitialization ? GrNamedArgument.EMPTY_ARRAY : argList.getNamedArguments();
        new ArgumentListGenerator(builder, context).generate(signature, argList.getExpressionArguments(), namedArgs, GrClosableBlock.EMPTY_ARRAY, newExpression);
    }
    final GrAnonymousClassDefinition anonymous = newExpression.getAnonymousClassDefinition();
    if (anonymous != null) {
        writeTypeBody(builder, anonymous);
    }
    if (arrayDeclaration != null) {
        final GrExpression[] boundExpressions = arrayDeclaration.getBoundExpressions();
        for (GrExpression boundExpression : boundExpressions) {
            builder.append('[');
            boundExpression.accept(this);
            builder.append(']');
        }
        if (boundExpressions.length == 0) {
            builder.append("[]");
        }
    }
    if (hasFieldInitialization) {
        builder.append(';');
        context.myStatements.add(builder.toString());
        final GrNamedArgument[] namedArguments = argList.getNamedArguments();
        for (GrNamedArgument namedArgument : namedArguments) {
            final String fieldName = namedArgument.getLabelName();
            if (fieldName == null) {
                //todo try to initialize field
                final GrArgumentLabel label = namedArgument.getLabel();
                LOG.info("cannot initialize field " + (label == null ? "<null>" : label.getText()));
            } else {
                final GroovyResolveResult resolveResult = referenceElement.advancedResolve();
                final PsiElement resolved = resolveResult.getElement();
                LOG.assertTrue(resolved instanceof PsiClass);
                initializeField(varName, type, ((PsiClass) resolved), resolveResult.getSubstitutor(), fieldName, namedArgument.getExpression());
            }
        }
    }
}