diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.form b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.form index 829270932ddf..5113474c3cf5 100644 --- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.form +++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.form @@ -1,6 +1,6 @@
- + @@ -109,9 +109,44 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.java index 4f817124c435..56cf6cbfd5f0 100644 --- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.java +++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/AdvancedSettingsUI.java @@ -53,6 +53,9 @@ public class AdvancedSettingsUI implements Configurable { private JPanel myLanguageAnnotationPanel; private JPanel myPatternAnnotationPanel; private JPanel mySubstAnnotationPanel; + private JCheckBox myAnalyzeReferencesCheckBox; + private JCheckBox myUseDataflowAnalysisIfCheckBox; + private JCheckBox myIncludeUncomputableOperandsAsCheckBox; private final ReferenceEditorWithBrowseButton myAnnotationField; private final ReferenceEditorWithBrowseButton myPatternField; @@ -126,6 +129,15 @@ public class AdvancedSettingsUI implements Configurable { if (!mySubstField.getText().equals(myConfiguration.getSubstAnnotationClass())) { return true; } + if (myConfiguration.isResolveReferences() != myAnalyzeReferencesCheckBox.isSelected()) { + return true; + } + if (myConfiguration.isUseDfaIfAvailable() != myUseDataflowAnalysisIfCheckBox.isSelected()) { + return true; + } + if (myConfiguration.isIncludeUncomputablesAsLiterals() != myIncludeUncomputableOperandsAsCheckBox.isSelected()) { + return true; + } return false; } @@ -144,6 +156,10 @@ public class AdvancedSettingsUI implements Configurable { myConfiguration.setLanguageAnnotation(myAnnotationField.getText()); myConfiguration.setPatternAnnotation(myPatternField.getText()); myConfiguration.setSubstAnnotation(mySubstField.getText()); + + myConfiguration.setResolveReferences(myAnalyzeReferencesCheckBox.isSelected()); + myConfiguration.setUseDfaIfAvailable(myUseDataflowAnalysisIfCheckBox.isSelected()); + myConfiguration.setIncludeUncomputablesAsLiterals(myIncludeUncomputableOperandsAsCheckBox.isSelected()); } public void reset() { @@ -154,6 +170,10 @@ public class AdvancedSettingsUI implements Configurable { myNoInstrumentation.setSelected(myConfiguration.getInstrumentation() == Configuration.InstrumentationType.NONE); myAssertInstrumentation.setSelected(myConfiguration.getInstrumentation() == Configuration.InstrumentationType.ASSERT); myExceptionInstrumentation.setSelected(myConfiguration.getInstrumentation() == Configuration.InstrumentationType.EXCEPTION); + + myAnalyzeReferencesCheckBox.setSelected(myConfiguration.isResolveReferences()); + myUseDataflowAnalysisIfCheckBox.setSelected(myConfiguration.isUseDfaIfAvailable()); + myIncludeUncomputableOperandsAsCheckBox.setSelected(myConfiguration.isIncludeUncomputablesAsLiterals()); } public void disposeUIResources() { diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/Configuration.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/Configuration.java index 64241b9039bf..31b2fa186f88 100644 --- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/Configuration.java +++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/Configuration.java @@ -77,6 +77,8 @@ public final class Configuration implements PersistentStateComponent { @NonNls private static final String SUBST_ANNOTATION_NAME = "SUBST_ANNOTATION"; @NonNls private static final String ENTRY_NAME = "entry"; @NonNls private static final String RESOLVE_REFERENCES = "RESOLVE_REFERENCES"; + @NonNls private static final String USE_DFA_IF_AVAILABLE = "USE_DFA_IF_AVAILABLE"; + @NonNls private static final String INCLUDE_UNCOMPUTABLES_AS_LITERALS = "INCLUDE_UNCOMPUTABLES_AS_LITERALS"; private final Map> myInjections = new ConcurrentFactoryMap>() { @Override @@ -94,6 +96,8 @@ public final class Configuration implements PersistentStateComponent { @NotNull private String mySubstAnnotation; private boolean myResolveReferences; + private boolean myIncludeUncomputablesAsLiterals; + private boolean myUseDfaIfAvailable; // cached annotation name pairs private Pair> myLanguageAnnotationPair; @@ -144,9 +148,10 @@ public final class Configuration implements PersistentStateComponent { setLanguageAnnotation(JDOMExternalizerUtil.readField(element, LANGUAGE_ANNOTATION_NAME)); setPatternAnnotation(JDOMExternalizerUtil.readField(element, PATTERN_ANNOTATION_NAME)); setSubstAnnotation(JDOMExternalizerUtil.readField(element, SUBST_ANNOTATION_NAME)); - final String resolveReferences = JDOMExternalizerUtil.readField(element, RESOLVE_REFERENCES); - setResolveReferences(resolveReferences == null || Boolean.parseBoolean(resolveReferences)); - + setResolveReferences(readBoolean(element, RESOLVE_REFERENCES, true)); + setUseDfaIfAvailable(readBoolean(element, USE_DFA_IF_AVAILABLE, true)); + setIncludeUncomputablesAsLiterals(readBoolean(element, INCLUDE_UNCOMPUTABLES_AS_LITERALS, true)); + if (mergeWithOriginalAndCompile) { mergeWithDefaultConfiguration(); @@ -158,6 +163,12 @@ public final class Configuration implements PersistentStateComponent { } } + private static boolean readBoolean(Element element, String key, boolean defValue) { + final String value = JDOMExternalizerUtil.readField(element, key); + if (value == null) return defValue; + return Boolean.parseBoolean(value); + } + private void mergeWithDefaultConfiguration() { Configuration cfg = null; try { @@ -363,6 +374,22 @@ public final class Configuration implements PersistentStateComponent { myResolveReferences = resolveReferences; } + public boolean isIncludeUncomputablesAsLiterals() { + return myIncludeUncomputablesAsLiterals; + } + + public void setIncludeUncomputablesAsLiterals(boolean flag) { + myIncludeUncomputablesAsLiterals = flag; + } + + public boolean isUseDfaIfAvailable() { + return myUseDfaIfAvailable; + } + + public void setUseDfaIfAvailable(boolean flag) { + myUseDfaIfAvailable = flag; + } + @Nullable public BaseInjection findExistingInjection(@NotNull final BaseInjection injection) { final List list = getInjections(injection.getSupportId()); diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/pattern/PatternValidator.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/pattern/PatternValidator.java index 5427e23de284..6dbf7b1a5207 100644 --- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/pattern/PatternValidator.java +++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/pattern/PatternValidator.java @@ -220,7 +220,9 @@ public class PatternValidator extends LocalInspectionTool { if (pattern == null) return; List nonConstantElements = new SmartList(); - String o = SubstitutedExpressionEvaluationHelper.computeExpression(expression, nonConstantElements); + final Object result = new SubstitutedExpressionEvaluationHelper(expression.getProject()).computeExpression( + expression, myConfiguration.isUseDfaIfAvailable(), false, nonConstantElements); + final String o = result == null ? null : String.valueOf(result); if (o != null) { if (!pattern.matcher(o).matches()) { if (annotations.length > 1) { diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/ContextComputationProcessor.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/ContextComputationProcessor.java index ea5975ac5159..feed23cd41fe 100644 --- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/ContextComputationProcessor.java +++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/ContextComputationProcessor.java @@ -95,7 +95,7 @@ public class ContextComputationProcessor { } else { final SmartList uncomputables = new SmartList(); - final Object o = expression instanceof PsiExpression? myEvaluationHelper.computeExpression((PsiExpression)expression, true, uncomputables) : null; + final Object o = expression instanceof PsiExpression? myEvaluationHelper.computeExpression((PsiExpression)expression, uncomputables) : null; if (uncomputables.size() > 0) { unparsable.set(Boolean.TRUE); } diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/SubstitutedExpressionEvaluationHelper.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/SubstitutedExpressionEvaluationHelper.java index 78dab4b9835f..51b252465365 100644 --- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/SubstitutedExpressionEvaluationHelper.java +++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/util/SubstitutedExpressionEvaluationHelper.java @@ -23,10 +23,10 @@ import com.intellij.psi.*; import com.intellij.psi.util.CachedValue; import com.intellij.util.containers.ConcurrentHashMap; import org.intellij.plugins.intelliLang.Configuration; -import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.Collection; +import java.util.Collections; import java.util.List; import java.util.concurrent.ConcurrentMap; @@ -47,11 +47,11 @@ public class SubstitutedExpressionEvaluationHelper { myConfiguration = Configuration.getInstance(); } - public Object computeExpression(final PsiExpression e, final boolean includeUncomputablesAsLiterals) { - return computeExpression(e, includeUncomputablesAsLiterals, null); + public Object computeExpression(final PsiExpression e, final List uncomputables) { + return computeExpression(e, myConfiguration.isUseDfaIfAvailable(), myConfiguration.isIncludeUncomputablesAsLiterals(), uncomputables); } - public Object computeExpression(final PsiExpression e, final boolean includeUncomputablesAsLiterals, final List uncomputables) { + public Object computeExpression(final PsiExpression e, final boolean useDfa, final boolean includeUncomputablesAsLiterals, final List uncomputables) { final ConcurrentMap map = new ConcurrentHashMap(); //if (true) return myHelper.computeConstantExpression(e, false); return myHelper.computeExpression(e, false, new PsiConstantEvaluationHelper.AuxEvaluator() { @@ -77,7 +77,8 @@ public class SubstitutedExpressionEvaluationHelper { if (substituted != null) return substituted; if (resolved instanceof PsiVariable) { resolvedType = ((PsiVariable)resolved).getType(); - final Collection values = DfaUtil.getCachedVariableValues(((PsiVariable)resolved), o); + final Collection values = + !useDfa? Collections.emptyList() : DfaUtil.getCachedVariableValues(((PsiVariable)resolved), o); // return the first computed value as far as we do not support multiple injection for (PsiExpression value : values) { final Object computedValue = auxEvaluator.computeExpression(value, this); @@ -126,16 +127,4 @@ public class SubstitutedExpressionEvaluationHelper { return null; } - /** - * Computes the value for the passed expression. - * - * @param e The expression whose value to compute - * @param nonConstant list that returns non-constant and non-substituted expressions - * @return the computed value, or null if the expression isn't compile time constant and not susbtituted - */ - @Nullable - public static String computeExpression(@NotNull final PsiExpression e, @Nullable List nonConstant) { - final Object result = new SubstitutedExpressionEvaluationHelper(e.getProject()).computeExpression(e, false, nonConstant); - return result == null? null : String.valueOf(result); - } }