codeInsight/impl/com/intellij/codeInsight/template/macro/MacroUtil.java

   1 package com.intellij.codeInsight.template.macro;
   2
   3 import com.intellij.codeInsight.completion.proc.VariablesProcessor;
   4 import com.intellij.codeInsight.template.ExpressionContext;
   5 import com.intellij.codeInsight.template.PsiElementResult;
   6 import com.intellij.codeInsight.template.PsiTypeResult;
   7 import com.intellij.codeInsight.template.Result;
   8 import com.intellij.openapi.diagnostic.Logger;
   9 import com.intellij.openapi.project.Project;
  10 import com.intellij.psi.*;
  11 import com.intellij.psi.scope.util.PsiScopesUtil;
  12 import com.intellij.psi.util.PsiTreeUtil;
  13 import com.intellij.psi.util.PsiUtil;
  14 import com.intellij.util.IncorrectOperationException;
  15 import org.jetbrains.annotations.NotNull;
  16 import org.jetbrains.annotations.Nullable;
  17
  18 import java.util.ArrayList;
  19 import java.util.List;
  20
  21 public class MacroUtil {
  22   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.template.macro.MacroUtil");
  23
  24   @Nullable public static PsiType resultToPsiType(Result result, ExpressionContext context){
  25     if (result instanceof PsiTypeResult) {
  26       return ((PsiTypeResult) result).getType();
  27     }
  28     Project project = context.getProject();
  29     String text = result.toString();
  30     if (text == null) return null;
  31     PsiManager manager = PsiManager.getInstance(project);
  32     PsiDocumentManager.getInstance(project).commitAllDocuments();
  33     PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument());
  34     //-1: Hack to deal with stupid resolve
  35     PsiElement place = file != null ? file.findElementAt(context.getStartOffset()) : null;
  36     PsiDeclarationStatement decl = file != null ? PsiTreeUtil.getParentOfType(place, PsiDeclarationStatement.class) : null;
  37     if (decl != null) {
  38       place = file.findElementAt(decl.getTextOffset() -1);
  39     }
  40     PsiElementFactory factory = manager.getElementFactory();
  41     try{
  42       return factory.createTypeFromText(text, place);
  43     }
  44     catch(IncorrectOperationException e){
  45       return null;
  46     }
  47   }
  48
  49   @Nullable public static PsiExpression resultToPsiExpression(Result result, ExpressionContext context){
  50     if (result instanceof PsiElementResult){
  51       PsiElement element = ((PsiElementResult)result).getElement();
  52       if (element instanceof PsiExpression){
  53         return (PsiExpression)element;
  54       }
  55     }
  56     Project project = context.getProject();
  57     String text = result.toString();
  58     if (text == null) return null;
  59     PsiManager manager = PsiManager.getInstance(project);
  60     PsiDocumentManager.getInstance(project).commitAllDocuments();
  61     PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument());
  62     //-1: Hack to deal with resolve algorithm
  63     PsiElement place = file != null ? file.findElementAt(context.getStartOffset()) : null;
  64     if (place != null) {
  65       PsiElement parent = place.getParent();
  66       if (parent != null) {
  67         PsiElement parentOfParent = parent.getParent();
  68         if (parentOfParent instanceof PsiDeclarationStatement) {
  69           place = file.findElementAt(parentOfParent.getTextOffset() -1);
  70         }
  71       }
  72     }
  73     PsiElementFactory factory = manager.getElementFactory();
  74     try{
  75       return factory.createExpressionFromText(text, place);
  76     }
  77     catch(IncorrectOperationException e){
  78       return null;
  79     }
  80   }
  81
  82   @NotNull private static PsiExpression[] getStandardExpressions(PsiElement place) {
  83     ArrayList<PsiExpression> array = new ArrayList<PsiExpression>();
  84     PsiElementFactory factory = place.getManager().getElementFactory();
  85     try {
  86       array.add(factory.createExpressionFromText("true", null));
  87       array.add(factory.createExpressionFromText("false", null));
  88
  89       PsiElement scope = place;
  90       boolean firstClass = true;
  91       boolean static_flag = false;
  92       while (scope != null) {
  93         if (scope instanceof PsiModifierListOwner && ((PsiModifierListOwner)scope).getModifierList() != null){
  94           if(((PsiModifierListOwner)scope).hasModifierProperty(PsiModifier.STATIC)){
  95             static_flag = true;
  96           }
  97         }
  98         if (scope instanceof PsiClass) {
  99           PsiClass aClass = (PsiClass)scope;
 100
 101           String name = aClass.getName();
 102           PsiExpression expr = null;
 103           if(!static_flag){
 104             if (firstClass) {
 105               expr = factory.createExpressionFromText("this", place);
 106             }
 107             else {
 108               if (name != null) {
 109                 expr = factory.createExpressionFromText(name + ".this", place);
 110               }
 111             }
 112             if (expr != null) {
 113               array.add(expr);
 114             }
 115           }
 116           firstClass = false;
 117           if (aClass.hasModifierProperty(PsiModifier.STATIC)) break;
 118         }
 119         else if (scope instanceof PsiMember) {
 120           if (((PsiMember)scope).hasModifierProperty(PsiModifier.STATIC)) break;
 121         }
 122         scope = scope.getParent();
 123       }
 124     }
 125     catch (IncorrectOperationException e) {
 126       LOG.error(e);
 127     }
 128     return array.toArray(new PsiExpression[array.size()]);
 129   }
 130
 131   @NotNull public static PsiExpression[] getStandardExpressionsOfType(PsiElement place, PsiType type) {
 132     List<PsiExpression> array = new ArrayList<PsiExpression>();
 133     PsiExpression[] expressions = getStandardExpressions(place);
 134     for (PsiExpression expr : expressions) {
 135       PsiType type1 = expr.getType();
 136       if (type == null || type1 != null && type.isAssignableFrom(type1)) {
 137         array.add(expr);
 138       }
 139     }
 140     return array.toArray(new PsiExpression[array.size()]);
 141   }
 142
 143   @NotNull public static PsiVariable[] getVariablesVisibleAt(final PsiElement place, String prefix) {
 144     final List<PsiVariable> list = new ArrayList<PsiVariable>();
 145     VariablesProcessor varproc = new VariablesProcessor(prefix, true, list){
 146       public boolean execute(PsiElement pe, PsiSubstitutor substitutor) {
 147         if (pe instanceof PsiVariable) {
 148           //exclude variables that are initialized in 'place'
 149           final PsiExpression initializer = ((PsiVariable)pe).getInitializer();
 150           if (initializer != null && PsiTreeUtil.isAncestor(initializer, place, false)) return true;
 151         }
 152         if(!(pe instanceof PsiField) || PsiUtil.isAccessible((PsiField)pe, place, null)) {
 153           return super.execute(pe, substitutor);
 154         }
 155         return true;
 156       }
 157     };
 158     PsiScopesUtil.treeWalkUp(varproc, place, null);
 159     return varproc.getResultsAsArray();
 160   }
 161 }