diff options
Diffstat (limited to 'java/java-psi-api')
7 files changed, 84 insertions, 56 deletions
diff --git a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java index 25034e9ab7ba..78f29c4c8488 100644 --- a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java +++ b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.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. @@ -95,7 +95,7 @@ public class AnnotationUtil { } @Nullable - public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, Collection<String> annotationNames) { + public static PsiAnnotation findAnnotation(@Nullable PsiModifierListOwner listOwner, @NotNull Collection<String> annotationNames) { return findAnnotation(listOwner, annotationNames, false); } @@ -133,7 +133,7 @@ public class AnnotationUtil { } @NotNull - public static PsiAnnotation[] findAnnotations(final PsiModifierListOwner modifierListOwner, @NotNull Collection<String> annotationNames) { + public static PsiAnnotation[] findAnnotations(@Nullable PsiModifierListOwner modifierListOwner, @NotNull Collection<String> annotationNames) { if (modifierListOwner == null) return PsiAnnotation.EMPTY_ARRAY; final PsiModifierList modifierList = modifierListOwner.getModifierList(); if (modifierList == null) return PsiAnnotation.EMPTY_ARRAY; @@ -171,8 +171,8 @@ public class AnnotationUtil { } @Nullable - private static PsiAnnotation doFindAnnotationInHierarchy(PsiParameter parameter, - Set<String> annotationNames, + private static PsiAnnotation doFindAnnotationInHierarchy(@NotNull PsiParameter parameter, + @NotNull Set<String> annotationNames, @Nullable Set<PsiModifierListOwner> visited) { PsiAnnotation annotation = findAnnotation(parameter, annotationNames); if (annotation != null) return annotation; @@ -206,7 +206,7 @@ public class AnnotationUtil { } @Nullable - private static PsiAnnotation findAnnotationInHierarchy(@NotNull final PsiClass psiClass, final Set<String> annotationNames, @Nullable Set<PsiClass> processed) { + private static PsiAnnotation findAnnotationInHierarchy(@NotNull final PsiClass psiClass, @NotNull Set<String> annotationNames, @Nullable Set<PsiClass> processed) { final PsiClass[] superClasses = psiClass.getSupers(); for (final PsiClass superClass : superClasses) { if (processed == null) processed = new THashSet<PsiClass>(); @@ -240,18 +240,18 @@ public class AnnotationUtil { return null; } - public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, Collection<String> annotations) { + public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, @NotNull Collection<String> annotations) { return isAnnotated(listOwner, annotations, false); } public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, - Collection<String> annotations, + @NotNull Collection<String> annotations, final boolean checkHierarchy) { return isAnnotated(listOwner, annotations, checkHierarchy, true); } public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, - Collection<String> annotations, + @NotNull Collection<String> annotations, final boolean checkHierarchy, boolean skipExternal) { for (String annotation : annotations) { @@ -260,17 +260,17 @@ public class AnnotationUtil { return false; } - public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, @NonNls String annotationFQN, boolean checkHierarchy) { + public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, @NonNls @NotNull String annotationFQN, boolean checkHierarchy) { return isAnnotated(listOwner, annotationFQN, checkHierarchy, true, null); } - public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, @NonNls String annotationFQN, boolean checkHierarchy, + public static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, @NonNls @NotNull String annotationFQN, boolean checkHierarchy, boolean skipExternal) { return isAnnotated(listOwner, annotationFQN, checkHierarchy, skipExternal, null); } private static boolean isAnnotated(@NotNull PsiModifierListOwner listOwner, - @NonNls String annotationFQN, + @NonNls @NotNull String annotationFQN, boolean checkHierarchy, final boolean skipExternal, @Nullable Set<PsiMember> processed) { if (!listOwner.isValid()) return false; final PsiModifierList modifierList = listOwner.getModifierList(); @@ -310,13 +310,13 @@ public class AnnotationUtil { return isAnnotatingApplicable(elt, NullableNotNullManager.getInstance(elt.getProject()).getDefaultNullable()); } - public static boolean isAnnotatingApplicable(@NotNull PsiElement elt, final String annotationFQN) { + public static boolean isAnnotatingApplicable(@NotNull PsiElement elt, @NotNull String annotationFQN) { final Project project = elt.getProject(); return PsiUtil.isLanguageLevel5OrHigher(elt) && JavaPsiFacade.getInstance(project).findClass(annotationFQN, elt.getResolveScope()) != null; } - public static boolean isJetbrainsAnnotation(@NonNls final String simpleName) { + public static boolean isJetbrainsAnnotation(@NonNls @NotNull String simpleName) { return ArrayUtil.find(SIMPLE_NAMES, simpleName) != -1; } @@ -328,7 +328,7 @@ public class AnnotationUtil { * @param annotations annotations qualified names or patterns. Patterns can have '*' at the end * @return <code>true</code> if annotated of at least one annotation from the annotations list */ - public static boolean checkAnnotatedUsingPatterns(PsiModifierListOwner owner, Collection<String> annotations) { + public static boolean checkAnnotatedUsingPatterns(@Nullable PsiModifierListOwner owner, @NotNull Collection<String> annotations) { final PsiModifierList modList; if (owner == null || (modList = owner.getModifierList()) == null) return false; @@ -361,7 +361,7 @@ public class AnnotationUtil { } @Nullable - public static PsiMethod getAnnotationMethod(PsiNameValuePair pair) { + public static PsiMethod getAnnotationMethod(@NotNull PsiNameValuePair pair) { final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(pair.getParent(), PsiAnnotation.class); assert annotation != null; diff --git a/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.java b/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.java index 2210e02a080a..0f19a245ff18 100644 --- a/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.java +++ b/java/java-psi-api/src/com/intellij/codeInsight/NullableNotNullManager.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. @@ -70,7 +70,7 @@ public class NullableNotNullManager implements PersistentStateComponent<Element> return isNullable(owner, false) || isNotNull(owner, false); } - private static void addAllIfNotPresent(Collection<String> collection, String... annotations) { + private static void addAllIfNotPresent(@NotNull Collection<String> collection, @NotNull String... annotations) { for (String annotation : annotations) { LOG.assertTrue(annotation != null); if (!collection.contains(annotation)) { @@ -79,30 +79,31 @@ public class NullableNotNullManager implements PersistentStateComponent<Element> } } - public void setNotNulls(String... annotations) { + public void setNotNulls(@NotNull String... annotations) { myNotNulls.clear(); addAllIfNotPresent(myNotNulls, DEFAULT_NOT_NULLS); addAllIfNotPresent(myNotNulls, annotations); } - public void setNullables(String... annotations) { + public void setNullables(@NotNull String... annotations) { myNullables.clear(); addAllIfNotPresent(myNullables, DEFAULT_NULLABLES); addAllIfNotPresent(myNullables, annotations); } + @NotNull public String getDefaultNullable() { return myDefaultNullable; } @Nullable - public String getNullable(PsiModifierListOwner owner) { + public String getNullable(@NotNull PsiModifierListOwner owner) { PsiAnnotation annotation = getNullableAnnotation(owner, false); return annotation == null ? null : annotation.getQualifiedName(); } @Nullable - public PsiAnnotation getNullableAnnotation(PsiModifierListOwner owner, boolean checkBases) { + public PsiAnnotation getNullableAnnotation(@NotNull PsiModifierListOwner owner, boolean checkBases) { return findNullabilityAnnotation(owner, checkBases, true); } @@ -116,17 +117,18 @@ public class NullableNotNullManager implements PersistentStateComponent<Element> myDefaultNullable = defaultNullable; } + @NotNull public String getDefaultNotNull() { return myDefaultNotNull; } @Nullable - public PsiAnnotation getNotNullAnnotation(PsiModifierListOwner owner, boolean checkBases) { + public PsiAnnotation getNotNullAnnotation(@NotNull PsiModifierListOwner owner, boolean checkBases) { return findNullabilityAnnotation(owner, checkBases, false); } @Nullable - public String getNotNull(PsiModifierListOwner owner) { + public String getNotNull(@NotNull PsiModifierListOwner owner) { PsiAnnotation annotation = getNotNullAnnotation(owner, false); return annotation == null ? null : annotation.getQualifiedName(); } @@ -226,10 +228,12 @@ public class NullableNotNullManager implements PersistentStateComponent<Element> return required.isEmpty() || ContainerUtil.intersects(required, Arrays.asList(placeTargetTypes)); } + @NotNull public List<String> getNullables() { return myNullables; } + @NotNull public List<String> getNotNulls() { return myNotNulls; } diff --git a/java/java-psi-api/src/com/intellij/psi/JavaRecursiveElementWalkingVisitor.java b/java/java-psi-api/src/com/intellij/psi/JavaRecursiveElementWalkingVisitor.java index a707a296b0cb..d5ed67d3525c 100644 --- a/java/java-psi-api/src/com/intellij/psi/JavaRecursiveElementWalkingVisitor.java +++ b/java/java-psi-api/src/com/intellij/psi/JavaRecursiveElementWalkingVisitor.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. @@ -34,8 +34,7 @@ public abstract class JavaRecursiveElementWalkingVisitor extends JavaElementVisi myWalkingState.elementStarted(element); } - @SuppressWarnings({"UnusedDeclaration"}) - protected void elementFinished(PsiElement element) { + protected void elementFinished(@NotNull PsiElement element) { } @Override diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java index 87afd3d4f8e4..0b0e09684128 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java @@ -75,20 +75,22 @@ public class PsiMethodReferenceUtil { return null; } - public static boolean isCorrectAssignment(PsiType[] signatureParameterTypes2, - PsiType[] parameterTypes, + public static boolean isCorrectAssignment(PsiType[] parameterTypes, + PsiType[] argTypes, boolean varargs, int offset) { - final int min = Math.min(signatureParameterTypes2.length, parameterTypes.length - offset); + final int min = Math.min(parameterTypes.length, argTypes.length - offset); for (int i = 0; i < min; i++) { - final PsiType type1 = parameterTypes[i + offset]; - final PsiType type2 = signatureParameterTypes2[i]; - if (varargs && i == signatureParameterTypes2.length - 1) { - if (!TypeConversionUtil.isAssignable(type2, type1) && !TypeConversionUtil.isAssignable(((PsiArrayType)type2).getComponentType(), type1)) { + final PsiType argType = argTypes[i + offset]; + PsiType parameterType = parameterTypes[i]; + parameterType = GenericsUtil.getVariableTypeByExpressionType(parameterType, true); + if (varargs && i == parameterTypes.length - 1) { + if (!TypeConversionUtil.isAssignable(parameterType, argType) && + !TypeConversionUtil.isAssignable(((PsiArrayType)parameterType).getComponentType(), argType)) { return false; } } - else if (!TypeConversionUtil.isAssignable(type2, type1)) { + else if (!TypeConversionUtil.isAssignable(parameterType, argType)) { return false; } } @@ -324,7 +326,8 @@ public class PsiMethodReferenceUtil { LOG.assertTrue(signature != null); final PsiType[] parameterTypes = signature.getParameterTypes(); final QualifierResolveResult qualifierResolveResult = getQualifierResolveResult(methodRef); - return (method.getParameterList().getParametersCount() + 1 == parameterTypes.length || method.isVarArgs() && parameterTypes.length > 0)&& + return (method.getParameterList().getParametersCount() + 1 == parameterTypes.length || + method.isVarArgs() && parameterTypes.length > 0 && !method.hasModifierProperty(PsiModifier.STATIC)) && hasReceiver(parameterTypes, qualifierResolveResult, methodRef); } diff --git a/java/java-psi-api/src/com/intellij/psi/PsiType.java b/java/java-psi-api/src/com/intellij/psi/PsiType.java index 1dd67fb31a7f..6834e39b2ff6 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiType.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiType.java @@ -15,6 +15,7 @@ */ package com.intellij.psi; +import com.intellij.openapi.project.Project; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.util.ArrayFactory; @@ -134,6 +135,19 @@ public abstract class PsiType implements PsiAnnotationOwner { public abstract boolean equalsToText(@NotNull @NonNls String text); /** + * Returns the class type for qualified class name. + * + * @param qName qualified class name. + * @param project + * @param resolveScope the scope in which the class is searched. + * @return the class instance. + */ + public static PsiClassType getTypeByName(String qName, Project project, GlobalSearchScope resolveScope) { + PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); + return factory.createTypeByFQClassName(qName, resolveScope); + } + + /** * Returns the class type for the java.lang.Object class. * * @param manager the PSI manager used to create the class type. @@ -142,8 +156,7 @@ public abstract class PsiType implements PsiAnnotationOwner { */ @NotNull public static PsiClassType getJavaLangObject(@NotNull PsiManager manager, @NotNull GlobalSearchScope resolveScope) { - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_OBJECT, manager.getProject(), resolveScope); } /** @@ -155,8 +168,7 @@ public abstract class PsiType implements PsiAnnotationOwner { */ @NotNull public static PsiClassType getJavaLangClass(@NotNull PsiManager manager, @NotNull GlobalSearchScope resolveScope) { - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_CLASS, resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_CLASS, manager.getProject(), resolveScope); } /** @@ -168,8 +180,7 @@ public abstract class PsiType implements PsiAnnotationOwner { */ @NotNull public static PsiClassType getJavaLangThrowable(@NotNull PsiManager manager, @NotNull GlobalSearchScope resolveScope) { - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_THROWABLE, resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_THROWABLE, manager.getProject(), resolveScope); } /** @@ -181,8 +192,7 @@ public abstract class PsiType implements PsiAnnotationOwner { */ @NotNull public static PsiClassType getJavaLangString(@NotNull PsiManager manager, @NotNull GlobalSearchScope resolveScope) { - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_STRING, resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_STRING, manager.getProject(), resolveScope); } /** @@ -194,8 +204,7 @@ public abstract class PsiType implements PsiAnnotationOwner { */ @NotNull public static PsiClassType getJavaLangError(@NotNull PsiManager manager, @NotNull GlobalSearchScope resolveScope) { - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_ERROR, resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_ERROR, manager.getProject(), resolveScope); } /** @@ -207,8 +216,7 @@ public abstract class PsiType implements PsiAnnotationOwner { */ @NotNull public static PsiClassType getJavaLangRuntimeException(@NotNull PsiManager manager, @NotNull GlobalSearchScope resolveScope) { - PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); - return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, resolveScope); + return getTypeByName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, manager.getProject(), resolveScope); } /** diff --git a/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java b/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java index f43358007eab..f05df7dab9c1 100644 --- a/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java +++ b/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java @@ -130,7 +130,6 @@ public class MethodCandidateInfo extends CandidateInfo{ final CurrentCandidateProperties properties = new CurrentCandidateProperties(method, substitutor, isVarargs(), true); final CurrentCandidateProperties alreadyThere = map.put(getMarkerList(), properties); try { - properties.setSubstitutor(substitutor); PsiType[] argumentTypes = getArgumentTypes(); if (argumentTypes == null) { return ApplicabilityLevel.NOT_APPLICABLE; @@ -143,7 +142,11 @@ public class MethodCandidateInfo extends CandidateInfo{ return applicabilityLevel; } finally { - if (alreadyThere == null) map.remove(getMarkerList()); + if (alreadyThere == null) { + map.remove(getMarkerList()); + } else { + map.put(getMarkerList(), alreadyThere); + } } } return getApplicabilityLevelInner(); @@ -269,10 +272,8 @@ public class MethodCandidateInfo extends CandidateInfo{ CURRENT_CANDIDATE.set(map); } final PsiMethod method = getElement(); - final CurrentCandidateProperties alreadyThere = map.get(getMarkerList()); - if (alreadyThere == null) { + final CurrentCandidateProperties alreadyThere = map.put(getMarkerList(), new CurrentCandidateProperties(method, super.getSubstitutor(), isVarargs(), !includeReturnConstraint)); - } try { PsiTypeParameter[] typeParameters = method.getTypeParameters(); @@ -293,7 +294,11 @@ public class MethodCandidateInfo extends CandidateInfo{ .inferTypeArguments(typeParameters, method.getParameterList().getParameters(), arguments, mySubstitutor, parent, policy, myLanguageLevel); } finally { - if (alreadyThere == null) map.remove(getMarkerList()); + if (alreadyThere == null) { + map.remove(getMarkerList()); + } else { + map.put(getMarkerList(), alreadyThere); + } } } diff --git a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java index d4382b40db7a..ccb606d51376 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java @@ -541,8 +541,17 @@ public class RedundantCastUtil { } } } - if (parent instanceof PsiInstanceOfExpression || (TypeConversionUtil.isAssignable(castTo, opType, false) && - (expectedTypeByParent == null || TypeConversionUtil.isAssignable(expectedTypeByParent, opType, false)))) { + if (parent instanceof PsiInstanceOfExpression) { + //15.20.2. Type Comparison Operator instanceof: + //If a cast (ยง15.16) of the RelationalExpression to the ReferenceType would be rejected as a compile-time error, + //then the instanceof relational expression likewise produces a compile-time error. + final PsiTypeElement checkTypeElement = ((PsiInstanceOfExpression)parent).getCheckType(); + if (checkTypeElement != null && TypeConversionUtil.areTypesConvertible(opType, checkTypeElement.getType())) { + addToResults(typeCast); + } + } + else if (TypeConversionUtil.isAssignable(castTo, opType, false) && + (expectedTypeByParent == null || TypeConversionUtil.isAssignable(expectedTypeByParent, opType, false))) { addToResults(typeCast); } } |