1 files changed, 56 insertions, 22 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();