From c936456649170bc9b4ff872b42b5da4e28a11ff4 Mon Sep 17 00:00:00 2001 From: Dave Griffith Date: Fri, 4 Feb 2005 17:35:51 +0300 Subject: [PATCH] (no message) --- plugins/InspectionGadgets/Leftovers.txt | 27 ++- .../com/siyeh/ig/InspectionGadgetsPlugin.java | 2 +- .../AnonymousInnerClassInspection.java | 12 +- .../LimitedScopeInnerClassInspection.java | 11 +- ...gnmentToCatchBlockParameterInspection.java | 140 ++++++++++++++-- ...AssignmentToMethodParameterInspection.java | 158 ++++++++++++++---- .../ImplicitCallToSuperInspection.java | 3 +- ...ComplexArithmeticExpressionInspection.java | 12 +- ...rlyComplexBooleanExpressionInspection.java | 16 +- .../com/siyeh/ig/fixes/ExtractMethodFix.java | 24 +++ .../ig/naming/QuestionableNameInspection.java | 10 ++ .../SynchronizedMethodInspection.java | 62 ++++++- .../ig/verbose/ExtendsObjectInspection.java | 10 +- .../SynchronizedMethodInspection.java | 14 +- 14 files changed, 417 insertions(+), 84 deletions(-) create mode 100644 plugins/InspectionGadgets/src/com/siyeh/ig/fixes/ExtractMethodFix.java diff --git a/plugins/InspectionGadgets/Leftovers.txt b/plugins/InspectionGadgets/Leftovers.txt index 2fed59b71ca6..b81293ddb6a5 100644 --- a/plugins/InspectionGadgets/Leftovers.txt +++ b/plugins/InspectionGadgets/Leftovers.txt @@ -13,13 +13,36 @@ Paired open/close for Sockets Paired open/close for Channels Paired acquire/release for Locks - - Questionable name + Local variable may be moved to first use; + Duplicate condition Boolean method name must begin with Non-Boolean method name cannot begin with Equals methods that do not check parameter type Call to simple getter or setter from within class Copyright comment + Tail recursion quickfix + Make "Merge else-if" understand chained returning ifs + "Extract method" as quickfix to overly complex expression + Static inheritance fix + Fixes for the assignment and return encapsulation inspections + Static import fix + Fixes for call to super for JUnit setUp() and tearDown() + Check IDs for all inspections + Flag inspections with default on-off and default warning level + Check that refactoring quickfixes are only available on-the-fly + Quick fix for "Constant StringBuffer may be String" + Quick fix for Non-constant String should be StringBuffer + Quick fix for "String concatenation in loop" + Quick fix for "StringBuffer may be StringBuilder" + Genericize "StringBuffer.toString() in concatenation" + Split "Portability Issues" into "Portability Issues" and "JDK issues" + QuickFix for "Confusing else Branch" + QuickFix for "Conditional expression with negated condition" + QuickFix for "Method names differing only by case" + QuickFix for "Integer difision in floating point context" + Quickfix for "Non-serializable class with..." + Quickfix for "Unnecessary default" + Inheritance as type def (change the EmptyClass inspection) changing multiply/divide to shift may change precedence! diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/InspectionGadgetsPlugin.java b/plugins/InspectionGadgets/src/com/siyeh/ig/InspectionGadgetsPlugin.java index c063373bf036..339894fe3fce 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/InspectionGadgetsPlugin.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/InspectionGadgetsPlugin.java @@ -114,7 +114,7 @@ public class InspectionGadgetsPlugin implements ApplicationComponent, final Class aClass = classes[i]; final String className = aClass.getName(); final String simpleClassName = className.substring(className.lastIndexOf('.') + 1, className.length() - "Inspection".length()); - final String fileName = "C:/InspectionGadgetsCVS/src/inspectionDescriptions/" + simpleClassName + ".html"; + final String fileName = "C:/InspectionGadgetsSVN/src/inspectionDescriptions/" + simpleClassName + ".html"; if (!new File(fileName).exists()) { out.println("Couldn't find documentation file " + fileName); } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/AnonymousInnerClassInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/AnonymousInnerClassInspection.java index 584ddaacb73b..3c052ac70c98 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/AnonymousInnerClassInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/AnonymousInnerClassInspection.java @@ -2,12 +2,12 @@ package com.siyeh.ig.classlayout; import com.intellij.codeInspection.InspectionManager; import com.intellij.psi.*; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.ClassInspection; -import com.siyeh.ig.GroupNames; +import com.siyeh.ig.*; +import com.siyeh.ig.fixes.MoveAnonymousToInnerClassFix; public class AnonymousInnerClassInspection extends ClassInspection { + private final MoveAnonymousToInnerClassFix fix = + new MoveAnonymousToInnerClassFix(); public String getDisplayName() { return "Anonymous inner class"; @@ -21,6 +21,10 @@ public class AnonymousInnerClassInspection extends ClassInspection { return "Anonymous inner class #ref #loc"; } + protected InspectionGadgetsFix buildFix(PsiElement location){ + return fix; + } + public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) { return new AnonymousInnerClassVisitor(this, inspectionManager, onTheFly); } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/LimitedScopeInnerClassInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/LimitedScopeInnerClassInspection.java index 6529ee2c13be..e9a442eeba5d 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/LimitedScopeInnerClassInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/classlayout/LimitedScopeInnerClassInspection.java @@ -2,13 +2,12 @@ package com.siyeh.ig.classlayout; import com.intellij.codeInspection.InspectionManager; import com.intellij.psi.*; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.ClassInspection; -import com.siyeh.ig.GroupNames; +import com.siyeh.ig.*; +import com.siyeh.ig.fixes.MoveClassFix; public class LimitedScopeInnerClassInspection extends ClassInspection { + private final MoveClassFix fix = new MoveClassFix(); public String getDisplayName() { return "Limited-scope class"; } @@ -21,6 +20,10 @@ public class LimitedScopeInnerClassInspection extends ClassInspection { return "Limited-scope inner class #ref #loc"; } + protected InspectionGadgetsFix buildFix(PsiElement location){ + return fix; + } + public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) { return new LimitedScopeInnerClassVisitor(this, inspectionManager, onTheFly); } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToCatchBlockParameterInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToCatchBlockParameterInspection.java index 7d5a83569591..71b63213e3a9 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToCatchBlockParameterInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToCatchBlockParameterInspection.java @@ -1,55 +1,159 @@ package com.siyeh.ig.confusing; import com.intellij.codeInspection.InspectionManager; +import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.psi.*; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.ExpressionInspection; -import com.siyeh.ig.GroupNames; +import com.intellij.psi.codeStyle.CodeStyleManager; +import com.intellij.psi.codeStyle.SuggestedNameInfo; +import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.openapi.project.Project; +import com.intellij.util.IncorrectOperationException; +import com.siyeh.ig.*; import com.siyeh.ig.psiutils.WellFormednessUtils; -public class AssignmentToCatchBlockParameterInspection extends ExpressionInspection { +public class AssignmentToCatchBlockParameterInspection + extends ExpressionInspection{ + private AssignmentToCatchBlockParameterFix fix = + new AssignmentToCatchBlockParameterFix(); - public String getDisplayName() { + public String getDisplayName(){ return "Assignment to catch block parameter"; } - public String getGroupDisplayName() { + public String getGroupDisplayName(){ return GroupNames.CONFUSING_GROUP_NAME; } - public String buildErrorString(PsiElement location) { + public String buildErrorString(PsiElement location){ return "Assignment to catch block parameter #ref #loc "; } - public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) { - return new AssignmentToCatchBlockParameterVisitor(this, inspectionManager, onTheFly); + protected InspectionGadgetsFix buildFix(PsiElement location){ + return fix; } - private static class AssignmentToCatchBlockParameterVisitor extends BaseInspectionVisitor { - private AssignmentToCatchBlockParameterVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) { + private static class AssignmentToCatchBlockParameterFix + extends InspectionGadgetsFix{ + public String getName(){ + return "Extract parameter as local variable"; + } + + public void applyFix(Project project, + ProblemDescriptor problemDescriptor){ + try{ + final PsiExpression variable = + (PsiExpression) problemDescriptor.getPsiElement(); + final PsiCatchSection catchSection = + (PsiCatchSection) PsiTreeUtil.getParentOfType(variable, + PsiCatchSection.class); + + final PsiCodeBlock body = catchSection.getCatchBlock(); + final String replacementText; + final PsiType type = variable.getType(); + + final PsiManager psiManager = PsiManager.getInstance(project); + + final CodeStyleManager codeStyleManager = + psiManager.getCodeStyleManager(); + final String originalVariableName = variable.getText(); + final SuggestedNameInfo suggestions = + codeStyleManager.suggestVariableName(VariableKind.LOCAL_VARIABLE, + originalVariableName + + '1', + variable, type); + final String[] names = suggestions.names; + final String baseName; + if(names != null && names.length > 0){ + baseName = names[0]; + } else{ + baseName = "value"; + } + final String variableName = + codeStyleManager.suggestUniqueVariableName(baseName, + catchSection, + false); + final String className = type.getPresentableText(); + final PsiElement[] children = body.getChildren(); + final StringBuffer buffer = new StringBuffer(); + for(int i = 1; i < children.length; i++){ + replaceVariableName(children[i], variableName, + originalVariableName, buffer); + } + replacementText = '{' + className + ' ' + variableName + " = " + + originalVariableName + + ';' + + buffer.toString(); + + final PsiElementFactory elementFactory = + psiManager.getElementFactory(); + final PsiCodeBlock block = + elementFactory.createCodeBlockFromText(replacementText, + null); + body.replace(block); + codeStyleManager.reformat(catchSection); + } catch(IncorrectOperationException e){ + } + } + + private void replaceVariableName(PsiElement element, + String newName, + String originalName, + StringBuffer out){ + + final String text = element.getText(); + if(element instanceof PsiReferenceExpression){ + if(text.equals(originalName)){ + out.append(newName); + return; + } + } + final PsiElement[] children = element.getChildren(); + if(children.length == 0){ + out.append(text); + } else{ + for(int i = 0; i < children.length; i++){ + final PsiElement child = children[i]; + replaceVariableName(child, newName, + originalName, out); + } + } + } + } + + public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, + boolean onTheFly){ + return new AssignmentToCatchBlockParameterVisitor(this, + inspectionManager, + onTheFly); + } + + private static class AssignmentToCatchBlockParameterVisitor + extends BaseInspectionVisitor{ + private AssignmentToCatchBlockParameterVisitor(BaseInspection inspection, + InspectionManager inspectionManager, + boolean isOnTheFly){ super(inspection, inspectionManager, isOnTheFly); } - public void visitAssignmentExpression(PsiAssignmentExpression expression) { + public void visitAssignmentExpression(PsiAssignmentExpression expression){ super.visitAssignmentExpression(expression); if(!WellFormednessUtils.isWellFormed(expression)){ return; } final PsiExpression lhs = expression.getLExpression(); - if (!(lhs instanceof PsiReferenceExpression)) { + if(!(lhs instanceof PsiReferenceExpression)){ return; } final PsiReferenceExpression ref = (PsiReferenceExpression) lhs; final PsiElement variable = ref.resolve(); - if (!(variable instanceof PsiParameter)) { + if(!(variable instanceof PsiParameter)){ return; } - if (!(((PsiParameter)variable).getDeclarationScope() instanceof PsiCatchSection)) { + if(!(((PsiParameter) variable).getDeclarationScope() instanceof PsiCatchSection)){ return; } - registerError(expression); + registerError(lhs); } } - } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToMethodParameterInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToMethodParameterInspection.java index ba35c30d1b43..6ce502d52bb1 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToMethodParameterInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/AssignmentToMethodParameterInspection.java @@ -1,38 +1,138 @@ package com.siyeh.ig.confusing; import com.intellij.codeInspection.InspectionManager; +import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.psi.*; +import com.intellij.psi.codeStyle.CodeStyleManager; +import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.codeStyle.SuggestedNameInfo; +import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.tree.IElementType; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.ExpressionInspection; -import com.siyeh.ig.GroupNames; +import com.intellij.openapi.project.Project; +import com.intellij.util.IncorrectOperationException; +import com.siyeh.ig.*; import com.siyeh.ig.psiutils.WellFormednessUtils; -public class AssignmentToMethodParameterInspection extends ExpressionInspection { +public class AssignmentToMethodParameterInspection extends ExpressionInspection{ + private AssignmentToMethodParameterFix fix = + new AssignmentToMethodParameterFix(); - public String getDisplayName() { + public String getDisplayName(){ return "Assignment to method parameter"; } - public String getGroupDisplayName() { + public String getGroupDisplayName(){ return GroupNames.CONFUSING_GROUP_NAME; } - public String buildErrorString(PsiElement location) { + public String buildErrorString(PsiElement location){ return "Assignment to method parameter #ref #loc "; } - public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) { - return new AssignmentToMethodParameterVisitor(this, inspectionManager, onTheFly); + protected InspectionGadgetsFix buildFix(PsiElement location){ + return fix; } - private static class AssignmentToMethodParameterVisitor extends BaseInspectionVisitor { - private AssignmentToMethodParameterVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) { + private static class AssignmentToMethodParameterFix + extends InspectionGadgetsFix{ + public String getName(){ + return "Extract parameter as local variable"; + } + + public void applyFix(Project project, + ProblemDescriptor problemDescriptor){ + try{ + final PsiExpression variable = + (PsiExpression) problemDescriptor.getPsiElement(); + final PsiMethod method = + (PsiMethod) PsiTreeUtil.getParentOfType(variable, + PsiMethod.class); + + final PsiCodeBlock body = method.getBody(); + final String replacementText; + final PsiType type = variable.getType(); + + final PsiManager psiManager = PsiManager.getInstance(project); + + final CodeStyleManager codeStyleManager = + psiManager.getCodeStyleManager(); + final String originalVariableName = variable.getText(); + final SuggestedNameInfo suggestions = + codeStyleManager.suggestVariableName(VariableKind.LOCAL_VARIABLE, + originalVariableName + '1', variable, type); + final String[] names = suggestions.names; + final String baseName; + if(names != null && names.length > 0){ + baseName = names[0]; + } else{ + baseName = "value"; + } + final String variableName = + codeStyleManager.suggestUniqueVariableName(baseName, + method, + false); + final String className = type.getPresentableText(); + final PsiElement[] children = body.getChildren(); + final StringBuffer buffer = new StringBuffer(); + for(int i = 1; i < children.length; i++){ + replaceVariableName( children[i], variableName, originalVariableName, buffer); + } + replacementText = '{' + className + ' ' + variableName + " = " + + originalVariableName + + ';' + + buffer.toString(); + + final PsiElementFactory elementFactory = + psiManager.getElementFactory(); + final PsiCodeBlock block = + elementFactory.createCodeBlockFromText(replacementText, + null); + body.replace(block); + codeStyleManager.reformat(method); + } catch(IncorrectOperationException e){ + } + } + + private void replaceVariableName(PsiElement element, + String newName, + String originalName, + StringBuffer out){ + + final String text = element.getText(); + if(element instanceof PsiReferenceExpression){ + if(text.equals(originalName)){ + out.append(newName); + return; + } + } + final PsiElement[] children = element.getChildren(); + if(children.length == 0){ + out.append(text); + } else{ + for(int i = 0; i < children.length; i++){ + final PsiElement child = children[i]; + replaceVariableName(child, newName, + originalName, out); + } + } + } + } + + public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, + boolean onTheFly){ + return new AssignmentToMethodParameterVisitor(this, inspectionManager, + onTheFly); + } + + private static class AssignmentToMethodParameterVisitor + extends BaseInspectionVisitor{ + private AssignmentToMethodParameterVisitor(BaseInspection inspection, + InspectionManager inspectionManager, + boolean isOnTheFly){ super(inspection, inspectionManager, isOnTheFly); } - public void visitAssignmentExpression(PsiAssignmentExpression expression) { + public void visitAssignmentExpression(PsiAssignmentExpression expression){ super.visitAssignmentExpression(expression); if(!WellFormednessUtils.isWellFormed(expression)){ return; @@ -41,56 +141,56 @@ public class AssignmentToMethodParameterInspection extends ExpressionInspection checkForMethodParam(lhs); } - public void visitPrefixExpression(PsiPrefixExpression expression) { + public void visitPrefixExpression(PsiPrefixExpression expression){ super.visitPrefixExpression(expression); final PsiJavaToken sign = expression.getOperationSign(); - if (sign == null) { + if(sign == null){ return; } final IElementType tokenType = sign.getTokenType(); - if (!tokenType.equals(JavaTokenType.PLUSPLUS) && - !tokenType.equals(JavaTokenType.MINUSMINUS)) { + if(!tokenType.equals(JavaTokenType.PLUSPLUS) && + !tokenType.equals(JavaTokenType.MINUSMINUS)){ return; } final PsiExpression operand = expression.getOperand(); - if (operand == null) { + if(operand == null){ return; } checkForMethodParam(operand); } - public void visitPostfixExpression(PsiPostfixExpression expression) { + public void visitPostfixExpression(PsiPostfixExpression expression){ super.visitPostfixExpression(expression); final PsiJavaToken sign = expression.getOperationSign(); - if (sign == null) { + if(sign == null){ return; } final IElementType tokenType = sign.getTokenType(); - if (!tokenType.equals(JavaTokenType.PLUSPLUS) && - !tokenType.equals(JavaTokenType.MINUSMINUS)) { + if(!tokenType.equals(JavaTokenType.PLUSPLUS) && + !tokenType.equals(JavaTokenType.MINUSMINUS)){ return; } final PsiExpression operand = expression.getOperand(); - if (operand == null) { + if(operand == null){ return; } checkForMethodParam(operand); } - private void checkForMethodParam(PsiExpression expression) { - if (!(expression instanceof PsiReferenceExpression)) { + private void checkForMethodParam(PsiExpression expression){ + if(!(expression instanceof PsiReferenceExpression)){ return; } - final PsiReferenceExpression ref = (PsiReferenceExpression) expression; + final PsiReferenceExpression ref = + (PsiReferenceExpression) expression; final PsiElement variable = ref.resolve(); - if (!(variable instanceof PsiParameter)) { + if(!(variable instanceof PsiParameter)){ return; } - if (((PsiParameter)variable).getDeclarationScope() instanceof PsiCatchSection) { + if(((PsiParameter) variable).getDeclarationScope() instanceof PsiCatchSection){ return; } registerError(expression); } } - } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/ImplicitCallToSuperInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/ImplicitCallToSuperInspection.java index 496e92fbc839..141439b3fb9b 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/ImplicitCallToSuperInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/ImplicitCallToSuperInspection.java @@ -10,6 +10,7 @@ import com.intellij.util.IncorrectOperationException; import com.siyeh.ig.*; public class ImplicitCallToSuperInspection extends MethodInspection { + private final AddExplicitSuperCall fix = new AddExplicitSuperCall(); public String getDisplayName() { return "Implicit call to super()"; @@ -24,7 +25,7 @@ public class ImplicitCallToSuperInspection extends MethodInspection { } public InspectionGadgetsFix buildFix(PsiElement location) { - return new AddExplicitSuperCall(); + return fix; } private static class AddExplicitSuperCall extends InspectionGadgetsFix { diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexArithmeticExpressionInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexArithmeticExpressionInspection.java index c3ce028ca7a8..159ba9dba1fa 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexArithmeticExpressionInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexArithmeticExpressionInspection.java @@ -3,10 +3,8 @@ package com.siyeh.ig.confusing; import com.intellij.codeInspection.InspectionManager; import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.GroupNames; -import com.siyeh.ig.StatementInspection; +import com.siyeh.ig.*; +import com.siyeh.ig.fixes.ExtractMethodFix; import com.siyeh.ig.psiutils.TypeUtils; import com.siyeh.ig.ui.SingleIntegerFieldOptionsPanel; @@ -17,6 +15,8 @@ public class OverlyComplexArithmeticExpressionInspection extends StatementInspec public int m_limit = TERM_LIMIT; //this is public for the DefaultJDOMExternalizer thingy + private InspectionGadgetsFix fix = new ExtractMethodFix(); + public String getDisplayName() { return "Overly complex arithmetic expression"; } @@ -38,6 +38,10 @@ public class OverlyComplexArithmeticExpressionInspection extends StatementInspec return "Overly complex arithmetic expression #loc"; } + protected InspectionGadgetsFix buildFix(PsiElement location){ + return fix; + } + public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) { return new SwitchStatementWithTooManyBranchesVisitor(this, inspectionManager, onTheFly); } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexBooleanExpressionInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexBooleanExpressionInspection.java index a23d41232ca3..59db51bdce99 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexBooleanExpressionInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/confusing/OverlyComplexBooleanExpressionInspection.java @@ -3,10 +3,8 @@ package com.siyeh.ig.confusing; import com.intellij.codeInspection.InspectionManager; import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.GroupNames; -import com.siyeh.ig.StatementInspection; +import com.siyeh.ig.*; +import com.siyeh.ig.fixes.ExtractMethodFix; import com.siyeh.ig.ui.SingleIntegerFieldOptionsPanel; import javax.swing.*; @@ -16,6 +14,8 @@ public class OverlyComplexBooleanExpressionInspection extends StatementInspectio public int m_limit = TERM_LIMIT; //this is public for the DefaultJDOMExternalizer thingy + private InspectionGadgetsFix fix = new ExtractMethodFix(); + public String getDisplayName() { return "Overly complex boolean expression"; } @@ -33,6 +33,14 @@ public class OverlyComplexBooleanExpressionInspection extends StatementInspectio this, "m_limit"); } + protected boolean buildQuickFixesOnlyForOnTheFlyErrors(){ + return true; + } + + protected InspectionGadgetsFix buildFix(PsiElement location){ + return fix; + } + protected String buildErrorString(PsiElement location) { return "Overly complex boolean expression #loc"; } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/fixes/ExtractMethodFix.java b/plugins/InspectionGadgets/src/com/siyeh/ig/fixes/ExtractMethodFix.java new file mode 100644 index 000000000000..adf2625346c4 --- /dev/null +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/fixes/ExtractMethodFix.java @@ -0,0 +1,24 @@ +package com.siyeh.ig.fixes; + +import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiExpression; +import com.intellij.refactoring.RefactoringActionHandler; +import com.intellij.refactoring.RefactoringActionHandlerFactory; +import com.siyeh.ig.InspectionGadgetsFix; + +public class ExtractMethodFix extends InspectionGadgetsFix { + + public String getName() { + return "Extract method"; + } + + public void applyFix(Project project, ProblemDescriptor problemDescriptor) { + final PsiExpression expression = (PsiExpression) problemDescriptor.getPsiElement(); + final RefactoringActionHandlerFactory factory = + RefactoringActionHandlerFactory.getInstance(); + final RefactoringActionHandler inlineHandler = factory.createExtractMethodHandler(); + inlineHandler.invoke(project, new PsiElement[]{expression}, null); + } +} diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/naming/QuestionableNameInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/naming/QuestionableNameInspection.java index d9bdd34abd34..311003a57984 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/naming/QuestionableNameInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/naming/QuestionableNameInspection.java @@ -5,6 +5,7 @@ import com.intellij.openapi.util.InvalidDataException; import com.intellij.openapi.util.WriteExternalException; import com.intellij.psi.*; import com.siyeh.ig.*; +import com.siyeh.ig.fixes.RenameFix; import org.jdom.Element; import javax.swing.*; @@ -19,6 +20,7 @@ import java.util.List; public class QuestionableNameInspection extends ClassInspection{ public String nameCheckString = "foo,bar,baz"; + private final RenameFix fix = new RenameFix(); private List nameList = new ArrayList(32); @@ -72,6 +74,14 @@ public class QuestionableNameInspection extends ClassInspection{ return form.getContentPanel(); } + protected InspectionGadgetsFix buildFix(PsiElement location){ + return fix; + } + + protected boolean buildQuickFixesOnlyForOnTheFlyErrors(){ + return true; + } + public String buildErrorString(PsiElement location){ return "Questionable name '#ref'. #loc "; } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/threading/SynchronizedMethodInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/threading/SynchronizedMethodInspection.java index 950780664fdc..9d931e35f5d2 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/threading/SynchronizedMethodInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/threading/SynchronizedMethodInspection.java @@ -1,20 +1,18 @@ package com.siyeh.ig.threading; import com.intellij.codeInspection.InspectionManager; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; -import com.intellij.psi.PsiModifier; -import com.intellij.psi.PsiModifierList; -import com.siyeh.ig.BaseInspection; -import com.siyeh.ig.BaseInspectionVisitor; -import com.siyeh.ig.GroupNames; -import com.siyeh.ig.MethodInspection; +import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.psi.*; +import com.intellij.openapi.project.Project; +import com.intellij.util.IncorrectOperationException; +import com.siyeh.ig.*; import com.siyeh.ig.ui.SingleCheckboxOptionsPanel; import javax.swing.*; public class SynchronizedMethodInspection extends MethodInspection { public boolean m_includeNativeMethods = true; + private SynchronizedMethodFix fix = new SynchronizedMethodFix(); public String getDisplayName() { return "'synchronized' method"; @@ -30,6 +28,16 @@ public class SynchronizedMethodInspection extends MethodInspection { return "Method " + method.getName() + "() declared '#ref' #loc"; } + protected InspectionGadgetsFix buildFix(PsiElement location){ + final PsiMethod method = (PsiMethod) location.getParent().getParent(); + if(method.getBody()== null) + { + return null; + } + + return fix; + } + public BaseInspectionVisitor createVisitor(InspectionManager inspectionManager, boolean onTheFly) { return new SynchronizedMethodVisitor(this, inspectionManager, onTheFly); } @@ -39,6 +47,44 @@ public class SynchronizedMethodInspection extends MethodInspection { this, "m_includeNativeMethods"); } + public static class SynchronizedMethodFix extends InspectionGadgetsFix{ + public String getName(){ + return "Move synchronization into method"; + } + + public void applyFix(Project project, + ProblemDescriptor problemDescriptor){ + try{ + final PsiElement nameElement = + problemDescriptor.getPsiElement(); + final PsiMethod method = + (PsiMethod) nameElement.getParent().getParent(); + method.getModifierList() + .setModifierProperty(PsiModifier.SYNCHRONIZED, false); + final PsiCodeBlock body = method.getBody(); + final String text = body.getText(); + final String replacementText; + if(method.hasModifierProperty(PsiModifier.STATIC)){ + final PsiClass containingClass = method.getContainingClass(); + final String className = containingClass.getName(); + replacementText = "{ synchronized(" + className + ".class){" + + text.substring(1) + '}'; + } else{ + replacementText = "{ synchronized(this){" + text.substring(1) + '}'; + } + final PsiManager psiManager = PsiManager.getInstance(project); + final PsiElementFactory elementFactory = + psiManager.getElementFactory(); + final PsiCodeBlock block = + elementFactory.createCodeBlockFromText(replacementText, + null); + body.replace(block); + psiManager.getCodeStyleManager().reformat(method); + } catch(IncorrectOperationException e){ + } + } + } + private class SynchronizedMethodVisitor extends BaseInspectionVisitor { private SynchronizedMethodVisitor(BaseInspection inspection, InspectionManager inspectionManager, boolean isOnTheFly) { super(inspection, inspectionManager, isOnTheFly); diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/verbose/ExtendsObjectInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/verbose/ExtendsObjectInspection.java index c978fa936cde..840d08026f9d 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/verbose/ExtendsObjectInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/verbose/ExtendsObjectInspection.java @@ -61,9 +61,13 @@ public class ExtendsObjectInspection extends ClassInspection { final PsiJavaCodeReferenceElement[] elements = extendsList.getReferenceElements(); for (int i = 0; i < elements.length; i++) { final PsiJavaCodeReferenceElement element = elements[i]; - final String text = element.getText(); - if ("Object".equals(text) || "java.lang.Object".equals(text)) { - registerClassError(aClass); + final PsiElement referent = element.resolve(); + if(referent instanceof PsiClass) + { + final String className = ((PsiClass) referent).getQualifiedName(); + if ( "java.lang.Object".equals(className)) { + registerClassError(aClass); + } } } diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/threading/SynchronizedMethodInspection.java b/plugins/InspectionGadgets/test/com/siyeh/igtest/threading/SynchronizedMethodInspection.java index ce5993af82f3..11deb79e4e63 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igtest/threading/SynchronizedMethodInspection.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/threading/SynchronizedMethodInspection.java @@ -1,11 +1,13 @@ package com.siyeh.igtest.threading; -public class SynchronizedMethodInspection -{ - public synchronized void fooBar() - { - +public class SynchronizedMethodInspection { + public synchronized void fooBar() { + System.out.println("foo"); } - + + public static synchronized void bar() { + System.out.println("foo"); + } + public synchronized native void fooBaz(); }