public void setType(@Nullable PsiType type) { final GrTypeElement typeElement = getTypeElementGroovy(); if (type == null) { if (typeElement == null) return; if (getModifierList().getModifiers().length == 0) { getModifierList().setModifierProperty(GrModifier.DEF, true); } typeElement.delete(); return; } type = TypesUtil.unboxPrimitiveTypeWrapper(type); GrTypeElement newTypeElement; try { newTypeElement = GroovyPsiElementFactory.getInstance(getProject()).createTypeElement(type); } catch (IncorrectOperationException e) { LOG.error(e); return; } if (typeElement == null) { getModifierList().setModifierProperty(GrModifier.DEF, false); final GrVariable[] variables = getVariables(); if (variables.length == 0) return; newTypeElement = (GrTypeElement) addBefore(newTypeElement, variables[0]); } else { newTypeElement = (GrTypeElement) typeElement.replace(newTypeElement); } JavaCodeStyleManager.getInstance(getProject()).shortenClassReferences(newTypeElement); }
private void createNameAndReturnTypeEditors() { myNameCodeFragment = new GroovyCodeFragment(myProject, ""); myNameField = new EditorTextField( PsiDocumentManager.getInstance(myProject).getDocument(myNameCodeFragment), myProject, myNameCodeFragment.getFileType()); final JavaCodeFragmentFactory factory = JavaCodeFragmentFactory.getInstance(myProject); myReturnTypeCodeFragment = factory.createTypeCodeFragment("", myMethod, true, JavaCodeFragmentFactory.ALLOW_VOID); final Document document = PsiDocumentManager.getInstance(myProject).getDocument(myReturnTypeCodeFragment); myReturnTypeField = new EditorTextField(document, myProject, myReturnTypeCodeFragment.getFileType()); myNameField.setText(myMethod.getName()); final GrTypeElement element = myMethod.getReturnTypeElementGroovy(); if (element != null) { myReturnTypeField.setText(element.getText()); } myReturnTypeLabel = new JLabel(); myReturnTypeLabel.setLabelFor(myReturnTypeField); myNameLabel = new JLabel(); myNameLabel.setLabelFor(myNameField); }
public static PsiTypeElement getOrCreateTypeElement(GrTypeElement typeElement) { if (typeElement == null) return null; final SoftReference<PsiTypeElement> ref = typeElement.getUserData(PSI_TYPE_ELEMENT); final PsiTypeElement element = ref == null ? null : ref.get(); if (element != null) return element; final GrSyntheticTypeElement newTypeElement = new GrSyntheticTypeElement(typeElement); typeElement.putUserData(PSI_TYPE_ELEMENT, new SoftReference<PsiTypeElement>(newTypeElement)); return newTypeElement; }
@Override public void visitInstanceofExpression(GrInstanceOfExpression expression) { final GrExpression operand = expression.getOperand(); final GrTypeElement typeElement = expression.getTypeElement(); if (typeElement == null) return; if (myExpression == operand) { final PsiType type = typeElement.getType(); myResult = new TypeConstraint[] {new SupertypeConstraint(type, type)}; } }
public void visitReturnStatement(GrReturnStatement returnStatement) { GrParametersOwner parent = PsiTreeUtil.getParentOfType(returnStatement, GrMethod.class, GrClosableBlock.class); if (parent instanceof GrMethod) { GrTypeElement typeElement = ((GrMethod) parent).getReturnTypeElementGroovy(); if (typeElement != null) { PsiType type = typeElement.getType(); myResult = new TypeConstraint[] {SubtypeConstraint.create(type)}; } } }
@Nullable private PsiType getNominalType() { if (PsiImplUtil.isMainMethod(this)) { return PsiType.VOID; } final GrTypeElement element = getReturnTypeElementGroovy(); if (element != null) { return element.getType(); } return null; }
private static boolean safecastExpressionsAreEquivalent( GrSafeCastExpression expression1, GrSafeCastExpression expression2) { final GrExpression operand1 = expression1.getOperand(); final GrExpression operand2 = expression2.getOperand(); if (!expressionsAreEquivalent(operand1, operand2)) { return false; } final GrTypeElement typeElement1 = expression1.getCastTypeElement(); final GrTypeElement typeElement2 = expression2.getCastTypeElement(); final PsiType safe1 = typeElement1 == null ? null : typeElement1.getType(); final PsiType safe2 = typeElement2 == null ? null : typeElement2.getType(); return typesAreEquivalent(safe1, safe2); }
private static PsiClassType doGetSuperClassType(GroovyScriptClass scriptClass) { GrVariableDeclaration declaration = findDeclaration(scriptClass.getContainingFile()); if (declaration != null) { GrModifierList modifierList = declaration.getModifierList(); if (modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_TRANSFORM_BASE_SCRIPT) != null) { GrTypeElement typeElement = declaration.getTypeElementGroovy(); if (typeElement != null) { PsiType type = typeElement.getType(); if (type instanceof PsiClassType) { return (PsiClassType) type; } } } } return null; }
@Override @Nullable public GrTypeElement setReturnType(@Nullable PsiType newReturnType) { GrTypeElement typeElement = getReturnTypeElementGroovy(); if (newReturnType == null || newReturnType == PsiType.NULL) { if (typeElement != null) typeElement.delete(); insertPlaceHolderToModifierList(); return null; } final GrTypeElement stub = GroovyPsiElementFactory.getInstance(getProject()).createTypeElement(newReturnType); GrTypeElement newTypeElement; if (typeElement == null) { final GrTypeParameterList typeParemeterList = getTypeParameterList(); PsiElement anchor = typeParemeterList != null ? typeParemeterList : getModifierList(); newTypeElement = (GrTypeElement) addAfter(stub, anchor); } else { newTypeElement = (GrTypeElement) typeElement.replace(stub); } return newTypeElement; }
public static boolean isMainMethod(GrMethod method) { if (!method.getName().equals(MAIN_METHOD)) return false; else if (!method.hasModifierProperty(PsiModifier.STATIC)) return false; final GrParameter[] parameters = method.getParameters(); if (parameters.length == 0) return false; if (parameters.length == 1 && parameters[0].getTypeElementGroovy() == null) return true; int args_count = 0; int optional_count = 0; for (GrParameter p : parameters) { final GrTypeElement declaredType = p.getTypeElementGroovy(); if ((declaredType == null || declaredType.getType().equalsToText(CommonClassNames.JAVA_LANG_STRING + "[]")) && p.getInitializerGroovy() == null) { args_count++; } if (p.getInitializerGroovy() != null) optional_count++; } return optional_count == parameters.length - 1 && args_count == 1; }
@Nullable public static String getTypeText(@Nullable GrTypeElement typeElement) { return typeElement == null ? null : typeElement.getText(); }
private static boolean processPrimaryMethodInner( JavaChangeInfo changeInfo, GrMethod method, @Nullable PsiMethod baseMethod) { if (changeInfo.isNameChanged()) { String newName = baseMethod == null ? changeInfo.getNewName() : RefactoringUtil.suggestNewOverriderName( method.getName(), baseMethod.getName(), changeInfo.getNewName()); if (newName != null && !newName.equals(method.getName())) { method.setName(changeInfo.getNewName()); } } final GrModifierList modifierList = method.getModifierList(); if (changeInfo.isVisibilityChanged()) { modifierList.setModifierProperty(changeInfo.getNewVisibility(), true); } PsiSubstitutor substitutor = baseMethod != null ? calculateSubstitutor(method, baseMethod) : PsiSubstitutor.EMPTY; final PsiMethod context = changeInfo.getMethod(); GrTypeElement oldReturnTypeElement = method.getReturnTypeElementGroovy(); if (changeInfo.isReturnTypeChanged()) { CanonicalTypes.Type newReturnType = changeInfo.getNewReturnType(); if (newReturnType == null) { if (oldReturnTypeElement != null) { oldReturnTypeElement.delete(); if (modifierList.getModifiers().length == 0) { modifierList.setModifierProperty(GrModifier.DEF, true); } } } else { PsiType type = newReturnType.getType(context, method.getManager()); GrReferenceAdjuster.shortenAllReferencesIn( method.setReturnType(substitutor.substitute(type))); if (oldReturnTypeElement == null) { modifierList.setModifierProperty(GrModifier.DEF, false); } } } JavaParameterInfo[] newParameters = changeInfo.getNewParameters(); final GrParameterList parameterList = method.getParameterList(); GrParameter[] oldParameters = parameterList.getParameters(); final PsiParameter[] oldBaseParams = baseMethod != null ? baseMethod.getParameterList().getParameters() : null; Set<GrParameter> toRemove = new HashSet<GrParameter>(oldParameters.length); ContainerUtil.addAll(toRemove, oldParameters); GrParameter anchor = null; final GrDocComment docComment = method.getDocComment(); final GrDocTag[] tags = docComment == null ? null : docComment.getTags(); for (JavaParameterInfo newParameter : newParameters) { // if old parameter name differs from base method parameter name we don't change it final String newName; final int oldIndex = newParameter.getOldIndex(); if (oldIndex >= 0 && oldBaseParams != null) { final String oldName = oldParameters[oldIndex].getName(); if (oldName.equals(oldBaseParams[oldIndex].getName())) { newName = newParameter.getName(); } else { newName = oldName; } } else { newName = newParameter.getName(); } final GrParameter oldParameter = oldIndex >= 0 ? oldParameters[oldIndex] : null; if (docComment != null && oldParameter != null) { final String oldName = oldParameter.getName(); for (GrDocTag tag : tags) { if ("@param".equals(tag.getName())) { final GrDocParameterReference parameterReference = tag.getDocParameterReference(); if (parameterReference != null && oldName.equals(parameterReference.getText())) { parameterReference.handleElementRename(newName); } } } } GrParameter grParameter = createNewParameter(substitutor, context, parameterList, newParameter, newName); if (oldParameter != null) { grParameter.getModifierList().replace(oldParameter.getModifierList()); } if ("def".equals(newParameter.getTypeText())) { grParameter.getModifierList().setModifierProperty(GrModifier.DEF, true); } else if (StringUtil.isEmpty(newParameter.getTypeText())) { grParameter.getModifierList().setModifierProperty(GrModifier.DEF, false); } anchor = (GrParameter) parameterList.addAfter(grParameter, anchor); } for (GrParameter oldParameter : toRemove) { oldParameter.delete(); } JavaCodeStyleManager.getInstance(parameterList.getProject()) .shortenClassReferences(parameterList); CodeStyleManager.getInstance(parameterList.getProject()).reformat(parameterList); if (changeInfo.isExceptionSetOrOrderChanged()) { final ThrownExceptionInfo[] infos = changeInfo.getNewExceptions(); PsiClassType[] exceptionTypes = new PsiClassType[infos.length]; for (int i = 0; i < infos.length; i++) { ThrownExceptionInfo info = infos[i]; exceptionTypes[i] = (PsiClassType) info.createType(method, method.getManager()); } PsiReferenceList thrownList = GroovyPsiElementFactory.getInstance(method.getProject()).createThrownList(exceptionTypes); thrownList = (PsiReferenceList) method.getThrowsList().replace(thrownList); JavaCodeStyleManager.getInstance(thrownList.getProject()).shortenClassReferences(thrownList); CodeStyleManager.getInstance(method.getProject()).reformat(method.getThrowsList()); } return true; }