示例#1
0
  @NotNull
  public static PsiPrimitiveType getPrimitiveTypeByText(String typeText) {
    for (final PsiPrimitiveType primitive : PRIMITIVES) {
      if (PsiType.VOID.equals(primitive)) {
        return primitive;
      }
      if (primitive.getCanonicalText().equals(typeText)) {
        return primitive;
      }
    }

    assert false : "Unknown primitive type";
    return null;
  }
  public static String[] getParameterString(ExtractInfoHelper helper, boolean useCanonicalText) {
    int i = 0;
    ParameterInfo[] infos = helper.getParameterInfos();
    int number = 0;
    for (ParameterInfo info : infos) {
      if (info.passAsParameter()) number++;
    }
    ArrayList<String> params = new ArrayList<String>();
    for (ParameterInfo info : infos) {
      if (info.passAsParameter()) {
        PsiType paramType = info.getType();
        final PsiPrimitiveType unboxed = PsiPrimitiveType.getUnboxedType(paramType);
        if (unboxed != null) paramType = unboxed;
        String paramTypeText;

        if (paramType == null || paramType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
          paramTypeText = "";
        } else {
          paramTypeText =
              (useCanonicalText ? paramType.getCanonicalText() : paramType.getPresentableText())
                  + " ";
        }
        params.add(paramTypeText + info.getName() + (i < number - 1 ? ", " : ""));
        i++;
      }
    }
    return ArrayUtil.toStringArray(params);
  }
  public static GrMethod createMethod(ExtractMethodInfoHelper helper) {
    StringBuilder buffer = new StringBuilder();

    // Add signature
    PsiType type = helper.getOutputType();
    final PsiPrimitiveType outUnboxed = PsiPrimitiveType.getUnboxedType(type);
    if (outUnboxed != null) type = outUnboxed;
    String modifier = getModifierString(helper);
    String typeText = getTypeString(helper, false, modifier);
    buffer.append(modifier);
    buffer.append(typeText);
    buffer.append(helper.getName());
    buffer.append("(");
    for (String param : getParameterString(helper, true)) {
      buffer.append(param);
    }
    buffer.append(") { \n");

    GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(helper.getProject());
    generateBody(helper, type == PsiType.VOID, buffer, helper.isForceReturn());

    buffer.append("\n}");

    String methodText = buffer.toString();
    GrMethod method = factory.createMethodFromText(methodText);
    LOG.assertTrue(method != null);
    return method;
  }
 public static boolean isAssociativeOperation(PsiPolyadicExpression expression) {
   final IElementType tokenType = expression.getOperationTokenType();
   final PsiType type = expression.getType();
   final PsiPrimitiveType primitiveType;
   if (type instanceof PsiClassType) {
     primitiveType = PsiPrimitiveType.getUnboxedType(type);
     if (primitiveType == null) {
       return false;
     }
   } else if (type instanceof PsiPrimitiveType) {
     primitiveType = (PsiPrimitiveType) type;
   } else {
     return false;
   }
   if (JavaTokenType.PLUS == tokenType || JavaTokenType.ASTERISK == tokenType) {
     return !PsiType.FLOAT.equals(primitiveType) && !PsiType.DOUBLE.equals(primitiveType);
   } else if (JavaTokenType.EQEQ == tokenType || JavaTokenType.NE == tokenType) {
     return PsiType.BOOLEAN.equals(primitiveType);
   } else if (JavaTokenType.AND == tokenType
       || JavaTokenType.OR == tokenType
       || JavaTokenType.XOR == tokenType) {
     return true;
   } else if (JavaTokenType.OROR == tokenType || JavaTokenType.ANDAND == tokenType) {
     return true;
   }
   return false;
 }
示例#5
0
  public static PsiType boxPrimitiveType(
      @Nullable PsiType result,
      @NotNull PsiManager manager,
      @NotNull GlobalSearchScope resolveScope,
      boolean boxVoid) {
    if (result instanceof PsiPrimitiveType && (boxVoid || result != PsiType.VOID)) {
      PsiPrimitiveType primitive = (PsiPrimitiveType) result;
      String boxedTypeName = primitive.getBoxedTypeName();
      if (boxedTypeName != null) {
        return GroovyPsiManager.getInstance(manager.getProject())
            .createTypeByFQClassName(boxedTypeName, resolveScope);
      }
    }

    return result;
  }
  private static Map<String, PsiType> getCompatibleTypeNames(
      @NotNull PsiType type, @Nullable PsiType min, PsiManager manager, GlobalSearchScope scope) {
    if (type instanceof PsiDisjunctionType) type = ((PsiDisjunctionType) type).getLeastUpperBound();

    // if initial type is not assignable to min type we don't take into consideration min type.
    if (min != null && !TypesUtil.isAssignable(min, type, manager, scope)) {
      min = null;
    }

    Map<String, PsiType> map = new LinkedHashMap<String, PsiType>();
    final PsiPrimitiveType unboxed = PsiPrimitiveType.getUnboxedType(type);
    if (unboxed != null) type = unboxed;
    final Set<PsiType> set = new LinkedHashSet<PsiType>();
    set.add(type);
    while (!set.isEmpty()) {
      PsiType cur = set.iterator().next();
      set.remove(cur);
      if (!map.containsValue(cur)
          && (min == null || TypesUtil.isAssignable(min, cur, manager, scope))) {
        if (isPartiallySubstituted(cur)) {
          LOG.assertTrue(cur instanceof PsiClassType);
          PsiClassType rawType = ((PsiClassType) cur).rawType();
          map.put(rawType.getPresentableText(), rawType);
        } else {
          map.put(cur.getPresentableText(), cur);
        }
        for (PsiType superType : cur.getSuperTypes()) {
          if (!map.containsValue(superType)) {
            set.add(superType);
          }
        }
      }
    }
    return map;
  }
 private void checkExpression(PsiExpression expression) {
   if (expression.getParent() instanceof PsiParenthesizedExpression) {
     return;
   }
   final PsiType expressionType = expression.getType();
   if (expressionType == null) {
     return;
   }
   if (expressionType.getArrayDimensions() > 0) {
     // a horrible hack to get around what happens when you pass
     // an array to a vararg expression
     return;
   }
   if (TypeConversionUtil.isPrimitiveAndNotNull(expressionType)) {
     return;
   }
   final PsiPrimitiveType unboxedType = PsiPrimitiveType.getUnboxedType(expressionType);
   if (unboxedType == null) {
     return;
   }
   final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, false);
   if (expectedType == null) {
     return;
   }
   if (!TypeConversionUtil.isPrimitiveAndNotNull(expectedType)) {
     return;
   }
   if (!expectedType.isAssignableFrom(unboxedType)) {
     return;
   }
   registerError(expression, expression);
 }
  public Object evaluate(EvaluationContextImpl context) throws EvaluateException {
    final Object result = myOperand.evaluate(context);
    if (result == null || result instanceof ObjectReference) {
      return result;
    }

    if (result instanceof PrimitiveValue) {
      PrimitiveValue primitiveValue = (PrimitiveValue) result;
      PsiPrimitiveType primitiveType =
          PsiJavaParserFacadeImpl.getPrimitiveType(primitiveValue.type().name());
      if (primitiveType != null) {
        return convertToWrapper(context, primitiveValue, primitiveType.getBoxedTypeName());
      }
    }
    throw new EvaluateException(
        "Cannot perform boxing conversion for a value of type " + ((Value) result).type().name());
  }
 private void checkExpression(@NotNull PsiExpression expression) {
   if (expression.getParent() instanceof PsiParenthesizedExpression) {
     return;
   }
   final PsiType expressionType = expression.getType();
   if (expressionType == null
       || expressionType.equals(PsiType.VOID)
       || !TypeConversionUtil.isPrimitiveAndNotNull(expressionType)) {
     return;
   }
   final PsiPrimitiveType primitiveType = (PsiPrimitiveType) expressionType;
   final PsiClassType boxedType = primitiveType.getBoxedType(expression);
   if (boxedType == null) {
     return;
   }
   final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, false);
   if (expectedType == null || ClassUtils.isPrimitive(expectedType)) {
     return;
   }
   if (!expectedType.isAssignableFrom(boxedType)) {
     // JLS 5.2 Assignment Conversion
     // check if a narrowing primitive conversion is applicable
     if (!(expectedType instanceof PsiClassType) || !PsiUtil.isConstantExpression(expression)) {
       return;
     }
     final PsiClassType classType = (PsiClassType) expectedType;
     final String className = classType.getCanonicalText();
     if (!convertableBoxedClassNames.contains(className)) {
       return;
     }
     if (!PsiType.BYTE.equals(expressionType)
         && !PsiType.CHAR.equals(expressionType)
         && !PsiType.SHORT.equals(expressionType)
         && !PsiType.INT.equals(expressionType)) {
       return;
     }
   }
   if (ignoreAddedToCollection && isAddedToCollection(expression)) {
     return;
   }
   registerError(expression);
 }
  public static String getTypeString(
      ExtractMethodInfoHelper helper, boolean forPresentation, String modifier) {
    PsiType type = helper.getOutputType();
    final PsiPrimitiveType outUnboxed = PsiPrimitiveType.getUnboxedType(type);
    if (outUnboxed != null) type = outUnboxed;

    String typeText = forPresentation ? type.getPresentableText() : type.getCanonicalText();
    String returnType = typeText == null || !helper.specifyType() ? "" : typeText;

    if (StringUtil.isEmptyOrSpaces(returnType) || "null".equals(returnType)) {
      if (modifier.length() == 0) {
        return "def ";
      } else {
        return "";
      }
    } else {
      return returnType + " ";
    }
  }
  @NotNull
  public static String getTypeString(
      @NotNull ExtractMethodInfoHelper helper, boolean forPresentation, @NotNull String modifier) {
    if (!helper.specifyType()) {
      return modifier.isEmpty() ? "def " : "";
    }

    PsiType type = helper.getOutputType();
    final PsiPrimitiveType unboxed = PsiPrimitiveType.getUnboxedType(type);
    if (unboxed != null) type = unboxed;

    final String returnType =
        StringUtil.notNullize(
            forPresentation ? type.getPresentableText() : type.getCanonicalText());

    if (StringUtil.isEmptyOrSpaces(returnType) || "null".equals(returnType)) {
      return modifier.isEmpty() ? "def " : "";
    } else {
      return returnType + " ";
    }
  }
 @Override
 public void visitTypeCastExpression(@NotNull PsiTypeCastExpression expression) {
   super.visitTypeCastExpression(expression);
   final PsiExpression operand = expression.getOperand();
   if (operand == null) {
     return;
   }
   final PsiType operandType = operand.getType();
   if (operandType == null) {
     return;
   }
   final PsiType type = expression.getType();
   if (type == null) {
     return;
   }
   final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, true);
   if (expectedType == null) {
     return;
   }
   if (expectedType.equals(type)) {
     return;
   }
   final PsiClass resolved = PsiUtil.resolveClassInType(expectedType);
   if (resolved != null && !resolved.isPhysical()) {
     return;
   }
   if (expectedType.isAssignableFrom(operandType)) {
     // then it's redundant, and caught by the built-in exception
     return;
   }
   if (isTypeParameter(expectedType)) {
     return;
   }
   if (expectedType instanceof PsiArrayType) {
     final PsiArrayType arrayType = (PsiArrayType) expectedType;
     final PsiType componentType = arrayType.getDeepComponentType();
     if (isTypeParameter(componentType)) {
       return;
     }
   }
   if (type instanceof PsiPrimitiveType || expectedType instanceof PsiPrimitiveType) {
     return;
   }
   if (PsiPrimitiveType.getUnboxedType(type) != null
       || PsiPrimitiveType.getUnboxedType(expectedType) != null) {
     return;
   }
   if (expectedType instanceof PsiClassType) {
     final PsiClassType expectedClassType = (PsiClassType) expectedType;
     final PsiClassType expectedRawType = expectedClassType.rawType();
     if (type.equals(expectedRawType)) {
       return;
     }
     if (type instanceof PsiClassType) {
       final PsiClassType classType = (PsiClassType) type;
       final PsiClassType rawType = classType.rawType();
       if (rawType.equals(expectedRawType)) {
         return;
       }
     }
     if (type instanceof PsiArrayType) {
       return;
     }
   }
   if (ignoreInMatchingInstanceof && InstanceOfUtils.hasAgreeingInstanceof(expression)) {
     return;
   }
   final PsiTypeElement castTypeElement = expression.getCastType();
   if (castTypeElement == null) {
     return;
   }
   registerError(castTypeElement, expectedType);
 }
 @Override
 public void doFix(Project project, ProblemDescriptor descriptor)
     throws IncorrectOperationException {
   final PsiExpression expression = (PsiExpression) descriptor.getPsiElement();
   final PsiType type = expression.getType();
   if (type == null) {
     return;
   }
   final PsiPrimitiveType unboxedType = PsiPrimitiveType.getUnboxedType(type);
   if (unboxedType == null) {
     return;
   }
   final String newExpressionText = buildNewExpressionText(expression, unboxedType);
   final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
   final PsiElementFactory factory = psiFacade.getElementFactory();
   final PsiElement parent = expression.getParent();
   final String expressionText = expression.getText();
   if (parent instanceof PsiPrefixExpression && !unboxedType.equalsToText("boolean")) {
     final PsiPrefixExpression prefixExpression = (PsiPrefixExpression) parent;
     final IElementType tokenType = prefixExpression.getOperationTokenType();
     if (JavaTokenType.PLUSPLUS.equals(tokenType)) {
       replaceExpression(prefixExpression, expressionText + '=' + newExpressionText + "+1");
     } else if (JavaTokenType.MINUSMINUS.equals(tokenType)) {
       replaceExpression(prefixExpression, expressionText + '=' + newExpressionText + "-1");
     } else {
       replaceExpression(
           prefixExpression, prefixExpression.getOperationSign().getText() + newExpressionText);
     }
   } else if (parent instanceof PsiPostfixExpression) {
     final PsiPostfixExpression postfixExpression = (PsiPostfixExpression) parent;
     final IElementType tokenType = postfixExpression.getOperationTokenType();
     final PsiElement grandParent = postfixExpression.getParent();
     if (grandParent instanceof PsiExpressionStatement) {
       if (JavaTokenType.PLUSPLUS.equals(tokenType)) {
         replaceExpression(postfixExpression, expressionText + '=' + newExpressionText + "+1");
       } else if (JavaTokenType.MINUSMINUS.equals(tokenType)) {
         replaceExpression(postfixExpression, expressionText + '=' + newExpressionText + "-1");
       }
     } else {
       final PsiElement element = postfixExpression.replace(postfixExpression.getOperand());
       final PsiStatement statement = PsiTreeUtil.getParentOfType(element, PsiStatement.class);
       if (statement == null) {
         return;
       }
       final PsiStatement newStatement;
       if (JavaTokenType.PLUSPLUS.equals(tokenType)) {
         newStatement =
             factory.createStatementFromText(
                 expressionText + '=' + newExpressionText + "+1;", statement);
       } else {
         newStatement =
             factory.createStatementFromText(
                 expressionText + '=' + newExpressionText + "-1;", statement);
       }
       final PsiElement greatGrandParent = statement.getParent();
       greatGrandParent.addAfter(newStatement, statement);
     }
   } else if (parent instanceof PsiAssignmentExpression) {
     final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) parent;
     final PsiExpression lExpression = assignmentExpression.getLExpression();
     if (expression.equals(lExpression)) {
       final PsiJavaToken operationSign = assignmentExpression.getOperationSign();
       final String operationSignText = operationSign.getText();
       final char sign = operationSignText.charAt(0);
       final PsiExpression rExpression = assignmentExpression.getRExpression();
       if (rExpression == null) {
         return;
       }
       final String text =
           lExpression.getText() + '=' + newExpressionText + sign + rExpression.getText();
       final PsiExpression newExpression =
           factory.createExpressionFromText(text, assignmentExpression);
       assignmentExpression.replace(newExpression);
     } else {
       replaceExpression(expression, newExpressionText);
     }
   } else {
     replaceExpression(expression, newExpressionText);
   }
 }