plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/SubstitutedExpressionEvaluationHelper.java

   1 /*
   2  * Copyright 2006 Sascha Weinreuter
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.intellij.plugins.intelliLang.util;
  17
  18 import com.intellij.codeInsight.AnnotationUtil;
  19 import com.intellij.codeInspection.dataFlow.DfaUtil;
  20 import com.intellij.openapi.project.Project;
  21 import com.intellij.psi.*;
  22 import com.intellij.util.containers.ConcurrentHashMap;
  23 import org.intellij.plugins.intelliLang.Configuration;
  24 import org.jetbrains.annotations.Nullable;
  25
  26 import java.util.Collection;
  27 import java.util.Collections;
  28 import java.util.List;
  29 import java.util.concurrent.ConcurrentMap;
  30
  31 /**
  32  * Computes the constant value of an expression while considering the substitution annotation for non-compile-time
  33  * constant expressions.
  34  * <p/>
  35  * This is a quite simplified implementation at the moment.
  36  */
  37 public class SubstitutedExpressionEvaluationHelper {
  38
  39   private final PsiConstantEvaluationHelper myHelper;
  40   private final Configuration myConfiguration;
  41
  42   public SubstitutedExpressionEvaluationHelper(final Project project) {
  43     myHelper = JavaPsiFacade.getInstance(project).getConstantEvaluationHelper();
  44     myConfiguration = Configuration.getInstance();
  45   }
  46
  47   public Object computeExpression(final PsiExpression e, final List<PsiExpression> uncomputables) {
  48     return computeExpression(e, myConfiguration.isUseDfaIfAvailable(), myConfiguration.isIncludeUncomputablesAsLiterals(), uncomputables);
  49   }
  50
  51   public Object computeExpression(final PsiExpression e, final boolean useDfa, final boolean includeUncomputablesAsLiterals, final List<PsiExpression> uncomputables) {
  52     final ConcurrentMap<PsiElement, Object> map = new ConcurrentHashMap<PsiElement, Object>();
  53     //if (true) return myHelper.computeConstantExpression(e, false);
  54     return myHelper.computeExpression(e, false, new PsiConstantEvaluationHelper.AuxEvaluator() {
  55       @Nullable
  56       public Object computeExpression(final PsiExpression o, final PsiConstantEvaluationHelper.AuxEvaluator auxEvaluator) {
  57         PsiType resolvedType = null;
  58         if (o instanceof PsiMethodCallExpression) {
  59           final PsiMethodCallExpression c = (PsiMethodCallExpression)o;
  60           final PsiMethod m = (PsiMethod)c.getMethodExpression().resolve();
  61           final PsiType returnType = m != null? m.getReturnType() : null;
  62           if (returnType != null && returnType != PsiType.VOID) {
  63             // find substitution
  64             final Object substituted = calcSubstituted(m);
  65             if (substituted != null) return substituted;
  66           }
  67           resolvedType = returnType;
  68         }
  69         else if (o instanceof PsiReferenceExpression) {
  70           final PsiElement resolved = ((PsiReferenceExpression)o).resolve();
  71           if (resolved instanceof PsiModifierListOwner) {
  72             // find substitution
  73             final Object substituted = calcSubstituted((PsiModifierListOwner)resolved);
  74             if (substituted != null) return substituted;
  75             if (resolved instanceof PsiVariable) {
  76               resolvedType = ((PsiVariable)resolved).getType();
  77               final Collection<PsiExpression> values =
  78                 !useDfa? Collections.<PsiExpression>emptyList() : DfaUtil.getCachedVariableValues((PsiVariable)resolved, o);
  79               // return the first computed value as far as we do not support multiple injection
  80               if (values != null) {
  81                 for (PsiExpression value : values) {
  82                   final Object computedValue = auxEvaluator.computeExpression(value, this);
  83                   if (computedValue != null) {
  84                     return computedValue;
  85                   }
  86                 }
  87               }
  88             }
  89           }
  90         }
  91         if (uncomputables != null) uncomputables.add(o);
  92         if (includeUncomputablesAsLiterals) {
  93           if (resolvedType != null) {
  94             if (PsiPrimitiveType.DOUBLE.isAssignableFrom(resolvedType)) return 1; // magic number!
  95           }
  96           final StringBuilder sb = new StringBuilder();
  97           o.accept(new PsiRecursiveElementWalkingVisitor() {
  98             @Override
  99             public void visitElement(PsiElement element) {
 100               if (element instanceof PsiExpressionList) return;
 101               if (element instanceof PsiIdentifier) {
 102                 if (sb.length() > 0) sb.append(".");
 103                 sb.append(element.getText());
 104               }
 105               super.visitElement(element);
 106             }
 107           });
 108           return sb.toString();
 109         }
 110         return null;
 111       }
 112
 113       public ConcurrentMap<PsiElement, Object> getCacheMap(final boolean overflow) {
 114         return map;
 115         //return PsiManager.getInstance(project).getCachedValuesManager().getCachedValue(project, COMPUTED_MAP_KEY, PROVIDER, false);
 116       }
 117     });
 118   }
 119
 120   @Nullable
 121   private Object calcSubstituted(final PsiModifierListOwner owner) {
 122     final PsiAnnotation annotation = AnnotationUtil.findAnnotation(owner, myConfiguration.getSubstAnnotationPair().second);
 123     if (annotation != null) {
 124       return AnnotationUtilEx.calcAnnotationValue(annotation, "value");
 125     }
 126     return null;
 127   }
 128
 129 }