Search in sources :

Example 1 with PsiTypeCastExpression

use of com.intellij.psi.PsiTypeCastExpression in project kotlin by JetBrains.

the class ConstantEvaluator method isArrayLiteral.

/**
     * Returns true if the node is pointing to a an array literal
     */
public static boolean isArrayLiteral(@Nullable PsiElement node) {
    if (node instanceof PsiReference) {
        PsiElement resolved = ((PsiReference) node).resolve();
        if (resolved instanceof PsiField) {
            PsiField field = (PsiField) resolved;
            if (field.getInitializer() != null) {
                return isArrayLiteral(field.getInitializer());
            }
        } else if (resolved instanceof PsiLocalVariable) {
            PsiLocalVariable variable = (PsiLocalVariable) resolved;
            PsiStatement statement = PsiTreeUtil.getParentOfType(node, PsiStatement.class, false);
            if (statement != null) {
                PsiStatement prev = PsiTreeUtil.getPrevSiblingOfType(statement, PsiStatement.class);
                String targetName = variable.getName();
                if (targetName == null) {
                    return false;
                }
                while (prev != null) {
                    if (prev instanceof PsiDeclarationStatement) {
                        for (PsiElement element : ((PsiDeclarationStatement) prev).getDeclaredElements()) {
                            if (variable.equals(element)) {
                                return isArrayLiteral(variable.getInitializer());
                            }
                        }
                    } else if (prev instanceof PsiExpressionStatement) {
                        PsiExpression expression = ((PsiExpressionStatement) prev).getExpression();
                        if (expression instanceof PsiAssignmentExpression) {
                            PsiAssignmentExpression assign = (PsiAssignmentExpression) expression;
                            PsiExpression lhs = assign.getLExpression();
                            if (lhs instanceof PsiReferenceExpression) {
                                PsiReferenceExpression reference = (PsiReferenceExpression) lhs;
                                if (targetName.equals(reference.getReferenceName()) && reference.getQualifier() == null) {
                                    return isArrayLiteral(assign.getRExpression());
                                }
                            }
                        }
                    }
                    prev = PsiTreeUtil.getPrevSiblingOfType(prev, PsiStatement.class);
                }
            }
        }
    } else if (node instanceof PsiNewExpression) {
        PsiNewExpression creation = (PsiNewExpression) node;
        if (creation.getArrayInitializer() != null) {
            return true;
        }
        PsiType type = creation.getType();
        if (type instanceof PsiArrayType) {
            return true;
        }
    } else if (node instanceof PsiParenthesizedExpression) {
        PsiParenthesizedExpression parenthesizedExpression = (PsiParenthesizedExpression) node;
        PsiExpression expression = parenthesizedExpression.getExpression();
        if (expression != null) {
            return isArrayLiteral(expression);
        }
    } else if (node instanceof PsiTypeCastExpression) {
        PsiTypeCastExpression castExpression = (PsiTypeCastExpression) node;
        PsiExpression operand = castExpression.getOperand();
        if (operand != null) {
            return isArrayLiteral(operand);
        }
    }
    return false;
}
Also used : PsiStatement(com.intellij.psi.PsiStatement) PsiDeclarationStatement(com.intellij.psi.PsiDeclarationStatement) PsiExpression(com.intellij.psi.PsiExpression) PsiReferenceExpression(com.intellij.psi.PsiReferenceExpression) PsiReference(com.intellij.psi.PsiReference) PsiAssignmentExpression(com.intellij.psi.PsiAssignmentExpression) PsiLocalVariable(com.intellij.psi.PsiLocalVariable) PsiNewExpression(com.intellij.psi.PsiNewExpression) PsiArrayType(com.intellij.psi.PsiArrayType) PsiTypeCastExpression(com.intellij.psi.PsiTypeCastExpression) PsiExpressionStatement(com.intellij.psi.PsiExpressionStatement) PsiField(com.intellij.psi.PsiField) PsiParenthesizedExpression(com.intellij.psi.PsiParenthesizedExpression) PsiElement(com.intellij.psi.PsiElement) PsiType(com.intellij.psi.PsiType)

Example 2 with PsiTypeCastExpression

use of com.intellij.psi.PsiTypeCastExpression in project intellij-community by JetBrains.

the class TypeCookProcessor method findUsages.

@NotNull
protected UsageInfo[] findUsages() {
    final SystemBuilder systemBuilder = new SystemBuilder(myProject, mySettings);
    final ReductionSystem commonSystem = systemBuilder.build(myElements);
    myResult = new Result(commonSystem);
    final ReductionSystem[] systems = commonSystem.isolate();
    for (final ReductionSystem system : systems) {
        if (system != null) {
            final ResolverTree tree = new ResolverTree(system);
            tree.resolve();
            final Binding solution = tree.getBestSolution();
            if (solution != null) {
                myResult.incorporateSolution(solution);
            }
        }
    }
    final Set<PsiElement> changedItems = myResult.getCookedElements();
    final UsageInfo[] usages = new UsageInfo[changedItems.size()];
    int i = 0;
    for (final PsiElement element : changedItems) {
        if (!(element instanceof PsiTypeCastExpression)) {
            usages[i++] = new UsageInfo(element) {

                public String getTooltipText() {
                    return myResult.getCookedType(element).getCanonicalText();
                }
            };
        } else {
            usages[i++] = new UsageInfo(element);
        }
    }
    return usages;
}
Also used : ReductionSystem(com.intellij.refactoring.typeCook.deductive.builder.ReductionSystem) Binding(com.intellij.refactoring.typeCook.deductive.resolver.Binding) PsiTypeCastExpression(com.intellij.psi.PsiTypeCastExpression) Result(com.intellij.refactoring.typeCook.deductive.builder.Result) ResolverTree(com.intellij.refactoring.typeCook.deductive.resolver.ResolverTree) SystemBuilder(com.intellij.refactoring.typeCook.deductive.builder.SystemBuilder) PsiElement(com.intellij.psi.PsiElement) UsageInfo(com.intellij.usageView.UsageInfo) NotNull(org.jetbrains.annotations.NotNull)

Example 3 with PsiTypeCastExpression

use of com.intellij.psi.PsiTypeCastExpression in project intellij-community by JetBrains.

the class FunctionalInterfaceTest method testIntersectionTypeWithSameBaseInterfaceInConjuncts.

public void testIntersectionTypeWithSameBaseInterfaceInConjuncts() throws Exception {
    String filePath = BASE_PATH + "/" + getTestName(false) + ".java";
    configureByFile(filePath);
    final PsiTypeCastExpression castExpression = PsiTreeUtil.getParentOfType(getFile().findElementAt(getEditor().getCaretModel().getOffset()), PsiTypeCastExpression.class);
    assertNotNull(castExpression);
    final PsiTypeElement castTypeElement = castExpression.getCastType();
    assertNotNull(castTypeElement);
    final PsiType type = castTypeElement.getType();
    final String errorMessage = LambdaHighlightingUtil.checkInterfaceFunctional(type);
    assertEquals(null, errorMessage);
}
Also used : PsiTypeElement(com.intellij.psi.PsiTypeElement) PsiTypeCastExpression(com.intellij.psi.PsiTypeCastExpression) PsiType(com.intellij.psi.PsiType)

Example 4 with PsiTypeCastExpression

use of com.intellij.psi.PsiTypeCastExpression in project intellij-community by JetBrains.

the class TypeCastSelectioner method select.

@Override
public List<TextRange> select(PsiElement e, CharSequence editorText, int cursorOffset, Editor editor) {
    List<TextRange> result = new ArrayList<>();
    result.addAll(expandToWholeLine(editorText, e.getTextRange(), false));
    PsiTypeCastExpression expression = (PsiTypeCastExpression) e;
    PsiElement[] children = expression.getChildren();
    PsiElement lParen = null;
    PsiElement rParen = null;
    for (PsiElement child : children) {
        if (child instanceof PsiJavaToken) {
            PsiJavaToken token = (PsiJavaToken) child;
            if (token.getTokenType() == JavaTokenType.LPARENTH)
                lParen = token;
            if (token.getTokenType() == JavaTokenType.RPARENTH)
                rParen = token;
        }
    }
    if (lParen != null && rParen != null) {
        result.addAll(expandToWholeLine(editorText, new TextRange(lParen.getTextRange().getStartOffset(), rParen.getTextRange().getEndOffset()), false));
    }
    return result;
}
Also used : PsiJavaToken(com.intellij.psi.PsiJavaToken) ArrayList(java.util.ArrayList) TextRange(com.intellij.openapi.util.TextRange) PsiTypeCastExpression(com.intellij.psi.PsiTypeCastExpression) PsiElement(com.intellij.psi.PsiElement)

Example 5 with PsiTypeCastExpression

use of com.intellij.psi.PsiTypeCastExpression in project kotlin by JetBrains.

the class ConstantEvaluator method evaluate.

/**
     * Evaluates the given node and returns the constant value it resolves to, if any
     *
     * @param node the node to compute the constant value for
     * @return the corresponding constant value - a String, an Integer, a Float, and so on
     */
@Nullable
public Object evaluate(@Nullable PsiElement node) {
    if (node == null) {
        return null;
    }
    if (node instanceof PsiLiteral) {
        return ((PsiLiteral) node).getValue();
    } else if (node instanceof PsiPrefixExpression) {
        IElementType operator = ((PsiPrefixExpression) node).getOperationTokenType();
        Object operand = evaluate(((PsiPrefixExpression) node).getOperand());
        if (operand == null) {
            return null;
        }
        if (operator == JavaTokenType.EXCL) {
            if (operand instanceof Boolean) {
                return !(Boolean) operand;
            }
        } else if (operator == JavaTokenType.PLUS) {
            return operand;
        } else if (operator == JavaTokenType.TILDE) {
            if (operand instanceof Integer) {
                return ~(Integer) operand;
            } else if (operand instanceof Long) {
                return ~(Long) operand;
            } else if (operand instanceof Short) {
                return ~(Short) operand;
            } else if (operand instanceof Character) {
                return ~(Character) operand;
            } else if (operand instanceof Byte) {
                return ~(Byte) operand;
            }
        } else if (operator == JavaTokenType.MINUS) {
            if (operand instanceof Integer) {
                return -(Integer) operand;
            } else if (operand instanceof Long) {
                return -(Long) operand;
            } else if (operand instanceof Double) {
                return -(Double) operand;
            } else if (operand instanceof Float) {
                return -(Float) operand;
            } else if (operand instanceof Short) {
                return -(Short) operand;
            } else if (operand instanceof Character) {
                return -(Character) operand;
            } else if (operand instanceof Byte) {
                return -(Byte) operand;
            }
        }
    } else if (node instanceof PsiConditionalExpression) {
        PsiConditionalExpression expression = (PsiConditionalExpression) node;
        Object known = evaluate(expression.getCondition());
        if (known == Boolean.TRUE && expression.getThenExpression() != null) {
            return evaluate(expression.getThenExpression());
        } else if (known == Boolean.FALSE && expression.getElseExpression() != null) {
            return evaluate(expression.getElseExpression());
        }
    } else if (node instanceof PsiParenthesizedExpression) {
        PsiParenthesizedExpression parenthesizedExpression = (PsiParenthesizedExpression) node;
        PsiExpression expression = parenthesizedExpression.getExpression();
        if (expression != null) {
            return evaluate(expression);
        }
    } else if (node instanceof PsiBinaryExpression) {
        IElementType operator = ((PsiBinaryExpression) node).getOperationTokenType();
        Object operandLeft = evaluate(((PsiBinaryExpression) node).getLOperand());
        Object operandRight = evaluate(((PsiBinaryExpression) node).getROperand());
        if (operandLeft == null || operandRight == null) {
            if (mAllowUnknown) {
                if (operandLeft == null) {
                    return operandRight;
                } else {
                    return operandLeft;
                }
            }
            return null;
        }
        if (operandLeft instanceof String && operandRight instanceof String) {
            if (operator == JavaTokenType.PLUS) {
                return operandLeft.toString() + operandRight.toString();
            }
            return null;
        } else if (operandLeft instanceof Boolean && operandRight instanceof Boolean) {
            boolean left = (Boolean) operandLeft;
            boolean right = (Boolean) operandRight;
            if (operator == JavaTokenType.OROR) {
                return left || right;
            } else if (operator == JavaTokenType.ANDAND) {
                return left && right;
            } else if (operator == JavaTokenType.OR) {
                return left | right;
            } else if (operator == JavaTokenType.XOR) {
                return left ^ right;
            } else if (operator == JavaTokenType.AND) {
                return left & right;
            } else if (operator == JavaTokenType.EQEQ) {
                return left == right;
            } else if (operator == JavaTokenType.NE) {
                return left != right;
            }
        } else if (operandLeft instanceof Number && operandRight instanceof Number) {
            Number left = (Number) operandLeft;
            Number right = (Number) operandRight;
            boolean isInteger = !(left instanceof Float || left instanceof Double || right instanceof Float || right instanceof Double);
            boolean isWide = isInteger ? (left instanceof Long || right instanceof Long) : (left instanceof Double || right instanceof Double);
            if (operator == JavaTokenType.OR) {
                if (isWide) {
                    return left.longValue() | right.longValue();
                } else {
                    return left.intValue() | right.intValue();
                }
            } else if (operator == JavaTokenType.XOR) {
                if (isWide) {
                    return left.longValue() ^ right.longValue();
                } else {
                    return left.intValue() ^ right.intValue();
                }
            } else if (operator == JavaTokenType.AND) {
                if (isWide) {
                    return left.longValue() & right.longValue();
                } else {
                    return left.intValue() & right.intValue();
                }
            } else if (operator == JavaTokenType.EQEQ) {
                if (isInteger) {
                    return left.longValue() == right.longValue();
                } else {
                    return left.doubleValue() == right.doubleValue();
                }
            } else if (operator == JavaTokenType.NE) {
                if (isInteger) {
                    return left.longValue() != right.longValue();
                } else {
                    return left.doubleValue() != right.doubleValue();
                }
            } else if (operator == JavaTokenType.GT) {
                if (isInteger) {
                    return left.longValue() > right.longValue();
                } else {
                    return left.doubleValue() > right.doubleValue();
                }
            } else if (operator == JavaTokenType.GE) {
                if (isInteger) {
                    return left.longValue() >= right.longValue();
                } else {
                    return left.doubleValue() >= right.doubleValue();
                }
            } else if (operator == JavaTokenType.LT) {
                if (isInteger) {
                    return left.longValue() < right.longValue();
                } else {
                    return left.doubleValue() < right.doubleValue();
                }
            } else if (operator == JavaTokenType.LE) {
                if (isInteger) {
                    return left.longValue() <= right.longValue();
                } else {
                    return left.doubleValue() <= right.doubleValue();
                }
            } else if (operator == JavaTokenType.LTLT) {
                if (isWide) {
                    return left.longValue() << right.intValue();
                } else {
                    return left.intValue() << right.intValue();
                }
            } else if (operator == JavaTokenType.GTGT) {
                if (isWide) {
                    return left.longValue() >> right.intValue();
                } else {
                    return left.intValue() >> right.intValue();
                }
            } else if (operator == JavaTokenType.GTGTGT) {
                if (isWide) {
                    return left.longValue() >>> right.intValue();
                } else {
                    return left.intValue() >>> right.intValue();
                }
            } else if (operator == JavaTokenType.PLUS) {
                if (isInteger) {
                    if (isWide) {
                        return left.longValue() + right.longValue();
                    } else {
                        return left.intValue() + right.intValue();
                    }
                } else {
                    if (isWide) {
                        return left.doubleValue() + right.doubleValue();
                    } else {
                        return left.floatValue() + right.floatValue();
                    }
                }
            } else if (operator == JavaTokenType.MINUS) {
                if (isInteger) {
                    if (isWide) {
                        return left.longValue() - right.longValue();
                    } else {
                        return left.intValue() - right.intValue();
                    }
                } else {
                    if (isWide) {
                        return left.doubleValue() - right.doubleValue();
                    } else {
                        return left.floatValue() - right.floatValue();
                    }
                }
            } else if (operator == JavaTokenType.ASTERISK) {
                if (isInteger) {
                    if (isWide) {
                        return left.longValue() * right.longValue();
                    } else {
                        return left.intValue() * right.intValue();
                    }
                } else {
                    if (isWide) {
                        return left.doubleValue() * right.doubleValue();
                    } else {
                        return left.floatValue() * right.floatValue();
                    }
                }
            } else if (operator == JavaTokenType.DIV) {
                if (isInteger) {
                    if (isWide) {
                        return left.longValue() / right.longValue();
                    } else {
                        return left.intValue() / right.intValue();
                    }
                } else {
                    if (isWide) {
                        return left.doubleValue() / right.doubleValue();
                    } else {
                        return left.floatValue() / right.floatValue();
                    }
                }
            } else if (operator == JavaTokenType.PERC) {
                if (isInteger) {
                    if (isWide) {
                        return left.longValue() % right.longValue();
                    } else {
                        return left.intValue() % right.intValue();
                    }
                } else {
                    if (isWide) {
                        return left.doubleValue() % right.doubleValue();
                    } else {
                        return left.floatValue() % right.floatValue();
                    }
                }
            } else {
                return null;
            }
        }
    } else if (node instanceof PsiTypeCastExpression) {
        PsiTypeCastExpression cast = (PsiTypeCastExpression) node;
        Object operandValue = evaluate(cast.getOperand());
        if (operandValue instanceof Number) {
            Number number = (Number) operandValue;
            PsiTypeElement typeElement = cast.getCastType();
            if (typeElement != null) {
                PsiType type = typeElement.getType();
                if (PsiType.FLOAT.equals(type)) {
                    return number.floatValue();
                } else if (PsiType.DOUBLE.equals(type)) {
                    return number.doubleValue();
                } else if (PsiType.INT.equals(type)) {
                    return number.intValue();
                } else if (PsiType.LONG.equals(type)) {
                    return number.longValue();
                } else if (PsiType.SHORT.equals(type)) {
                    return number.shortValue();
                } else if (PsiType.BYTE.equals(type)) {
                    return number.byteValue();
                }
            }
        }
        return operandValue;
    } else if (node instanceof PsiReference) {
        PsiElement resolved = ((PsiReference) node).resolve();
        if (resolved instanceof PsiField) {
            PsiField field = (PsiField) resolved;
            Object value = field.computeConstantValue();
            if (value != null) {
                return value;
            }
            if (field.getInitializer() != null) {
                return evaluate(field.getInitializer());
            }
            return null;
        } else if (resolved instanceof PsiLocalVariable) {
            PsiLocalVariable variable = (PsiLocalVariable) resolved;
            PsiStatement statement = PsiTreeUtil.getParentOfType(node, PsiStatement.class, false);
            if (statement != null) {
                PsiStatement prev = PsiTreeUtil.getPrevSiblingOfType(statement, PsiStatement.class);
                String targetName = variable.getName();
                if (targetName == null) {
                    return null;
                }
                while (prev != null) {
                    if (prev instanceof PsiDeclarationStatement) {
                        for (PsiElement element : ((PsiDeclarationStatement) prev).getDeclaredElements()) {
                            if (variable.equals(element)) {
                                return evaluate(variable.getInitializer());
                            }
                        }
                    } else if (prev instanceof PsiExpressionStatement) {
                        PsiExpression expression = ((PsiExpressionStatement) prev).getExpression();
                        if (expression instanceof PsiAssignmentExpression) {
                            PsiAssignmentExpression assign = (PsiAssignmentExpression) expression;
                            PsiExpression lhs = assign.getLExpression();
                            if (lhs instanceof PsiReferenceExpression) {
                                PsiReferenceExpression reference = (PsiReferenceExpression) lhs;
                                if (targetName.equals(reference.getReferenceName()) && reference.getQualifier() == null) {
                                    return evaluate(assign.getRExpression());
                                }
                            }
                        }
                    }
                    prev = PsiTreeUtil.getPrevSiblingOfType(prev, PsiStatement.class);
                }
            }
        }
    } else if (node instanceof PsiNewExpression) {
        PsiNewExpression creation = (PsiNewExpression) node;
        PsiArrayInitializerExpression initializer = creation.getArrayInitializer();
        PsiType type = creation.getType();
        if (type instanceof PsiArrayType) {
            if (initializer != null) {
                PsiExpression[] initializers = initializer.getInitializers();
                Class<?> commonType = null;
                List<Object> values = Lists.newArrayListWithExpectedSize(initializers.length);
                int count = 0;
                for (PsiExpression expression : initializers) {
                    Object value = evaluate(expression);
                    if (value != null) {
                        values.add(value);
                        if (commonType == null) {
                            commonType = value.getClass();
                        } else {
                            while (!commonType.isAssignableFrom(value.getClass())) {
                                commonType = commonType.getSuperclass();
                            }
                        }
                    } else if (!mAllowUnknown) {
                        // Inconclusive
                        return null;
                    }
                    count++;
                    if (count == 20) {
                        // avoid large initializers
                        break;
                    }
                }
                type = type.getDeepComponentType();
                if (type == PsiType.INT) {
                    if (!values.isEmpty()) {
                        int[] array = new int[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Integer) {
                                array[i] = (Integer) o;
                            }
                        }
                        return array;
                    }
                    return new int[0];
                } else if (type == PsiType.BOOLEAN) {
                    if (!values.isEmpty()) {
                        boolean[] array = new boolean[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Boolean) {
                                array[i] = (Boolean) o;
                            }
                        }
                        return array;
                    }
                    return new boolean[0];
                } else if (type == PsiType.DOUBLE) {
                    if (!values.isEmpty()) {
                        double[] array = new double[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Double) {
                                array[i] = (Double) o;
                            }
                        }
                        return array;
                    }
                    return new double[0];
                } else if (type == PsiType.LONG) {
                    if (!values.isEmpty()) {
                        long[] array = new long[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Long) {
                                array[i] = (Long) o;
                            }
                        }
                        return array;
                    }
                    return new long[0];
                } else if (type == PsiType.FLOAT) {
                    if (!values.isEmpty()) {
                        float[] array = new float[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Float) {
                                array[i] = (Float) o;
                            }
                        }
                        return array;
                    }
                    return new float[0];
                } else if (type == PsiType.CHAR) {
                    if (!values.isEmpty()) {
                        char[] array = new char[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Character) {
                                array[i] = (Character) o;
                            }
                        }
                        return array;
                    }
                    return new char[0];
                } else if (type == PsiType.BYTE) {
                    if (!values.isEmpty()) {
                        byte[] array = new byte[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Byte) {
                                array[i] = (Byte) o;
                            }
                        }
                        return array;
                    }
                    return new byte[0];
                } else if (type == PsiType.SHORT) {
                    if (!values.isEmpty()) {
                        short[] array = new short[values.size()];
                        for (int i = 0; i < values.size(); i++) {
                            Object o = values.get(i);
                            if (o instanceof Short) {
                                array[i] = (Short) o;
                            }
                        }
                        return array;
                    }
                    return new short[0];
                } else {
                    if (!values.isEmpty()) {
                        Object o = Array.newInstance(commonType, values.size());
                        return values.toArray((Object[]) o);
                    }
                    return null;
                }
            } else {
                // something like "new byte[3]" but with no initializer.
                // Look up the size and only if small, use it. E.g. if it was byte[3]
                // we return a byte[3] array, but if it's say byte[1024*1024] we don't
                // want to do that.
                PsiExpression[] arrayDimensions = creation.getArrayDimensions();
                int size = 0;
                if (arrayDimensions.length == 1) {
                    Object fixedSize = evaluate(arrayDimensions[0]);
                    if (fixedSize instanceof Number) {
                        size = ((Number) fixedSize).intValue();
                        if (size > 30) {
                            size = 30;
                        }
                    }
                }
                type = type.getDeepComponentType();
                if (type instanceof PsiPrimitiveType) {
                    if (PsiType.BYTE.equals(type)) {
                        return new byte[size];
                    }
                    if (PsiType.BOOLEAN.equals(type)) {
                        return new boolean[size];
                    }
                    if (PsiType.INT.equals(type)) {
                        return new int[size];
                    }
                    if (PsiType.LONG.equals(type)) {
                        return new long[size];
                    }
                    if (PsiType.CHAR.equals(type)) {
                        return new char[size];
                    }
                    if (PsiType.FLOAT.equals(type)) {
                        return new float[size];
                    }
                    if (PsiType.DOUBLE.equals(type)) {
                        return new double[size];
                    }
                    if (PsiType.SHORT.equals(type)) {
                        return new short[size];
                    }
                } else if (type instanceof PsiClassType) {
                    String className = type.getCanonicalText();
                    if (TYPE_STRING.equals(className)) {
                        //noinspection SSBasedInspection
                        return new String[size];
                    }
                    if (TYPE_OBJECT.equals(className)) {
                        //noinspection SSBasedInspection
                        return new Object[size];
                    }
                }
            }
        }
    }
    return null;
}
Also used : PsiPrefixExpression(com.intellij.psi.PsiPrefixExpression) PsiExpression(com.intellij.psi.PsiExpression) PsiReferenceExpression(com.intellij.psi.PsiReferenceExpression) PsiAssignmentExpression(com.intellij.psi.PsiAssignmentExpression) PsiLiteral(com.intellij.psi.PsiLiteral) PsiLocalVariable(com.intellij.psi.PsiLocalVariable) PsiArrayInitializerExpression(com.intellij.psi.PsiArrayInitializerExpression) PsiTypeCastExpression(com.intellij.psi.PsiTypeCastExpression) PsiArrayType(com.intellij.psi.PsiArrayType) PsiParenthesizedExpression(com.intellij.psi.PsiParenthesizedExpression) List(java.util.List) ArrayList(java.util.ArrayList) PsiElement(com.intellij.psi.PsiElement) PsiType(com.intellij.psi.PsiType) PsiStatement(com.intellij.psi.PsiStatement) PsiDeclarationStatement(com.intellij.psi.PsiDeclarationStatement) PsiPrimitiveType(com.intellij.psi.PsiPrimitiveType) PsiReference(com.intellij.psi.PsiReference) PsiNewExpression(com.intellij.psi.PsiNewExpression) PsiConditionalExpression(com.intellij.psi.PsiConditionalExpression) IElementType(com.intellij.psi.tree.IElementType) PsiClassType(com.intellij.psi.PsiClassType) PsiExpressionStatement(com.intellij.psi.PsiExpressionStatement) PsiTypeElement(com.intellij.psi.PsiTypeElement) PsiField(com.intellij.psi.PsiField) PsiClass(com.intellij.psi.PsiClass) PsiBinaryExpression(com.intellij.psi.PsiBinaryExpression) Nullable(com.android.annotations.Nullable)

Aggregations

PsiTypeCastExpression (com.intellij.psi.PsiTypeCastExpression)5 PsiElement (com.intellij.psi.PsiElement)4 PsiType (com.intellij.psi.PsiType)3 PsiArrayType (com.intellij.psi.PsiArrayType)2 PsiAssignmentExpression (com.intellij.psi.PsiAssignmentExpression)2 PsiDeclarationStatement (com.intellij.psi.PsiDeclarationStatement)2 PsiExpression (com.intellij.psi.PsiExpression)2 PsiExpressionStatement (com.intellij.psi.PsiExpressionStatement)2 PsiField (com.intellij.psi.PsiField)2 PsiLocalVariable (com.intellij.psi.PsiLocalVariable)2 PsiNewExpression (com.intellij.psi.PsiNewExpression)2 PsiParenthesizedExpression (com.intellij.psi.PsiParenthesizedExpression)2 PsiReference (com.intellij.psi.PsiReference)2 PsiReferenceExpression (com.intellij.psi.PsiReferenceExpression)2 PsiStatement (com.intellij.psi.PsiStatement)2 PsiTypeElement (com.intellij.psi.PsiTypeElement)2 ArrayList (java.util.ArrayList)2 Nullable (com.android.annotations.Nullable)1 TextRange (com.intellij.openapi.util.TextRange)1 PsiArrayInitializerExpression (com.intellij.psi.PsiArrayInitializerExpression)1