implicit collector regression fixed

#SCL-10624 fixed
#SCL-8827 fixed
#SCL-9877 fixed

src/org/jetbrains/plugins/scala/lang/psi/implicits/ImplicitCollector.scala

@@ -231,7 +231,9 @@ class ImplicitCollector(private var place: PsiElement,
           if (isAccessible(member)) addResultForElement()
         case _: ScBindingPattern | _: ScFieldId =>
           val member = ScalaPsiUtil.getContextOfType(element, true, classOf[ScValue], classOf[ScVariable]) match {
-            case m: ScMember if m.hasModifierProperty("implicit") => m
+            case m: ScMember if m.hasModifierProperty("implicit") =>
+              placeCalculated = true
+              m
             case _ => return true
           }
           if (isAccessible(member)) addResultForElement()

test/org/jetbrains/plugins/scala/lang/typeInference/generated/TypeInferenceImplicitsTest.scala

@@ -26,4 +26,6 @@ class TypeInferenceImplicitsTest extends TypeInferenceTestBase {
   def testSpecialConversion() {doTest()}
 
   def testSCL7475() {doTest()}
+
+  def testSCL9877() {doTest()}
 }

testdata/typeInference/implicits/SCL9877.scala

@@ -0,0 +1,52 @@
+object Holder {
+
+  object ActorMaterializer {
+
+    def apply()(implicit context: ActorRefFactory): ActorMaterializer = ???
+  }
+
+  trait Materializer
+
+  abstract class ActorMaterializer extends Materializer
+
+  class ActorMaterializerSettings
+
+  trait ActorRefFactory
+
+  case class ActorSystem(s: String) extends ActorRefFactory
+
+  class Route
+
+  class Flow
+
+  implicit def route2HandlerFlow(route: Route)
+                                (implicit routingSettings: RoutingSettings, materializer: Materializer): Flow = ???
+
+  trait SettingsCompanion[T] {
+    implicit def default(implicit system: ActorRefFactory): T = ???
+  }
+
+  object RoutingSettings extends SettingsCompanion[RoutingSettings]
+
+  abstract class RoutingSettings
+}
+
+object Test {
+
+  import scala.concurrent.ExecutionContext
+  import Holder._
+
+  def bindAndHandle(handler: Flow, interface: String, port: Int)
+                   (implicit fm: Materializer): Any = ???
+
+  def main(args: Array[String]) {
+    implicit val system = ActorSystem("foo")
+    implicit val materializer = ActorMaterializer()
+    implicit val executionContext: ExecutionContext = ???
+
+    val route: Route = ???
+
+    val bindingFuture = bindAndHandle(/*start*/route/*end*/, "localhost", 8080)
+  }
+}
+//Holder.Flow