diff options
Diffstat (limited to 'java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression')
4 files changed, 94 insertions, 26 deletions
diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java index 83ad91b4e27d..7d0a4aeb0989 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java @@ -31,7 +31,7 @@ import com.intellij.debugger.engine.DebuggerUtils; import com.intellij.debugger.engine.JVMName; import com.intellij.debugger.engine.JVMNameUtil; import com.intellij.debugger.engine.evaluation.*; -import com.intellij.debugger.ui.DebuggerEditorImpl; +import com.intellij.debugger.impl.DebuggerUtilsEx; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.psi.*; @@ -66,8 +66,8 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { final Project project = contextElement.getProject(); - CodeFragmentFactory factory = DebuggerEditorImpl.findAppropriateFactory(text, contextElement); - PsiCodeFragment codeFragment = new CodeFragmentFactoryContextWrapper(factory).createCodeFragment(text, contextElement, project); + CodeFragmentFactory factory = DebuggerUtilsEx.findAppropriateCodeFragmentFactory(text, contextElement); + PsiCodeFragment codeFragment = factory.createCodeFragment(text, contextElement, project); if (codeFragment == null) { throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("evaluation.error.invalid.expression", text.getText())); } @@ -185,6 +185,11 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { } @Override + public void visitTryStatement(PsiTryStatement statement) { + throw new EvaluateRuntimeException(new UnsupportedExpressionException(statement.getText())); + } + + @Override public void visitStatement(PsiStatement statement) { throwEvaluateException(DebuggerBundle.message("evaluation.error.statement.not.supported", statement.getText())); } @@ -741,24 +746,28 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { } private int calcIterationCount(final PsiJavaCodeReferenceElement qualifier) { - int iterationCount = 0; if (qualifier != null) { - PsiElement targetClass = qualifier.resolve(); - if (targetClass == null || getContextPsiClass() == null) { - throwEvaluateException(DebuggerBundle.message("evaluation.error.invalid.expression", qualifier.getText())); - } - try { - PsiClass aClass = getContextPsiClass(); - while (aClass != null && !aClass.equals(targetClass)) { - iterationCount++; - aClass = getOuterClass(aClass); - } - } - catch (Exception e) { - //noinspection ThrowableResultOfMethodCallIgnored - throw new EvaluateRuntimeException(EvaluateExceptionUtil.createEvaluateException(e)); + return calcIterationCount(qualifier.resolve(), qualifier.getText()); + } + return 0; + } + + private int calcIterationCount(PsiElement targetClass, String name) { + int iterationCount = 0; + if (targetClass == null || getContextPsiClass() == null) { + throwEvaluateException(DebuggerBundle.message("evaluation.error.invalid.expression", name)); + } + try { + PsiClass aClass = getContextPsiClass(); + while (aClass != null && !aClass.equals(targetClass)) { + iterationCount++; + aClass = getOuterClass(aClass); } } + catch (Exception e) { + //noinspection ThrowableResultOfMethodCallIgnored + throw new EvaluateRuntimeException(EvaluateExceptionUtil.createEvaluateException(e)); + } return iterationCount; } @@ -962,12 +971,16 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { } } + boolean defaultInterfaceMethod = false; + if (psiMethod != null) { processBoxingConversions(psiMethod.getParameterList().getParameters(), argExpressions, resolveResult.getSubstitutor(), argumentEvaluators); argumentEvaluators = wrapVarargs(psiMethod.getParameterList().getParameters(), argExpressions, resolveResult.getSubstitutor(), argumentEvaluators); + defaultInterfaceMethod = psiMethod.hasModifierProperty(PsiModifier.DEFAULT); } - myResult = new MethodEvaluator(objectEvaluator, contextClass, methodExpr.getReferenceName(), psiMethod != null ? JVMNameUtil.getJVMSignature(psiMethod) : null, argumentEvaluators); + myResult = new MethodEvaluator(objectEvaluator, contextClass, methodExpr.getReferenceName(), + psiMethod != null ? JVMNameUtil.getJVMSignature(psiMethod) : null, argumentEvaluators, defaultInterfaceMethod); } @Override @@ -1082,6 +1095,16 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { } @Override + public void visitLambdaExpression(PsiLambdaExpression expression) { + throw new EvaluateRuntimeException(new UnsupportedExpressionException(DebuggerBundle.message("evaluation.error.lambda.evaluation.not.supported"))); + } + + @Override + public void visitMethodReferenceExpression(PsiMethodReferenceExpression expression) { + throw new EvaluateRuntimeException(new UnsupportedExpressionException(DebuggerBundle.message("evaluation.error.method.reference.evaluation.not.supported"))); + } + + @Override public void visitNewExpression(final PsiNewExpression expression) { PsiType expressionPsiType = expression.getType(); if (expressionPsiType instanceof PsiArrayType) { @@ -1142,7 +1165,7 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { else if (expressionPsiType instanceof PsiClassType){ // must be a class ref PsiClass aClass = ((PsiClassType)expressionPsiType).resolve(); if(aClass instanceof PsiAnonymousClass) { - throwEvaluateException(DebuggerBundle.message("evaluation.error.anonymous.class.evaluation.not.supported")); + throw new EvaluateRuntimeException(new UnsupportedExpressionException(DebuggerBundle.message("evaluation.error.anonymous.class.evaluation.not.supported"))); } PsiExpressionList argumentList = expression.getArgumentList(); if (argumentList == null) { @@ -1173,8 +1196,11 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { argumentEvaluators = wrapVarargs(constructor.getParameterList().getParameters(), argExpressions, constructorResolveResult.getSubstitutor(), argumentEvaluators); } - //noinspection HardCodedStringLiteral - JVMName signature = constructor != null ? JVMNameUtil.getJVMSignature(constructor) : JVMNameUtil.getJVMRawText("()V"); + if (aClass != null && aClass.getContainingClass() != null && !aClass.hasModifierProperty(PsiModifier.STATIC)) { + argumentEvaluators = addThisEvaluator(argumentEvaluators, aClass.getContainingClass()); + } + + JVMName signature = JVMNameUtil.getJVMConstructorSignature(constructor, aClass); myResult = new NewClassInstanceEvaluator( new TypeEvaluator(JVMNameUtil.getJVMQualifiedName(expressionPsiType)), signature, @@ -1191,6 +1217,14 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { } } + private Evaluator[] addThisEvaluator(Evaluator[] argumentEvaluators, PsiClass cls) { + Evaluator[] res = new Evaluator[argumentEvaluators.length+1]; + int depth = calcIterationCount(cls, "this"); + res[0] = new ThisEvaluator(depth); + System.arraycopy(argumentEvaluators, 0, res, 1, argumentEvaluators.length); + return res; + } + @Override public void visitArrayInitializerExpression(PsiArrayInitializerExpression expression) { PsiExpression[] initializers = expression.getInitializers(); diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java index 6ba88653749b..80e42e3b61e2 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java @@ -43,13 +43,19 @@ public class MethodEvaluator implements Evaluator { private final String myMethodName; private final Evaluator[] myArgumentEvaluators; private final Evaluator myObjectEvaluator; + private final boolean myCheckDefaultInterfaceMethod; public MethodEvaluator(Evaluator objectEvaluator, JVMName className, String methodName, JVMName signature, Evaluator[] argumentEvaluators) { + this(objectEvaluator, className, methodName, signature, argumentEvaluators, false); + } + + public MethodEvaluator(Evaluator objectEvaluator, JVMName className, String methodName, JVMName signature, Evaluator[] argumentEvaluators, boolean checkDefaultInterfaceMethod) { myObjectEvaluator = new DisableGC(objectEvaluator); myClassName = className; myMethodName = methodName; myMethodSignature = signature; myArgumentEvaluators = argumentEvaluators; + myCheckDefaultInterfaceMethod = checkDefaultInterfaceMethod; } @Override @@ -148,7 +154,7 @@ public class MethodEvaluator implements Evaluator { return debugProcess.invokeInstanceMethod(context, objRef, jdiMethod, args, ObjectReference.INVOKE_NONVIRTUAL); } // fix for default methods in interfaces, see IDEA-124066 - if (Boolean.valueOf(System.getProperty("debugger.invoke.default")) && jdiMethod.declaringType() instanceof InterfaceType) { + if (myCheckDefaultInterfaceMethod && jdiMethod.declaringType() instanceof InterfaceType) { return invokeDefaultMethod(debugProcess, context, objRef, myMethodName); } else { diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/NewClassInstanceEvaluator.java b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/NewClassInstanceEvaluator.java index c3e7f8173322..3bbb0c633cd6 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/NewClassInstanceEvaluator.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/NewClassInstanceEvaluator.java @@ -21,13 +21,13 @@ */ package com.intellij.debugger.engine.evaluation.expression; +import com.intellij.debugger.DebuggerBundle; import com.intellij.debugger.engine.DebugProcessImpl; +import com.intellij.debugger.engine.DebuggerUtils; import com.intellij.debugger.engine.JVMName; import com.intellij.debugger.engine.evaluation.EvaluateException; import com.intellij.debugger.engine.evaluation.EvaluateExceptionUtil; import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; -import com.intellij.debugger.impl.DebuggerUtilsEx; -import com.intellij.debugger.DebuggerBundle; import com.sun.jdi.ClassType; import com.sun.jdi.Method; import com.sun.jdi.ObjectReference; @@ -55,7 +55,7 @@ class NewClassInstanceEvaluator implements Evaluator { } ClassType classType = (ClassType)obj; // find constructor - Method method = DebuggerUtilsEx.findMethod(classType, "<init>", myConstructorSignature.getName(debugProcess)); + Method method = DebuggerUtils.findMethod(classType, "<init>", myConstructorSignature.getName(debugProcess)); if (method == null) { throw EvaluateExceptionUtil.createEvaluateException( DebuggerBundle.message("evaluation.error.cannot.resolve.constructor", myConstructorSignature.getDisplayName(debugProcess))); diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/UnsupportedExpressionException.java b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/UnsupportedExpressionException.java new file mode 100644 index 000000000000..f4c513d4036c --- /dev/null +++ b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/UnsupportedExpressionException.java @@ -0,0 +1,28 @@ +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.debugger.engine.evaluation.expression; + +import com.intellij.debugger.DebuggerBundle; +import com.intellij.debugger.engine.evaluation.EvaluateException; + +/** + * @author egor + */ +public class UnsupportedExpressionException extends EvaluateException { + public UnsupportedExpressionException(String message) { + super(message); + } +} |