MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-04-19 13:02:30 +07:00
Code Issues Packages Projects Releases Wiki Activity

shorten Java and Groovy references with JavaCodeStyleManager.shortenClassReferences()

Browse Source
This commit is contained in:
Max Medvedev
2013-06-10 01:22:11 +04:00
parent 57c4367539
commit dac30636f2
13 changed files with 466 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
java/java-impl/src/com/intellij/psi/AbstractQualifiedReference.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2000-2009 JetBrains s.r.o.
* Copyright 2000-2013 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.
@@ -19,7 +19,7 @@ import com.intellij.extapi.psi.ASTWrapperPsiElement;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.impl.CheckUtil;
import com.intellij.psi.impl.source.codeStyle.ReferenceAdjuster;
import com.intellij.psi.impl.source.codeStyle.JavaReferenceAdjuster;
import com.intellij.psi.impl.source.resolve.JavaResolveUtil;
import com.intellij.psi.impl.source.resolve.ResolveCache;
import com.intellij.psi.meta.PsiMetaData;
@@ -187,7 +187,7 @@ public abstract class AbstractQualifiedReference<T extends AbstractQualifiedRefe
protected AbstractQualifiedReference shortenReferences() {
final PsiElement refElement = resolve();
if (refElement instanceof PsiClass) {
final PsiQualifiedReference reference = ReferenceAdjuster.getClassReferenceToShorten((PsiClass)refElement, false, this);
final PsiQualifiedReference reference = JavaReferenceAdjuster.getClassReferenceToShorten((PsiClass)refElement, false, this);
if (reference instanceof AbstractQualifiedReference) {
((AbstractQualifiedReference)reference).dequalify();
}

12
java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaCodeStyleManagerImpl.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2000-2012 JetBrains s.r.o.
* Copyright 2000-2013 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.
@@ -19,6 +19,7 @@
*/
package com.intellij.psi.impl.source.codeStyle;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Comparing;
@@ -29,7 +30,6 @@ import com.intellij.psi.codeStyle.*;
import com.intellij.psi.impl.CheckUtil;
import com.intellij.psi.impl.source.SourceTreeToPsiMap;
import com.intellij.psi.impl.source.jsp.jspJava.JspxImportStatement;
import com.intellij.psi.impl.source.tree.TreeElement;
import com.intellij.psi.statistics.JavaStatisticsManager;
import com.intellij.psi.util.PsiElementFilter;
import com.intellij.psi.util.PsiTreeUtil;
@@ -74,7 +74,8 @@ public class JavaCodeStyleManagerImpl extends JavaCodeStyleManager {
final boolean addImports = (flags & DO_NOT_ADD_IMPORTS) == 0;
final boolean incompleteCode = (flags & UNCOMPLETE_CODE) != 0;
final TreeElement reference = new ReferenceAdjuster(myProject).process((TreeElement)element.getNode(), addImports, incompleteCode);
final ReferenceAdjuster adjuster = ReferenceAdjusterFactory.Extension.getFactory(element.getLanguage()).createReferenceAdjuster(myProject);
final ASTNode reference = adjuster.process(element.getNode(), addImports, incompleteCode);
return SourceTreeToPsiMap.treeToPsiNotNull(reference);
}
@@ -83,13 +84,14 @@ public class JavaCodeStyleManagerImpl extends JavaCodeStyleManager {
throws IncorrectOperationException {
CheckUtil.checkWritable(element);
if (SourceTreeToPsiMap.hasTreeElement(element)) {
new ReferenceAdjuster(myProject).processRange((TreeElement)element.getNode(), startOffset, endOffset);
final ReferenceAdjuster adjuster = ReferenceAdjusterFactory.Extension.getFactory(element.getLanguage()).createReferenceAdjuster(myProject);
adjuster.processRange(element.getNode(), startOffset, endOffset);
}
}
@Override
public PsiElement qualifyClassReferences(@NotNull PsiElement element) {
final TreeElement reference = new ReferenceAdjuster(true, true).process((TreeElement)element.getNode(), false, false);
final ASTNode reference = new JavaReferenceAdjuster(true, true).process(element.getNode(), false, false);
return SourceTreeToPsiMap.treeToPsiNotNull(reference);
}

55
java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ReferenceAdjuster.java → java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaReferenceAdjuster.java
View File

@@ -16,10 +16,10 @@
package com.intellij.psi.impl.source.codeStyle;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleSettings;
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
import com.intellij.psi.codeStyle.ReferenceAdjuster;
import com.intellij.psi.impl.PsiImplUtil;
import com.intellij.psi.impl.source.PsiJavaCodeReferenceElementImpl;
import com.intellij.psi.impl.source.SourceJavaCodeReference;
@@ -34,24 +34,21 @@ import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
public class ReferenceAdjuster {
public class JavaReferenceAdjuster implements ReferenceAdjuster {
private final boolean myUseFqClassNamesInJavadoc;
private final boolean myUseFqClassNames;
public ReferenceAdjuster(boolean useFqInJavadoc, boolean useFqInCode) {
public JavaReferenceAdjuster(boolean useFqInJavadoc, boolean useFqInCode) {
myUseFqClassNamesInJavadoc = useFqInJavadoc;
myUseFqClassNames = useFqInCode;
}
public ReferenceAdjuster(Project project) {
this(CodeStyleSettingsManager.getSettings(project));
}
public ReferenceAdjuster(CodeStyleSettings settings) {
public JavaReferenceAdjuster(CodeStyleSettings settings) {
this(settings.USE_FQ_CLASS_NAMES_IN_JAVADOC, settings.USE_FQ_CLASS_NAMES);
}
public TreeElement process(TreeElement element, boolean addImports, boolean incompleteCode) {
@Override
public ASTNode process(ASTNode element, boolean addImports, boolean incompleteCode) {
IElementType elementType = element.getElementType();
if ((elementType == JavaElementType.JAVA_CODE_REFERENCE || elementType == JavaElementType.REFERENCE_EXPRESSION) && !isAnnotated(element)) {
IElementType parentType = element.getTreeParent().getElementType();
@@ -63,7 +60,7 @@ public class ReferenceAdjuster {
if (parameterList != null) {
PsiTypeElement[] typeParameters = parameterList.getTypeParameterElements();
for (PsiTypeElement typeParameter : typeParameters) {
process((TreeElement)typeParameter.getNode(), addImports, incompleteCode);
process(typeParameter.getNode(), addImports, incompleteCode);
}
}
@@ -85,8 +82,9 @@ public class ReferenceAdjuster {
refElement = ref.resolve();
}
else {
PsiResolveHelper helper = JavaPsiFacade.getInstance(element.getManager().getProject()).getResolveHelper();
refElement = helper.resolveReferencedClass(((SourceJavaCodeReference)element).getClassNameText(), ref);
PsiResolveHelper helper = JavaPsiFacade.getInstance(ref.getManager().getProject()).getResolveHelper();
final SourceJavaCodeReference reference = (SourceJavaCodeReference)element;
refElement = helper.resolveReferencedClass(reference.getClassNameText(), ref);
}
if (refElement instanceof PsiClass) {
@@ -99,26 +97,26 @@ public class ReferenceAdjuster {
if (file instanceof PsiJavaFile) {
if (ImportHelper.isImplicitlyImported(qName, (PsiJavaFile)file)) {
if (isShort) return element;
return (TreeElement)makeShortReference((CompositeElement)element, psiClass, addImports);
return makeShortReference((CompositeElement)element, psiClass, addImports);
}
String thisPackageName = ((PsiJavaFile)file).getPackageName();
if (ImportHelper.hasPackage(qName, thisPackageName)) {
if (!isShort) {
return (TreeElement)makeShortReference((CompositeElement)element, psiClass, addImports);
return makeShortReference((CompositeElement)element, psiClass, addImports);
}
}
}
return (TreeElement)replaceReferenceWithFQ(element, psiClass);
return replaceReferenceWithFQ(element, psiClass);
}
else {
int oldLength = element.getTextLength();
TreeElement treeElement = (TreeElement)makeShortReference((CompositeElement)element, psiClass, addImports);
ASTNode treeElement = makeShortReference((CompositeElement)element, psiClass, addImports);
if (treeElement.getTextLength() == oldLength && psiClass.getContainingClass() != null) {
PsiElement qualifier = ref.getQualifier();
if (qualifier instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement)qualifier).resolve() instanceof PsiClass) {
process((TreeElement)qualifier.getNode(), addImports, incompleteCode);
process(qualifier.getNode(), addImports, incompleteCode);
}
}
return treeElement;
@@ -128,7 +126,7 @@ public class ReferenceAdjuster {
}
}
for (TreeElement child = element.getFirstChildNode(); child != null; child = child.getTreeNext()) {
for (ASTNode child = element.getFirstChildNode(); child != null; child = child.getTreeNext()) {
//noinspection AssignmentToForLoopParameter
child = process(child, addImports, incompleteCode);
}
@@ -136,7 +134,7 @@ public class ReferenceAdjuster {
return element;
}
private static boolean isAnnotated(TreeElement element) {
private static boolean isAnnotated(ASTNode element) {
PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement)element.getPsi();
PsiElement qualifier = ref.getQualifier();
@@ -160,17 +158,18 @@ public class ReferenceAdjuster {
return isInsideDocComment ? myUseFqClassNamesInJavadoc : myUseFqClassNames;
}
public void processRange(TreeElement element, int startOffset, int endOffset) {
@Override
public void processRange(ASTNode element, int startOffset, int endOffset) {
List<ASTNode> array = new ArrayList<ASTNode>();
addReferencesInRange(array, element, startOffset, endOffset);
for (ASTNode ref : array) {
if (ref.getPsi().isValid()) {
process((TreeElement)ref, true, true);
process(ref, true, true);
}
}
}
private static void addReferencesInRange(List<ASTNode> array, TreeElement parent, int startOffset, int endOffset) {
private static void addReferencesInRange(List<ASTNode> array, ASTNode parent, int startOffset, int endOffset) {
if (parent.getElementType() == JavaElementType.JAVA_CODE_REFERENCE || parent.getElementType() == JavaElementType.REFERENCE_EXPRESSION) {
array.add(parent);
return;
@@ -180,7 +179,7 @@ public class ReferenceAdjuster {
JspFile jspFile = JspPsiUtil.getJspFile(parent.getPsi());
if (jspFile != null) {
JspClass jspClass = (JspClass)jspFile.getJavaClass();
addReferencesInRange(array, (TreeElement)jspClass.getNode(), startOffset, endOffset);
addReferencesInRange(array, jspClass.getNode(), startOffset, endOffset);
return;
}
}
@@ -188,9 +187,9 @@ public class ReferenceAdjuster {
addReferencesInRangeForComposite(array, parent, startOffset, endOffset);
}
private static void addReferencesInRangeForComposite(List<ASTNode> array, TreeElement parent, int startOffset, int endOffset) {
private static void addReferencesInRangeForComposite(List<ASTNode> array, ASTNode parent, int startOffset, int endOffset) {
int offset = 0;
for (TreeElement child = parent.getFirstChildNode(); child != null; child = child.getTreeNext()) {
for (ASTNode child = parent.getFirstChildNode(); child != null; child = child.getTreeNext()) {
int length = child.getTextLength();
if (startOffset <= offset + length && offset <= endOffset) {
IElementType type = child.getElementType();
@@ -214,8 +213,8 @@ public class ReferenceAdjuster {
@Nullable
public static PsiQualifiedReferenceElement getClassReferenceToShorten(@NotNull final PsiClass refClass,
final boolean addImports,
@NotNull final PsiQualifiedReferenceElement reference) {
final boolean addImports,
@NotNull final PsiQualifiedReferenceElement reference) {
PsiClass parentClass = refClass.getContainingClass();
if (parentClass != null) {
JavaPsiFacade facade = JavaPsiFacade.getInstance(parentClass.getProject());
@@ -226,7 +225,7 @@ public class ReferenceAdjuster {
if (!CodeStyleSettingsManager.getSettings(reference.getProject()).INSERT_INNER_CLASS_IMPORTS) {
final PsiElement qualifier = reference.getQualifier();
if (qualifier instanceof PsiQualifiedReference) {
if (qualifier instanceof PsiQualifiedReferenceElement) {
return getClassReferenceToShorten(parentClass, addImports, (PsiQualifiedReferenceElement)qualifier);
}
return null;

37
java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaReferenceAdjusterFactory.java Normal file
View File

@@ -0,0 +1,37 @@
/*
* Copyright 2000-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.psi.impl.source.codeStyle;
import com.intellij.openapi.project.Project;
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
import com.intellij.psi.codeStyle.ReferenceAdjuster;
import com.intellij.psi.codeStyle.ReferenceAdjusterFactory;
/**
* @author Max Medvedev
*/
public class JavaReferenceAdjusterFactory implements ReferenceAdjusterFactory {
@Override
public ReferenceAdjuster createReferenceAdjuster(boolean useFqInJavadoc, boolean useFqInCode) {
return new JavaReferenceAdjuster(useFqInJavadoc, useFqInCode);
}
@Override
public ReferenceAdjuster createReferenceAdjuster(Project project) {
return new JavaReferenceAdjuster(CodeStyleSettingsManager.getSettings(project));
}
}

27
java/java-psi-api/src/com/intellij/psi/codeStyle/ReferenceAdjuster.java Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 2000-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.psi.codeStyle;
import com.intellij.lang.ASTNode;
/**
* @author Max Medvedev
*/
public interface ReferenceAdjuster {
ASTNode process(ASTNode element, boolean addImports, boolean incompleteCode);
void processRange(ASTNode element, int startOffset, int endOffset);
}

42
java/java-psi-api/src/com/intellij/psi/codeStyle/ReferenceAdjusterFactory.java Normal file
View File

@@ -0,0 +1,42 @@
/*
* Copyright 2000-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.psi.codeStyle;
import com.intellij.lang.Language;
import com.intellij.lang.LanguageExtension;
import com.intellij.openapi.project.Project;
/**
* @author Max Medvedev
*/
public interface ReferenceAdjusterFactory {
ReferenceAdjuster createReferenceAdjuster(boolean useFqInJavadoc, boolean useFqInCode);
ReferenceAdjuster createReferenceAdjuster(Project project);
class Extension extends LanguageExtension<ReferenceAdjusterFactory> {
private static final Extension INSTANCE = new Extension();
public Extension() {
super("com.intellij.codeStyle.ReferenceAdjusterFactory");
}
public static ReferenceAdjusterFactory getFactory(Language language) {
return INSTANCE.forLanguage(language);
}
}
}

2
plugins/groovy/src/META-INF/plugin.xml
View File

@@ -1409,6 +1409,8 @@
implementation="org.jetbrains.plugins.groovy.debugger.GroovyPositionManagerFactory"/>
<debugger.positionManagerFactory order="after groovyPositionManager"
implementation="org.jetbrains.plugins.groovy.springloaded.SpringLoadedPositionManagerFactory"/>
<codeStyle.ReferenceAdjusterFactory language="Groovy"
implementationClass="org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjusterFactory"/>
</extensions>
<extensions defaultExtensionNs="com.intellij.debugger">

5
plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/confusing/UnnecessaryQualifiedReferenceInspection.java
View File

@@ -31,8 +31,8 @@ import org.jetbrains.plugins.groovy.codeInspection.BaseInspection;
import org.jetbrains.plugins.groovy.codeInspection.BaseInspectionVisitor;
import org.jetbrains.plugins.groovy.codeInspection.GroovyFix;
import org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle;
import org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster;
import org.jetbrains.plugins.groovy.codeStyle.GroovyCodeStyleSettings;
import org.jetbrains.plugins.groovy.lang.GrReferenceAdjuster;
import org.jetbrains.plugins.groovy.lang.psi.GrQualifiedReference;
import org.jetbrains.plugins.groovy.lang.psi.GrReferenceElement;
import org.jetbrains.plugins.groovy.lang.psi.GroovyFileBase;
@@ -122,7 +122,8 @@ public class UnnecessaryQualifiedReferenceInspection extends BaseInspection {
protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException {
final PsiElement startElement = descriptor.getStartElement();
LOG.assertTrue(startElement instanceof GrReferenceElement<?>);
GrReferenceAdjuster.shortenReference((GrQualifiedReference<?>)startElement);
final GrReferenceAdjuster adjuster = GrReferenceAdjuster.getInstance(project);
adjuster.shortenReference((GrQualifiedReference<?>)startElement);
}
@NotNull

247
plugins/groovy/src/org/jetbrains/plugins/groovy/codeStyle/GrReferenceAdjuster.java Normal file
View File

@@ -0,0 +1,247 @@
/*
* Copyright 2000-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.plugins.groovy.codeStyle;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
import com.intellij.psi.codeStyle.ReferenceAdjuster;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiTreeUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.debugger.fragments.GroovyCodeFragment;
import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocComment;
import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
import org.jetbrains.plugins.groovy.lang.psi.GrQualifiedReference;
import org.jetbrains.plugins.groovy.lang.psi.GrReferenceElement;
import org.jetbrains.plugins.groovy.lang.psi.GroovyFileBase;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.imports.GrImportStatement;
import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
import org.jetbrains.plugins.groovy.lang.psi.api.types.GrTypeArgumentList;
import org.jetbrains.plugins.groovy.lang.psi.impl.GrReferenceElementImpl;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrBindingVariable;
import org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil;
/**
* @author Max Medvedev
*/
public class GrReferenceAdjuster implements ReferenceAdjuster {
private final boolean myUseFqClassNamesInJavadoc;
private final boolean myUseFqClassNames;
public GrReferenceAdjuster(boolean useFqInJavadoc, boolean useFqInCode) {
myUseFqClassNamesInJavadoc = useFqInJavadoc;
myUseFqClassNames = useFqInCode;
}
public GrReferenceAdjuster(GroovyCodeStyleSettings settings) {
this(settings.USE_FQ_CLASS_NAMES_IN_JAVADOC, settings.USE_FQ_CLASS_NAMES);
}
public GrReferenceAdjuster(Project project) {
this(CodeStyleSettingsManager.getInstance(project).getCurrentSettings().getCustomSettings(GroovyCodeStyleSettings.class));
}
public static boolean seemsToBeQualifiedClassName(@Nullable GrExpression expr) {
if (expr == null) return false;
while (expr instanceof GrReferenceExpression) {
final PsiElement nameElement = ((GrReferenceExpression)expr).getReferenceNameElement();
if (((GrReferenceExpression)expr).getTypeArguments().length > 0) return false;
if (nameElement == null || nameElement.getNode().getElementType() != GroovyTokenTypes.mIDENT) return false;
IElementType dotType = ((GrReferenceExpression)expr).getDotTokenType();
if (dotType != null && dotType != GroovyTokenTypes.mDOT) return false;
expr = ((GrReferenceExpression)expr).getQualifierExpression();
}
return expr == null;
}
@Override
public ASTNode process(ASTNode element, boolean addImports, boolean incompleteCode) {
final TextRange range = element.getTextRange();
process(element.getPsi(), range.getStartOffset(), range.getEndOffset(), addImports, incompleteCode);
return element;
}
@Override
public void processRange(ASTNode element, int startOffset, int endOffset) {
process(element.getPsi(), startOffset, endOffset, true, true);
}
private boolean process(@NotNull PsiElement element, int start, int end, boolean addImports, boolean incomplete) {
boolean result = false;
if (element instanceof GrQualifiedReference<?> && ((GrQualifiedReference)element).resolve() instanceof PsiClass) {
result = shortenReferenceInner((GrQualifiedReference<?>)element, addImports, incomplete);
}
else if (element instanceof GrReferenceExpression && PsiUtil.isSuperReference(((GrReferenceExpression)element).getQualifier())) {
result = shortenReferenceInner((GrReferenceExpression)element, addImports, incomplete);
}
PsiElement child = element.getFirstChild();
while (child != null) {
final TextRange range = child.getTextRange();
if (start < range.getEndOffset() && range.getStartOffset() < end) {
result |= process(child, start, end, addImports, incomplete);
}
child = child.getNextSibling();
}
return result;
}
public <T extends PsiElement> boolean shortenReference(@NotNull GrQualifiedReference<T> ref) {
boolean result = shortenReferenceInner(ref, true, false);
final TextRange range = ref.getTextRange();
result |= process(ref, range.getStartOffset(), range.getEndOffset(), true, false);
return result;
}
private <Qualifier extends PsiElement> boolean shortenReferenceInner(@NotNull GrQualifiedReference<Qualifier> ref,
boolean addImports,
boolean incomplete) {
final Qualifier qualifier = ref.getQualifier();
if (qualifier == null || PsiUtil.isSuperReference(qualifier) || cannotShortenInContext(ref)) {
return false;
}
if (ref instanceof GrReferenceExpression) {
final GrTypeArgumentList typeArgs = ((GrReferenceExpression)ref).getTypeArgumentList();
if (typeArgs != null && typeArgs.getTypeArgumentElements().length > 0) {
return false;
}
}
if (!shorteningIsMeaningfully(ref)) return false;
final PsiElement resolved = resolveRef(ref, incomplete);
if (resolved == null) return false;
if (!checkCopyWithoutQualifier(ref, addImports, resolved)) return false;
ref.setQualifier(null);
return true;
}
private static <Qualifier extends PsiElement> boolean checkCopyWithoutQualifier(@NotNull GrQualifiedReference<Qualifier> ref,
boolean addImports,
@NotNull PsiElement resolved) {
final GrQualifiedReference<Qualifier> copy = getCopy(ref);
if (copy == null) return false;
copy.setQualifier(null);
final PsiElement resolvedCopy = copy.resolve();
if (ref.getManager().areElementsEquivalent(resolved, resolvedCopy)) {
return true;
}
else if (resolvedCopy != null && !(resolvedCopy instanceof GrBindingVariable)) {
return false;
}
if (resolved instanceof PsiClass) {
final PsiClass clazz = (PsiClass)resolved;
final String qName = clazz.getQualifiedName();
if (qName != null && addImports && checkIsInnerClass(clazz, ref) && mayInsertImport(ref)) {
final GroovyFileBase file = (GroovyFileBase)ref.getContainingFile();
final GrImportStatement added = file.addImportForClass(clazz);
if (copy.isReferenceTo(resolved)) return true;
file.removeImport(added);
}
}
return false;
}
private static <Qualifier extends PsiElement> boolean checkIsInnerClass(@NotNull PsiClass resolved, GrQualifiedReference<Qualifier> ref) {
final PsiClass containingClass = resolved.getContainingClass();
return containingClass == null ||
PsiTreeUtil.isAncestor(containingClass, ref, true) ||
CodeStyleSettingsManager.getSettings(resolved.getProject()).getCustomSettings(GroovyCodeStyleSettings.class).INSERT_INNER_CLASS_IMPORTS;
}
@Nullable
private static <Qualifier extends PsiElement> PsiElement resolveRef(@NotNull GrQualifiedReference<Qualifier> ref, boolean incomplete) {
if (!incomplete) return ref.resolve();
PsiResolveHelper helper = JavaPsiFacade.getInstance(ref.getProject()).getResolveHelper();
if (ref instanceof GrReferenceElement) {
final String classNameText = ((GrReferenceElement)ref).getClassNameText();
if (classNameText != null) {
return helper.resolveReferencedClass(classNameText, ref);
}
}
return null;
}
@SuppressWarnings("unchecked")
@Nullable
private static <Qualifier extends PsiElement> GrQualifiedReference<Qualifier> getCopy(@NotNull GrQualifiedReference<Qualifier> ref) {
if (ref.getParent() instanceof GrMethodCall) {
final GrMethodCall copy = ((GrMethodCall)ref.getParent().copy());
return (GrQualifiedReference<Qualifier>)copy.getInvokedExpression();
}
return (GrQualifiedReference<Qualifier>)ref.copy();
}
private <Qualifier extends PsiElement> boolean shorteningIsMeaningfully(@NotNull GrQualifiedReference<Qualifier> ref) {
if (ref instanceof GrReferenceElementImpl && ((GrReferenceElementImpl)ref).isFullyQualified()) {
final GrDocComment doc = PsiTreeUtil.getParentOfType(ref, GrDocComment.class);
if (doc != null) {
if (myUseFqClassNamesInJavadoc) return false;
}
else {
if (myUseFqClassNames) return false;
}
}
final Qualifier qualifier = ref.getQualifier();
if (qualifier instanceof GrCodeReferenceElement) {
return true;
}
if (qualifier instanceof GrExpression) {
if (qualifier instanceof GrReferenceExpression && PsiUtil.isThisReference(qualifier)) return true;
if (qualifier instanceof GrReferenceExpression &&
seemsToBeQualifiedClassName((GrExpression)qualifier)) {
final PsiElement resolved = ((GrReferenceExpression)qualifier).resolve();
if (resolved instanceof PsiClass || resolved instanceof PsiPackage) return true;
}
}
return false;
}
private static <Qualifier extends PsiElement> boolean cannotShortenInContext(@NotNull GrQualifiedReference<Qualifier> ref) {
return PsiTreeUtil.getParentOfType(ref, GrImportStatement.class) != null ||
PsiTreeUtil.getParentOfType(ref, GroovyCodeFragment.class) != null;
}
private static <Qualifier extends PsiElement> boolean mayInsertImport(@NotNull GrQualifiedReference<Qualifier> ref) {
return !(ref.getContainingFile() instanceof GroovyCodeFragment) &&
PsiTreeUtil.getParentOfType(ref, GrImportStatement.class) == null &&
ref.getContainingFile() instanceof GroovyFileBase;
}
public static GrReferenceAdjuster getInstance(Project project) {
return new GrReferenceAdjuster(CodeStyleSettingsManager.getInstance(project).getCurrentSettings().getCustomSettings(GroovyCodeStyleSettings.class));
}
}

36
plugins/groovy/src/org/jetbrains/plugins/groovy/codeStyle/GrReferenceAdjusterFactory.java Normal file
View File

@@ -0,0 +1,36 @@
/*
* Copyright 2000-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.plugins.groovy.codeStyle;
import com.intellij.openapi.project.Project;
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
import com.intellij.psi.codeStyle.ReferenceAdjuster;
import com.intellij.psi.codeStyle.ReferenceAdjusterFactory;
/**
* @author Max Medvedev
*/
public class GrReferenceAdjusterFactory implements ReferenceAdjusterFactory {
@Override
public ReferenceAdjuster createReferenceAdjuster(boolean useFqInJavadoc, boolean useFqInCode) {
return new GrReferenceAdjuster(useFqInJavadoc, useFqInCode);
}
@Override
public ReferenceAdjuster createReferenceAdjuster(Project project) {
return new GrReferenceAdjuster(CodeStyleSettingsManager.getSettings(project).getCustomSettings(GroovyCodeStyleSettings.class));
}
}

202
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/GrReferenceAdjuster.java
View File

@@ -16,28 +16,9 @@
package org.jetbrains.plugins.groovy.lang;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.codeStyle.GroovyCodeStyleSettings;
import org.jetbrains.plugins.groovy.debugger.fragments.GroovyCodeFragment;
import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocComment;
import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
import org.jetbrains.plugins.groovy.lang.psi.GrQualifiedReference;
import org.jetbrains.plugins.groovy.lang.psi.GrReferenceElement;
import org.jetbrains.plugins.groovy.lang.psi.GroovyFileBase;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.imports.GrImportStatement;
import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
import org.jetbrains.plugins.groovy.lang.psi.api.types.GrTypeArgumentList;
import org.jetbrains.plugins.groovy.lang.psi.impl.GrReferenceElementImpl;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrBindingVariable;
import org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil;
/**
* @author Max Medvedev
@@ -46,179 +27,20 @@ public class GrReferenceAdjuster {
private GrReferenceAdjuster() {
}
public static boolean shortenReferences(@NotNull PsiElement element) {
/**
* @deprecated use com.intellij.psi.codeStyle.JavaCodeStyleManager#shortenReferences(PsiElement) instead
*/
public static void shortenReferences(@NotNull PsiElement element) {
final TextRange range = element.getTextRange();
return shortenReferences(element, range.getStartOffset(), range.getEndOffset(), true, false);
}
public static boolean shortenReferences(@NotNull PsiElement element, int start, int end, boolean addImports, boolean incomplete) {
return process(element, start, end, addImports, incomplete);
final org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster adjuster = org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster.getInstance(element.getProject());
adjuster.processRange(element.getNode(), range.getStartOffset(), range.getEndOffset());
}
/**
* @deprecated use org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster#shortenReference(PsiElement) instead
*/
public static <T extends PsiElement> boolean shortenReference(@NotNull GrQualifiedReference<T> ref) {
boolean result = shortenReferenceInner(ref, true, false);
final TextRange range = ref.getTextRange();
result |= process(ref, range.getStartOffset(), range.getEndOffset(), true, false);
return result;
}
private static boolean process(@NotNull PsiElement element, int start, int end, boolean addImports, boolean incomplete) {
boolean result = false;
if (element instanceof GrQualifiedReference<?> && ((GrQualifiedReference)element).resolve() instanceof PsiClass) {
result = shortenReferenceInner((GrQualifiedReference<?>)element, addImports, incomplete);
}
else if (element instanceof GrReferenceExpression && PsiUtil.isSuperReference(((GrReferenceExpression)element).getQualifier())) {
result = shortenReferenceInner((GrReferenceExpression)element, addImports, incomplete);
}
PsiElement child = element.getFirstChild();
while (child != null) {
final TextRange range = child.getTextRange();
if (start < range.getEndOffset() && range.getStartOffset() < end) {
result |= process(child, start, end, addImports, incomplete);
}
child = child.getNextSibling();
}
return result;
}
private static <Qualifier extends PsiElement> boolean shortenReferenceInner(@NotNull GrQualifiedReference<Qualifier> ref,
boolean addImports,
boolean incomplete) {
final Qualifier qualifier = ref.getQualifier();
if (qualifier == null || PsiUtil.isSuperReference(qualifier) || cannotShortenInContext(ref)) {
return false;
}
if (ref instanceof GrReferenceExpression) {
final GrTypeArgumentList typeArgs = ((GrReferenceExpression)ref).getTypeArgumentList();
if (typeArgs != null && typeArgs.getTypeArgumentElements().length > 0) {
return false;
}
}
if (!shorteningIsMeaningfully(ref)) return false;
final PsiElement resolved = resolveRef(ref, incomplete);
if (resolved == null) return false;
if (!checkCopyWithoutQualifier(ref, addImports, resolved)) return false;
ref.setQualifier(null);
return true;
}
private static <Qualifier extends PsiElement> boolean checkCopyWithoutQualifier(@NotNull GrQualifiedReference<Qualifier> ref,
boolean addImports,
@NotNull PsiElement resolved) {
final GrQualifiedReference<Qualifier> copy = getCopy(ref);
if (copy == null) return false;
copy.setQualifier(null);
final PsiElement resolvedCopy = copy.resolve();
if (ref.getManager().areElementsEquivalent(resolved, resolvedCopy)) {
return true;
}
else if (resolvedCopy != null && !(resolvedCopy instanceof GrBindingVariable)) {
return false;
}
if (resolved instanceof PsiClass) {
final PsiClass clazz = (PsiClass)resolved;
final String qName = clazz.getQualifiedName();
if (qName != null && addImports && checkIsInnerClass(clazz, ref) && mayInsertImport(ref)) {
final GroovyFileBase file = (GroovyFileBase)ref.getContainingFile();
final GrImportStatement added = file.addImportForClass(clazz);
if (copy.isReferenceTo(resolved)) return true;
file.removeImport(added);
}
}
return false;
}
private static <Qualifier extends PsiElement> boolean checkIsInnerClass(@NotNull PsiClass resolved, GrQualifiedReference<Qualifier> ref) {
final PsiClass containingClass = resolved.getContainingClass();
return containingClass == null ||
PsiTreeUtil.isAncestor(containingClass, ref, true) ||
CodeStyleSettingsManager.getSettings(resolved.getProject()).getCustomSettings(GroovyCodeStyleSettings.class).INSERT_INNER_CLASS_IMPORTS;
}
@Nullable
private static <Qualifier extends PsiElement> PsiElement resolveRef(@NotNull GrQualifiedReference<Qualifier> ref, boolean incomplete) {
if (!incomplete) return ref.resolve();
PsiResolveHelper helper = JavaPsiFacade.getInstance(ref.getProject()).getResolveHelper();
if (ref instanceof GrReferenceElement) {
final String classNameText = ((GrReferenceElement)ref).getClassNameText();
if (classNameText != null) {
return helper.resolveReferencedClass(classNameText, ref);
}
}
return null;
}
@SuppressWarnings("unchecked")
@Nullable
private static <Qualifier extends PsiElement> GrQualifiedReference<Qualifier> getCopy(@NotNull GrQualifiedReference<Qualifier> ref) {
if (ref.getParent() instanceof GrMethodCall) {
final GrMethodCall copy = ((GrMethodCall)ref.getParent().copy());
return (GrQualifiedReference<Qualifier>)copy.getInvokedExpression();
}
return (GrQualifiedReference<Qualifier>)ref.copy();
}
private static <Qualifier extends PsiElement> boolean shorteningIsMeaningfully(@NotNull GrQualifiedReference<Qualifier> ref) {
if (ref instanceof GrReferenceElementImpl && ((GrReferenceElementImpl)ref).isFullyQualified()) {
final GrDocComment doc = PsiTreeUtil.getParentOfType(ref, GrDocComment.class);
if (doc != null) {
if (CodeStyleSettingsManager.getSettings(ref.getProject()).getCustomSettings(GroovyCodeStyleSettings.class).USE_FQ_CLASS_NAMES_IN_JAVADOC) return false;
}
else {
if (CodeStyleSettingsManager.getSettings(ref.getProject()).getCustomSettings(GroovyCodeStyleSettings.class).USE_FQ_CLASS_NAMES) return false;
}
}
final Qualifier qualifier = ref.getQualifier();
if (qualifier instanceof GrCodeReferenceElement) {
return true;
}
if (qualifier instanceof GrExpression) {
if (qualifier instanceof GrReferenceExpression && PsiUtil.isThisReference(qualifier)) return true;
if (qualifier instanceof GrReferenceExpression && seemsToBeQualifiedClassName((GrExpression)qualifier)) {
final PsiElement resolved = ((GrReferenceExpression)qualifier).resolve();
if (resolved instanceof PsiClass || resolved instanceof PsiPackage) return true;
}
}
return false;
}
private static <Qualifier extends PsiElement> boolean cannotShortenInContext(@NotNull GrQualifiedReference<Qualifier> ref) {
return PsiTreeUtil.getParentOfType(ref, GrImportStatement.class) != null ||
PsiTreeUtil.getParentOfType(ref, GroovyCodeFragment.class) != null;
}
private static <Qualifier extends PsiElement> boolean mayInsertImport(@NotNull GrQualifiedReference<Qualifier> ref) {
return !(ref.getContainingFile() instanceof GroovyCodeFragment) &&
PsiTreeUtil.getParentOfType(ref, GrImportStatement.class) == null &&
ref.getContainingFile() instanceof GroovyFileBase;
}
public static boolean seemsToBeQualifiedClassName(@Nullable GrExpression expr) {
if (expr == null) return false;
while (expr instanceof GrReferenceExpression) {
final PsiElement nameElement = ((GrReferenceExpression)expr).getReferenceNameElement();
if (((GrReferenceExpression)expr).getTypeArguments().length > 0) return false;
if (nameElement == null || nameElement.getNode().getElementType() != GroovyTokenTypes.mIDENT) return false;
IElementType dotType = ((GrReferenceExpression)expr).getDotTokenType();
if (dotType != null && dotType != GroovyTokenTypes.mDOT) return false;
expr = ((GrReferenceExpression)expr).getQualifierExpression();
}
return expr == null;
final org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster adjuster = org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster.getInstance(ref.getProject());
return adjuster.shortenReference(ref);
}
}

19
plugins/groovy/src/org/jetbrains/plugins/groovy/template/GroovyShortenFQNamesProcessor.java
View File

@@ -1,3 +1,18 @@
/*
* Copyright 2000-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.plugins.groovy.template;
import com.intellij.codeInsight.CodeInsightBundle;
@@ -10,9 +25,9 @@ import com.intellij.openapi.editor.RangeMarker;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
import com.intellij.psi.codeStyle.JavaCodeStyleManager;
import com.intellij.psi.util.PsiUtilBase;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.plugins.groovy.lang.GrReferenceAdjuster;
import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
/**
@@ -32,7 +47,7 @@ public class GroovyShortenFQNamesProcessor implements TemplateOptionalProcessor
PsiDocumentManager.getInstance(project).commitDocument(document);
final PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
if (file instanceof GroovyFile) {
GrReferenceAdjuster.shortenReferences(file, templateRange.getStartOffset(), templateRange.getEndOffset(), true, false);
JavaCodeStyleManager.getInstance(project).shortenClassReferences(file, templateRange.getStartOffset(),templateRange.getEndOffset());
}
PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(document);
}

6
resources/src/META-INF/IdeaPlugin.xml
View File

@@ -139,6 +139,10 @@
<with attribute="implementationClass" implements="com.intellij.debugger.impl.EditorTextProvider"/>
</extensionPoint>
<extensionPoint name="codeStyle.ReferenceAdjusterFactory" beanClass="com.intellij.lang.LanguageExtensionPoint">
<with attribute="implementationClass" implements="com.intellij.psi.codeStyle.ReferenceAdjusterFactory"/>
</extensionPoint>
<extensionPoint name="javadocTagInfo" area="IDEA_PROJECT" interface="com.intellij.psi.javadoc.JavadocTagInfo"/>
<extensionPoint name="refactoring.introduceParameterMethodUsagesProcessor" interface="com.intellij.refactoring.introduceParameter.IntroduceParameterMethodUsagesProcessor"/>
@@ -926,6 +930,8 @@
implementationClass="com.intellij.codeInsight.editorActions.smartEnter.JavaSmartEnterProcessor"/>
<lang.smartEnterProcessor language="JSPX" implementationClass="com.intellij.codeInsight.completion.XmlSmartEnterProcessor"/>
<codeStyle.ReferenceAdjusterFactory language="JAVA" implementationClass="com.intellij.psi.impl.source.codeStyle.JavaReferenceAdjusterFactory"/>
<iconProvider implementation="com.intellij.psi.impl.JavaDirectoryIconProvider" id="javaDirectory"/>
<iconProvider implementation="com.intellij.execution.testframework.TestIconProvider" id="testIcons"/>