1 files changed, 33 insertions, 99 deletions

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/PsiImplUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/PsiImplUtil.java
index 514087492300..938b40f51bb8 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/PsiImplUtil.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/PsiImplUtil.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.psi.impl;
 
+import com.intellij.codeInsight.AnnotationTargetUtil;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
@@ -51,7 +52,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
@@ -60,22 +60,6 @@ import static com.intellij.psi.PsiAnnotation.TargetType;
 public class PsiImplUtil {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.PsiImplUtil");
 
-  private static final Set<TargetType> DEFAULT_TARGETS = Collections.unmodifiableSet(ContainerUtil.newHashSet(
-    TargetType.PACKAGE, TargetType.TYPE, TargetType.ANNOTATION_TYPE,
-    TargetType.FIELD, TargetType.METHOD, TargetType.CONSTRUCTOR,
-    TargetType.PARAMETER, TargetType.LOCAL_VARIABLE));
-
-  private static final TargetType[] PACKAGE_TARGETS = {TargetType.PACKAGE};
-  private static final TargetType[] TYPE_USE_TARGETS = {TargetType.TYPE_USE};
-  private static final TargetType[] ANNOTATION_TARGETS = {TargetType.ANNOTATION_TYPE, TargetType.TYPE, TargetType.TYPE_USE};
-  private static final TargetType[] TYPE_TARGETS = {TargetType.TYPE, TargetType.TYPE_USE};
-  private static final TargetType[] TYPE_PARAMETER_TARGETS = {TargetType.TYPE_PARAMETER, TargetType.TYPE_USE};
-  private static final TargetType[] CONSTRUCTOR_TARGETS = {TargetType.CONSTRUCTOR, TargetType.TYPE_USE};
-  private static final TargetType[] METHOD_TARGETS = {TargetType.METHOD, TargetType.TYPE_USE};
-  private static final TargetType[] FIELD_TARGETS = {TargetType.FIELD, TargetType.TYPE_USE};
-  private static final TargetType[] PARAMETER_TARGETS = {TargetType.PARAMETER, TargetType.TYPE_USE};
-  private static final TargetType[] LOCAL_VARIABLE_TARGETS ={TargetType.LOCAL_VARIABLE, TargetType.TYPE_USE};
-
   private PsiImplUtil() { }
 
   @NotNull
@@ -376,93 +360,14 @@ public class PsiImplUtil {
     PsiModifierList modifierList = annotationType.getModifierList();
     if (modifierList == null) return null;
     PsiAnnotation target = modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_TARGET);
-    if (target == null) return DEFAULT_TARGETS;  // if omitted it is applicable to all but Java 8 TYPE_USE/TYPE_PARAMETERS targets
-
-    PsiAnnotationMemberValue value = target.findAttributeValue(null);
-    if (value instanceof PsiReference) {
-      TargetType targetType = translateTargetRef((PsiReference)value);
-      if (targetType != null) {
-        return Collections.singleton(targetType);
-      }
-    }
-    else if (value instanceof PsiArrayInitializerMemberValue) {
-      Set <TargetType> targets = ContainerUtil.newHashSet();
-      for (PsiAnnotationMemberValue initializer : ((PsiArrayInitializerMemberValue)value).getInitializers()) {
-        if (initializer instanceof PsiReference) {
-          TargetType targetType = translateTargetRef((PsiReference)initializer);
-          if (targetType != null) {
-            targets.add(targetType);
-          }
-        }
-      }
-      return targets;
-    }
+    if (target == null) return AnnotationTargetUtil.DEFAULT_TARGETS;  // if omitted it is applicable to all but Java 8 TYPE_USE/TYPE_PARAMETERS targets
 
-    return null;
-  }
-
-  @Nullable
-  private static TargetType translateTargetRef(PsiReference reference) {
-    PsiElement field = reference.resolve();
-    if (field instanceof PsiEnumConstant) {
-      String name = ((PsiEnumConstant)field).getName();
-      try {
-        return TargetType.valueOf(name);
-      }
-      catch (IllegalArgumentException e) {
-        LOG.warn("Unknown target: " + name);
-      }
-    }
-    return null;
+    return AnnotationTargetUtil.extractRequiredAnnotationTargets(target.findAttributeValue(null));
   }
 
   @NotNull
   public static TargetType[] getTargetsForLocation(@Nullable PsiAnnotationOwner owner) {
-    if (owner == null) {
-      return TargetType.EMPTY_ARRAY;
-    }
-
-    if (owner instanceof PsiType || owner instanceof PsiTypeElement) {
-      return TYPE_USE_TARGETS;
-    }
-
-    if (owner instanceof PsiTypeParameter) {
-      return TYPE_PARAMETER_TARGETS;
-    }
-
-    if (owner instanceof PsiModifierList) {
-      PsiElement element = ((PsiModifierList)owner).getParent();
-      if (element instanceof PsiPackageStatement) {
-        return PACKAGE_TARGETS;
-      }
-      if (element instanceof PsiClass) {
-        if (((PsiClass)element).isAnnotationType()) {
-          return ANNOTATION_TARGETS;
-        }
-        else {
-          return TYPE_TARGETS;
-        }
-      }
-      if (element instanceof PsiMethod) {
-        if (((PsiMethod)element).isConstructor()) {
-          return CONSTRUCTOR_TARGETS;
-        }
-        else {
-          return METHOD_TARGETS;
-        }
-      }
-      if (element instanceof PsiField) {
-        return FIELD_TARGETS;
-      }
-      if (element instanceof PsiParameter) {
-        return PARAMETER_TARGETS;
-      }
-      if (element instanceof PsiLocalVariable) {
-        return LOCAL_VARIABLE_TARGETS;
-      }
-    }
-
-    return TargetType.EMPTY_ARRAY;
+    return AnnotationTargetUtil.getTargetsForLocation(owner);
   }
 
   @Nullable
@@ -782,4 +687,33 @@ public class PsiImplUtil {
     return element instanceof LeafElement && tokenSet.contains(((LeafElement)element).getElementType());
   }
 
+  public static PsiType buildTypeFromTypeString(@NotNull final String typeName, @NotNull final PsiElement context, @NotNull final PsiFile psiFile) {
+    PsiType resultType;
+    final PsiManager psiManager = psiFile.getManager();
+
+    if (typeName.indexOf('<') != -1 || typeName.indexOf('[') != -1 || typeName.indexOf('.') == -1) {
+      try {
+        return JavaPsiFacade.getInstance(psiManager.getProject()).getElementFactory().createTypeFromText(typeName, context);
+      } catch(Exception ex) {} // invalid syntax will produce unresolved class type
+    }
+
+    PsiClass aClass = JavaPsiFacade.getInstance(psiManager.getProject()).findClass(typeName, context.getResolveScope());
+
+    if (aClass == null) {
+      final LightClassReference ref = new LightClassReference(
+        psiManager,
+        PsiNameHelper.getShortClassName(typeName),
+        typeName,
+        PsiSubstitutor.EMPTY,
+        psiFile
+      );
+      resultType = new PsiClassReferenceType(ref, null);
+    } else {
+      PsiElementFactory factory = JavaPsiFacade.getInstance(psiManager.getProject()).getElementFactory();
+      PsiSubstitutor substitutor = factory.createRawSubstitutor(aClass);
+      resultType = factory.createType(aClass, substitutor);
+    }
+
+    return resultType;
+  }
 }