tests fixed

JetBrains · Jun 6, 2014 · dde4d72 · dde4d72
1 parent e6f295f
commit dde4d72
Show file tree

Hide file tree

Showing 10 changed files with 92 additions and 84 deletions.
diff --git a/src/org/jetbrains/plugins/scala/ScalaBundle.properties b/src/org/jetbrains/plugins/scala/ScalaBundle.properties
@@ -194,6 +194,7 @@ final.class.cannot.be.extended=Final class cannot be extended
 cannot.resolve=Cannot resolve symbol {0}
 cannot.resolve.apply.method=Cannot resolve method {0}.apply
 cannot.resolve.in.StringContext=Value ''{0}'' is not a member of StringContext
+cannot.resolve.such.signature=Cannot resolve reference {0} with such signature
 element.is.not.accessible=Element {0} has private access from this place
 class.must.declared.abstract=Class ''{0}'' must be declared abstract or implement inherited abstract members
 object.must.implement=Object ''{0}'' must implement not implemented methods

diff --git a/src/org/jetbrains/plugins/scala/annotator/ApplicationAnnotator.scala b/src/org/jetbrains/plugins/scala/annotator/ApplicationAnnotator.scala
@@ -1,24 +1,24 @@
 package org.jetbrains.plugins.scala
 package annotator
 
-import org.jetbrains.plugins.scala.lang.psi.api.base.ScReferenceElement
-import org.jetbrains.plugins.scala.lang.resolve.ScalaResolveResult
+import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.lang.annotation.{Annotation, AnnotationHolder}
-import org.jetbrains.plugins.scala.lang.psi.types._
-import nonvalue.Parameter
-import quickfix.ReportHighlightingErrorQuickFix
-import result.TypingContext
-import org.jetbrains.plugins.scala.lang.psi.impl.toplevel.synthetic.ScSyntheticFunction
+import com.intellij.psi.{PsiElement, PsiMethod, PsiNamedElement, PsiParameter}
+import org.jetbrains.plugins.scala.annotator.createFromUsage.{CreateMethodQuickFix, CreateParameterlessMethodQuickFix, CreateValueQuickFix, CreateVariableQuickFix}
+import org.jetbrains.plugins.scala.annotator.quickfix.ReportHighlightingErrorQuickFix
+import org.jetbrains.plugins.scala.codeInspection.varCouldBeValInspection.ValToVarQuickFix
+import org.jetbrains.plugins.scala.extensions._
 import org.jetbrains.plugins.scala.lang.psi.ScalaPsiUtil
-import org.jetbrains.plugins.scala.lang.psi.api.statements.params.{ScParameters, ScParameter}
-import com.intellij.psi.{PsiElement, PsiParameter, PsiNamedElement, PsiMethod}
-import lang.psi.api.statements.{ScValue, ScFunction}
-import codeInspection.varCouldBeValInspection.ValToVarQuickFix
-import extensions._
-import lang.psi.api.expr._
-import lang.psi.impl.expr.ScInterpolatedStringPrefixReference
-import com.intellij.codeInspection.ProblemHighlightType
-import org.jetbrains.plugins.scala.annotator.createFromUsage.{CreateVariableQuickFix, CreateValueQuickFix, CreateParameterlessMethodQuickFix, CreateMethodQuickFix}
+import org.jetbrains.plugins.scala.lang.psi.api.base.ScReferenceElement
+import org.jetbrains.plugins.scala.lang.psi.api.expr._
+import org.jetbrains.plugins.scala.lang.psi.api.statements.params.{ScParameter, ScParameters}
+import org.jetbrains.plugins.scala.lang.psi.api.statements.{ScFunction, ScValue}
+import org.jetbrains.plugins.scala.lang.psi.impl.expr.ScInterpolatedStringPrefixReference
+import org.jetbrains.plugins.scala.lang.psi.impl.toplevel.synthetic.ScSyntheticFunction
+import org.jetbrains.plugins.scala.lang.psi.types._
+import org.jetbrains.plugins.scala.lang.psi.types.nonvalue.Parameter
+import org.jetbrains.plugins.scala.lang.psi.types.result.TypingContext
+import org.jetbrains.plugins.scala.lang.resolve.ScalaResolveResult
 
 /**
  * Pavel.Fatin, 31.05.2010
@@ -257,7 +257,7 @@ trait ApplicationAnnotator {
   private def parenthesise(items: Seq[_]) = items.mkString("(", ", ", ")")
 
   private def addCreateFromUsagesQuickFixes(ref: ScReferenceElement, holder: AnnotationHolder) = {
-    val annotation = holder.createErrorAnnotation(ref, null)
+    val annotation = holder.createErrorAnnotation(ref, ScalaBundle.message("cannot.resolve.such.signature", ref.refName))
     annotation.setHighlightType(ProblemHighlightType.INFORMATION)
     registerCreateFromUsageFixesFor(ref, annotation)
   }

diff --git a/src/org/jetbrains/plugins/scala/codeInsight/delegate/ScalaGenerateDelegateHandler.scala b/src/org/jetbrains/plugins/scala/codeInsight/delegate/ScalaGenerateDelegateHandler.scala
@@ -61,7 +61,7 @@ class ScalaGenerateDelegateHandler extends GenerateDelegateHandler {
           val prototype: ScFunctionDefinition =
             ScalaPsiElementFactory.createMethodFromSignature(member.sign, aClass.getManager, specifyType, body = "???")
                   .asInstanceOf[ScFunctionDefinition]
-          prototype.setModifierProperty("override", value = member.needsOverride)
+          prototype.setModifierProperty("override", value = member.isOverride)
           val body = methodBody(target, prototype)
           prototype.body.foreach(_.replace(body))
           val genInfo = new ScalaGenerationInfo(member)
@@ -158,7 +158,7 @@ class ScalaGenerateDelegateHandler extends GenerateDelegateHandler {
     }
 
     candidates.toSeq.collect {
-      case isSuitable(sign) => new ScMethodMember(sign, needsOverride = false)
+      case isSuitable(sign) => new ScMethodMember(sign, isOverride = false)
     }
   }
 

diff --git a/src/org/jetbrains/plugins/scala/debugger/evaluation/ScalaEvaluatorBuilder.scala b/src/org/jetbrains/plugins/scala/debugger/evaluation/ScalaEvaluatorBuilder.scala
@@ -1,38 +1,37 @@
 package org.jetbrains.plugins.scala.debugger.evaluation
 
 import com.intellij.debugger.SourcePosition
-import evaluator._
-import org.jetbrains.plugins.scala.lang.psi.ScalaPsiUtil
 import com.intellij.debugger.engine.evaluation._
-import com.intellij.psi._
 import com.intellij.debugger.engine.evaluation.expression._
-import org.jetbrains.plugins.scala.lang.psi.api.statements.params.{ScParameterClause, ScParameter, ScClassParameter}
-import scala.reflect.NameTransformer
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.plugins.scala.lang.psi.impl.ScalaPsiElementFactory
-import org.jetbrains.plugins.scala.lang.resolve.ScalaResolveResult
-import org.jetbrains.plugins.scala.lang.psi.api.expr._
-import org.jetbrains.plugins.scala.lang.psi.api.toplevel.{ScNamedElement, ScEarlyDefinitions}
-import org.jetbrains.plugins.scala.lang.psi.api.{ScPackage, ScalaRecursiveElementVisitor, ScalaElementVisitor}
-import org.jetbrains.plugins.scala.lang.psi.types.result.TypingContext
 import com.intellij.debugger.engine.{JVMName, JVMNameUtil}
-import util.DebuggerUtil
-import scala.collection.mutable
-import scala.collection.mutable.ArrayBuffer
-import org.jetbrains.plugins.scala.lang.psi.impl.toplevel.synthetic.ScSyntheticFunction
-import org.jetbrains.plugins.scala.lang.psi.types._
+import com.intellij.lang.java.JavaLanguage
+import com.intellij.psi._
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.plugins.scala.debugger.evaluation.evaluator._
+import org.jetbrains.plugins.scala.debugger.evaluation.util.DebuggerUtil
+import org.jetbrains.plugins.scala.extensions.{toObjectExt, toPsiClassExt, toPsiModifierListOwnerExt, toPsiNamedElementExt}
+import org.jetbrains.plugins.scala.lang.psi.ScalaPsiUtil
+import org.jetbrains.plugins.scala.lang.psi.api.base._
 import org.jetbrains.plugins.scala.lang.psi.api.base.patterns._
-import org.jetbrains.plugins.scala.lang.psi.api.toplevel.templates.{ScClassParents, ScTemplateBody}
+import org.jetbrains.plugins.scala.lang.psi.api.expr._
+import org.jetbrains.plugins.scala.lang.psi.api.expr.xml.ScXmlPattern
 import org.jetbrains.plugins.scala.lang.psi.api.statements._
+import org.jetbrains.plugins.scala.lang.psi.api.statements.params.{ScClassParameter, ScParameter, ScParameterClause}
+import org.jetbrains.plugins.scala.lang.psi.api.toplevel.templates.{ScClassParents, ScTemplateBody}
 import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef._
-import org.jetbrains.plugins.scala.lang.psi.api.base._
-import org.jetbrains.plugins.scala.extensions.{toPsiModifierListOwnerExt, toPsiNamedElementExt, toPsiClassExt}
-import org.jetbrains.plugins.scala.lang.psi.api.expr.xml.ScXmlPattern
-import org.jetbrains.plugins.scala.debugger.evaluation.evaluator.ScalaMethodEvaluator
+import org.jetbrains.plugins.scala.lang.psi.api.toplevel.{ScEarlyDefinitions, ScNamedElement}
+import org.jetbrains.plugins.scala.lang.psi.api.{ScPackage, ScalaElementVisitor, ScalaRecursiveElementVisitor}
+import org.jetbrains.plugins.scala.lang.psi.impl.ScalaPsiElementFactory
+import org.jetbrains.plugins.scala.lang.psi.impl.toplevel.synthetic.ScSyntheticFunction
+import org.jetbrains.plugins.scala.lang.psi.types._
 import org.jetbrains.plugins.scala.lang.psi.types.nonvalue.Parameter
-import org.jetbrains.plugins.scala.lang.psi.types.ScThisType
-import com.intellij.lang.java.JavaLanguage
+import org.jetbrains.plugins.scala.lang.psi.types.result.TypingContext
+import org.jetbrains.plugins.scala.lang.resolve.ScalaResolveResult
+
 import scala.annotation.tailrec
+import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
+import scala.reflect.NameTransformer
 
 /**
  * User: Alefas
@@ -689,7 +688,7 @@ object ScalaEvaluatorBuilder extends EvaluatorBuilder {
             val evaluator = arguments(i)
             if (params.length > i) {
               val param = params(i)
-              import PsiType._
+              import com.intellij.psi.PsiType._
               res += (param.getType match {
                 case BOOLEAN | INT | CHAR | DOUBLE | FLOAT | LONG | BYTE | SHORT => evaluator
                 case _ => boxEvaluator(evaluator)
@@ -1302,7 +1301,7 @@ object ScalaEvaluatorBuilder extends EvaluatorBuilder {
                                            resolve: PsiElement,
                                            ref: ScReferenceExpression, replaceWithImplicit: String => ScExpression) {
       val isLocalValue = isLocalV(resolve)
-      val fileName = resolve.getContainingFile.name
+      val fileName = myContextClass.toOption.flatMap(_.getContainingFile.toOption).map(_.name).orNull
 
       def evaluateFromParameter(fun: PsiElement, resolve: PsiElement): Evaluator = {
         val name = NameTransformer.encode(resolve.asInstanceOf[PsiNamedElement].name)

diff --git a/...g/jetbrains/plugins/scala/debugger/evaluation/evaluator/ScalaLocalVariableEvaluator.scala b/...g/jetbrains/plugins/scala/debugger/evaluation/evaluator/ScalaLocalVariableEvaluator.scala
@@ -1,13 +1,13 @@
 package org.jetbrains.plugins.scala.debugger.evaluation.evaluator
 
 import com.intellij.debugger.DebuggerBundle
-import com.intellij.debugger.jdi.{StackFrameProxyImpl, LocalVariableProxyImpl}
-import com.intellij.debugger.ui.impl.watch.{LocalVariableDescriptorImpl, NodeDescriptorImpl}
 import com.intellij.debugger.engine.evaluation.expression.{Evaluator, Modifier}
 import com.intellij.debugger.engine.evaluation.{EvaluateException, EvaluateExceptionUtil, EvaluationContextImpl}
-import com.sun.jdi.{InternalException, Value, Type}
-import com.intellij.openapi.project.Project
+import com.intellij.debugger.jdi.{LocalVariableProxyImpl, StackFrameProxyImpl}
+import com.intellij.debugger.ui.impl.watch.{LocalVariableDescriptorImpl, NodeDescriptorImpl}
 import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.project.Project
+import com.sun.jdi.{InternalException, Type, Value}
 import org.jetbrains.plugins.scala.debugger.evaluation.util.DebuggerUtil
 
 /**
@@ -16,7 +16,7 @@ import org.jetbrains.plugins.scala.debugger.evaluation.util.DebuggerUtil
  */
 
 class ScalaLocalVariableEvaluator(name: String, sourceName: String) extends Evaluator {
-  import ScalaLocalVariableEvaluator.LOG
+  import org.jetbrains.plugins.scala.debugger.evaluation.evaluator.ScalaLocalVariableEvaluator.LOG
   private val myName: String = DebuggerUtil.withoutBackticks(name)
   private val mySourceName: String = DebuggerUtil.withoutBackticks(sourceName)
   private var myContext: EvaluationContextImpl = null

diff --git a/src/org/jetbrains/plugins/scala/debugger/evaluation/util/DebuggerUtil.scala b/src/org/jetbrains/plugins/scala/debugger/evaluation/util/DebuggerUtil.scala
@@ -1,24 +1,25 @@
 package org.jetbrains.plugins.scala.debugger.evaluation.util
 
-import com.intellij.debugger.jdi.VirtualMachineProxyImpl
-import org.jetbrains.plugins.scala.lang.psi.api.expr.ScNewTemplateDefinition
 import com.intellij.debugger.engine.evaluation.EvaluateExceptionUtil
+import com.intellij.debugger.engine.{DebugProcessImpl, JVMName, JVMNameUtil}
+import com.intellij.debugger.jdi.VirtualMachineProxyImpl
 import com.intellij.debugger.{DebuggerBundle, SourcePosition}
+import com.intellij.lang.ASTNode
 import com.intellij.openapi.application.ApplicationManager
-import com.sun.jdi.{ObjectReference, Value}
-import com.intellij.debugger.engine.{DebugProcessImpl, JVMNameUtil, JVMName}
 import com.intellij.openapi.util.Computable
+import com.intellij.psi.{PsiClass, PsiElement}
+import com.sun.jdi.{ObjectReference, Value}
+import org.jetbrains.plugins.scala.extensions.toPsiClassExt
 import org.jetbrains.plugins.scala.lang.psi.ScalaPsiUtil
-import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.{ScObject, ScTrait, ScTypeDefinition}
-import com.intellij.psi.{PsiElement, PsiClass}
-import com.intellij.lang.ASTNode
-import collection.mutable.ArrayBuffer
+import org.jetbrains.plugins.scala.lang.psi.api.base.ScPrimaryConstructor
+import org.jetbrains.plugins.scala.lang.psi.api.expr.ScNewTemplateDefinition
 import org.jetbrains.plugins.scala.lang.psi.api.statements.ScFunction
-import org.jetbrains.plugins.scala.lang.psi.types.{ScSubstitutor, ScType}
+import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.{ScObject, ScTrait, ScTypeDefinition}
 import org.jetbrains.plugins.scala.lang.psi.types.result.TypingContext
-import org.jetbrains.plugins.scala.lang.psi.api.base.ScPrimaryConstructor
-import org.jetbrains.plugins.scala.extensions.toPsiClassExt
+import org.jetbrains.plugins.scala.lang.psi.types.{ScSubstitutor, ScType}
+
 import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
 
 /**
  * User: Alefas
@@ -262,6 +263,7 @@ object DebuggerUtil {
   def withoutBackticks(name: String): String = {
     val backticked = """\$u0060(.+)\$u0060""".r
     name match {
+      case null => null
       case backticked(id) => id
       case _ => name
     }

diff --git a/src/org/jetbrains/plugins/scala/overrideImplement/ScalaGenerationInfo.scala b/src/org/jetbrains/plugins/scala/overrideImplement/ScalaGenerationInfo.scala
@@ -48,7 +48,7 @@ class ScalaGenerationInfo(classMember: ClassMember)
       case member: ScAliasMember =>
         val alias = member.getElement
         val substitutor = addUpdateThisType(member.substitutor, templDef)
-        val needsOverride = member.needsOverride || addOverrideToImplemented
+        val needsOverride = member.isOverride || toAddOverrideToImplemented
         val m = ScalaPsiElementFactory.createOverrideImplementType(alias, substitutor, alias.getManager, needsOverride)
         val added = templDef.addMember(m, Option(anchor))
         myMember = added
@@ -57,11 +57,11 @@ class ScalaGenerationInfo(classMember: ClassMember)
         val isVal = classMember match {case _: ScValueMember => true case _: ScVariableMember => false}
         val value = classMember match {case x: ScValueMember => x.element case x: ScVariableMember => x.element}
         val (origSubstitutor, needsOverride) = classMember match {
-          case x: ScValueMember => (x.substitutor, x.needsOverride)
-          case x: ScVariableMember => (x.substitutor, x.needsOverride)
+          case x: ScValueMember => (x.substitutor, x.isOverride)
+          case x: ScVariableMember => (x.substitutor, x.isOverride)
         }
         val substitutor = addUpdateThisType(origSubstitutor, templDef)
-        val addOverride = needsOverride || addOverrideToImplemented
+        val addOverride = needsOverride || toAddOverrideToImplemented
         val m = ScalaPsiElementFactory.createOverrideImplementVariable(value, substitutor, value.getManager,
           addOverride, isVal, needsInferType)
         val added = templDef.addMember(m, Option(anchor))
@@ -171,7 +171,7 @@ object ScalaGenerationInfo {
     val method: PsiMethod = member.getElement
     val sign = member.sign.updateSubst(addUpdateThisType(_, td))
 
-    val isImplement = !member.needsOverride
+    val isImplement = !member.isOverride
     val templateName =
       if (isImplement) ScalaFileTemplateUtil.SCALA_IMPLEMENTED_METHOD_TEMPLATE
       else ScalaFileTemplateUtil.SCALA_OVERRIDDEN_METHOD_TEMPLATE
@@ -192,7 +192,7 @@ object ScalaGenerationInfo {
 
     val body = template.getText(properties)
 
-    val needsOverride = !isImplement || addOverrideToImplemented
+    val needsOverride = !isImplement || toAddOverrideToImplemented
     val m = ScalaPsiElementFactory.createOverrideImplementMethod(sign, method.getManager, needsOverride, needsInferType, body)
     val added = td.addMember(m, Option(anchor))
     ScalaPsiUtil.adjustTypes(added)
@@ -204,9 +204,9 @@ object ScalaGenerationInfo {
     case Failure(_, _) => subst
   }
 
-  val addOverrideToImplemented =
+  def toAddOverrideToImplemented =
     if (ApplicationManager.getApplication.isUnitTestMode) false
     else ScalaApplicationSettings.getInstance.ADD_OVERRIDE_TO_IMPLEMENTED
 
-  val needsInferType = ScalaApplicationSettings.getInstance.SPECIFY_RETURN_TYPE_EXPLICITLY
+  def needsInferType = ScalaApplicationSettings.getInstance.SPECIFY_RETURN_TYPE_EXPLICITLY
 }
diff --git a/src/org/jetbrains/plugins/scala/overrideImplement/ScalaMethodImplementor.scala b/src/org/jetbrains/plugins/scala/overrideImplement/ScalaMethodImplementor.scala
@@ -62,7 +62,7 @@ private class ScalaPsiMethodGenerationInfo(method: PsiMethod, baseMethod: PsiMet
       case _ => return
     }
     val sign = new PhysicalSignature(method, ScSubstitutor.empty)
-    val methodMember = new ScMethodMember(sign, ScalaApplicationSettings.getInstance.ADD_OVERRIDE_TO_IMPLEMENTED)
+    val methodMember = new ScMethodMember(sign, isOverride = false)
 
     addedMember = ScalaGenerationInfo.insertMethod(methodMember, td, findAnchor(td, baseMethod))
   }

diff --git a/src/org/jetbrains/plugins/scala/overrideImplement/ScalaNamedMember.scala b/src/org/jetbrains/plugins/scala/overrideImplement/ScalaNamedMember.scala
@@ -1,13 +1,13 @@
 package org.jetbrains.plugins.scala
 package overrideImplement
 
-import com.intellij.psi._
 import com.intellij.codeInsight.generation.PsiElementClassMember
-import org.jetbrains.plugins.scala.lang.psi.api.statements.{ScFunction, ScValue, ScTypeAlias, ScVariable}
-import lang.psi.api.toplevel.ScTypedDefinition
-import lang.psi.ScalaPsiUtil
-import lang.psi.types._
-import lang.psi.types.result.TypingContext
+import com.intellij.psi._
+import org.jetbrains.plugins.scala.lang.psi.ScalaPsiUtil
+import org.jetbrains.plugins.scala.lang.psi.api.statements.{ScFunction, ScTypeAlias, ScValue, ScVariable}
+import org.jetbrains.plugins.scala.lang.psi.api.toplevel.ScTypedDefinition
+import org.jetbrains.plugins.scala.lang.psi.types._
+import org.jetbrains.plugins.scala.lang.psi.types.result.TypingContext
 
 /**
 * User: Alexander Podkhalyuzin
@@ -22,12 +22,12 @@ trait ScalaTypedMember {
   def scType: ScType
 }
 
-class ScAliasMember(member: ScTypeAlias, val substitutor: ScSubstitutor, val needsOverride: Boolean)
+class ScAliasMember(member: ScTypeAlias, val substitutor: ScSubstitutor, val isOverride: Boolean)
         extends {
           val name: String = member.name
         } with PsiElementClassMember[ScTypeAlias](member, name) with ScalaNamedMember
 
-class ScMethodMember(val sign: PhysicalSignature, val needsOverride: Boolean)
+class ScMethodMember(val sign: PhysicalSignature, val isOverride: Boolean)
         extends {
           val name: String = sign.name
           val scType: ScType = sign.method match {
@@ -40,14 +40,14 @@ class ScMethodMember(val sign: PhysicalSignature, val needsOverride: Boolean)
           val text = ScalaPsiUtil.getMethodPresentableText(sign.method)
         } with PsiElementClassMember[PsiMethod](sign.method, text) with ScalaNamedMember with ScalaTypedMember
 
-class ScValueMember(member: ScValue, val element: ScTypedDefinition, val substitutor: ScSubstitutor, val needsOverride: Boolean)
+class ScValueMember(member: ScValue, val element: ScTypedDefinition, val substitutor: ScSubstitutor, val isOverride: Boolean)
         extends {
           val name = element.getName
           val scType = substitutor.subst(element.getType(TypingContext.empty).getOrAny)
           val text = element.name + ": " + ScType.presentableText(scType)
         } with PsiElementClassMember[ScValue](member, text) with ScalaNamedMember with ScalaTypedMember
 
-class ScVariableMember(member: ScVariable, val element: ScTypedDefinition, val substitutor: ScSubstitutor, val needsOverride: Boolean)
+class ScVariableMember(member: ScVariable, val element: ScTypedDefinition, val substitutor: ScSubstitutor, val isOverride: Boolean)
         extends {
           val name = element.getName
           val scType = substitutor.subst(element.getType(TypingContext.empty).getOrAny)