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

Example 81 with GrVariable

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

the class ReachingDefinitionsCollector method filterNonlocals.

private static VariableInfo[] filterNonlocals(Map<String, VariableInfo> infos, GrStatement place) {
    List<VariableInfo> result = new ArrayList<>();
    for (Iterator<VariableInfo> iterator = infos.values().iterator(); iterator.hasNext(); ) {
        VariableInfo info = iterator.next();
        String name = info.getName();
        GroovyPsiElement property = ResolveUtil.resolveProperty(place, name);
        if (property instanceof GrVariable) {
            iterator.remove();
        } else if (property instanceof GrReferenceExpression) {
            GrMember member = PsiTreeUtil.getParentOfType(property, GrMember.class);
            if (member == null) {
                continue;
            } else if (!member.hasModifierProperty(PsiModifier.STATIC)) {
                if (member.getContainingClass() instanceof GroovyScriptClass) {
                    //binding variable
                    continue;
                }
            }
        }
        if (ResolveUtil.resolveClass(place, name) == null) {
            result.add(info);
        }
    }
    return result.toArray(new VariableInfo[result.size()]);
}

Example 82 with GrVariable

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

the class GrCharConverter method isConvertibleEx.

@Nullable
@Override
public ConversionResult isConvertibleEx(@NotNull PsiType lType, @NotNull PsiType rType, @NotNull GroovyPsiElement context, @NotNull ApplicableTo currentPosition) {
    if (!PsiType.CHAR.equals(TypesUtil.unboxPrimitiveTypeWrapper(lType)))
        return null;
    if (PsiType.CHAR.equals(TypesUtil.unboxPrimitiveTypeWrapper(rType)))
        return ConversionResult.OK;
    // can assign numeric types to char
    if (TypesUtil.isNumericType(rType)) {
        if (rType instanceof PsiPrimitiveType || TypesUtil.unboxPrimitiveTypeWrapper(rType) instanceof PsiPrimitiveType) {
            return PsiType.CHAR.equals(lType) ? ConversionResult.OK : ConversionResult.ERROR;
        } else {
            // BigDecimal && BigInteger
            return ConversionResult.ERROR;
        }
    }
    {
        // special case 'c = []' will throw RuntimeError
        final GrExpression rValue;
        if (context instanceof GrAssignmentExpression) {
            final GrAssignmentExpression assignmentExpression = (GrAssignmentExpression) context;
            rValue = assignmentExpression.getRValue();
        } else if (context instanceof GrVariable) {
            final GrVariable assignmentExpression = (GrVariable) context;
            rValue = assignmentExpression.getInitializerGroovy();
        } else {
            rValue = null;
        }
        if (rValue instanceof GrListOrMap && ((GrListOrMap) rValue).isEmpty()) {
            return ConversionResult.WARNING;
        }
    }
    if (PsiType.BOOLEAN.equals(TypesUtil.unboxPrimitiveTypeWrapper(rType))) {
        switch(currentPosition) {
            case ASSIGNMENT:
            case RETURN_VALUE:
                return ConversionResult.WARNING;
            default:
                return null;
        }
    }
    // one-symbol string-to-char conversion doesn't work with return value
    if (currentPosition == ApplicableTo.RETURN_VALUE) {
        return null;
    }
    // can cast and assign one-symbol strings to char
    if (!TypesUtil.isClassType(rType, CommonClassNames.JAVA_LANG_STRING))
        return null;
    return checkSingleSymbolLiteral(context) ? ConversionResult.OK : ConversionResult.ERROR;
}

Example 83 with GrVariable

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

the class GrMainCompletionProvider method suggestVariableNames.

private static void suggestVariableNames(PsiElement context, CompletionResultSet result) {
    final PsiElement parent = context.getParent();
    if (GroovyCompletionUtil.isWildcardCompletion(context))
        return;
    if (parent instanceof GrVariable) {
        final GrVariable variable = (GrVariable) parent;
        if (context.equals(variable.getNameIdentifierGroovy())) {
            final PsiType type = variable.getTypeGroovy();
            if (type != null) {
                final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(context.getProject());
                VariableKind kind = variable instanceof GrParameter ? VariableKind.PARAMETER : variable instanceof GrField ? VariableKind.FIELD : VariableKind.LOCAL_VARIABLE;
                SuggestedNameInfo suggestedNameInfo = codeStyleManager.suggestVariableName(kind, null, null, type);
                String[] names = suggestedNameInfo.names;
                if (names.length > 0) {
                    String name = names[0];
                    String newName = InlineMethodConflictSolver.suggestNewName(name, null, parent);
                    if (!name.equals(newName)) {
                        result.addElement(LookupElementBuilder.create(newName));
                        return;
                    }
                }
                for (String name : names) {
                    result.addElement(LookupElementBuilder.create(name));
                }
            }
            GrExpression initializer = variable.getInitializerGroovy();
            if (initializer != null) {
                for (String name : GroovyNameSuggestionUtil.suggestVariableNames(initializer, new DefaultGroovyVariableNameValidator(variable), variable.hasModifierProperty(PsiModifier.STATIC))) {
                    result.addElement(LookupElementBuilder.create(name));
                }
            }
        }
    }
}

Example 84 with GrVariable

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

the class GroovySmartCompletionContributor method addExpectedType.

@Nullable
private static LookupElement addExpectedType(PsiType type, final PsiElement place, CompletionParameters parameters, @Nullable PsiType diamond) {
    if (!JavaCompletionUtil.hasAccessibleConstructor(type))
        return null;
    final PsiClass psiClass = com.intellij.psi.util.PsiUtil.resolveClassInType(type);
    if (psiClass == null)
        return null;
    if (!checkForInnerClass(psiClass, place))
        return null;
    boolean isDiamond = false;
    if (diamond != null && psiClass.hasTypeParameters() && !((PsiClassType) type).isRaw() && !psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
        final String canonicalText = TypeConversionUtil.erasure(type).getCanonicalText();
        final GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(place.getProject());
        final String text = diamond.getCanonicalText() + " v = new " + canonicalText + "<>()";
        final GrStatement statement = elementFactory.createStatementFromText(text, parameters.getOriginalFile());
        final GrVariable declaredVar = ((GrVariableDeclaration) statement).getVariables()[0];
        final GrNewExpression initializer = (GrNewExpression) declaredVar.getInitializerGroovy();
        assert initializer != null;
        final boolean hasDefaultConstructorOrNoGenericsOne = PsiDiamondTypeImpl.hasDefaultConstructor(psiClass) || !PsiDiamondTypeImpl.haveConstructorsGenericsParameters(psiClass);
        final PsiType initializerType = initializer.getType();
        if (hasDefaultConstructorOrNoGenericsOne && initializerType != null && initializerType instanceof PsiClassType && ((PsiClassType) initializerType).getParameters().length > 0) {
            type = initializerType;
            isDiamond = true;
        }
    }
    final PsiTypeLookupItem item = PsiTypeLookupItem.createLookupItem(GenericsUtil.eliminateWildcards(type), place, isDiamond, ChooseTypeExpression.IMPORT_FIXER).setShowPackage();
    Object object = item.getObject();
    if (object instanceof PsiClass && ((PsiClass) object).hasModifierProperty(PsiModifier.ABSTRACT)) {
        item.setIndicateAnonymous(true);
    }
    item.setInsertHandler(new AfterNewClassInsertHandler((PsiClassType) type, true));
    return item;
}

Example 85 with GrVariable

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

the class GroovyDocumentationProvider method getQuickNavigateInfo.

@Override
@Nullable
public String getQuickNavigateInfo(PsiElement element, PsiElement originalElement) {
    if (element instanceof GrVariable || element instanceof GrImplicitVariable) {
        StringBuilder buffer = new StringBuilder();
        PsiVariable variable = (PsiVariable) element;
        if (originalElement instanceof GrVariableDeclaration && ((GrVariableDeclaration) originalElement).getVariables().length > 1) {
            for (GrVariable var : ((GrVariableDeclaration) originalElement).getVariables()) {
                generateVariableInfo(originalElement, buffer, var);
                buffer.append("\n\n");
            }
        } else {
            generateVariableInfo(originalElement, buffer, variable);
        }
        return buffer.toString();
    } else if (element instanceof PsiMethod) {
        StringBuilder buffer = new StringBuilder();
        PsiMethod method = (PsiMethod) element;
        if (method instanceof GrGdkMethod) {
            buffer.append("[GDK] ");
        } else {
            PsiClass hisClass = method.getContainingClass();
            if (hisClass != null) {
                String qName = hisClass.getQualifiedName();
                if (qName != null) {
                    buffer.append(qName).append("\n");
                }
            }
        }
        PsiSubstitutor substitutor = calcSubstitutor(originalElement);
        if (!method.isConstructor()) {
            final PsiType substituted = substitutor.substitute(PsiUtil.getSmartReturnType(method));
            PsiImplUtil.appendTypeString(buffer, substituted, originalElement);
            buffer.append(" ");
        }
        buffer.append(method.getName()).append(" ");
        buffer.append("(");
        PsiParameter[] parameters = method.getParameterList().getParameters();
        for (int i = 0; i < parameters.length; i++) {
            PsiParameter parameter = parameters[i];
            if (i > 0)
                buffer.append(", ");
            if (parameter instanceof GrParameter) {
                GroovyPresentationUtil.appendParameterPresentation((GrParameter) parameter, substitutor, TypePresentation.LINK, buffer);
            } else {
                PsiType type = parameter.getType();
                PsiImplUtil.appendTypeString(buffer, substitutor.substitute(type), originalElement);
                buffer.append(" ");
                buffer.append(parameter.getName());
            }
        }
        buffer.append(")");
        final PsiClassType[] referencedTypes = method.getThrowsList().getReferencedTypes();
        if (referencedTypes.length > 0) {
            buffer.append("\nthrows ");
            for (PsiClassType referencedType : referencedTypes) {
                PsiImplUtil.appendTypeString(buffer, referencedType, originalElement);
                buffer.append(", ");
            }
            buffer.delete(buffer.length() - 2, buffer.length());
        }
        return buffer.toString();
    } else if (element instanceof GrTypeDefinition) {
        return generateClassInfo((GrTypeDefinition) element);
    }
    return null;
}