diff options
Diffstat (limited to 'java/java-impl')
61 files changed, 676 insertions, 285 deletions
diff --git a/java/java-impl/java-impl.iml b/java/java-impl/java-impl.iml index f9eca174d12c..cf601bbd0f76 100644 --- a/java/java-impl/java-impl.iml +++ b/java/java-impl/java-impl.iml @@ -48,13 +48,14 @@ <orderEntry type="module" module-name="jps-model-impl" /> <orderEntry type="module" module-name="java-analysis-impl" exported="" /> <orderEntry type="module" module-name="external-system-api" /> - <orderEntry type="library" name="asm4" level="project" /> + <orderEntry type="library" name="asm5" level="project" /> <orderEntry type="library" name="Guava" level="project" /> <orderEntry type="library" name="Xerces" level="project" /> <orderEntry type="library" name="Velocity" level="project" /> <orderEntry type="module" module-name="testFramework-java" scope="TEST" /> <orderEntry type="module" module-name="java-structure-view" exported="" /> <orderEntry type="module" module-name="spellchecker" /> + <orderEntry type="library" name="nekohtml" level="project" /> </component> <component name="copyright"> <Base> diff --git a/java/java-impl/src/com/intellij/application/options/editor/JavaCodeFoldingOptionsProvider.java b/java/java-impl/src/com/intellij/application/options/editor/JavaCodeFoldingOptionsProvider.java index 7657ea05396d..7a9aed06479c 100644 --- a/java/java-impl/src/com/intellij/application/options/editor/JavaCodeFoldingOptionsProvider.java +++ b/java/java-impl/src/com/intellij/application/options/editor/JavaCodeFoldingOptionsProvider.java @@ -27,6 +27,7 @@ import com.intellij.openapi.options.BeanConfigurable; public class JavaCodeFoldingOptionsProvider extends BeanConfigurable<JavaCodeFoldingSettings> implements CodeFoldingOptionsProvider { public JavaCodeFoldingOptionsProvider() { super(JavaCodeFoldingSettings.getInstance()); + checkBox("INLINE_PARAMETER_NAMES_FOR_LITERAL_CALL_ARGUMENTS", ApplicationBundle.message("checkbox.collapse.boolean.parameters")); checkBox("COLLAPSE_ONE_LINE_METHODS", ApplicationBundle.message("checkbox.collapse.one.line.methods")); checkBox("COLLAPSE_ACCESSORS", ApplicationBundle.message("checkbox.collapse.simple.property.accessors")); checkBox("COLLAPSE_INNER_CLASSES", ApplicationBundle.message("checkbox.collapse.inner.classes")); diff --git a/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java b/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java index 81968fed0a5d..af5f14e25131 100644 --- a/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java +++ b/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java @@ -509,11 +509,9 @@ public class ExternalAnnotationsManagerImpl extends ReadableExternalAnnotationsM if (entry instanceof LibraryOrderEntry) { Library library = ((LibraryOrderEntry)entry).getLibrary(); LOG.assertTrue(library != null); - final ModifiableRootModel rootModel = ModuleRootManager.getInstance(entry.getOwnerModule()).getModifiableModel(); final Library.ModifiableModel model = library.getModifiableModel(); model.addRoot(vFile, AnnotationOrderRootType.getInstance()); model.commit(); - rootModel.commit(); } else if (entry instanceof ModuleSourceOrderEntry) { final ModifiableRootModel model = ModuleRootManager.getInstance(entry.getOwnerModule()).getModifiableModel(); @@ -558,7 +556,6 @@ public class ExternalAnnotationsManagerImpl extends ReadableExternalAnnotationsM annotation.delete(); break; } - if (compare < 0) break; anchor = annotation; } XmlTag newTag = XmlElementFactory.getInstance(myPsiManager.getProject()).createTagFromText( diff --git a/java/java-impl/src/com/intellij/codeInsight/TargetElementUtil.java b/java/java-impl/src/com/intellij/codeInsight/TargetElementUtil.java index 88c1aa63eb9b..59521b1d6c47 100644 --- a/java/java-impl/src/com/intellij/codeInsight/TargetElementUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/TargetElementUtil.java @@ -250,7 +250,7 @@ public class TargetElementUtil extends TargetElementUtilBase { } @Override - public boolean includeSelfInGotoImplementation(final PsiElement element) { + public boolean includeSelfInGotoImplementation(@NotNull final PsiElement element) { if (element instanceof PsiModifierListOwner && ((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.ABSTRACT)) { return false; } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameCompletionContributor.java index df113a5a77a1..2fc06a2dabd5 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameCompletionContributor.java @@ -52,7 +52,7 @@ public class JavaClassNameCompletionContributor extends CompletionContributor { psiElement(PsiReferenceList.class).withParent(PsiTypeParameter.class)); @Override - public void fillCompletionVariants(CompletionParameters parameters, final CompletionResultSet _result) { + public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull final CompletionResultSet _result) { if (parameters.getCompletionType() == CompletionType.CLASS_NAME || parameters.isExtendedCompletion() && mayContainClassName(parameters)) { addAllClasses(parameters, _result); @@ -151,9 +151,11 @@ public class JavaClassNameCompletionContributor extends CompletionContributor { if (withInners && name != null) { for (PsiClass inner : psiClass.getInnerClasses()) { if (inner.hasModifierProperty(PsiModifier.STATIC)) { - for (JavaPsiClassReferenceElement lookupInner : createClassLookupItems(inner, withInners, insertHandler, condition)) { + for (JavaPsiClassReferenceElement lookupInner : createClassLookupItems(inner, true, insertHandler, condition)) { String forced = lookupInner.getForcedPresentableName(); - lookupInner.setForcedPresentableName(name + "." + (forced != null ? forced : inner.getName())); + String qualifiedName = name + "." + (forced != null ? forced : inner.getName()); + lookupInner.setForcedPresentableName(qualifiedName); + lookupInner.setLookupString(qualifiedName); result.add(lookupInner); } } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameInsertHandler.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameInsertHandler.java index d80b6b590c98..be6d8146ce3d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameInsertHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassNameInsertHandler.java @@ -53,6 +53,8 @@ class JavaClassNameInsertHandler implements InsertHandler<JavaPsiClassReferenceE } PsiElement position = file.findElementAt(offset); + PsiJavaCodeReferenceElement ref = position != null && position.getParent() instanceof PsiJavaCodeReferenceElement ? + (PsiJavaCodeReferenceElement) position.getParent() : null; PsiClass psiClass = item.getObject(); final Project project = context.getProject(); @@ -75,14 +77,8 @@ class JavaClassNameInsertHandler implements InsertHandler<JavaPsiClassReferenceE return; } - if (position != null) { - PsiElement parent = position.getParent(); - if (parent instanceof PsiJavaCodeReferenceElement) { - final PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement)parent; - if (PsiTreeUtil.getParentOfType(position, PsiDocTag.class) != null && ref.isReferenceTo(psiClass)) { - return; - } - } + if (ref != null && PsiTreeUtil.getParentOfType(position, PsiDocTag.class) != null && ref.isReferenceTo(psiClass)) { + return; } OffsetKey refEnd = context.trackOffset(context.getTailOffset(), false); @@ -92,7 +88,9 @@ class JavaClassNameInsertHandler implements InsertHandler<JavaPsiClassReferenceE context.setAddCompletionChar(false); } - PsiTypeLookupItem.addImportForItem(context, psiClass); + if (ref == null || !ref.isQualified()) { + PsiTypeLookupItem.addImportForItem(context, psiClass); + } if (context.getOffset(refEnd) < 0) { return; } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassReferenceCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassReferenceCompletionContributor.java index e84eb2646ec0..f6871faea16e 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassReferenceCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaClassReferenceCompletionContributor.java @@ -41,7 +41,7 @@ public class JavaClassReferenceCompletionContributor extends CompletionContribut } @Override - public void fillCompletionVariants(CompletionParameters parameters, CompletionResultSet result) { + public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull CompletionResultSet result) { PsiElement position = parameters.getPosition(); JavaClassReference reference = findJavaClassReference(position.getContainingFile(), parameters.getOffset()); if (reference == null) { diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionContributor.java index 20615a027a42..7310227a80f0 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionContributor.java @@ -53,6 +53,7 @@ import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.Consumer; +import com.intellij.util.ObjectUtils; import com.intellij.util.PairConsumer; import com.intellij.util.ProcessingContext; import org.jetbrains.annotations.NotNull; @@ -196,7 +197,7 @@ public class JavaCompletionContributor extends CompletionContributor { } @Override - public void fillCompletionVariants(final CompletionParameters parameters, final CompletionResultSet _result) { + public void fillCompletionVariants(@NotNull final CompletionParameters parameters, @NotNull final CompletionResultSet _result) { if (parameters.getCompletionType() != CompletionType.BASIC) { return; } @@ -340,6 +341,7 @@ public class JavaCompletionContributor extends CompletionContributor { } final Object[] variants = reference.getVariants(); + //noinspection ConstantConditions if (variants == null) { LOG.error("Reference=" + reference); } @@ -365,6 +367,7 @@ public class JavaCompletionContributor extends CompletionContributor { } else { + //noinspection deprecation LookupElement element = LookupItemUtil.objectToLookupItem(completion); usedWords.add(element.getLookupString()); result.addElement(element); @@ -434,7 +437,7 @@ public class JavaCompletionContributor extends CompletionContributor { private static void completeAnnotationAttributeName(CompletionResultSet result, PsiElement insertedElement, CompletionParameters parameters) { PsiNameValuePair pair = PsiTreeUtil.getParentOfType(insertedElement, PsiNameValuePair.class); - PsiAnnotationParameterList parameterList = (PsiAnnotationParameterList)pair.getParent(); + PsiAnnotationParameterList parameterList = (PsiAnnotationParameterList)ObjectUtils.assertNotNull(pair).getParent(); PsiAnnotation anno = (PsiAnnotation)parameterList.getParent(); boolean showClasses = psiElement().afterLeaf("(").accepts(insertedElement); PsiClass annoClass = null; @@ -507,7 +510,7 @@ public class JavaCompletionContributor extends CompletionContributor { if (psiElement().withParent(psiReferenceExpression().withFirstChild(psiReferenceExpression().referencing(psiClass()))).accepts(position)) { if (CompletionUtil.shouldShowFeature(parameters, JavaCompletionFeatures.GLOBAL_MEMBER_NAME)) { final String shortcut = getActionShortcut(IdeActions.ACTION_CODE_COMPLETION); - if (shortcut != null) { + if (StringUtil.isNotEmpty(shortcut)) { return "Pressing " + shortcut + " twice without a class qualifier would show all accessible static methods"; } } @@ -517,7 +520,7 @@ public class JavaCompletionContributor extends CompletionContributor { if (parameters.getCompletionType() != CompletionType.SMART && shouldSuggestSmartCompletion(parameters.getPosition())) { if (CompletionUtil.shouldShowFeature(parameters, CodeCompletionFeatures.EDITING_COMPLETION_SMARTTYPE_GENERAL)) { final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION); - if (shortcut != null) { + if (StringUtil.isNotEmpty(shortcut)) { return CompletionBundle.message("completion.smart.hint", shortcut); } } @@ -528,7 +531,7 @@ public class JavaCompletionContributor extends CompletionContributor { if (psiTypes.length > 0) { if (CompletionUtil.shouldShowFeature(parameters, JavaCompletionFeatures.SECOND_SMART_COMPLETION_TOAR)) { final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION); - if (shortcut != null) { + if (StringUtil.isNotEmpty(shortcut)) { for (final PsiType psiType : psiTypes) { final PsiType type = PsiUtil.extractIterableTypeParameter(psiType, false); if (type != null) { @@ -539,7 +542,7 @@ public class JavaCompletionContributor extends CompletionContributor { } if (CompletionUtil.shouldShowFeature(parameters, JavaCompletionFeatures.SECOND_SMART_COMPLETION_ASLIST)) { final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION); - if (shortcut != null) { + if (StringUtil.isNotEmpty(shortcut)) { for (final PsiType psiType : psiTypes) { if (psiType instanceof PsiArrayType) { final PsiType componentType = ((PsiArrayType)psiType).getComponentType(); @@ -553,7 +556,7 @@ public class JavaCompletionContributor extends CompletionContributor { if (CompletionUtil.shouldShowFeature(parameters, JavaCompletionFeatures.SECOND_SMART_COMPLETION_CHAIN)) { final String shortcut = getActionShortcut(IdeActions.ACTION_SMART_TYPE_COMPLETION); - if (shortcut != null) { + if (StringUtil.isNotEmpty(shortcut)) { return CompletionBundle.message("completion.smart.chain.hint", shortcut); } } @@ -639,9 +642,12 @@ public class JavaCompletionContributor extends CompletionContributor { final PsiFile file = context.getFile(); if (file instanceof PsiJavaFile) { - JavaCompletionUtil.initOffsets(file, context.getOffsetMap()); + if (context.getInvocationCount() > 0) { + autoImport(file, context.getStartOffset() - 1, context.getEditor()); + PsiDocumentManager.getInstance(context.getProject()).commitDocument(context.getEditor().getDocument()); + } - autoImport(file, context.getStartOffset() - 1, context.getEditor()); + JavaCompletionUtil.initOffsets(file, context.getOffsetMap()); if (context.getCompletionType() == CompletionType.BASIC) { if (semicolonNeeded(context.getEditor(), file, context.getStartOffset())) { diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java index d5b16a9bbcb5..1112738c5464 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java @@ -56,7 +56,6 @@ import com.intellij.util.PairConsumer; import com.intellij.util.PairFunction; import com.intellij.util.containers.ContainerUtil; import gnu.trove.THashSet; -import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -447,8 +446,10 @@ public class JavaCompletionUtil { PsiSubstitutor plainSub = plainResult.getSubstitutor(); PsiSubstitutor castSub = TypeConversionUtil.getSuperClassSubstitutor(plainClass, (PsiClassType)castType); + PsiType returnType = method.getReturnType(); if (method.getSignature(plainSub).equals(method.getSignature(castSub)) && - Comparing.equal(plainSub.substitute(method.getReturnType()), castSub.substitute(method.getReturnType())) && + returnType != null && + castSub.substitute(returnType).isAssignableFrom(plainSub.substitute(returnType)) && processor.isAccessible(plainClass.findMethodBySignature(method, true)) ) { return item; @@ -600,12 +601,7 @@ public class JavaCompletionUtil { } public static LookupItem setShowFQN(final LookupItem ret) { - final PsiClass psiClass = (PsiClass)ret.getObject(); - @NonNls String packageName = PsiFormatUtil.getPackageDisplayName(psiClass); - - final String tailText = (String)ret.getAttribute(LookupItem.TAIL_TEXT_ATTR); - ret.setAttribute(LookupItem.TAIL_TEXT_ATTR, StringUtil.notNullize(tailText) + " (" + packageName + ")"); - ret.setAttribute(LookupItem.TAIL_TEXT_SMALL_ATTR, ""); + ret.setAttribute(JavaPsiClassReferenceElement.PACKAGE_NAME, PsiFormatUtil.getPackageDisplayName((PsiClass)ret.getObject())); return ret; } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaDocCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaDocCompletionContributor.java index 7e7e0955b560..49379c2c4f3e 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaDocCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaDocCompletionContributor.java @@ -140,7 +140,7 @@ public class JavaDocCompletionContributor extends CompletionContributor { } @Override - public void fillCompletionVariants(final CompletionParameters parameters, final CompletionResultSet result) { + public void fillCompletionVariants(@NotNull final CompletionParameters parameters, @NotNull final CompletionResultSet result) { PsiElement position = parameters.getPosition(); if (PsiJavaPatterns.psiElement(JavaDocTokenType.DOC_COMMENT_DATA).accepts(position)) { diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java index a484e4b1f4f9..a1d4a6f8ac81 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java @@ -39,6 +39,7 @@ import com.intellij.util.ArrayUtil; import com.intellij.util.PlatformIcons; import com.intellij.util.containers.ContainerUtil; import gnu.trove.THashSet; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.ArrayList; @@ -63,7 +64,7 @@ public class JavaMemberNameCompletionContributor extends CompletionContributor { static final int MAX_SCOPE_SIZE_TO_SEARCH_UNRESOLVED = 50000; @Override - public void fillCompletionVariants(CompletionParameters parameters, CompletionResultSet result) { + public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull CompletionResultSet result) { if (parameters.getCompletionType() != CompletionType.BASIC && parameters.getCompletionType() != CompletionType.SMART) { return; } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMethodMergingContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMethodMergingContributor.java index 74bdc7ccc0a5..b409014c1fe8 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMethodMergingContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMethodMergingContributor.java @@ -19,6 +19,7 @@ import com.intellij.codeInsight.lookup.LookupElement; import com.intellij.codeInsight.lookup.LookupItem; import com.intellij.psi.PsiMethod; import com.intellij.psi.ResolveResult; +import org.jetbrains.annotations.NotNull; import java.util.ArrayList; @@ -28,7 +29,7 @@ import java.util.ArrayList; public class JavaMethodMergingContributor extends CompletionContributor { @Override - public AutoCompletionDecision handleAutoCompletionPossibility(AutoCompletionContext context) { + public AutoCompletionDecision handleAutoCompletionPossibility(@NotNull AutoCompletionContext context) { final CompletionParameters parameters = context.getParameters(); if (parameters.getCompletionType() != CompletionType.SMART && parameters.getCompletionType() != CompletionType.BASIC) { return null; diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaNoVariantsDelegator.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaNoVariantsDelegator.java index a174ef437acf..f36f567199a0 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaNoVariantsDelegator.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaNoVariantsDelegator.java @@ -27,6 +27,7 @@ import com.intellij.psi.filters.ElementFilter; import com.intellij.psi.search.PsiShortNamesCache; import com.intellij.util.CollectConsumer; import com.intellij.util.Consumer; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.Collections; @@ -42,7 +43,7 @@ import static com.intellij.patterns.PsiJavaPatterns.psiElement; public class JavaNoVariantsDelegator extends CompletionContributor { @Override - public void fillCompletionVariants(final CompletionParameters parameters, CompletionResultSet result) { + public void fillCompletionVariants(@NotNull final CompletionParameters parameters, @NotNull CompletionResultSet result) { LinkedHashSet<CompletionResult> plainResults = result.runRemainingContributors(parameters, true); final boolean empty = containsOnlyPackages(plainResults) || suggestMetaAnnotations(parameters); diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java index 43c19b0483b5..9934cddc90ff 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java @@ -23,6 +23,7 @@ import com.intellij.codeInsight.lookup.PsiTypeLookupItem; import com.intellij.codeInsight.lookup.impl.JavaElementLookupRenderer; import com.intellij.openapi.util.ClassConditionKey; import com.intellij.openapi.util.Comparing; +import com.intellij.openapi.util.Key; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; @@ -41,6 +42,7 @@ import java.util.Set; * @author peter */ public class JavaPsiClassReferenceElement extends LookupItem<Object> { + public static final Key<String> PACKAGE_NAME = Key.create("PACKAGE_NAME"); public static final ClassConditionKey<JavaPsiClassReferenceElement> CLASS_CONDITION_KEY = ClassConditionKey.create(JavaPsiClassReferenceElement.class); private final Object myClass; private volatile Reference<PsiClass> myCache; @@ -171,8 +173,9 @@ public class JavaPsiClassReferenceElement extends LookupItem<Object> { presentation.setTailText(tailText, true); } - public static String getLocationString(LookupItem item) { - return StringUtil.notNullize((String)item.getAttribute(LookupItem.TAIL_TEXT_ATTR)); + public static String getLocationString(LookupItem<?> item) { + String pkgName = item.getAttribute(PACKAGE_NAME); + return pkgName == null ? "" : " (" + pkgName + ")"; } private static String getName(final PsiClass psiClass, final LookupItem<?> item, boolean diamond) { diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java index 37dc0829f969..61d8abe18368 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java @@ -352,7 +352,7 @@ public class JavaSmartCompletionContributor extends CompletionContributor { } @Override - public void fillCompletionVariants(CompletionParameters parameters, CompletionResultSet result) { + public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull CompletionResultSet result) { super.fillCompletionVariants(parameters, JavaCompletionSorting.addJavaSorting(parameters, result)); } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/PreferByKindWeigher.java b/java/java-impl/src/com/intellij/codeInsight/completion/PreferByKindWeigher.java index 2960bd797dea..b60094ffbd6f 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/PreferByKindWeigher.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/PreferByKindWeigher.java @@ -15,6 +15,7 @@ */ package com.intellij.codeInsight.completion; +import com.intellij.codeInsight.ExceptionUtil; import com.intellij.codeInsight.completion.scope.JavaCompletionProcessor; import com.intellij.codeInsight.lookup.LookupElement; import com.intellij.codeInsight.lookup.LookupElementWeigher; @@ -29,8 +30,10 @@ import com.intellij.psi.util.PropertyUtil; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.proximity.KnownElementWeigher; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; +import java.util.List; import java.util.Set; import static com.intellij.patterns.PsiJavaPatterns.psiElement; @@ -69,10 +72,32 @@ public class PreferByKindWeigher extends LookupElementWeigher { } private static Condition<PsiClass> createSuitabilityCondition(final PsiElement position) { - if (IN_CATCH_TYPE.accepts(position) || - IN_MULTI_CATCH_TYPE.accepts(position) || - JavaSmartCompletionContributor.AFTER_THROW_NEW.accepts(position) || - INSIDE_METHOD_THROWS_CLAUSE.accepts(position)) { + if (IN_CATCH_TYPE.accepts(position) || IN_MULTI_CATCH_TYPE.accepts(position)) { + PsiTryStatement tryStatement = PsiTreeUtil.getParentOfType(position, PsiTryStatement.class); + final List<PsiClass> thrownExceptions = ContainerUtil.newArrayList(); + if (tryStatement != null && tryStatement.getTryBlock() != null) { + for (PsiClassType type : ExceptionUtil.getThrownExceptions(tryStatement.getTryBlock())) { + ContainerUtil.addIfNotNull(thrownExceptions, type.resolve()); + } + } + if (thrownExceptions.isEmpty()) { + ContainerUtil.addIfNotNull(thrownExceptions, + JavaPsiFacade.getInstance(position.getProject()).findClass( + CommonClassNames.JAVA_LANG_THROWABLE, position.getResolveScope())); + } + return new Condition<PsiClass>() { + @Override + public boolean value(PsiClass psiClass) { + for (PsiClass exception : thrownExceptions) { + if (InheritanceUtil.isInheritorOrSelf(psiClass, exception, true)) { + return true; + } + } + return false; + } + }; + } + else if (JavaSmartCompletionContributor.AFTER_THROW_NEW.accepts(position) || INSIDE_METHOD_THROWS_CLAUSE.accepts(position)) { return new Condition<PsiClass>() { @Override public boolean value(PsiClass psiClass) { @@ -120,6 +145,7 @@ public class PreferByKindWeigher extends LookupElementWeigher { collectionFactory, expectedTypeMethod, suitableClass, + improbableKeyword, nonInitialized, classLiteral, classNameOrGlobalStatic, @@ -138,10 +164,13 @@ public class PreferByKindWeigher extends LookupElementWeigher { if (PsiKeyword.ELSE.equals(keyword) || PsiKeyword.FINALLY.equals(keyword)) { return MyResult.probableKeyword; } - if (PsiKeyword.TRUE.equals(keyword) || PsiKeyword.FALSE.equals(keyword)) { - boolean inReturn = PsiTreeUtil.getParentOfType(myPosition, PsiReturnStatement.class, false, PsiMember.class) != null; + if ((PsiKeyword.TRUE.equals(keyword) || PsiKeyword.FALSE.equals(keyword)) && myCompletionType == CompletionType.SMART) { + boolean inReturn = psiElement().withParents(PsiReferenceExpression.class, PsiReturnStatement.class).accepts(myPosition); return inReturn ? MyResult.probableKeyword : MyResult.normal; } + if (PsiKeyword.INTERFACE.equals(keyword) && psiElement().afterLeaf("@").accepts(myPosition)) { + return MyResult.improbableKeyword; + } } if (object instanceof PsiLocalVariable || object instanceof PsiParameter || object instanceof PsiThisExpression) { diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/RefactoringCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/RefactoringCompletionContributor.java index 62dbd0df8f79..9264599a4e1b 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/RefactoringCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/RefactoringCompletionContributor.java @@ -24,13 +24,14 @@ import com.intellij.openapi.module.ModuleUtil; import com.intellij.psi.PsiClass; import com.intellij.refactoring.ui.ClassNameReferenceEditor; import com.intellij.util.Consumer; +import org.jetbrains.annotations.NotNull; /** * @author peter */ public class RefactoringCompletionContributor extends CompletionContributor { @Override - public void fillCompletionVariants(CompletionParameters parameters, final CompletionResultSet resultSet) { + public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull final CompletionResultSet resultSet) { if (parameters.getOriginalFile().getUserData(ClassNameReferenceEditor.CLASS_NAME_REFERENCE_FRAGMENT) == null) { return; } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/XmlBasicToClassNameDelegator.java b/java/java-impl/src/com/intellij/codeInsight/completion/XmlBasicToClassNameDelegator.java index a57303044485..310cf1444e88 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/XmlBasicToClassNameDelegator.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/XmlBasicToClassNameDelegator.java @@ -21,6 +21,7 @@ import com.intellij.lang.StdLanguages; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.util.Consumer; +import org.jetbrains.annotations.NotNull; /** * @author peter @@ -28,7 +29,7 @@ import com.intellij.util.Consumer; public class XmlBasicToClassNameDelegator extends CompletionContributor { @Override - public void fillCompletionVariants(CompletionParameters parameters, final CompletionResultSet result) { + public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull final CompletionResultSet result) { PsiElement position = parameters.getPosition(); PsiFile file = position.getContainingFile(); if (parameters.getCompletionType() != CompletionType.BASIC || diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddMethodQualifierFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddMethodQualifierFix.java new file mode 100644 index 000000000000..ff851372e208 --- /dev/null +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddMethodQualifierFix.java @@ -0,0 +1,162 @@ +/* + * Copyright 2000-2014 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.codeInsight.daemon.impl.quickfix; + +import com.intellij.codeInsight.daemon.QuickFixBundle; +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.command.WriteCommandAction; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.ui.popup.PopupStep; +import com.intellij.openapi.ui.popup.util.BaseListPopupStep; +import com.intellij.psi.*; +import com.intellij.ui.popup.list.ListPopupImpl; +import com.intellij.util.IncorrectOperationException; +import com.intellij.util.ObjectUtils; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.TestOnly; + +import javax.swing.*; +import java.util.ArrayList; +import java.util.List; + +/** + * @author Dmitry Batkovich + */ +public class AddMethodQualifierFix implements IntentionAction { + private static final boolean UNIT_TEST_MODE = ApplicationManager.getApplication().isUnitTestMode(); + + private final SmartPsiElementPointer<PsiMethodCallExpression> myMethodCall; + private List<PsiVariable> myCandidates = null; + + public AddMethodQualifierFix(final PsiMethodCallExpression methodCallExpression) { + myMethodCall = SmartPointerManager.getInstance(methodCallExpression.getProject()).createSmartPsiElementPointer(methodCallExpression); + } + + @NotNull + @Override + public String getText() { + String text = QuickFixBundle.message("add.method.qualifier.fix.text", myCandidates.size() > 1 ? "" : myCandidates.get(0).getName()); + if (myCandidates.size() > 1) { + text += "..."; + } + return text; + } + + @NotNull + @Override + public String getFamilyName() { + return getText(); + } + + @Override + public boolean isAvailable(@NotNull final Project project, final Editor editor, final PsiFile file) { + final PsiMethodCallExpression element = myMethodCall.getElement(); + if (element == null || !element.isValid()) { + return false; + } + if (myCandidates == null) { + findCandidates(); + } + return myCandidates.size() != 0; + } + + private void findCandidates() { + myCandidates = new ArrayList<PsiVariable>(); + final PsiMethodCallExpression methodCallElement = myMethodCall.getElement(); + final String methodName = methodCallElement.getMethodExpression().getReferenceName(); + if (methodName == null) { + return; + } + + for (final PsiVariable var : CreateFromUsageUtils.guessMatchingVariables(methodCallElement)) { + final PsiType type = var.getType(); + if (!(type instanceof PsiClassType)) { + continue; + } + final PsiClass resolvedClass = ((PsiClassType)type).resolve(); + if (resolvedClass == null) { + continue; + } + if (resolvedClass.findMethodsByName(methodName, true).length > 0) { + myCandidates.add(var); + } + } + } + + @TestOnly + public List<PsiVariable> getCandidates() { + return myCandidates; + } + + @Override + public void invoke(@NotNull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException { + if (myCandidates.size() == 1 || UNIT_TEST_MODE) { + qualify(myCandidates.get(0), editor); + } + else { + chooseAndQualify(editor); + } + } + + private void chooseAndQualify(final Editor editor) { + final BaseListPopupStep<PsiVariable> step = + new BaseListPopupStep<PsiVariable>(QuickFixBundle.message("add.qualifier"), myCandidates) { + @Override + public PopupStep onChosen(final PsiVariable selectedValue, final boolean finalChoice) { + if (selectedValue != null && finalChoice) { + WriteCommandAction.runWriteCommandAction(selectedValue.getProject(), new Runnable() { + @Override + public void run() { + qualify(selectedValue, editor); + } + }); + } + return FINAL_CHOICE; + } + + @NotNull + @Override + public String getTextFor(final PsiVariable value) { + return ObjectUtils.assertNotNull(value.getName()); + } + + @Override + public Icon getIconFor(final PsiVariable aValue) { + return aValue.getIcon(0); + } + }; + + final ListPopupImpl popup = new ListPopupImpl(step); + popup.showInBestPositionFor(editor); + } + + private void qualify(final PsiVariable qualifier, final Editor editor) { + final String qualifierPresentableText = qualifier.getName(); + final PsiMethodCallExpression oldExpression = myMethodCall.getElement(); + final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(qualifier.getProject()); + final PsiExpression expression = elementFactory + .createExpressionFromText(qualifierPresentableText + "." + oldExpression.getMethodExpression().getReferenceName() + "()", null); + final PsiElement replacedExpression = oldExpression.replace(expression); + editor.getCaretModel().moveToOffset(replacedExpression.getTextOffset() + replacedExpression.getTextLength()); + } + + @Override + public boolean startInWriteAction() { + return true; + } +}
\ No newline at end of file diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java index 348d052a81b4..f3b95702eac7 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddModuleDependencyFix.java @@ -15,6 +15,7 @@ */ package com.intellij.codeInsight.daemon.impl.quickfix; +import com.intellij.application.options.ModuleListCellRenderer; import com.intellij.codeInsight.daemon.QuickFixBundle; import com.intellij.codeInsight.daemon.impl.actions.AddImportAction; import com.intellij.compiler.ModuleCompilerUtil; @@ -22,7 +23,6 @@ import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.module.Module; -import com.intellij.openapi.module.ModuleType; import com.intellij.openapi.module.ModuleUtilCore; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.*; @@ -32,13 +32,11 @@ import com.intellij.openapi.ui.popup.JBPopupFactory; import com.intellij.openapi.util.Pair; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; -import com.intellij.ui.ListCellRendererWrapper; import com.intellij.ui.components.JBList; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import javax.swing.*; import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; @@ -115,15 +113,7 @@ class AddModuleDependencyFix extends OrderEntryFix { } else { final JBList list = new JBList(myModules); - list.setCellRenderer(new ListCellRendererWrapper<Module>() { - @Override - public void customize(JList list, Module module, int index, boolean selected, boolean hasFocus) { - if (module != null) { - setIcon(ModuleType.get(module).getIcon()); - setText(module.getName()); - } - } - }); + list.setCellRenderer(new ModuleListCellRenderer()); final JBPopup popup = JBPopupFactory.getInstance().createListPopupBuilder(list) .setTitle("Choose Module to Add Dependency on") .setMovable(false) diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeExtendsToImplementsFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeExtendsToImplementsFix.java index 8e3fe5158d13..dce0d54e405b 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeExtendsToImplementsFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeExtendsToImplementsFix.java @@ -33,7 +33,8 @@ public class ChangeExtendsToImplementsFix extends ExtendsListFix { public ChangeExtendsToImplementsFix(@NotNull PsiClass aClass, @NotNull PsiClassType classToExtendFrom) { super(aClass, classToExtendFrom, true); - myName = QuickFixBundle.message("exchange.extends.implements.keyword", + myName = myClassToExtendFrom == null ? getFamilyName() : + QuickFixBundle.message("exchange.extends.implements.keyword", aClass.isInterface() == myClassToExtendFrom.isInterface() ? PsiKeyword.IMPLEMENTS : PsiKeyword.EXTENDS, aClass.isInterface() == myClassToExtendFrom.isInterface() ? PsiKeyword.EXTENDS : PsiKeyword.IMPLEMENTS, myClassToExtendFrom.getName()); diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ConvertSwitchToIfIntention.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ConvertSwitchToIfIntention.java index dab9a3bb6208..72df2025348f 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ConvertSwitchToIfIntention.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ConvertSwitchToIfIntention.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -33,6 +33,8 @@ import java.util.HashSet; import java.util.List; import java.util.Set; +import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING; + /** * User: anna * Date: 2/22/12 @@ -82,7 +84,7 @@ public class ConvertSwitchToIfIntention implements IntentionAction { return; } final boolean isSwitchOnString = - switchExpressionType.equalsToText("java.lang.String"); + switchExpressionType.equalsToText(JAVA_LANG_STRING); boolean useEquals = isSwitchOnString; if (!useEquals) { final PsiClass aClass = PsiUtil.resolveClassInType(switchExpressionType); diff --git a/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java b/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java index ee371f8e1206..e2dedf5ea3ec 100644 --- a/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java @@ -131,7 +131,7 @@ public class JavaTypedHandler extends TypedHandlerDelegate { return Result.CONTINUE; } if (PsiTreeUtil.getParentOfType(leaf, PsiCodeBlock.class, false, PsiMember.class) != null) { - EditorModificationUtil.typeInStringAtCaretHonorMultipleCarets(editor, "{"); + EditorModificationUtil.insertStringAtCaret(editor, "{"); TypedHandler.indentOpenedBrace(project, editor); return Result.STOP; } @@ -169,7 +169,7 @@ public class JavaTypedHandler extends TypedHandlerDelegate { char charAt = editor.getDocument().getCharsSequence().charAt(offset); if (charAt != ';') return false; - EditorModificationUtil.moveAllCaretsRelatively(editor, 1); + EditorModificationUtil.moveCaretRelatively(editor, 1); return true; } @@ -209,7 +209,7 @@ public class JavaTypedHandler extends TypedHandlerDelegate { } if (balance == 0) { - EditorModificationUtil.moveAllCaretsRelatively(editor, 1); + EditorModificationUtil.moveCaretRelatively(editor, 1); return true; } @@ -248,12 +248,7 @@ public class JavaTypedHandler extends TypedHandlerDelegate { } if (balance == 1) { - if (editor.getCaretModel().supportsMultipleCarets()) { - EditorModificationUtil.typeInStringAtCaretHonorMultipleCarets(editor, ">", 0); - } - else { - editor.getDocument().insertString(offset, ">"); - } + editor.getDocument().insertString(offset, ">"); } } diff --git a/java/java-impl/src/com/intellij/codeInsight/editorActions/smartEnter/AfterSemicolonEnterProcessor.java b/java/java-impl/src/com/intellij/codeInsight/editorActions/smartEnter/AfterSemicolonEnterProcessor.java index ff2f19d465c0..9d43379ce920 100644 --- a/java/java-impl/src/com/intellij/codeInsight/editorActions/smartEnter/AfterSemicolonEnterProcessor.java +++ b/java/java-impl/src/com/intellij/codeInsight/editorActions/smartEnter/AfterSemicolonEnterProcessor.java @@ -44,8 +44,8 @@ public class AfterSemicolonEnterProcessor implements EnterProcessor { ((PsiMethod) psiElement).hasModifierProperty(PsiModifier.NATIVE))) { int errorOffset = getErrorElementOffset(psiElement); int elementEndOffset = psiElement.getTextRange().getEndOffset(); - final CharSequence text = editor.getDocument().getCharsSequence(); if (psiElement instanceof PsiEnumConstant) { + final CharSequence text = editor.getDocument().getCharsSequence(); final int commaOffset = CharArrayUtil.shiftForwardUntil(text, elementEndOffset, ","); if (commaOffset < text.length()) { elementEndOffset = commaOffset + 1; @@ -53,18 +53,13 @@ public class AfterSemicolonEnterProcessor implements EnterProcessor { } if (errorOffset >= 0 && errorOffset < elementEndOffset) { + final CharSequence text = editor.getDocument().getCharsSequence(); if (text.charAt(errorOffset) == ' ' && text.charAt(errorOffset + 1) == ';') { errorOffset++; } } editor.getCaretModel().moveToOffset(errorOffset >= 0 ? errorOffset : elementEndOffset); - if (errorOffset < 0 && - isModified && - (elementEndOffset == text.length() || text.charAt(elementEndOffset) == '\n') && - (psiElement instanceof PsiExpressionStatement || psiElement instanceof PsiDeclarationStatement)) { - JavaSmartEnterProcessor.plainEnter(editor); - } return isModified; } return false; diff --git a/java/java-impl/src/com/intellij/codeInsight/editorActions/wordSelection/LiteralSelectioner.java b/java/java-impl/src/com/intellij/codeInsight/editorActions/wordSelection/LiteralSelectioner.java index 1c51da143810..6d903cafb418 100644 --- a/java/java-impl/src/com/intellij/codeInsight/editorActions/wordSelection/LiteralSelectioner.java +++ b/java/java-impl/src/com/intellij/codeInsight/editorActions/wordSelection/LiteralSelectioner.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -22,9 +22,12 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.JavaTokenType; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiLiteralExpression; +import com.intellij.psi.PsiType; import java.util.List; +import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING; + public class LiteralSelectioner extends BasicSelectioner { @Override public boolean canSelect(PsiElement e) { @@ -34,8 +37,10 @@ public class LiteralSelectioner extends BasicSelectioner { } private static boolean isStringLiteral(PsiElement element) { - return element instanceof PsiLiteralExpression && - ((PsiLiteralExpression)element).getType().equalsToText("java.lang.String") && element.getText().startsWith("\"") && element.getText().endsWith("\""); + final PsiType type = element instanceof PsiLiteralExpression ? ((PsiLiteralExpression)element).getType() : null; + return type != null && type.equalsToText(JAVA_LANG_STRING) + && element.getText().startsWith("\"") + && element.getText().endsWith("\""); } @Override diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddAnnotationIntention.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddAnnotationIntention.java index daf5aa5eac74..899da3035ce5 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddAnnotationIntention.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddAnnotationIntention.java @@ -31,6 +31,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.util.PsiUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; @@ -64,6 +65,11 @@ public abstract class AddAnnotationIntention extends BaseIntentionAction { return returnType != null && !(returnType instanceof PsiPrimitiveType); } + + if (owner instanceof PsiClass) { + return PsiUtil.isLanguageLevel8OrHigher(owner); + } + return true; } diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddJavadocIntention.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddJavadocIntention.java index a26e78ac85c7..22abefb01c98 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddJavadocIntention.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/AddJavadocIntention.java @@ -16,6 +16,7 @@ package com.intellij.codeInsight.intention.impl; import com.intellij.codeInsight.editorActions.FixDocCommentAction; +import com.intellij.codeInsight.intention.LowPriorityAction; import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; @@ -26,7 +27,7 @@ import org.jetbrains.annotations.NotNull; /** * @author Dmitry Batkovich */ -public class AddJavadocIntention extends PsiElementBaseIntentionAction { +public class AddJavadocIntention extends PsiElementBaseIntentionAction implements LowPriorityAction { @Override public void invoke(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) throws IncorrectOperationException { final PsiDocCommentOwner docCommentOwner = (PsiDocCommentOwner)element.getParent(); diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/DeannotateIntentionAction.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/DeannotateIntentionAction.java index 84831e2dc6e2..4fba52583963 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/DeannotateIntentionAction.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/DeannotateIntentionAction.java @@ -48,7 +48,7 @@ public class DeannotateIntentionAction implements IntentionAction { @Override @NotNull public String getText() { - return CodeInsightBundle.message("deannotate.intention.action.text") + (myAnnotationName != null ? " " + myAnnotationName : ""); + return CodeInsightBundle.message("deannotate.intention.action.text") + (myAnnotationName != null ? " " + myAnnotationName : "..."); } @Override @@ -59,6 +59,7 @@ public class DeannotateIntentionAction implements IntentionAction { @Override public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + myAnnotationName = null; PsiModifierListOwner listOwner = getContainer(editor, file); if (listOwner != null) { final ExternalAnnotationsManager externalAnnotationsManager = ExternalAnnotationsManager.getInstance(project); diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/SwapIfStatementsIntentionAction.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/SwapIfStatementsIntentionAction.java new file mode 100644 index 000000000000..cd8ce8dd1dce --- /dev/null +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/SwapIfStatementsIntentionAction.java @@ -0,0 +1,75 @@ +/* + * Copyright 2000-2014 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.codeInsight.intention.impl; + +import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.*; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; + +/** + * @author Dmitry Batkovich + */ +public class SwapIfStatementsIntentionAction extends PsiElementBaseIntentionAction { + @Override + public void invoke(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) throws IncorrectOperationException { + final PsiIfStatement ifStatement = (PsiIfStatement)element.getParent(); + final PsiIfStatement nestedIfStatement = (PsiIfStatement) ifStatement.getElseBranch(); + assert nestedIfStatement != null; + + final PsiExpression condition = ifStatement.getCondition(); + final PsiExpression nestedCondition = nestedIfStatement.getCondition(); + + final PsiStatement thenBranch = ifStatement.getThenBranch(); + final PsiStatement nestedThenBranch = nestedIfStatement.getThenBranch(); + + assert condition != null; + assert nestedCondition != null; + assert thenBranch != null; + assert nestedThenBranch != null; + + final PsiElement conditionCopy = condition.copy(); + condition.replace(nestedCondition); + nestedCondition.replace(conditionCopy); + + final PsiElement thenBranchCopy = thenBranch.copy(); + thenBranch.replace(nestedThenBranch); + nestedThenBranch.replace(thenBranchCopy); + } + + @Override + public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) { + if (!(element instanceof PsiKeyword) || !PsiKeyword.ELSE.equals(element.getText())) { + return false; + } + final PsiElement parent = element.getParent(); + return parent instanceof PsiIfStatement && ((PsiIfStatement)parent).getElseBranch() instanceof PsiIfStatement; + } + + @NotNull + @Override + public String getFamilyName() { + return "Swap If Statements"; + } + + @NotNull + @Override + public String getText() { + return getFamilyName(); + } +} diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java index e934a9f387cf..81f0204049b6 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java @@ -762,6 +762,12 @@ public class QuickFixFactoryImpl extends QuickFixFactory { return new SurroundWithQuotesAnnotationParameterValueFix(value, expectedType); } + @NotNull + @Override + public IntentionAction addMethodQualifierFix(@NotNull PsiMethodCallExpression methodCall) { + return new AddMethodQualifierFix(methodCall); + } + private static boolean timeToOptimizeImports(@NotNull PsiFile file) { if (!CodeInsightSettings.getInstance().OPTIMIZE_IMPORTS_ON_THE_FLY) return false; diff --git a/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java b/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java index 49befb363437..a6d734b92d8e 100644 --- a/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java +++ b/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java @@ -103,10 +103,11 @@ public class PsiTypeLookupItem extends LookupItem { myImportFixer.handleInsert(context, this); PsiElement position = context.getFile().findElementAt(context.getStartOffset()); - assert position != null; - int genericsStart = context.getTailOffset(); - context.getDocument().insertString(genericsStart, JavaCompletionUtil.escapeXmlIfNeeded(context, calcGenerics(position, context))); - JavaCompletionUtil.shortenReference(context.getFile(), genericsStart - 1); + if (position != null) { + int genericsStart = context.getTailOffset(); + context.getDocument().insertString(genericsStart, JavaCompletionUtil.escapeXmlIfNeeded(context, calcGenerics(position, context))); + JavaCompletionUtil.shortenReference(context.getFile(), genericsStart - 1); + } int tail = context.getTailOffset(); String braces = StringUtil.repeat("[]", getBracketsCount()); diff --git a/java/java-impl/src/com/intellij/codeInspection/RemoveAssignmentFix.java b/java/java-impl/src/com/intellij/codeInspection/RemoveAssignmentFix.java index b80e3a07121d..9db065ad321f 100644 --- a/java/java-impl/src/com/intellij/codeInspection/RemoveAssignmentFix.java +++ b/java/java-impl/src/com/intellij/codeInspection/RemoveAssignmentFix.java @@ -40,7 +40,7 @@ public class RemoveAssignmentFix extends RemoveInitializerFix { if (!(parent instanceof PsiAssignmentExpression)) return; final PsiExpression rExpression = ((PsiAssignmentExpression)parent).getRExpression(); final PsiElement gParent = parent.getParent(); - if (gParent instanceof PsiExpression && rExpression != null) { + if ((gParent instanceof PsiExpression || gParent instanceof PsiExpressionList) && rExpression != null) { if (!FileModificationService.getInstance().prepareFileForWrite(gParent.getContainingFile())) return; if (gParent instanceof PsiParenthesizedExpression) { gParent.replace(rExpression); diff --git a/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java b/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java index c3d61021c0d0..f9127f0b48a5 100644 --- a/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java +++ b/java/java-impl/src/com/intellij/codeInspection/inferNullity/InferNullityAnnotationsAction.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -79,7 +79,6 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { @Override protected void analyze(@NotNull final Project project, @NotNull final AnalysisScope scope) { - PropertiesComponent.getInstance().setValue(ANNOTATE_LOCAL_VARIABLES, String.valueOf(myAnnotateLocalVariablesCb.isSelected())); final ProgressManager progressManager = ProgressManager.getInstance(); @@ -174,7 +173,7 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { final String path = dialog.getResultingLibraryPath(); new WriteCommandAction(project) { @Override - protected void run(final Result result) throws Throwable { + protected void run(@NotNull final Result result) throws Throwable { for (Module module : modulesWithoutAnnotations) { OrderEntryFix.addBundledJarToRoots(project, null, module, null, AnnotationUtil.NOT_NULL, path); } @@ -206,8 +205,8 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { } } - private UsageInfo[] findUsages(final Project project, - final AnalysisScope scope) { + private UsageInfo[] findUsages(@NotNull final Project project, + @NotNull final AnalysisScope scope) { final NullityInferrer inferrer = new NullityInferrer(myAnnotateLocalVariablesCb.isSelected(), project); final PsiManager psiManager = PsiManager.getInstance(project); final Runnable searchForUsages = new Runnable() { @@ -257,7 +256,7 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { try { new WriteCommandAction(project, INFER_NULLITY_ANNOTATIONS) { @Override - protected void run(Result result) throws Throwable { + protected void run(@NotNull Result result) throws Throwable { final UsageInfo[] infos = computable.compute(); if (infos.length > 0) { final SequentialModalProgressTask progressTask = new SequentialModalProgressTask(project, INFER_NULLITY_ANNOTATIONS, false); @@ -287,7 +286,7 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { } - private void showUsageView(final Project project, final UsageInfo[] usageInfos, AnalysisScope scope) { + private void showUsageView(@NotNull Project project, final UsageInfo[] usageInfos, @NotNull AnalysisScope scope) { final UsageTarget[] targets = UsageTarget.EMPTY_ARRAY; final Ref<Usage[]> convertUsagesRef = new Ref<Usage[]>(); if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() { @@ -326,7 +325,8 @@ public class InferNullityAnnotationsAction extends BaseAnalysisAction { usageView.addPerformOperationAction(refactoringRunnable, INFER_NULLITY_ANNOTATIONS, canNotMakeString, INFER_NULLITY_ANNOTATIONS, false); } - private Factory<UsageSearcher> rerunFactory(final Project project, final AnalysisScope scope) { + @NotNull + private Factory<UsageSearcher> rerunFactory(@NotNull final Project project, @NotNull final AnalysisScope scope) { return new Factory<UsageSearcher>() { @Override public UsageSearcher create() { diff --git a/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicCompletionContributor.java b/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicCompletionContributor.java index 4f9fa882be6e..8150b618f8dc 100644 --- a/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicCompletionContributor.java @@ -25,6 +25,7 @@ import com.intellij.util.ArrayUtil; import com.intellij.util.Consumer; import gnu.trove.THashSet; import gnu.trove.TObjectHashingStrategy; +import org.jetbrains.annotations.NotNull; import java.util.Arrays; import java.util.List; @@ -46,7 +47,7 @@ public class MagicCompletionContributor extends CompletionContributor { private static final int PRIORITY = 100; @Override - public void fillCompletionVariants(final CompletionParameters parameters, final CompletionResultSet result) { + public void fillCompletionVariants(@NotNull final CompletionParameters parameters, @NotNull final CompletionResultSet result) { //if (parameters.getCompletionType() != CompletionType.SMART) return; PsiElement pos = parameters.getPosition(); MagicConstantInspection.AllowedValues allowedValues = null; diff --git a/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java index 400acce6d8c2..e9c059eff080 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -22,6 +22,7 @@ import com.intellij.psi.impl.search.ThrowSearchUtil; import com.intellij.ui.IdeBorderFactory; import com.intellij.ui.StateRestoringCheckBox; import com.intellij.util.ui.UIUtil; +import org.jetbrains.annotations.NotNull; import javax.swing.*; import java.awt.*; @@ -32,9 +33,13 @@ public class FindThrowUsagesDialog extends JavaFindUsagesDialog<JavaThrowFindUsa private boolean myHasFindWhatPanel; private ThrowSearchUtil.Root [] myRoots; - public FindThrowUsagesDialog(final PsiElement element, final Project project, - final FindUsagesOptions findUsagesOptions, boolean toShowInNewTab, boolean mustOpenInNewTab, - boolean isSingleFile, FindUsagesHandler handler){ + public FindThrowUsagesDialog(@NotNull PsiElement element, + @NotNull Project project, + @NotNull JavaThrowFindUsagesOptions findUsagesOptions, + boolean toShowInNewTab, + boolean mustOpenInNewTab, + boolean isSingleFile, + @NotNull FindUsagesHandler handler) { super(element, project, findUsagesOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, handler); } @@ -92,7 +97,7 @@ public class FindThrowUsagesDialog extends JavaFindUsagesDialog<JavaThrowFindUsa @Override protected void doOKAction() { - myFindUsagesOptions.putUserData(ThrowSearchUtil.THROW_SEARCH_ROOT_KEY, (ThrowSearchUtil.Root)myCbExns.getSelectedItem()); + getFindUsagesOptions().setRoot((ThrowSearchUtil.Root)myCbExns.getSelectedItem()); super.doOKAction(); } @@ -102,7 +107,7 @@ public class FindThrowUsagesDialog extends JavaFindUsagesDialog<JavaThrowFindUsa setOKActionEnabled(true); } else{ - myFindUsagesOptions.putUserData(ThrowSearchUtil.THROW_SEARCH_ROOT_KEY, (ThrowSearchUtil.Root)myCbExns.getSelectedItem()); + getFindUsagesOptions().setRoot((ThrowSearchUtil.Root)myCbExns.getSelectedItem()); final boolean hasSelected = isSelected(myCbUsages); setOKActionEnabled(hasSelected); } diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java index 17f9650b3b24..65528fb8a921 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -36,7 +36,7 @@ public abstract class JavaFindUsagesDialog<T extends JavaFindUsagesOptions> exte boolean toShowInNewTab, boolean mustOpenInNewTab, boolean isSingleFile, - FindUsagesHandler handler) { + @NotNull FindUsagesHandler handler) { super(element, project, findUsagesOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, handler); } @@ -82,10 +82,12 @@ public abstract class JavaFindUsagesDialog<T extends JavaFindUsagesOptions> exte } } + @NotNull protected final PsiElement getPsiElement() { return myPsiElement; } + @NotNull protected T getFindUsagesOptions() { return (T)myFindUsagesOptions; } diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java index 3fd1161bb0ed..1791fd0d6e8e 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java @@ -220,9 +220,10 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } @Override - protected Set<String> getStringsToSearch(final PsiElement element) { + protected Set<String> getStringsToSearch(@NotNull final PsiElement element) { if (element instanceof PsiDirectory) { // normalize a directory to a corresponding package - return getStringsToSearch(JavaDirectoryService.getInstance().getPackage((PsiDirectory)element)); + PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage((PsiDirectory)element); + return aPackage == null ? Collections.<String>emptySet() : getStringsToSearch(aPackage); } final Set<String> result = new HashSet<String>(); @@ -264,7 +265,8 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } else if (element instanceof XmlAttributeValue) { ContainerUtil.addIfNotNull(result, ((XmlAttributeValue)element).getValue()); - } else { + } + else { LOG.error("Unknown element type: " + element); } } @@ -306,7 +308,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ @Override public Boolean compute() { if (ThrowSearchUtil.isSearchable (element) && options instanceof JavaThrowFindUsagesOptions && options.isUsages) { - ThrowSearchUtil.Root root = options.getUserData(ThrowSearchUtil.THROW_SEARCH_ROOT_KEY); + ThrowSearchUtil.Root root = ((JavaThrowFindUsagesOptions)options).getRoot(); if (root == null) { final ThrowSearchUtil.Root[] roots = ThrowSearchUtil.getSearchRoots(element); if (roots != null && roots.length > 0) { @@ -346,6 +348,9 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } else if (classOptions.isImplementingClasses){ if (!addImplementingClasses(psiClass, processor, classOptions)) return false; + } + + if (classOptions.isImplementingClasses) { FunctionalExpressionSearch.search(psiClass, classOptions.searchScope).forEach(new PsiElementProcessorAdapter<PsiFunctionalExpression>( new PsiElementProcessor<PsiFunctionalExpression>() { @Override @@ -755,6 +760,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } + @NotNull @Override public Collection<PsiReference> findReferencesToHighlight(@NotNull final PsiElement target, @NotNull final SearchScope searchScope) { if (target instanceof PsiMethod) { diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java index 2d28a8ddf57c..b78dfca59fe5 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java @@ -34,6 +34,7 @@ public abstract class JavaFindUsagesOptions extends FindUsagesOptions { isUsages = true; } + @Override public boolean equals(final Object o) { if (this == o) return true; if (!super.equals(this)) return false; @@ -42,6 +43,7 @@ public abstract class JavaFindUsagesOptions extends FindUsagesOptions { return isSkipImportStatements == ((JavaFindUsagesOptions)o).isSkipImportStatements; } + @Override public int hashCode() { int result = super.hashCode(); result = 31 * result + (isSkipImportStatements ? 1 : 0); diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaThrowFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaThrowFindUsagesOptions.java index c90c6a675dee..4ccc0c4aef6e 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaThrowFindUsagesOptions.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaThrowFindUsagesOptions.java @@ -1,16 +1,40 @@ +/* + * Copyright 2000-2014 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.find.findUsages; import com.intellij.openapi.project.Project; +import com.intellij.psi.impl.search.ThrowSearchUtil; import org.jetbrains.annotations.NotNull; /** * @author peter */ public class JavaThrowFindUsagesOptions extends JavaFindUsagesOptions { + private ThrowSearchUtil.Root root; public JavaThrowFindUsagesOptions(@NotNull Project project) { super(project); isSearchForTextOccurrences = false; } + public ThrowSearchUtil.Root getRoot() { + return root; + } + + public void setRoot(ThrowSearchUtil.Root root) { + this.root = root; + } } diff --git a/java/java-impl/src/com/intellij/jarFinder/FindJarFix.java b/java/java-impl/src/com/intellij/jarFinder/FindJarFix.java index 688788ae3c16..ee203e34deac 100644 --- a/java/java-impl/src/com/intellij/jarFinder/FindJarFix.java +++ b/java/java-impl/src/com/intellij/jarFinder/FindJarFix.java @@ -31,7 +31,7 @@ import com.intellij.util.NotNullFunction; import com.intellij.util.PlatformIcons; import com.intellij.util.download.DownloadableFileDescription; import com.intellij.util.download.DownloadableFileService; -import org.apache.xerces.parsers.DOMParser; +import org.cyberneko.html.parsers.DOMParser; import org.jetbrains.annotations.NotNull; import org.w3c.dom.Document; import org.w3c.dom.NamedNodeMap; @@ -40,11 +40,8 @@ import org.w3c.dom.NodeList; import org.xml.sax.SAXException; import javax.swing.*; -import javax.xml.parsers.DocumentBuilderFactory; import java.io.File; import java.io.IOException; -import java.io.InputStream; -import java.net.URL; import java.util.*; /** @@ -129,22 +126,9 @@ public abstract class FindJarFix<T extends PsiElement> implements IntentionActio final Runnable runnable = new Runnable() { public void run() { try { - Document doc; - - DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance(); - builderFactory.setExpandEntityReferences(false); - builderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); - - URL url = new URL(CLASS_ROOT_URL + fqn.replace('.', '/') + CLASS_PAGE_EXT); - - InputStream stream = url.openStream(); - try { - doc = builderFactory.newDocumentBuilder().parse(stream); - } - finally { - stream.close(); - } - + final DOMParser parser = new DOMParser(); + parser.parse(CLASS_ROOT_URL + fqn.replace('.', '/') + CLASS_PAGE_EXT); + final Document doc = parser.getDocument(); if (doc != null) { final NodeList links = doc.getElementsByTagName(LINK_TAG_NAME); for (int i = 0; i < links.getLength(); i++) { diff --git a/java/java-impl/src/com/intellij/openapi/roots/impl/JavaLanguageLevelPusher.java b/java/java-impl/src/com/intellij/openapi/roots/impl/JavaLanguageLevelPusher.java index 6daedef21ef9..d933576fc697 100644 --- a/java/java-impl/src/com/intellij/openapi/roots/impl/JavaLanguageLevelPusher.java +++ b/java/java-impl/src/com/intellij/openapi/roots/impl/JavaLanguageLevelPusher.java @@ -37,7 +37,7 @@ import java.io.IOException; * @author Gregory.Shrago */ public class JavaLanguageLevelPusher implements FilePropertyPusher<LanguageLevel> { - public static void pushLanguageLevel(final Project project) { + public static void pushLanguageLevel(@NotNull final Project project) { PushedFilePropertiesUpdater.getInstance(project).pushAll(new JavaLanguageLevelPusher()); } diff --git a/java/java-impl/src/com/intellij/psi/NonClasspathResolveScopeEnlarger.java b/java/java-impl/src/com/intellij/psi/NonClasspathResolveScopeEnlarger.java index 01114788ac9d..b7b5a05aef28 100644 --- a/java/java-impl/src/com/intellij/psi/NonClasspathResolveScopeEnlarger.java +++ b/java/java-impl/src/com/intellij/psi/NonClasspathResolveScopeEnlarger.java @@ -5,7 +5,7 @@ import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.project.Project; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.search.NonClasspathDirectoryScope; +import com.intellij.psi.search.NonClasspathDirectoriesScope; import com.intellij.psi.search.SearchScope; import org.jetbrains.annotations.NotNull; @@ -25,7 +25,7 @@ public class NonClasspathResolveScopeEnlarger extends ResolveScopeEnlarger { final List<VirtualFile> roots = ((NonClasspathClassFinder)finder).getClassRoots(); for (VirtualFile root : roots) { if (VfsUtil.isAncestor(root, file, true)) { - return NonClasspathDirectoryScope.compose(roots); + return NonClasspathDirectoriesScope.compose(roots); } } } diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/FieldDependenciesManager.java b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/FieldDependenciesManager.java new file mode 100644 index 000000000000..cea1c9e07f4c --- /dev/null +++ b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/FieldDependenciesManager.java @@ -0,0 +1,56 @@ +/* + * Copyright 2000-2014 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.arrangement; + +import com.intellij.psi.PsiField; +import com.intellij.util.containers.ContainerUtil; +import org.jetbrains.annotations.NotNull; + +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class FieldDependenciesManager { + private final Map<PsiField, Set<PsiField>> myFieldDependencies; + private final Map<PsiField, ArrangementEntryDependencyInfo> myFieldInfosMap = ContainerUtil.newHashMap(); + + public FieldDependenciesManager(@NotNull Map<PsiField, Set<PsiField>> fieldDependencies, @NotNull Map<PsiField, JavaElementArrangementEntry> fields) { + myFieldDependencies = fieldDependencies; + for (PsiField field : fields.keySet()) { + JavaElementArrangementEntry entry = fields.get(field); + myFieldInfosMap.put(field, new ArrangementEntryDependencyInfo(entry)); + } + } + + @NotNull + public List<ArrangementEntryDependencyInfo> getRoots() { + List<ArrangementEntryDependencyInfo> list = ContainerUtil.newArrayList(); + + for (Map.Entry<PsiField, Set<PsiField>> entry : myFieldDependencies.entrySet()) { + ArrangementEntryDependencyInfo currentInfo = myFieldInfosMap.get(entry.getKey()); + + for (PsiField usedInInitialization : entry.getValue()) { + ArrangementEntryDependencyInfo fieldInfo = myFieldInfosMap.get(usedInInitialization); + if (fieldInfo != null) + currentInfo.addDependentEntryInfo(fieldInfo); + } + + list.add(currentInfo); + } + + return list; + } +}
\ No newline at end of file diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementParseInfo.java b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementParseInfo.java index 2796fecea024..f042bb316c40 100644 --- a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementParseInfo.java +++ b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementParseInfo.java @@ -27,8 +27,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.*; -import java.util.HashMap; -import java.util.HashSet; /** * @author Denis Zhdanov @@ -36,28 +34,22 @@ import java.util.HashSet; */ public class JavaArrangementParseInfo { - @NotNull private final List<JavaElementArrangementEntry> myEntries = new ArrayList<JavaElementArrangementEntry>(); + private final List<JavaElementArrangementEntry> myEntries = new ArrayList<JavaElementArrangementEntry>(); - @NotNull private final Map<Pair<String/* property name */, String/* class name */>, JavaArrangementPropertyInfo> myProperties - = new HashMap<Pair<String, String>, JavaArrangementPropertyInfo>(); + private final Map<Pair<String/* property name */, String/* class name */>, JavaArrangementPropertyInfo> myProperties = new HashMap<Pair<String, String>, JavaArrangementPropertyInfo>(); - @NotNull private final List<ArrangementEntryDependencyInfo> myMethodDependencyRoots - = new ArrayList<ArrangementEntryDependencyInfo>(); + private final List<ArrangementEntryDependencyInfo> myMethodDependencyRoots = new ArrayList<ArrangementEntryDependencyInfo>(); + private final Map<PsiMethod /* anchor */, Set<PsiMethod /* dependencies */>> myMethodDependencies = new HashMap<PsiMethod, Set<PsiMethod>>(); - @NotNull private final Map<PsiMethod /* anchor */, Set<PsiMethod /* dependencies */>> myMethodDependencies - = new HashMap<PsiMethod, Set<PsiMethod>>(); + private final Map<PsiMethod, JavaElementArrangementEntry> myMethodEntriesMap = new HashMap<PsiMethod, JavaElementArrangementEntry>(); + private final Map<PsiClass, List<Pair<PsiMethod/*overridden*/, PsiMethod/*overriding*/>>> myOverriddenMethods = new LinkedHashMap<PsiClass, List<Pair<PsiMethod, PsiMethod>>>(); - @NotNull private final Map<PsiMethod, JavaElementArrangementEntry> myMethodEntriesMap = - new HashMap<PsiMethod, JavaElementArrangementEntry>(); - - @NotNull private final Map<PsiClass, List<Pair<PsiMethod/*overridden*/, PsiMethod/*overriding*/>>> myOverriddenMethods - = new LinkedHashMap<PsiClass, List<Pair<PsiMethod, PsiMethod>>>(); - - @NotNull private final Set<PsiMethod> myTmpMethodDependencyRoots = new LinkedHashSet<PsiMethod>(); - @NotNull private final Set<PsiMethod> myDependentMethods = new HashSet<PsiMethod>(); + private final Set<PsiMethod> myTmpMethodDependencyRoots = new LinkedHashSet<PsiMethod>(); + private final Set<PsiMethod> myDependentMethods = new HashSet<PsiMethod>(); private boolean myRebuildMethodDependencies; - @NotNull private FieldDependenciesManager myFieldDependenciesManager = new FieldDependenciesManager(); + private final HashMap<PsiField, JavaElementArrangementEntry> myFields = ContainerUtil.newLinkedHashMap(); + private final Map<PsiField, Set<PsiField>> myFieldDependencies = ContainerUtil.newHashMap(); @NotNull public List<JavaElementArrangementEntry> getEntries() { @@ -96,8 +88,7 @@ public class JavaArrangementParseInfo { @Nullable private ArrangementEntryDependencyInfo buildMethodDependencyInfo(@NotNull final PsiMethod method, - @NotNull Map<PsiMethod, ArrangementEntryDependencyInfo> cache) - { + @NotNull Map<PsiMethod, ArrangementEntryDependencyInfo> cache) { JavaElementArrangementEntry entry = myMethodEntriesMap.get(method); if (entry == null) { return null; @@ -158,7 +149,7 @@ public class JavaArrangementParseInfo { } public void onFieldEntryCreated(@NotNull PsiField field, @NotNull JavaElementArrangementEntry entry) { - myFieldDependenciesManager.registerFieldAndEntry(field, entry); + myFields.put(field, entry); } public void onOverriddenMethod(@NotNull PsiMethod baseMethod, @NotNull PsiMethod overridingMethod) { @@ -201,7 +192,7 @@ public class JavaArrangementParseInfo { result.add(info); } } - + return result; } @@ -226,49 +217,21 @@ public class JavaArrangementParseInfo { } public void registerFieldInitializationDependency(@NotNull PsiField fieldToInitialize, @NotNull PsiField usedInInitialization) { - myFieldDependenciesManager.registerInitializationDependency(fieldToInitialize, usedInInitialization); + Set<PsiField> fields = myFieldDependencies.get(fieldToInitialize); + if (fields == null) { + fields = ContainerUtil.newHashSet(); + myFieldDependencies.put(fieldToInitialize, fields); + } + fields.add(usedInInitialization); } @NotNull public List<ArrangementEntryDependencyInfo> getFieldDependencyRoots() { - return myFieldDependenciesManager.getRoots(); + return new FieldDependenciesManager(myFieldDependencies, myFields).getRoots(); } - private static class FieldDependenciesManager { - private final Map<PsiField, Set<PsiField>> myFieldDependencies = ContainerUtil.newHashMap(); - private final Map<PsiField, ArrangementEntryDependencyInfo> myFieldInfosMap = ContainerUtil.newHashMap(); - - - public void registerFieldAndEntry(@NotNull PsiField field, @NotNull JavaElementArrangementEntry entry) { - myFieldInfosMap.put(field, new ArrangementEntryDependencyInfo(entry)); - } - - public void registerInitializationDependency(@NotNull PsiField fieldToInitialize, @NotNull PsiField usedInInitialization) { - Set<PsiField> fields = myFieldDependencies.get(fieldToInitialize); - if (fields == null) { - fields = new HashSet<PsiField>(); - myFieldDependencies.put(fieldToInitialize, fields); - } - fields.add(usedInInitialization); - } - - @NotNull - public List<ArrangementEntryDependencyInfo> getRoots() { - List<ArrangementEntryDependencyInfo> list = ContainerUtil.newArrayList(); - - for (Map.Entry<PsiField, Set<PsiField>> entry : myFieldDependencies.entrySet()) { - ArrangementEntryDependencyInfo currentInfo = myFieldInfosMap.get(entry.getKey()); - - for (PsiField usedInInitialization : entry.getValue()) { - ArrangementEntryDependencyInfo fieldInfo = myFieldInfosMap.get(usedInInitialization); - if (fieldInfo != null) - currentInfo.addDependentEntryInfo(fieldInfo); - } - - list.add(currentInfo); - } - - return list; - } + @NotNull + public Collection<JavaElementArrangementEntry> getFields() { + return myFields.values(); } }
\ No newline at end of file diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java index e35cc50379dd..9e23eadc3073 100644 --- a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java +++ b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java @@ -27,6 +27,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; +import com.intellij.psi.codeStyle.arrangement.engine.ArrangementEngine; import com.intellij.psi.codeStyle.arrangement.group.ArrangementGroupingRule; import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; @@ -34,8 +35,6 @@ import com.intellij.psi.codeStyle.arrangement.match.StdArrangementMatchRule; import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.ArrangementCompositeMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; -import com.intellij.psi.codeStyle.arrangement.std.ArrangementColorsAware; -import com.intellij.psi.codeStyle.arrangement.std.ArrangementStandardSettingsAware; import com.intellij.psi.codeStyle.arrangement.std.*; import com.intellij.util.containers.ContainerUtilRt; import org.jetbrains.annotations.NotNull; @@ -46,10 +45,10 @@ import java.util.*; import java.util.List; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.*; +import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.General.*; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Grouping.*; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Modifier.*; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Order.*; -import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.General.*; /** * @author Denis Zhdanov @@ -250,16 +249,29 @@ public class JavaRearranger implements Rearranger<JavaElementArrangementEntry>, setupOverriddenMethods(parseInfo); } } - setupFieldInitializationDependencies(parseInfo.getFieldDependencyRoots()); + List<ArrangementEntryDependencyInfo> fieldDependencyRoots = parseInfo.getFieldDependencyRoots(); + if (!fieldDependencyRoots.isEmpty()) { + setupFieldInitializationDependencies(fieldDependencyRoots, settings, parseInfo); + } return parseInfo.getEntries(); } + public void setupFieldInitializationDependencies(@NotNull List<ArrangementEntryDependencyInfo> fieldDependencyRoots, + @NotNull ArrangementSettings settings, + @NotNull JavaArrangementParseInfo parseInfo) + { + Collection<JavaElementArrangementEntry> fields = parseInfo.getFields(); + List<JavaElementArrangementEntry> arrangedFields = ArrangementEngine.arrange(fields, settings.getSections(), settings.getRulesSortedByPriority(), null); + + for (ArrangementEntryDependencyInfo root : fieldDependencyRoots) { + JavaElementArrangementEntry anchorField = root.getAnchorEntry(); + final int anchorEntryIndex = arrangedFields.indexOf(anchorField); - public void setupFieldInitializationDependencies(@NotNull List<ArrangementEntryDependencyInfo> list) { - for (ArrangementEntryDependencyInfo info : list) { - JavaElementArrangementEntry anchorField = info.getAnchorEntry(); - for (ArrangementEntryDependencyInfo fieldUsedInInitialization : info.getDependentEntriesInfos()) { - anchorField.addDependency(fieldUsedInInitialization.getAnchorEntry()); + for (ArrangementEntryDependencyInfo fieldInInitializerInfo : root.getDependentEntriesInfos()) { + JavaElementArrangementEntry fieldInInitializer = fieldInInitializerInfo.getAnchorEntry(); + if (arrangedFields.indexOf(fieldInInitializer) > anchorEntryIndex) { + anchorField.addDependency(fieldInInitializer); + } } } } diff --git a/java/java-impl/src/com/intellij/psi/impl/beanProperties/CreateBeanPropertyFix.java b/java/java-impl/src/com/intellij/psi/impl/beanProperties/CreateBeanPropertyFix.java index 053a534e0c98..a53bd1c9d187 100644 --- a/java/java-impl/src/com/intellij/psi/impl/beanProperties/CreateBeanPropertyFix.java +++ b/java/java-impl/src/com/intellij/psi/impl/beanProperties/CreateBeanPropertyFix.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -34,6 +34,8 @@ import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import static com.intellij.psi.CommonClassNames.JAVA_LANG_STRING; + /** * @author Dmitry Avdeev */ @@ -59,7 +61,7 @@ public abstract class CreateBeanPropertyFix implements LocalQuickFix, IntentionA if (type == null) { final Project project = psiClass.getProject(); final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - final PsiClass aClass = facade.findClass("java.lang.String", GlobalSearchScope.allScope(project)); + final PsiClass aClass = facade.findClass(JAVA_LANG_STRING, GlobalSearchScope.allScope(project)); if (aClass == null) { return NO_FIXES; } diff --git a/java/java-impl/src/com/intellij/psi/impl/search/ThrowSearchUtil.java b/java/java-impl/src/com/intellij/psi/impl/search/ThrowSearchUtil.java index f3adf354de41..9375561d92e1 100644 --- a/java/java-impl/src/com/intellij/psi/impl/search/ThrowSearchUtil.java +++ b/java/java-impl/src/com/intellij/psi/impl/search/ThrowSearchUtil.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -17,7 +17,6 @@ package com.intellij.psi.impl.search; import com.intellij.find.findUsages.FindUsagesOptions; import com.intellij.openapi.diagnostic.Logger; -import com.intellij.openapi.util.Key; import com.intellij.psi.*; import com.intellij.psi.search.searches.MethodReferencesSearch; import com.intellij.psi.util.PsiFormatUtil; @@ -34,34 +33,29 @@ import java.util.Set; * Author: msk */ public class ThrowSearchUtil { - private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.search.ThrowSearchUtil"); private ThrowSearchUtil() { } public static class Root { - final PsiElement myElement; - final PsiType myType; - final boolean isExact; + @NotNull private final PsiElement myElement; + @NotNull private final PsiType myType; + private final boolean isExact; - public Root(final PsiElement root, final PsiType type, final boolean exact) { + public Root(@NotNull PsiElement root, @NotNull PsiType type, final boolean exact) { myElement = root; myType = type; isExact = exact; } + @Override public String toString() { return PsiFormatUtil.formatType(myType, PsiFormatUtilBase.SHOW_FQ_CLASS_NAMES, PsiSubstitutor.EMPTY); } } - public static Key<Root> THROW_SEARCH_ROOT_KEY = Key.create("ThrowSearchUtil.root"); - /** - * @param aCatch - * @param processor - * @param root * @return true, if we should continue processing */ private static boolean processExn(@NotNull PsiParameter aCatch, @NotNull Processor<UsageInfo> processor, @NotNull Root root) { @@ -123,7 +117,6 @@ public class ThrowSearchUtil { } /** - * @param exn * @return is type of exn exactly known */ diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/JavaCharsetReferenceContributor.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/JavaCharsetReferenceContributor.java new file mode 100644 index 000000000000..db1a385d5137 --- /dev/null +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/JavaCharsetReferenceContributor.java @@ -0,0 +1,52 @@ +/* + * Copyright 2000-2014 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.resolve.reference.impl; + +import com.intellij.codeInsight.daemon.impl.analysis.encoding.EncodingReference; +import com.intellij.psi.*; +import com.intellij.psi.impl.source.resolve.reference.impl.manipulators.StringLiteralManipulator; +import com.intellij.util.ProcessingContext; +import org.jetbrains.annotations.NotNull; + +import java.nio.charset.Charset; + +import static com.intellij.patterns.PsiJavaPatterns.literalExpression; +import static com.intellij.patterns.PsiJavaPatterns.psiMethod; +import static com.intellij.patterns.StandardPatterns.string; + +/** + * @author peter + */ +public class JavaCharsetReferenceContributor extends PsiReferenceContributor { + @Override + public void registerReferenceProviders(@NotNull PsiReferenceRegistrar registrar) { + registrar.registerReferenceProvider( + literalExpression().methodCallParameter( + 0, psiMethod().withName(string().oneOf("forName", "isSupported")).inClass(Charset.class.getName())), + new PsiReferenceProvider() { + @NotNull + @Override + public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext context) { + PsiLiteralExpression literal = (PsiLiteralExpression)element; + Object value = literal.getValue(); + if (value instanceof String) { + return new PsiReference[]{new EncodingReference(element, (String)value, StringLiteralManipulator.getValueRange(literal))}; + } + return PsiReference.EMPTY_ARRAY; + } + }); + } +} diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/JavaReflectionReferenceContributor.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/JavaReflectionReferenceContributor.java index 06e5d4a672f4..dbcc03041c6f 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/JavaReflectionReferenceContributor.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/JavaReflectionReferenceContributor.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2014 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 @@ import com.intellij.patterns.PsiJavaElementPattern; import com.intellij.psi.PsiLiteral; import com.intellij.psi.PsiReferenceContributor; import com.intellij.psi.PsiReferenceRegistrar; +import org.jetbrains.annotations.NotNull; import static com.intellij.patterns.PsiJavaPatterns.psiExpression; import static com.intellij.patterns.PsiJavaPatterns.psiLiteral; @@ -38,7 +39,7 @@ public class JavaReflectionReferenceContributor extends PsiReferenceContributor .definedInClass(JAVA_LANG_CLASS))); @Override - public void registerReferenceProviders(PsiReferenceRegistrar registrar) { + public void registerReferenceProviders(@NotNull PsiReferenceRegistrar registrar) { registrar.registerReferenceProvider(PATTERN, new JavaReflectionReferenceProvider()); } } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/PackagePrefixFileSystemItemImpl.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/PackagePrefixFileSystemItemImpl.java index 7b85d17470ed..ce56ac3a36ad 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/PackagePrefixFileSystemItemImpl.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/PackagePrefixFileSystemItemImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -37,11 +37,11 @@ import java.util.ArrayList; * @author Gregory.Shrago */ class PackagePrefixFileSystemItemImpl extends PsiElementBase implements PsiFileSystemItem, PackagePrefixFileSystemItem { - private final PsiDirectory myDirectory; + @NotNull private final PsiDirectory myDirectory; private final int myIndex; private final PsiPackage[] myPackages; - public static PackagePrefixFileSystemItemImpl create(final PsiDirectory directory) { + public static PackagePrefixFileSystemItemImpl create(@NotNull PsiDirectory directory) { final ArrayList<PsiPackage> packages = new ArrayList<PsiPackage>(); for (PsiPackage cur = JavaDirectoryService.getInstance().getPackage(directory); cur != null; cur = cur.getParentPackage()) { packages.add(0, cur); @@ -49,7 +49,7 @@ class PackagePrefixFileSystemItemImpl extends PsiElementBase implements PsiFileS return new PackagePrefixFileSystemItemImpl(directory, 0, packages.toArray(new PsiPackage[packages.size()])); } - private PackagePrefixFileSystemItemImpl(final PsiDirectory directory, int index, final PsiPackage[] packages) { + private PackagePrefixFileSystemItemImpl(@NotNull PsiDirectory directory, int index, final PsiPackage[] packages) { myDirectory = directory; myIndex = index; myPackages = packages; @@ -249,6 +249,7 @@ class PackagePrefixFileSystemItemImpl extends PsiElementBase implements PsiFileS return myDirectory.getIcon(flags); } + @NotNull @Override public PsiDirectory getDirectory() { return myDirectory; diff --git a/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/JavaConcatenationInjectorManager.java b/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/JavaConcatenationInjectorManager.java index 5ffbaec2217d..195f06fb9cd3 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/JavaConcatenationInjectorManager.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/JavaConcatenationInjectorManager.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -22,8 +22,8 @@ import com.intellij.openapi.components.ServiceManager; import com.intellij.openapi.extensions.*; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; -import com.intellij.openapi.util.ModificationTracker; import com.intellij.openapi.util.Pair; +import com.intellij.openapi.util.SimpleModificationTracker; import com.intellij.psi.*; import com.intellij.psi.impl.PsiManagerEx; import com.intellij.psi.impl.PsiParameterizedCachedValue; @@ -38,9 +38,8 @@ import java.util.List; /** * @author cdr */ -public class JavaConcatenationInjectorManager implements ModificationTracker { +public class JavaConcatenationInjectorManager extends SimpleModificationTracker { public static final ExtensionPointName<ConcatenationAwareInjector> CONCATENATION_INJECTOR_EP_NAME = ExtensionPointName.create("com.intellij.concatenationAwareInjector"); - private volatile long myModificationCounter; public JavaConcatenationInjectorManager(Project project, PsiManagerEx psiManagerEx) { final ExtensionPoint<ConcatenationAwareInjector> concatPoint = Extensions.getArea(project).getExtensionPoint(CONCATENATION_INJECTOR_EP_NAME); @@ -58,7 +57,7 @@ public class JavaConcatenationInjectorManager implements ModificationTracker { psiManagerEx.registerRunnableToRunOnAnyChange(new Runnable() { @Override public void run() { - myModificationCounter++; // clear caches even on non-physical changes + incModificationCount(); // clear caches even on non-physical changes } }); } @@ -67,11 +66,6 @@ public class JavaConcatenationInjectorManager implements ModificationTracker { return ServiceManager.getService(project, JavaConcatenationInjectorManager.class); } - @Override - public long getModificationCount() { - return myModificationCounter; - } - private static Pair<PsiElement,PsiElement[]> computeAnchorAndOperandsImpl(@NotNull PsiElement context) { PsiElement element = context; PsiElement parent = context.getParent(); @@ -228,6 +222,6 @@ public class JavaConcatenationInjectorManager implements ModificationTracker { } private void concatenationInjectorsChanged() { - myModificationCounter++; + incModificationCount(); } } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/MyTestInjector.java b/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/MyTestInjector.java index 271eb0ca87b6..e9b8da7f7d20 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/MyTestInjector.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/tree/injected/MyTestInjector.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -160,6 +160,7 @@ public class MyTestInjector { private static void injectVariousStuffEverywhere(Disposable parent, final PsiManager psiManager) { final Language ql = Language.findLanguageByID("JPAQL"); final Language js = Language.findLanguageByID("JavaScript"); + final Language html = Language.findLanguageByID("HTML"); if (ql == null || js == null) return; final Language ecma4 = Language.findLanguageByID("ECMA Script Level 4"); @@ -216,6 +217,7 @@ public class MyTestInjector { inject(host, placesToInject, js); return; } + if ("jsprefix".equals(attrName)) { inject(host, placesToInject, js, "function foo(doc, window){", "}"); return; @@ -235,6 +237,10 @@ public class MyTestInjector { inject(host, placesToInject, js); return; } + if ("htmlInject".equals(tag.getLocalName())) { + inject(host, placesToInject, html); + return; + } if (ecma4 != null && "ecma4".equals(tag.getLocalName())) { inject(host, placesToInject, ecma4); return; diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java index a9fe12d19126..75544f9d8ab9 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java @@ -244,8 +244,6 @@ public class ExtractMethodProcessor implements MatchProvider { myOutputVariables = myControlFlowWrapper.getOutputVariables(); - checkCanBeChainedConstructor(); - return chooseTargetClass(codeFragment, pass); } @@ -1287,6 +1285,9 @@ public class ExtractMethodProcessor implements MatchProvider { if (!checkExitPoints()){ return false; } + + checkCanBeChainedConstructor(); + if (extractPass != null) { extractPass.pass(this); } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalDialog.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalDialog.java index 78d96096a8e7..f994eeb07db0 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalDialog.java @@ -23,15 +23,15 @@ import com.intellij.refactoring.HelpID; import com.intellij.refactoring.JavaRefactoringSettings; import com.intellij.refactoring.RefactoringBundle; -public class InlineLocalDialog extends InlineOptionsDialog { +public class InlineLocalDialog extends AbstractInlineLocalDialog { public static final String REFACTORING_NAME = RefactoringBundle.message("inline.method.title"); private final PsiVariable myVariable; private int myOccurrencesNumber = -1; - public InlineLocalDialog(Project project, PsiVariable variable, PsiJavaCodeReferenceElement ref, int occurrencesCount) { - super(project, true, variable); + public InlineLocalDialog(Project project, PsiVariable variable, final PsiJavaCodeReferenceElement ref, int occurrencesCount) { + super(project, variable, ref, occurrencesCount); myVariable = variable; myInvokedOnReference = ref != null; diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java index 44fd8cb8f724..78e99d94ef51 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java @@ -26,6 +26,7 @@ import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.editor.colors.EditorColors; import com.intellij.openapi.editor.colors.EditorColorsManager; +import com.intellij.openapi.editor.ex.EditorSettingsExternalizable; import com.intellij.openapi.editor.markup.TextAttributes; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Ref; @@ -147,15 +148,18 @@ public class InlineLocalHandler extends JavaInlineActionHandler { final Ref<Boolean> inlineAll = new Ref<Boolean>(true); if (editor != null && !ApplicationManager.getApplication().isUnitTestMode()) { int occurrencesCount = refsToInlineList.size(); - final InlineLocalDialog inlineLocalDialog = new InlineLocalDialog(project, local, refExpr, occurrencesCount); - inlineLocalDialog.show(); - if (!inlineLocalDialog.isOK()){ - WindowManager.getInstance().getStatusBar(project).setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting")); - return; - } - if (refExpr != null && inlineLocalDialog.isInlineThis()) { - refsToInlineList = Collections.<PsiElement>singletonList(refExpr); - inlineAll.set(false); + if (refExpr != null && occurrencesCount > 1 || EditorSettingsExternalizable.getInstance().isShowInlineLocalDialog()) { + final InlineLocalDialog inlineLocalDialog = new InlineLocalDialog(project, local, refExpr, occurrencesCount); + inlineLocalDialog.show(); + if (!inlineLocalDialog.isOK()){ + WindowManager.getInstance().getStatusBar(project).setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting")); + return; + } + + if (refExpr != null && inlineLocalDialog.isInlineThis()) { + refsToInlineList = Collections.<PsiElement>singletonList(refExpr); + inlineAll.set(false); + } } } @@ -280,7 +284,7 @@ public class InlineLocalHandler extends JavaInlineActionHandler { finally { final RefactoringEventData afterData = new RefactoringEventData(); afterData.addElement(containingClass); - project.getMessageBus().syncPublisher(RefactoringEventListener.REFACTORING_EVENT_TOPIC).refactoringStarted(refactoringId, afterData); + project.getMessageBus().syncPublisher(RefactoringEventListener.REFACTORING_EVENT_TOPIC).refactoringDone(refactoringId, afterData); } } }; diff --git a/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java index 071e2cf59bbc..4bae67e08f16 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -268,7 +268,7 @@ class IntroduceConstantDialog extends DialogWrapper { } final PsiManager psiManager = PsiManager.getInstance(myProject); - if ((myTypeSelectorManager.isSuggestedType("java.lang.String") || (myLocalVariable != null && AnnotationUtil.isAnnotated(myLocalVariable, AnnotationUtil.NON_NLS, false, false)))&& + if ((myTypeSelectorManager.isSuggestedType(CommonClassNames.JAVA_LANG_STRING) || (myLocalVariable != null && AnnotationUtil.isAnnotated(myLocalVariable, AnnotationUtil.NON_NLS, false, false)))&& LanguageLevelProjectExtension.getInstance(psiManager.getProject()).getLanguageLevel().isAtLeast(LanguageLevel.JDK_1_5) && JavaPsiFacade.getInstance(psiManager.getProject()).findClass(AnnotationUtil.NON_NLS, myParentClass.getResolveScope()) != null) { final PropertiesComponent component = PropertiesComponent.getInstance(myProject); diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveJavaMemberHandler.java b/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveJavaMemberHandler.java index e24c40dbfe32..5bd1c20a0b1e 100644 --- a/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveJavaMemberHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveJavaMemberHandler.java @@ -180,7 +180,7 @@ public class MoveJavaMemberHandler implements MoveMemberHandler { } else { final PsiReferenceParameterList parameterList = refExpr.getParameterList(); - if (parameterList != null && parameterList.getTypeArguments().length == 0){ + if (parameterList != null && parameterList.getTypeArguments().length == 0 && !(refExpr instanceof PsiMethodReferenceExpression)){ refExpr.setQualifierExpression(null); } else { final Project project = element.getProject(); diff --git a/java/java-impl/src/com/intellij/refactoring/rename/BeanPropertyRenameHandler.java b/java/java-impl/src/com/intellij/refactoring/rename/BeanPropertyRenameHandler.java index 4f3bf58ab4ab..9e19232ede36 100644 --- a/java/java-impl/src/com/intellij/refactoring/rename/BeanPropertyRenameHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/rename/BeanPropertyRenameHandler.java @@ -20,10 +20,7 @@ import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.DialogWrapper; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; -import com.intellij.psi.PsiMethod; -import com.intellij.psi.PsiParameter; +import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.codeStyle.VariableKind; import com.intellij.psi.impl.beanProperties.BeanProperty; @@ -56,7 +53,11 @@ public abstract class BeanPropertyRenameHandler implements RenameHandler { private void performInvoke(@Nullable Editor editor, DataContext dataContext) { final BeanProperty property = getProperty(dataContext); - new PropertyRenameDialog(property, editor).show(); + assert property != null; + PsiNamedElement element = property.getPsiElement(); + if (PsiElementRenameHandler.canRename(element.getProject(), editor, element)) { + new PropertyRenameDialog(property, editor).show(); + } } public static void doRename(@NotNull final BeanProperty property, final String newName, final boolean searchInComments, boolean isPreview) { diff --git a/java/java-impl/src/com/intellij/slicer/SliceUtil.java b/java/java-impl/src/com/intellij/slicer/SliceUtil.java index f27701a88c67..6d556b5f9681 100644 --- a/java/java-impl/src/com/intellij/slicer/SliceUtil.java +++ b/java/java-impl/src/com/intellij/slicer/SliceUtil.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 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. @@ -64,14 +64,25 @@ public class SliceUtil { expression = ((PsiArrayAccessExpression)expression).getArrayExpression(); indexNesting++; } - if (expression instanceof PsiExpressionList && indexNesting != 0 && expression.getParent() instanceof PsiMethodCallExpression) { + PsiElement par = expression == null ? null : expression.getParent(); + if (expression instanceof PsiExpressionList && par instanceof PsiMethodCallExpression) { // expression list ends up here if we track varargs - // unfold varargs list into individual expressions - PsiExpression[] expressions = ((PsiExpressionList)expression).getExpressions(); - for (PsiExpression arg : expressions) { - if (!handToProcessor(arg, processor, parent, parentSubstitutor, indexNesting -1, syntheticField)) return false; + PsiMethod method = ((PsiMethodCallExpression)par).resolveMethod(); + if (method != null) { + int parametersCount = method.getParameterList().getParametersCount(); + if (parametersCount != 0) { + // unfold varargs list into individual expressions + PsiExpression[] expressions = ((PsiExpressionList)expression).getExpressions(); + if (indexNesting != 0) { + // should skip not-vararg arguments + for (int i = parametersCount-1; i < expressions.length; i++) { + PsiExpression arg = expressions[i]; + if (!handToProcessor(arg, processor, parent, parentSubstitutor, indexNesting - 1, syntheticField)) return false; + } + } + return true; + } } - return true; } boolean needToReportDeclaration = false; @@ -409,7 +420,6 @@ public class SliceUtil { PsiType actualExpressionType; if (actualParameterType instanceof PsiEllipsisType) { passExpression = argumentList; - //passExpression = createArrayInitializerFromExpressions(argumentList, ((PsiEllipsisType)actualType).getComponentType(), expressions); actualExpressionType = expressions[paramSeqNo].getType(); } else { @@ -446,6 +456,10 @@ public class SliceUtil { if (substituted == null) return true; PsiType typeToCheck; if (actualParameterType instanceof PsiEllipsisType) { + // there may be the case of passing the vararg argument to the other vararg method: foo(int... ints) { bar(ints); } bar(int... ints) {} + if (TypeConversionUtil.areTypesConvertible(substituted, actualParameterType)) { + return handToProcessor(expressions[paramSeqNo], processor, parent, combined, indexNesting, syntheticField); + } typeToCheck = ((PsiEllipsisType)actualParameterType).getComponentType(); } else { diff --git a/java/java-impl/src/com/intellij/spellchecker/JavaSpellcheckingStrategy.java b/java/java-impl/src/com/intellij/spellchecker/JavaSpellcheckingStrategy.java index ee198727ffa8..0086b72ea0b1 100644 --- a/java/java-impl/src/com/intellij/spellchecker/JavaSpellcheckingStrategy.java +++ b/java/java-impl/src/com/intellij/spellchecker/JavaSpellcheckingStrategy.java @@ -15,23 +15,20 @@ */ package com.intellij.spellchecker; -import com.intellij.codeInsight.daemon.HighlightDisplayKey; -import com.intellij.codeInspection.BatchSuppressManager; import com.intellij.codeInspection.SuppressManager; -import com.intellij.codeInspection.SuppressQuickFix; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiLiteralExpression; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiNamedElement; import com.intellij.psi.javadoc.PsiDocComment; -import com.intellij.spellchecker.tokenizer.SuppressibleSpellcheckingStrategy; +import com.intellij.spellchecker.tokenizer.SpellcheckingStrategy; import com.intellij.spellchecker.tokenizer.Tokenizer; import org.jetbrains.annotations.NotNull; /** * @author shkate@jetbrains.com */ -public class JavaSpellcheckingStrategy extends SuppressibleSpellcheckingStrategy { +public class JavaSpellcheckingStrategy extends SpellcheckingStrategy { private final MethodNameTokenizerJava myMethodNameTokenizer = new MethodNameTokenizerJava(); private final DocCommentTokenizer myDocCommentTokenizer = new DocCommentTokenizer(); private final LiteralExpressionTokenizer myLiteralExpressionTokenizer = new LiteralExpressionTokenizer(); @@ -58,14 +55,4 @@ public class JavaSpellcheckingStrategy extends SuppressibleSpellcheckingStrategy return super.getTokenizer(element); } - - @Override - public boolean isSuppressedFor(@NotNull PsiElement element, @NotNull String name) { - return SuppressManager.getInstance().isSuppressedFor(element, name); - } - - @Override - public SuppressQuickFix[] getSuppressActions(@NotNull PsiElement element, @NotNull String name) { - return BatchSuppressManager.SERVICE.getInstance().createBatchSuppressActions(HighlightDisplayKey.find(name)); - } } diff --git a/java/java-impl/src/com/intellij/spellchecker/LiteralExpressionTokenizer.java b/java/java-impl/src/com/intellij/spellchecker/LiteralExpressionTokenizer.java index 77246ec92763..2eade6903cd2 100644 --- a/java/java-impl/src/com/intellij/spellchecker/LiteralExpressionTokenizer.java +++ b/java/java-impl/src/com/intellij/spellchecker/LiteralExpressionTokenizer.java @@ -17,8 +17,10 @@ package com.intellij.spellchecker; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.psi.JavaTokenType; +import com.intellij.psi.PsiLanguageInjectionHost; import com.intellij.psi.PsiLiteralExpression; import com.intellij.psi.PsiModifierListOwner; +import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil; import com.intellij.psi.impl.source.tree.java.PsiLiteralExpressionImpl; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.spellchecker.inspections.PlainTextSplitter; @@ -30,8 +32,6 @@ import org.jetbrains.annotations.NotNull; import java.util.Collections; /** - * Created by IntelliJ IDEA. - * * @author shkate@jetbrains.com */ public class LiteralExpressionTokenizer extends Tokenizer<PsiLiteralExpression> { @@ -42,6 +42,8 @@ public class LiteralExpressionTokenizer extends Tokenizer<PsiLiteralExpression> return; // not a string literal } + if (InjectedLanguageUtil.hasInjections((PsiLanguageInjectionHost)element)) return; + final PsiModifierListOwner listOwner = PsiTreeUtil.getParentOfType(element, PsiModifierListOwner.class); if (listOwner != null && AnnotationUtil.isAnnotated(listOwner, Collections.singleton(AnnotationUtil.NON_NLS), false, false)) { return; |