Added import implicit to import definitions into the implicit scope only.

Author: milessabin

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -2453,12 +2453,14 @@ self =>
 
 
     /** {{{
-     *  Import  ::= import ImportExpr {`,' ImportExpr}
+     *  Import  ::= import [implicit] ImportExpr {`,' ImportExpr}
      *  }}}
      */
     def importClause(): List[Tree] = {
       val offset = accept(IMPORT)
-      commaSeparated(importExpr()) match {
+      val implicitMod = in.token == IMPLICIT
+      if(implicitMod) in.nextToken
+      commaSeparated(importExpr(implicitMod)) match {
         case Nil => Nil
         case t :: rest =>
           // The first import should start at the position of the keyword.
@@ -2471,7 +2473,7 @@ self =>
      *  ImportExpr ::= StableId `.' (Id | `_' | ImportSelectors)
      *  }}}
      */
-    def importExpr(): Tree = {
+    def importExpr(implicitMod: Boolean): Tree = {
       val start = in.offset
       def thisDotted(name: TypeName) = {
         in.nextToken()
@@ -2502,7 +2504,9 @@ self =>
             else List(makeImportSelector(name, nameOffset))
         }
         // reaching here means we're done walking.
-        atPos(start)(Import(expr, selectors))
+        val tree = Import(expr, selectors)
+        if(implicitMod) tree updateAttachment ImplicitImport
+        atPos(start)(tree)
       }
 
       loop(in.token match {

src/compiler/scala/tools/nsc/typechecker/Contexts.scala

@@ -35,6 +35,7 @@ trait Contexts { self: Analyzer =>
     override def implicitss: List[List[ImplicitInfo]] = Nil
     override def imports: List[ImportInfo] = Nil
     override def firstImport: Option[ImportInfo] = None
+    override def implicitImports: List[ImportInfo] = Nil
     override def toString = "NoContext"
   }
   private object RootImports {
@@ -236,6 +237,7 @@ trait Contexts { self: Analyzer =>
 
     /** The currently visible imports */
     def imports: List[ImportInfo] = outer.imports
+    def implicitImports: List[ImportInfo] = outer.implicitImports
     /** Equivalent to `imports.headOption`, but more efficient */
     def firstImport: Option[ImportInfo] = outer.firstImport
     def isRootImport: Boolean = false
@@ -472,9 +474,12 @@ trait Contexts { self: Analyzer =>
         else prefix
 
       // The blank canvas
-      val c = if (isImport)
-        new Context(tree, owner, scope, unit, this, reporter) with ImportContext
-      else
+      val c = if (isImport) {
+        if(tree.hasAttachment[ImplicitImport.type])
+          new Context(tree, owner, scope, unit, this, reporter) with ImplicitImportContext
+        else
+          new Context(tree, owner, scope, unit, this, reporter) with ImportContext
+      } else
         new Context(tree, owner, scope, unit, this, reporter)
 
       // Fields that are directly propagated
@@ -1260,6 +1265,13 @@ trait Contexts { self: Analyzer =>
     override final def toString     = s"${super.toString} with ImportContext { $impInfo; outer.owner = ${outer.owner} }"
   }
 
+  trait ImplicitImportContext extends Context {
+    private val impInfo: ImportInfo = new ImportInfo(tree.asInstanceOf[Import], outerDepth)
+
+    override final def implicitImports = impInfo :: super.implicitImports
+    override final def toString     = super.toString + " with " + s"ImplicitImportContext { $impInfo; outer.owner = ${outer.owner} }"
+  }
+
   /** A reporter for use during type checking. It has multiple modes for handling errors.
    *
    *  The default (immediate mode) is to send the error to the global reporter.

src/compiler/scala/tools/nsc/typechecker/Implicits.scala

@@ -1432,8 +1432,20 @@ trait Implicits {
 
         // `materializeImplicit` does some preprocessing for `pt`
         // is it only meant for manifests/tags or we need to do the same for `implicitsOfExpectedType`?
-        if (result.isFailure && !wasAmbiguous)
-          result = searchImplicit(implicitsOfExpectedType, isLocalToCallsite = false)
+        if (result.isFailure && !wasAmbiguous) {
+          val implicitScope =
+            if(context.implicitImports.isEmpty) implicitsOfExpectedType
+            else {
+              val importedInfos = context.implicitImports.flatMap { imp =>
+                imp.allImportedSymbols.filter(_.isImplicit).map { sym =>
+                  new ImplicitInfo(sym.name, imp.qual.tpe, sym)
+                }
+              }
+              importedInfos :: implicitsOfExpectedType
+            }
+
+          result = searchImplicit(implicitScope, isLocalToCallsite = false)
+        }
 
         if (result.isFailure)
           context.reporter ++= previousErrs

src/reflect/scala/reflect/internal/StdAttachments.scala

@@ -100,4 +100,6 @@ trait StdAttachments {
   case object KnownDirectSubclassesCalled extends PlainAttachment
 
   class QualTypeSymAttachment(val sym: Symbol)
+
+  case object ImplicitImport extends PlainAttachment
 }

src/reflect/scala/reflect/runtime/JavaUniverseForce.scala

@@ -50,6 +50,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     this.UseInvokeSpecial
     this.TypeParamVarargsAttachment
     this.KnownDirectSubclassesCalled
+    this.ImplicitImport
     this.noPrint
     this.typeDebug
     this.Range

test/files/run/import-implicit-1.scala

@@ -0,0 +1,52 @@
+class Show[T](val i: Int)
+object Show extends Show0 {
+  def apply[T](i: Int): Show[T] = new Show[T](i)
+
+  implicit val show0: Show[Int] = Show[Int](0)
+}
+
+trait Show0 {
+  // currently this generates an ambiguity with showGen ... we need to
+  // tweak the specificity rules so that showGen is preferred to show1.
+  //implicit def show1[T]: Show[T] = Show[T](1)
+}
+
+class Foo[T]
+object Foo {
+  implicit def showFoo[T](implicit st: Show[T]): Show[Foo[T]] = new Show[Foo[T]](2)
+}
+
+class Bar[T]
+object Bar {
+  implicit def barFoo[T]: Bar[Foo[T]] = new Bar[Foo[T]]
+  implicit def barOption[T]: Bar[Option[T]] = new Bar[Option[T]]
+}
+
+object DerivedShow {
+  implicit def showGen[T](implicit bar: Bar[T]): Show[T] = new Show[T](3)
+}
+
+object Test extends App {
+  def check[T](i: Int)(implicit show: Show[T]): Unit = assert(show.i == i)
+
+  check[Int](0)
+  //check[String](1)
+  check[Foo[Int]](2)
+  //check[Option[Int]](1)
+
+  {
+    import DerivedShow._
+    check[Int](0)
+    //check[String](1)
+    check[Foo[Int]](3) // Would like 2
+    check[Option[Int]](3)
+  }
+
+  {
+    import implicit DerivedShow._
+    check[Int](0)
+    //check[String](1)
+    check[Foo[Int]](2)
+    check[Option[Int]](3) // Would like 3
+  }
+}