From 37ef1d7bca294d7f0fa11c5a776974e4533c75a5 Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Tue, 17 Nov 2015 12:58:08 +0100 Subject: [PATCH] [java] avoid copying nullability type annotations (IDEA-132058) --- ...reateConstructorParameterFromFieldFix.java | 10 +---- .../GenerateConstructorHandler.java | 8 +--- .../generation/GenerateMembersUtil.java | 17 ++------ .../impl/FieldFromParameterUtils.java | 12 +----- .../InheritanceToDelegationProcessor.java | 39 +++++++------------ .../codeInsight/NullableNotNullManager.java | 32 +++++++++++++++ .../com/intellij/psi/util/PropertyUtil.java | 28 +++---------- .../afterTypeAnnotatedField.java | 9 +++++ .../beforeTypeAnnotatedField.java | 7 ++++ .../codeInsight/GenerateConstructorTest.java | 31 +++++++++++++-- .../lang/psi/util/GroovyPropertyUtils.java | 34 ++++------------ 11 files changed, 110 insertions(+), 117 deletions(-) create mode 100644 java/java-tests/testData/codeInsight/generateConstructor/afterTypeAnnotatedField.java create mode 100644 java/java-tests/testData/codeInsight/generateConstructor/beforeTypeAnnotatedField.java diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java index 14813816ef6f..5ef6d1737af4 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java @@ -342,7 +342,7 @@ public class CreateConstructorParameterFromFieldFix implements IntentionAction { if (parameter == null) { continue; } - notNull(field, parameter); + NullableNotNullManager.getInstance(field.getProject()).copyNotNullAnnotation(field, parameter); cleanupElements.add(parameter); final PsiElement assignmentStatement = AssignFieldFromParameterAction.addFieldAssignmentStatement(project, field, parameter, editor); if (assignmentStatement != null) { @@ -356,14 +356,6 @@ public class CreateConstructorParameterFromFieldFix implements IntentionAction { } } - private static void notNull(PsiField field, PsiParameter parameter) { - final PsiAnnotation notNull = NullableNotNullManager.getInstance(field.getProject()).copyNotNullAnnotation(field); - if (notNull != null) { - //noinspection ConstantConditions - parameter.getModifierList().addBefore(notNull, null); - } - } - @Nullable private static PsiParameter findParamByName(String newName, PsiType type, diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java index 69408385586f..e10b9a8a88f2 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java @@ -275,13 +275,7 @@ public class GenerateConstructorHandler extends GenerateMembersHandlerBase { parmName = javaStyle.suggestUniqueVariableName(parmName, dummyConstructor, true); PsiParameter parm = factory.createParameter(parmName, field.getType(), aClass); - PsiAnnotation notNull = NullableNotNullManager.getInstance(project).copyNotNullAnnotation(field); - if (notNull != null) { - PsiModifierList modifierList = parm.getModifierList(); - if (modifierList != null) { - modifierList.addAfter(notNull, null); - } - } + NullableNotNullManager.getInstance(project).copyNotNullAnnotation(field, parm); if (constructor.isVarArgs()) { final PsiParameterList parameterList = constructor.getParameterList(); diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java index f92ec15228ee..0900dfac9e1c 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java @@ -17,6 +17,7 @@ package com.intellij.codeInsight.generation; import com.intellij.codeInsight.AnnotationTargetUtil; import com.intellij.codeInsight.ExceptionUtil; +import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils; import com.intellij.lang.ASTNode; import com.intellij.openapi.diagnostic.Logger; @@ -685,19 +686,9 @@ public class GenerateMembersUtil { } result = (PsiMethod)CodeStyleManager.getInstance(project).reformat(result); - PsiModifierListOwner listOwner = null; - if (isGetter) { - listOwner = result; - } - else { - final PsiParameter[] parameters = result.getParameterList().getParameters(); - if (parameters.length == 1) { - listOwner = parameters[0]; - } - } - if (listOwner != null) { - PropertyUtil.annotateWithNullableStuff(field, listOwner); - } + PsiModifierListOwner annotationTarget = isGetter ? result : result.getParameterList().getParameters()[0]; + NullableNotNullManager.getInstance(project).copyNullableOrNotNullAnnotation(field, annotationTarget); + return generatePrototype(field, result); } diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/FieldFromParameterUtils.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/FieldFromParameterUtils.java index 63127a66dd04..a8b3d19e3d93 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/FieldFromParameterUtils.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/FieldFromParameterUtils.java @@ -195,17 +195,7 @@ public final class FieldFromParameterUtils { modifierList.setModifierProperty(PsiModifier.STATIC, isStatic); modifierList.setModifierProperty(PsiModifier.FINAL, isFinal); - final NullableNotNullManager manager = NullableNotNullManager.getInstance(project); - final PsiAnnotation nullable = manager.copyNullableAnnotation(parameter); - if (nullable != null) { - modifierList.addAfter(nullable, null); - } - else if (isFinal) { - final PsiAnnotation notNull = manager.copyNotNullAnnotation(parameter); - if (notNull != null) { - modifierList.addAfter(notNull, null); - } - } + NullableNotNullManager.getInstance(project).copyNullableOrNotNullAnnotation(parameter, field); PsiCodeBlock methodBody = method.getBody(); if (methodBody == null) return; diff --git a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java index 22c8fd78f9db..503465594db3 100644 --- a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationProcessor.java @@ -18,7 +18,7 @@ package com.intellij.refactoring.inheritanceToDelegation; import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil; import com.intellij.codeInsight.generation.GenerateMembersUtil; -import com.intellij.codeInsight.generation.OverrideImplementUtil; +import com.intellij.codeInsight.generation.OverrideImplementExploreUtil; import com.intellij.find.findUsages.PsiElement2UsageTargetAdapter; import com.intellij.lang.findUsages.DescriptiveNameUtil; import com.intellij.openapi.diagnostic.Logger; @@ -53,7 +53,6 @@ import com.intellij.util.IncorrectOperationException; import com.intellij.util.VisibilityUtil; import com.intellij.util.containers.HashMap; import com.intellij.util.containers.MultiMap; -import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -465,7 +464,7 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { final PsiExpression newExpr; final PsiReferenceExpression ref; - @NonNls final String delegateQualifier; + final String delegateQualifier; if (!(expression instanceof PsiThisExpression || expression instanceof PsiSuperExpression)) { delegateQualifier = "a."; } else { @@ -498,7 +497,7 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { if (!myAbstractDelegatedMethods.contains(method)) { PsiMethod methodToAdd = delegateMethod(myFieldName, method, getSuperSubstitutor(method.getContainingClass())); - String visibility = myDelegatedMethodsVisibility.get(method); + @PsiModifier.ModifierConstant String visibility = myDelegatedMethodsVisibility.get(method); if (visibility != null) { PsiUtil.setModifierProperty(methodToAdd, visibility, true); } @@ -508,25 +507,15 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { } } - private PsiMethod delegateMethod(@NonNls String delegationTarget, + private PsiMethod delegateMethod(String delegationTarget, PsiMethod method, PsiSubstitutor substitutor) throws IncorrectOperationException { - substitutor = OverrideImplementUtil.correctSubstitutor(method, substitutor); + substitutor = OverrideImplementExploreUtil.correctSubstitutor(method, substitutor); PsiMethod methodToAdd = GenerateMembersUtil.substituteGenericMethod(method, substitutor); - final PsiModifierList modifierList = methodToAdd.getModifierList(); - final NullableNotNullManager manager = NullableNotNullManager.getInstance(myProject); - modifierList.setModifierProperty(PsiModifier.ABSTRACT, false); - final PsiAnnotation nullable = manager.copyNullableAnnotation(method); - if (nullable != null) { - modifierList.addAfter(nullable, null); - } - else { - final PsiAnnotation notNull = manager.copyNotNullAnnotation(method); - if (notNull != null) { - modifierList.addAfter(notNull, null); - } - } + methodToAdd.getModifierList().setModifierProperty(PsiModifier.ABSTRACT, false); + + NullableNotNullManager.getInstance(myProject).copyNullableOrNotNullAnnotation(method, methodToAdd); final String delegationBody = getDelegationBody(methodToAdd, delegationTarget); PsiCodeBlock newBody = myFactory.createCodeBlockFromText(delegationBody, method); @@ -546,7 +535,7 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { } private static String getDelegationBody(PsiMethod methodToAdd, String delegationTarget) { - @NonNls final StringBuffer buffer = new StringBuffer(); + StringBuilder buffer = new StringBuilder(); buffer.append("{\n"); if (!PsiType.VOID.equals(methodToAdd.getReturnType())) { @@ -618,7 +607,7 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { if (myGenerateGetter) { final String getterVisibility = PsiModifier.PUBLIC; - @NonNls StringBuffer getterBuffer = new StringBuffer(); + StringBuffer getterBuffer = new StringBuffer(); getterBuffer.append(getterVisibility); getterBuffer.append(" Object "); getterBuffer.append(myGetterName); @@ -647,12 +636,12 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { return PsiModifier.PRIVATE; } - private @NonNls String defaultClassFieldType() { + private String defaultClassFieldType() { return (myIsInnerClassNeeded ? myInnerClassName : "Object"); } private PsiField createField(final String fieldVisibility, final boolean fieldInitializerNeeded, String defaultTypeName) throws IncorrectOperationException { - @NonNls StringBuffer buffer = new StringBuffer(); + StringBuffer buffer = new StringBuffer(); buffer.append(fieldVisibility); buffer.append(" final " + defaultTypeName + " "); buffer.append(myFieldName); @@ -671,7 +660,7 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { for (PsiMethod constructor : constructors) { PsiCodeBlock body = constructor.getBody(); final PsiStatement[] statements = body.getStatements(); - @NonNls String fieldQualifier = ""; + String fieldQualifier = ""; PsiParameter[] constructorParams = constructor.getParameterList().getParameters(); for (PsiParameter constructorParam : constructorParams) { if (myFieldName.equals(constructorParam.getName())) { @@ -679,7 +668,7 @@ public class InheritanceToDelegationProcessor extends BaseRefactoringProcessor { break; } } - final @NonNls String assignmentText = fieldQualifier + myFieldName + "= new " + defaultClassFieldType() + "()"; + final String assignmentText = fieldQualifier + myFieldName + "= new " + defaultClassFieldType() + "()"; if (statements.length < 1 || !JavaHighlightUtil.isSuperOrThisCall(statements[0], true, true) || myBaseClass.isInterface()) { PsiExpressionStatement assignmentStatement = (PsiExpressionStatement)myFactory.createStatementFromText( diff --git a/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.java b/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.java index 9d8e8ff605e5..f2b43f58d0fd 100644 --- a/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.java +++ b/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.java @@ -137,10 +137,42 @@ public abstract class NullableNotNullManager implements PersistentStateComponent return findNullabilityAnnotationWithDefault(owner, checkBases, false); } + @Nullable + public PsiAnnotation copyNotNullAnnotation(@NotNull PsiModifierListOwner original, @NotNull PsiModifierListOwner generated) { + return copyAnnotation(getNotNullAnnotation(original, false), generated); + } + + @Nullable + public PsiAnnotation copyNullableOrNotNullAnnotation(@NotNull PsiModifierListOwner original, @NotNull PsiModifierListOwner generated) { + PsiAnnotation annotation = getNullableAnnotation(original, false); + if (annotation == null) annotation = getNotNullAnnotation(original, false); + return copyAnnotation(annotation, generated); + } + + @Nullable + private PsiAnnotation copyAnnotation(PsiAnnotation annotation, PsiModifierListOwner target) { + // type annotations are part of target's type and should not to be copied explicitly to avoid duplication + if (annotation != null && !AnnotationTargetUtil.isTypeAnnotation(annotation)) { + String qualifiedName = checkContainer(annotation, false); + if (qualifiedName != null) { + PsiModifierList modifierList = target.getModifierList(); + if (modifierList != null && modifierList.findAnnotation(qualifiedName) == null) { + return modifierList.addAnnotation(qualifiedName); + } + } + } + + return null; + } + + /** @deprecated use {@link #copyNotNullAnnotation(PsiModifierListOwner, PsiModifierListOwner)} (to be removed in IDEA 17) */ + @SuppressWarnings("unused") public PsiAnnotation copyNotNullAnnotation(PsiModifierListOwner owner) { return copyAnnotation(owner, getNotNullAnnotation(owner, false)); } + /** @deprecated use {@link #copyNullableOrNotNullAnnotation(PsiModifierListOwner, PsiModifierListOwner)} (to be removed in IDEA 17) */ + @SuppressWarnings("unused") public PsiAnnotation copyNullableAnnotation(PsiModifierListOwner owner) { return copyAnnotation(owner, getNullableAnnotation(owner, false)); } diff --git a/java/java-psi-api/src/com/intellij/psi/util/PropertyUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PropertyUtil.java index ad7c721d9178..083d5e36b050 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/PropertyUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/PropertyUtil.java @@ -401,7 +401,7 @@ public class PropertyUtil { PsiUtil.setModifierProperty(getMethod, PsiModifier.STATIC, true); } - annotateWithNullableStuff(field, getMethod); + NullableNotNullManager.getInstance(project).copyNullableOrNotNullAnnotation(field, getMethod); PsiCodeBlock body = factory.createCodeBlockFromText("{\nreturn " + name + ";\n}", null); getMethod.getBody().replace(body); @@ -457,7 +457,7 @@ public class PropertyUtil { String parameterName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER); PsiParameter param = factory.createParameter(parameterName, field.getType()); - annotateWithNullableStuff(field, param); + NullableNotNullManager.getInstance(project).copyNullableOrNotNullAnnotation(field, param); setMethod.getParameterList().add(param); PsiUtil.setModifierProperty(setMethod, PsiModifier.PUBLIC, true); @@ -496,27 +496,11 @@ public class PropertyUtil { } } + /** @deprecated use {@link NullableNotNullManager#copyNullableOrNotNullAnnotation(PsiModifierListOwner, PsiModifierListOwner)} (to be removed in IDEA 17) */ + @SuppressWarnings("unused") public static void annotateWithNullableStuff(@NotNull PsiModifierListOwner field, - @NotNull PsiModifierListOwner listOwner) - throws IncorrectOperationException { - final NullableNotNullManager manager = NullableNotNullManager.getInstance(field.getProject()); - final PsiAnnotation notNull = manager.copyNotNullAnnotation(field); - if (notNull != null) { - annotate(listOwner, notNull); - } - else { - final PsiAnnotation nullable = manager.copyNullableAnnotation(field); - if (nullable != null) { - annotate(listOwner, nullable); - } - } - } - - private static void annotate(@NotNull PsiModifierListOwner listOwner, @NotNull PsiAnnotation annotation) - throws IncorrectOperationException { - final PsiModifierList modifierList = listOwner.getModifierList(); - LOG.assertTrue(modifierList != null); - modifierList.addAfter(annotation, null); + @NotNull PsiModifierListOwner listOwner) throws IncorrectOperationException { + NullableNotNullManager.getInstance(field.getProject()).copyNullableOrNotNullAnnotation(field, listOwner); } public static String suggestPropertyName(@NotNull PsiField field) { diff --git a/java/java-tests/testData/codeInsight/generateConstructor/afterTypeAnnotatedField.java b/java/java-tests/testData/codeInsight/generateConstructor/afterTypeAnnotatedField.java new file mode 100644 index 000000000000..ed93b18df223 --- /dev/null +++ b/java/java-tests/testData/codeInsight/generateConstructor/afterTypeAnnotatedField.java @@ -0,0 +1,9 @@ +import foo.TestNotNull; + +class C { + private @TestNotNull String s; + + public C(@TestNotNull String s) { + this.s = s; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/generateConstructor/beforeTypeAnnotatedField.java b/java/java-tests/testData/codeInsight/generateConstructor/beforeTypeAnnotatedField.java new file mode 100644 index 000000000000..0604a7f0fd79 --- /dev/null +++ b/java/java-tests/testData/codeInsight/generateConstructor/beforeTypeAnnotatedField.java @@ -0,0 +1,7 @@ +import foo.TestNotNull; + +class C { + private @TestNotNull String s; + + +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/GenerateConstructorTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/GenerateConstructorTest.java index 9e5dc005c7da..ff8283f95238 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/GenerateConstructorTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/GenerateConstructorTest.java @@ -15,21 +15,36 @@ */ package com.intellij.codeInsight; +import com.intellij.JavaTestUtil; import com.intellij.codeInsight.generation.ClassMember; import com.intellij.codeInsight.generation.GenerateConstructorHandler; import com.intellij.lang.java.JavaLanguage; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Disposer; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; -import com.intellij.testFramework.LightCodeInsightTestCase; +import com.intellij.testFramework.LightProjectDescriptor; +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; +import org.jetbrains.annotations.NotNull; import java.util.List; /** * @author ven */ -public class GenerateConstructorTest extends LightCodeInsightTestCase { +public class GenerateConstructorTest extends LightCodeInsightFixtureTestCase { + @NotNull + @Override + protected LightProjectDescriptor getProjectDescriptor() { + return JAVA_8; + } + + @Override + protected String getBasePath() { + return JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/generateConstructor"; + } + public void testAbstractClass() { doTest(); } public void testPackageLocalClass() { doTest(); } public void testPrivateClass() { doTest(); } @@ -61,13 +76,21 @@ public class GenerateConstructorTest extends LightCodeInsightTestCase { doTest(); } + public void testTypeAnnotatedField() { + myFixture.addClass("package foo;\n\nimport java.lang.annotation.*;\n\n@Target(ElementType.TYPE_USE) public @interface TestNotNull { }"); + NullableNotNullManager manager = NullableNotNullManager.getInstance(getProject()); + manager.setNotNulls("foo.TestNotNull"); + Disposer.register(myTestRootDisposable, manager::setNotNulls); + doTest(); + } + private void doTest() { doTest(false); } private void doTest(boolean preSelect) { String name = getTestName(false); - configureByFile("/codeInsight/generateConstructor/before" + name + ".java"); + myFixture.configureByFile("before" + name + ".java"); new GenerateConstructorHandler() { @Override protected ClassMember[] chooseMembers(ClassMember[] members, boolean allowEmpty, boolean copyJavadoc, Project project, Editor editor) { @@ -80,6 +103,6 @@ public class GenerateConstructorTest extends LightCodeInsightTestCase { } } }.invoke(getProject(), getEditor(), getFile()); - checkResultByFile("/codeInsight/generateConstructor/after" + name + ".java"); + myFixture.checkResultByFile("after" + name + ".java"); } } \ No newline at end of file diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyPropertyUtils.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyPropertyUtils.java index 7bbe205e61c4..e7afbeaa25ea 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyPropertyUtils.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyPropertyUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2014 JetBrains s.r.o. + * Copyright 2000-2015 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -554,35 +554,17 @@ public class GroovyPropertyUtils { } } - private static void annotateWithNullableStuff(final PsiModifierListOwner field, final PsiModifierListOwner listOwner) - throws IncorrectOperationException { - final NullableNotNullManager manager = NullableNotNullManager.getInstance(field.getProject()); - final PsiAnnotation notNull = manager.copyNotNullAnnotation(field); - if (notNull != null) { - annotate(listOwner, notNull); - } - else { - final PsiAnnotation nullable = manager.copyNullableAnnotation(field); - if (nullable != null) { - annotate(listOwner, nullable); - } - } + @SuppressWarnings("MagicConstant") + private static void annotateWithNullableStuff(PsiModifierListOwner original, + PsiModifierListOwner generated) throws IncorrectOperationException { + NullableNotNullManager.getInstance(original.getProject()).copyNullableOrNotNullAnnotation(original, generated); - final PsiModifierList modifierList = listOwner.getModifierList(); - if (modifierList.hasExplicitModifier(GrModifier.DEF)) { + PsiModifierList modifierList = generated.getModifierList(); + if (modifierList != null && modifierList.hasExplicitModifier(GrModifier.DEF)) { LOG.assertTrue(modifierList instanceof GrModifierList); if (modifierList.getAnnotations().length > 0 || ((GrModifierList)modifierList).getModifiers().length > 1) { - ((GrModifierList)modifierList).setModifierProperty(GrModifier.DEF, false); + modifierList.setModifierProperty(GrModifier.DEF, false); } } } - - private static void annotate(final PsiModifierListOwner listOwner, final PsiAnnotation annotation) - throws IncorrectOperationException { - final PsiModifierList modifierList = listOwner.getModifierList(); - LOG.assertTrue(modifierList != null); - modifierList.addAnnotation(annotation.getQualifiedName()); - } - - }