private static void addSuppressAnnotation( final Project project, final GrModifierList modifierList, final String id) throws IncorrectOperationException { PsiAnnotation annotation = modifierList.findAnnotation(BatchSuppressManager.SUPPRESS_INSPECTIONS_ANNOTATION_NAME); final GrExpression toAdd = GroovyPsiElementFactory.getInstance(project).createExpressionFromText("\"" + id + "\""); if (annotation != null) { final PsiAnnotationMemberValue value = annotation.findDeclaredAttributeValue(null); if (value instanceof GrAnnotationArrayInitializer) { value.add(toAdd); } else if (value != null) { GrAnnotation anno = GroovyPsiElementFactory.getInstance(project).createAnnotationFromText("@A([])"); final GrAnnotationArrayInitializer list = (GrAnnotationArrayInitializer) anno.findDeclaredAttributeValue(null); list.add(value); list.add(toAdd); annotation.setDeclaredAttributeValue(null, list); } } else { modifierList .addAnnotation(BatchSuppressManager.SUPPRESS_INSPECTIONS_ANNOTATION_NAME) .setDeclaredAttributeValue(null, toAdd); } }
private static boolean shouldProcessInstanceMembers( @NotNull GrTypeDefinition grType, @Nullable PsiElement lastParent) { if (lastParent != null) { final GrModifierList modifierList = grType.getModifierList(); if (modifierList != null && modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_LANG_CATEGORY) != null) { return false; } } return true; }
private PsiElement findSuitableModifier() { final GrModifierList list = getModifierList(); PsiElement modifier = PsiUtil.findModifierInList(list, GrModifier.DEF); if (modifier != null) return modifier; modifier = PsiUtil.findModifierInList(list, PsiModifier.FINAL); if (modifier != null) return modifier; for (PsiElement element : list.getModifiers()) { if (!(element instanceof GrAnnotation)) { return element; } } return null; }
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; }
private void appendParenthesesIfNeeded() { PsiElement first = getFirstChild(); if (first == null) { getNode().addLeaf(GroovyTokenTypes.mLT, "<", null); } PsiElement last = getLastChild(); if (last.getNode().getElementType() != GroovyTokenTypes.mGT) { getNode().addLeaf(GroovyTokenTypes.mGT, ">", null); } PsiElement parent = getParent(); if (parent instanceof GrMethod) { GrModifierList list = ((GrMethod) parent).getModifierList(); PsiElement[] modifiers = list.getModifiers(); if (modifiers.length == 0) { list.setModifierProperty(GrModifier.DEF, true); } } }
private static void processClassUsage(GrTypeDefinition psiClass, JavaChangeInfo changeInfo) { String name = psiClass.getName(); GrMethod constructor = GroovyPsiElementFactory.getInstance(psiClass.getProject()) .createConstructorFromText( name, ArrayUtil.EMPTY_STRING_ARRAY, ArrayUtil.EMPTY_STRING_ARRAY, "{}", null); GrModifierList list = constructor.getModifierList(); if (psiClass.hasModifierProperty(PsiModifier.PRIVATE)) list.setModifierProperty(PsiModifier.PRIVATE, true); if (psiClass.hasModifierProperty(PsiModifier.PROTECTED)) list.setModifierProperty(PsiModifier.PROTECTED, true); if (!list.hasExplicitVisibilityModifiers()) { list.setModifierProperty(GrModifier.DEF, true); } constructor = (GrMethod) psiClass.add(constructor); processConstructor(constructor, changeInfo); }
private static void execute(final GrField field, final Collection<PsiElement> fieldUsages) { final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(field.getProject()); final StringBuilder builder = new StringBuilder(field.getTextLength()); final GrClosableBlock block = (GrClosableBlock) field.getInitializerGroovy(); final GrModifierList modifierList = field.getModifierList(); if (modifierList.getModifiers().length > 0 || modifierList.getAnnotations().length > 0) { builder.append(modifierList.getText()); } else { builder.append(GrModifier.DEF); } builder.append(' ').append(field.getName()); builder.append('('); if (block.hasParametersSection()) { builder.append(block.getParameterList().getText()); } else { builder.append("def it = null"); } builder.append(") {"); ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { block.getParameterList().delete(); block.getLBrace().delete(); final PsiElement psiElement = PsiUtil.skipWhitespacesAndComments(block.getFirstChild(), true); if (psiElement != null && "->".equals(psiElement.getText())) { psiElement.delete(); } builder.append(block.getText()); final GrMethod method = GroovyPsiElementFactory.getInstance(field.getProject()) .createMethodFromText(builder.toString()); field.getParent().replace(method); for (PsiElement usage : fieldUsages) { if (usage instanceof GrReferenceExpression) { final PsiElement parent = usage.getParent(); StringBuilder newRefText = new StringBuilder(); if (parent instanceof GrReferenceExpression && usage == ((GrReferenceExpression) parent).getQualifier() && "call".equals(((GrReferenceExpression) parent).getReferenceName())) { newRefText.append(usage.getText()); usage = parent; } else { PsiElement qualifier = ((GrReferenceExpression) usage).getQualifier(); if (qualifier == null) { if (parent instanceof GrReferenceExpression && ((GrReferenceExpression) parent).getQualifier() != null && usage != ((GrReferenceExpression) parent).getQualifier()) { qualifier = ((GrReferenceExpression) parent).getQualifier(); usage = parent; } } if (qualifier != null) { newRefText.append(qualifier.getText()).append('.'); ((GrReferenceExpression) usage).setQualifier(null); } else { newRefText.append("this."); } newRefText.append('&').append(usage.getText()); } usage.replace(factory.createReferenceExpressionFromText(newRefText.toString())); } } } }); }
public static boolean checkModifierProperty( @NotNull GrModifierList modifierList, @GrModifier.GrModifierConstant @NotNull String modifier) { final PsiElement owner = modifierList.getParent(); if (owner instanceof GrVariableDeclaration && owner.getParent() instanceof GrTypeDefinitionBody) { PsiElement pParent = owner.getParent().getParent(); if (!modifierList .hasExplicitVisibilityModifiers()) { // properties are backed by private fields if (!(pParent instanceof PsiClass) || !((PsiClass) pParent).isInterface()) { if (modifier.equals(GrModifier.PRIVATE)) return true; if (modifier.equals(GrModifier.PROTECTED)) return false; if (modifier.equals(GrModifier.PUBLIC)) return false; } } if (pParent instanceof PsiClass && ((PsiClass) pParent).isInterface()) { if (modifier.equals(GrModifier.STATIC)) return true; if (modifier.equals(GrModifier.FINAL)) return true; } if (pParent instanceof GrTypeDefinition) { PsiModifierList pModifierList = ((GrTypeDefinition) pParent).getModifierList(); if (pModifierList != null && pModifierList.findAnnotation(ConstructorAnnotationsProcessor.IMMUTABLE) != null) { if (modifier.equals(GrModifier.FINAL)) return true; } } } // top level classes cannot have private and protected modifiers if (owner instanceof GrTypeDefinition && ((GrTypeDefinition) owner).getContainingClass() == null) { if (modifier.equals(PROTECTED) || modifier.equals(PRIVATE)) return false; if (modifier.equals(PACKAGE_LOCAL)) return modifierList.hasExplicitModifier(PRIVATE) || modifierList.hasExplicitModifier(PROTECTED); } if (modifierList.hasExplicitModifier(modifier)) { return true; } if (modifier.equals(GrModifier.PUBLIC)) { if (owner instanceof GrPackageDefinition) return false; if (owner instanceof GrVariableDeclaration && !(owner.getParent() instanceof GrTypeDefinitionBody) || owner instanceof GrVariable) { return false; } // groovy type definitions and methods are public by default return !modifierList.hasExplicitModifier(GrModifier.PRIVATE) && !modifierList.hasExplicitModifier(GrModifier.PROTECTED); } if (owner instanceof GrTypeDefinition) { if (modifier.equals(GrModifier.STATIC)) { final PsiClass containingClass = ((GrTypeDefinition) owner).getContainingClass(); return containingClass != null && containingClass.isInterface(); } if (modifier.equals(GrModifier.ABSTRACT)) { return ((GrTypeDefinition) owner).isInterface(); } } return false; }
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; }