More useful checkfile output in interactive tests.

I resisted the urge to fix "aksTypeCompletion" for as long
as I possibly could. While I was there I threw in what seem
to be like significant output improvements, but you tell me.

12 files changed, 698 insertions, 698 deletions

diff --git a/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala b/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala
index b4d3fd8aa0..c38c7c8257 100644
--- a/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala
+++ b/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala
@@ -295,6 +295,9 @@ trait CompilerControl { self: Global =>
     val tpe: Type
     val accessible: Boolean
     def implicitlyAdded = false
+
+    private def accessible_s = if (accessible) "" else "[inaccessible] "
+    def infoString = s"$accessible_s${sym.defStringSeenAs(tpe)}"
   }
 
   case class TypeMember(
diff --git a/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala b/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala
index c0ad245091..08d84af8f5 100644
--- a/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala
+++ b/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala
@@ -16,21 +16,18 @@ private[tests] trait CoreTestDefs
     extends PresentationCompilerTestDef
     with AskCompletionAt {
 
-    def memberPrinter(member: compiler.Member): String =
-        "[accessible: %5s] ".format(member.accessible) + "`" + (member.sym.toString.trim + member.tpe.toString()).trim + "`"
-
     override def runTest() {
       askAllSources(CompletionMarker) { pos =>
         askCompletionAt(pos)
       } { (pos, members) =>
         withResponseDelimiter {
-          reporter.println("[response] aksTypeCompletion at " + format(pos))
+          reporter.println("[response] askCompletionAt " + format(pos))
           // we skip getClass because it changed signature between 1.5 and 1.6, so there is no
           // universal check file that we can provide for this to work
           reporter.println("retrieved %d members".format(members.size))
           compiler ask { () =>
             val filtered = members.filterNot(member => (member.sym.name string_== "getClass") || member.sym.isConstructor)
-            reporter.println(filtered.map(memberPrinter).sortBy(_.toString()).mkString("\n"))
+            reporter println (filtered.map(_.infoString).sorted mkString "\n")
           }
         }
       }
@@ -48,7 +45,7 @@ private[tests] trait CoreTestDefs
         askTypeAt(pos)
       } { (pos, tree) =>
         withResponseDelimiter {
-          reporter.println("[response] askTypeAt at " + format(pos))
+          reporter.println("[response] askTypeAt " + format(pos))
           compiler.ask(() => reporter.println(tree))
         }
       }
diff --git a/test/files/presentation/callcc-interpreter.check b/test/files/presentation/callcc-interpreter.check
index 804b365101..59c841a255 100644
--- a/test/files/presentation/callcc-interpreter.check
+++ b/test/files/presentation/callcc-interpreter.check
@@ -2,91 +2,91 @@ reload: CallccInterpreter.scala
 
 askTypeCompletion at CallccInterpreter.scala(51,38)
 ================================================================================
-[response] aksTypeCompletion at (51,38)
+[response] askCompletionAt (51,38)
 retrieved 63 members
-[accessible:  true] `class AddcallccInterpreter.Add`
-[accessible:  true] `class AppcallccInterpreter.App`
-[accessible:  true] `class CcccallccInterpreter.Ccc`
-[accessible:  true] `class ConcallccInterpreter.Con`
-[accessible:  true] `class FuncallccInterpreter.Fun`
-[accessible:  true] `class LamcallccInterpreter.Lam`
-[accessible:  true] `class McallccInterpreter.M`
-[accessible:  true] `class NumcallccInterpreter.Num`
-[accessible:  true] `class VarcallccInterpreter.Var`
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(callccInterpreter.type, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method add(a: callccInterpreter.Value, b: callccInterpreter.Value)callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value]`
-[accessible:  true] `method apply(a: callccInterpreter.Value, b: callccInterpreter.Value)callccInterpreter.M[callccInterpreter.Value]`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method callCC[A](h: (A => callccInterpreter.M[A]) => callccInterpreter.M[A])callccInterpreter.M[A]`
-[accessible:  true] `method clone()Object`
-[accessible:  true] `method ensuring(cond: Boolean)callccInterpreter.type`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)callccInterpreter.type`
-[accessible:  true] `method ensuring(cond: callccInterpreter.type => Boolean)callccInterpreter.type`
-[accessible:  true] `method ensuring(cond: callccInterpreter.type => Boolean, msg: => Any)callccInterpreter.type`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method finalize()Unit`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method id[A]=> A => A`
-[accessible:  true] `method interp(t: callccInterpreter.Term, e: callccInterpreter.Environment)callccInterpreter.M[callccInterpreter.Value]`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method lookup(x: callccInterpreter.Name, e: callccInterpreter.Environment)callccInterpreter.M[callccInterpreter.Value]`
-[accessible:  true] `method main(args: Array[String])Unit`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method showM(m: callccInterpreter.M[callccInterpreter.Value])String`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method test(t: callccInterpreter.Term)String`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method unitM[A](a: A)callccInterpreter.M[A]`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(callccInterpreter.type, B)`
-[accessible:  true] `object WrongcallccInterpreter.Wrong.type`
-[accessible:  true] `trait TermcallccInterpreter.Term`
-[accessible:  true] `trait ValuecallccInterpreter.Value`
-[accessible:  true] `type AnswercallccInterpreter.Answer`
-[accessible:  true] `type EnvironmentcallccInterpreter.Environment`
-[accessible:  true] `type NamecallccInterpreter.Name`
-[accessible:  true] `value __leftOfArrowcallccInterpreter.type`
-[accessible:  true] `value __resultOfEnsuringcallccInterpreter.type`
-[accessible:  true] `value __stringToFormatcallccInterpreter.type`
-[accessible:  true] `value __thingToAddcallccInterpreter.type`
-[accessible:  true] `value term0callccInterpreter.App`
-[accessible:  true] `value term1callccInterpreter.App`
-[accessible:  true] `value term2callccInterpreter.Add`
+abstract trait Term extends AnyRef
+abstract trait Value extends AnyRef
+case class Add extends callccInterpreter.Term with Product with Serializable
+case class App extends callccInterpreter.Term with Product with Serializable
+case class Ccc extends callccInterpreter.Term with Product with Serializable
+case class Con extends callccInterpreter.Term with Product with Serializable
+case class Fun extends callccInterpreter.Value with Product with Serializable
+case class Lam extends callccInterpreter.Term with Product with Serializable
+case class M[A] extends Product with Serializable
+case class Num extends callccInterpreter.Value with Product with Serializable
+case class Var extends callccInterpreter.Term with Product with Serializable
+case object Wrong
+def +(other: String): String
+def ->[B](y: B): (callccInterpreter.type, B)
+def add(a: callccInterpreter.Value,b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value]
+def apply(a: callccInterpreter.Value,b: callccInterpreter.Value): callccInterpreter.M[callccInterpreter.Value]
+def callCC[A](h: (A => callccInterpreter.M[A]) => callccInterpreter.M[A]): callccInterpreter.M[A]
+def ensuring(cond: Boolean): callccInterpreter.type
+def ensuring(cond: Boolean,msg: => Any): callccInterpreter.type
+def ensuring(cond: callccInterpreter.type => Boolean): callccInterpreter.type
+def ensuring(cond: callccInterpreter.type => Boolean,msg: => Any): callccInterpreter.type
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def id[A]: A => A
+def interp(t: callccInterpreter.Term,e: callccInterpreter.Environment): callccInterpreter.M[callccInterpreter.Value]
+def lookup(x: callccInterpreter.Name,e: callccInterpreter.Environment): callccInterpreter.M[callccInterpreter.Value]
+def main(args: Array[String]): Unit
+def showM(m: callccInterpreter.M[callccInterpreter.Value]): String
+def test(t: callccInterpreter.Term): String
+def toString(): String
+def unitM[A](a: A): callccInterpreter.M[A]
+def →[B](y: B): (callccInterpreter.type, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: callccInterpreter.type
+private[this] val __resultOfEnsuring: callccInterpreter.type
+private[this] val __stringToFormat: callccInterpreter.type
+private[this] val __thingToAdd: callccInterpreter.type
+private[this] val term0: callccInterpreter.App
+private[this] val term1: callccInterpreter.App
+private[this] val term2: callccInterpreter.Add
+protected[package lang] def clone(): Object
+protected[package lang] def finalize(): Unit
+type Answer = callccInterpreter.Answer
+type Environment = callccInterpreter.Environment
+type Name = callccInterpreter.Name
 ================================================================================
 
 askType at CallccInterpreter.scala(14,21)
 ================================================================================
-[response] askTypeAt at (14,21)
+[response] askTypeAt (14,21)
 def unitM[A](a: A): callccInterpreter.M[A] = callccInterpreter.this.M.apply[A](((c: A => callccInterpreter.Answer) => c.apply(a)))
 ================================================================================
 
 askType at CallccInterpreter.scala(16,12)
 ================================================================================
-[response] askTypeAt at (16,12)
+[response] askTypeAt (16,12)
 def id[A]: A => A = ((x: A) => x)
 ================================================================================
 
 askType at CallccInterpreter.scala(17,25)
 ================================================================================
-[response] askTypeAt at (17,25)
+[response] askTypeAt (17,25)
 def showM(m: callccInterpreter.M[callccInterpreter.Value]): String = m.in.apply(callccInterpreter.this.id[callccInterpreter.Value]).toString()
 ================================================================================
 
 askType at CallccInterpreter.scala(50,30)
 ================================================================================
-[response] askTypeAt at (50,30)
+[response] askTypeAt (50,30)
 def add(a: callccInterpreter.Value, b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value] = scala.this.Predef.Pair.apply[callccInterpreter.Value, callccInterpreter.Value](a, b) match {
   case scala.this.Predef.Pair.unapply[callccInterpreter.Value, callccInterpreter.Value](<unapply-selector>) <unapply> ((n: Int)callccInterpreter.Num((m @ _)), (n: Int)callccInterpreter.Num((n @ _))) => this.unitM[callccInterpreter.Num](callccInterpreter.this.Num.apply(m.+(n)))
   case _ => callccInterpreter.this.unitM[callccInterpreter.Wrong.type](callccInterpreter.this.Wrong)
diff --git a/test/files/presentation/ide-bug-1000349.check b/test/files/presentation/ide-bug-1000349.check
index 0040300083..b15486f4ac 100644
--- a/test/files/presentation/ide-bug-1000349.check
+++ b/test/files/presentation/ide-bug-1000349.check
@@ -2,39 +2,39 @@ reload: CompletionOnEmptyArgMethod.scala
 
 askTypeCompletion at CompletionOnEmptyArgMethod.scala(2,17)
 ================================================================================
-[response] aksTypeCompletion at (2,17)
+[response] askCompletionAt (2,17)
 retrieved 36 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(Foo, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method clone()Object`
-[accessible:  true] `method ensuring(cond: Boolean)Foo`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)Foo`
-[accessible:  true] `method ensuring(cond: Foo => Boolean)Foo`
-[accessible:  true] `method ensuring(cond: Foo => Boolean, msg: => Any)Foo`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method finalize()Unit`
-[accessible:  true] `method foo=> Foo`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(Foo, B)`
-[accessible:  true] `value __leftOfArrowFoo`
-[accessible:  true] `value __resultOfEnsuringFoo`
-[accessible:  true] `value __stringToFormatFoo`
-[accessible:  true] `value __thingToAddFoo`
+def +(other: String): String
+def ->[B](y: B): (Foo, B)
+def ensuring(cond: Boolean): Foo
+def ensuring(cond: Boolean,msg: => Any): Foo
+def ensuring(cond: Foo => Boolean): Foo
+def ensuring(cond: Foo => Boolean,msg: => Any): Foo
+def equals(x$1: Any): Boolean
+def foo: Foo
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def toString(): String
+def →[B](y: B): (Foo, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: Foo
+private[this] val __resultOfEnsuring: Foo
+private[this] val __stringToFormat: Foo
+private[this] val __thingToAdd: Foo
+protected[package lang] def clone(): Object
+protected[package lang] def finalize(): Unit
 ================================================================================
diff --git a/test/files/presentation/ide-bug-1000475.check b/test/files/presentation/ide-bug-1000475.check
index 7866e4af15..e4b8508846 100644
--- a/test/files/presentation/ide-bug-1000475.check
+++ b/test/files/presentation/ide-bug-1000475.check
@@ -2,114 +2,114 @@ reload: Foo.scala
 
 askTypeCompletion at Foo.scala(3,7)
 ================================================================================
-[response] aksTypeCompletion at (3,7)
+[response] askCompletionAt (3,7)
 retrieved 35 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(Object, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)Object`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)Object`
-[accessible:  true] `method ensuring(cond: Object => Boolean)Object`
-[accessible:  true] `method ensuring(cond: Object => Boolean, msg: => Any)Object`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(Object, B)`
-[accessible:  true] `value __leftOfArrowObject`
-[accessible:  true] `value __resultOfEnsuringObject`
-[accessible:  true] `value __stringToFormatObject`
-[accessible:  true] `value __thingToAddObject`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (Object, B)
+def ensuring(cond: Boolean): Object
+def ensuring(cond: Boolean,msg: => Any): Object
+def ensuring(cond: Object => Boolean): Object
+def ensuring(cond: Object => Boolean,msg: => Any): Object
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def toString(): String
+def →[B](y: B): (Object, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: Object
+private[this] val __resultOfEnsuring: Object
+private[this] val __stringToFormat: Object
+private[this] val __thingToAdd: Object
 ================================================================================
 
 askTypeCompletion at Foo.scala(6,10)
 ================================================================================
-[response] aksTypeCompletion at (6,10)
+[response] askCompletionAt (6,10)
 retrieved 35 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(Object, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)Object`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)Object`
-[accessible:  true] `method ensuring(cond: Object => Boolean)Object`
-[accessible:  true] `method ensuring(cond: Object => Boolean, msg: => Any)Object`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(Object, B)`
-[accessible:  true] `value __leftOfArrowObject`
-[accessible:  true] `value __resultOfEnsuringObject`
-[accessible:  true] `value __stringToFormatObject`
-[accessible:  true] `value __thingToAddObject`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (Object, B)
+def ensuring(cond: Boolean): Object
+def ensuring(cond: Boolean,msg: => Any): Object
+def ensuring(cond: Object => Boolean): Object
+def ensuring(cond: Object => Boolean,msg: => Any): Object
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def toString(): String
+def →[B](y: B): (Object, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: Object
+private[this] val __resultOfEnsuring: Object
+private[this] val __stringToFormat: Object
+private[this] val __thingToAdd: Object
 ================================================================================
 
 askTypeCompletion at Foo.scala(7,7)
 ================================================================================
-[response] aksTypeCompletion at (7,7)
+[response] askCompletionAt (7,7)
 retrieved 35 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(Object, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)Object`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)Object`
-[accessible:  true] `method ensuring(cond: Object => Boolean)Object`
-[accessible:  true] `method ensuring(cond: Object => Boolean, msg: => Any)Object`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(Object, B)`
-[accessible:  true] `value __leftOfArrowObject`
-[accessible:  true] `value __resultOfEnsuringObject`
-[accessible:  true] `value __stringToFormatObject`
-[accessible:  true] `value __thingToAddObject`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (Object, B)
+def ensuring(cond: Boolean): Object
+def ensuring(cond: Boolean,msg: => Any): Object
+def ensuring(cond: Object => Boolean): Object
+def ensuring(cond: Object => Boolean,msg: => Any): Object
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def toString(): String
+def →[B](y: B): (Object, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: Object
+private[this] val __resultOfEnsuring: Object
+private[this] val __stringToFormat: Object
+private[this] val __thingToAdd: Object
 ================================================================================
diff --git a/test/files/presentation/ide-bug-1000531.check b/test/files/presentation/ide-bug-1000531.check
index 18ecd4b536..980bb0a25d 100644
--- a/test/files/presentation/ide-bug-1000531.check
+++ b/test/files/presentation/ide-bug-1000531.check
@@ -2,127 +2,127 @@ reload: CrashOnLoad.scala
 
 askTypeCompletion at CrashOnLoad.scala(6,12)
 ================================================================================
-[response] aksTypeCompletion at (6,12)
+[response] askCompletionAt (6,12)
 retrieved 124 members
-[accessible:  true] `class GroupedIteratorIterator[B]#GroupedIterator`
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ++[B >: B](that: => scala.collection.GenTraversableOnce[B])Iterator[B]`
-[accessible:  true] `method ->[B](y: B)(java.util.Iterator[B], B)`
-[accessible:  true] `method /:[B](z: B)(op: (B, B) => B)B`
-[accessible:  true] `method :\[B](z: B)(op: (B, B) => B)B`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method addString(b: StringBuilder)StringBuilder`
-[accessible:  true] `method addString(b: StringBuilder, sep: String)StringBuilder`
-[accessible:  true] `method addString(b: StringBuilder, start: String, sep: String, end: String)StringBuilder`
-[accessible:  true] `method aggregate[B](z: => B)(seqop: (B, B) => B, combop: (B, B) => B)B`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method buffered=> scala.collection.BufferedIterator[B]`
-[accessible:  true] `method collectFirst[B](pf: PartialFunction[B,B])Option[B]`
-[accessible:  true] `method collect[B](pf: PartialFunction[B,B])Iterator[B]`
-[accessible:  true] `method contains(elem: Any)Boolean`
-[accessible:  true] `method copyToArray[B >: B](xs: Array[B])Unit`
-[accessible:  true] `method copyToArray[B >: B](xs: Array[B], start: Int)Unit`
-[accessible:  true] `method copyToArray[B >: B](xs: Array[B], start: Int, len: Int)Unit`
-[accessible:  true] `method copyToBuffer[B >: B](dest: scala.collection.mutable.Buffer[B])Unit`
-[accessible:  true] `method corresponds[B](that: scala.collection.GenTraversableOnce[B])(p: (B, B) => Boolean)Boolean`
-[accessible:  true] `method count(p: B => Boolean)Int`
-[accessible:  true] `method drop(n: Int)Iterator[B]`
-[accessible:  true] `method dropWhile(p: B => Boolean)Iterator[B]`
-[accessible:  true] `method duplicate=> (Iterator[B], Iterator[B])`
-[accessible:  true] `method ensuring(cond: Boolean)java.util.Iterator[B]`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)java.util.Iterator[B]`
-[accessible:  true] `method ensuring(cond: java.util.Iterator[B] => Boolean)java.util.Iterator[B]`
-[accessible:  true] `method ensuring(cond: java.util.Iterator[B] => Boolean, msg: => Any)java.util.Iterator[B]`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method exists(p: B => Boolean)Boolean`
-[accessible:  true] `method filter(p: B => Boolean)Iterator[B]`
-[accessible:  true] `method filterNot(p: B => Boolean)Iterator[B]`
-[accessible:  true] `method find(p: B => Boolean)Option[B]`
-[accessible:  true] `method flatMap[B](f: B => scala.collection.GenTraversableOnce[B])Iterator[B]`
-[accessible:  true] `method foldLeft[B](z: B)(op: (B, B) => B)B`
-[accessible:  true] `method foldRight[B](z: B)(op: (B, B) => B)B`
-[accessible:  true] `method fold[A1 >: B](z: A1)(op: (A1, A1) => A1)A1`
-[accessible:  true] `method forall(p: B => Boolean)Boolean`
-[accessible:  true] `method foreach[U](f: B => U)Unit`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method grouped[B >: B](size: Int)Iterator[B]#GroupedIterator[B]`
-[accessible:  true] `method hasDefiniteSize=> Boolean`
-[accessible:  true] `method hasNext()Boolean`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method indexOf[B >: B](elem: B)Int`
-[accessible:  true] `method indexWhere(p: B => Boolean)Int`
-[accessible:  true] `method isEmpty=> Boolean`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method isTraversableAgain=> Boolean`
-[accessible:  true] `method length=> Int`
-[accessible:  true] `method map[B](f: B => B)Iterator[B]`
-[accessible:  true] `method maxBy[B](f: B => B)(implicit cmp: Ordering[B])B`
-[accessible:  true] `method max[B >: B](implicit cmp: Ordering[B])B`
-[accessible:  true] `method minBy[B](f: B => B)(implicit cmp: Ordering[B])B`
-[accessible:  true] `method min[B >: B](implicit cmp: Ordering[B])B`
-[accessible:  true] `method mkString(sep: String)String`
-[accessible:  true] `method mkString(start: String, sep: String, end: String)String`
-[accessible:  true] `method mkString=> String`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method next()B`
-[accessible:  true] `method nonEmpty=> Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method padTo[A1 >: B](len: Int, elem: A1)Iterator[A1]`
-[accessible:  true] `method partition(p: B => Boolean)(Iterator[B], Iterator[B])`
-[accessible:  true] `method patch[B >: B](from: Int, patchElems: Iterator[B], replaced: Int)Iterator[B]`
-[accessible:  true] `method product[B >: B](implicit num: Numeric[B])B`
-[accessible:  true] `method reduceLeftOption[B >: B](op: (B, B) => B)Option[B]`
-[accessible:  true] `method reduceLeft[B >: B](op: (B, B) => B)B`
-[accessible:  true] `method reduceOption[A1 >: B](op: (A1, A1) => A1)Option[A1]`
-[accessible:  true] `method reduceRightOption[B >: B](op: (B, B) => B)Option[B]`
-[accessible:  true] `method reduceRight[B >: B](op: (B, B) => B)B`
-[accessible:  true] `method reduce[A1 >: B](op: (A1, A1) => A1)A1`
-[accessible:  true] `method remove()Unit`
-[accessible:  true] `method sameElements(that: Iterator[_])Boolean`
-[accessible:  true] `method scanLeft[B](z: B)(op: (B, B) => B)Iterator[B]`
-[accessible:  true] `method scanRight[B](z: B)(op: (B, B) => B)Iterator[B]`
-[accessible:  true] `method seq=> Iterator[B]`
-[accessible:  true] `method size=> Int`
-[accessible:  true] `method slice(from: Int, until: Int)Iterator[B]`
-[accessible:  true] `method sliding[B >: B](size: Int, step: Int)Iterator[B]#GroupedIterator[B]`
-[accessible:  true] `method span(p: B => Boolean)(Iterator[B], Iterator[B])`
-[accessible:  true] `method sum[B >: B](implicit num: Numeric[B])B`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method take(n: Int)Iterator[B]`
-[accessible:  true] `method takeWhile(p: B => Boolean)Iterator[B]`
-[accessible:  true] `method toArray[B >: B](implicit evidence$1: scala.reflect.ClassTag[B])Array[B]`
-[accessible:  true] `method toBuffer[B >: B]=> scala.collection.mutable.Buffer[B]`
-[accessible:  true] `method toIndexedSeq=> scala.collection.immutable.IndexedSeq[B]`
-[accessible:  true] `method toIterable=> Iterable[B]`
-[accessible:  true] `method toIterator=> Iterator[B]`
-[accessible:  true] `method toList=> List[B]`
-[accessible:  true] `method toMap[T, U](implicit ev: <:<[B,(T, U)])scala.collection.immutable.Map[T,U]`
-[accessible:  true] `method toSeq=> Seq[B]`
-[accessible:  true] `method toSet[B >: B]=> scala.collection.immutable.Set[B]`
-[accessible:  true] `method toStream=> scala.collection.immutable.Stream[B]`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method toTraversable=> Traversable[B]`
-[accessible:  true] `method toVector=> Vector[B]`
-[accessible:  true] `method to[Col[_]](implicit cbf: scala.collection.generic.CanBuildFrom[Nothing,B,Col[B]])Col[B]`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method withFilter(p: B => Boolean)Iterator[B]`
-[accessible:  true] `method zipAll[B, A1 >: B, B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1)Iterator[(A1, B1)]`
-[accessible:  true] `method zipWithIndex=> Iterator[(B, Int)]`
-[accessible:  true] `method zip[B](that: Iterator[B])Iterator[(B, B)]`
-[accessible:  true] `method →[B](y: B)(java.util.Iterator[B], B)`
-[accessible:  true] `value __leftOfArrowjava.util.Iterator[B]`
-[accessible:  true] `value __resultOfEnsuringjava.util.Iterator[B]`
-[accessible:  true] `value __stringToFormatjava.util.Iterator[B]`
-[accessible:  true] `value __thingToAddjava.util.Iterator[B]`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
-[accessible: false] `method reversed=> List[B]`
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+[inaccessible] protected[this] def reversed: List[B]
+class GroupedIterator[B <: <?>] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]]
+def +(other: String): String
+def ++[B >: B](that: => scala.collection.GenTraversableOnce[B]): Iterator[B]
+def ->[B](y: B): (java.util.Iterator[B], B)
+def /:[B](z: B)(op: (B, B) => B): B
+def :\[B](z: B)(op: (B, B) => B): B
+def addString(b: StringBuilder): StringBuilder
+def addString(b: StringBuilder,sep: String): StringBuilder
+def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder
+def aggregate[B](z: => B)(seqop: (B, B) => B,combop: (B, B) => B): B
+def buffered: scala.collection.BufferedIterator[B]
+def collectFirst[B](pf: PartialFunction[B,B]): Option[B]
+def collect[B](pf: PartialFunction[B,B]): Iterator[B]
+def contains(elem: Any): Boolean
+def copyToArray[B >: B](xs: Array[B]): Unit
+def copyToArray[B >: B](xs: Array[B],start: Int): Unit
+def copyToArray[B >: B](xs: Array[B],start: Int,len: Int): Unit
+def copyToBuffer[B >: B](dest: scala.collection.mutable.Buffer[B]): Unit
+def corresponds[B](that: scala.collection.GenTraversableOnce[B])(p: (B, B) => Boolean): Boolean
+def count(p: B => Boolean): Int
+def drop(n: Int): Iterator[B]
+def dropWhile(p: B => Boolean): Iterator[B]
+def duplicate: (Iterator[B], Iterator[B])
+def ensuring(cond: Boolean): java.util.Iterator[B]
+def ensuring(cond: Boolean,msg: => Any): java.util.Iterator[B]
+def ensuring(cond: java.util.Iterator[B] => Boolean): java.util.Iterator[B]
+def ensuring(cond: java.util.Iterator[B] => Boolean,msg: => Any): java.util.Iterator[B]
+def equals(x$1: Any): Boolean
+def exists(p: B => Boolean): Boolean
+def filter(p: B => Boolean): Iterator[B]
+def filterNot(p: B => Boolean): Iterator[B]
+def find(p: B => Boolean): Option[B]
+def flatMap[B](f: B => scala.collection.GenTraversableOnce[B]): Iterator[B]
+def foldLeft[B](z: B)(op: (B, B) => B): B
+def foldRight[B](z: B)(op: (B, B) => B): B
+def fold[A1 >: B](z: A1)(op: (A1, A1) => A1): A1
+def forall(p: B => Boolean): Boolean
+def foreach[U](f: B => U): Unit
+def formatted(fmtstr: String): String
+def grouped[B >: B](size: Int): Iterator[B]#GroupedIterator[B]
+def hasDefiniteSize: Boolean
+def hasNext(): Boolean
+def hashCode(): Int
+def indexOf[B >: B](elem: B): Int
+def indexWhere(p: B => Boolean): Int
+def isEmpty: Boolean
+def isTraversableAgain: Boolean
+def length: Int
+def map[B](f: B => B): Iterator[B]
+def maxBy[B](f: B => B)(implicit cmp: Ordering[B]): B
+def max[B >: B](implicit cmp: Ordering[B]): B
+def minBy[B](f: B => B)(implicit cmp: Ordering[B]): B
+def min[B >: B](implicit cmp: Ordering[B]): B
+def mkString(sep: String): String
+def mkString(start: String,sep: String,end: String): String
+def mkString: String
+def next(): B
+def nonEmpty: Boolean
+def padTo[A1 >: B](len: Int,elem: A1): Iterator[A1]
+def partition(p: B => Boolean): (Iterator[B], Iterator[B])
+def patch[B >: B](from: Int,patchElems: Iterator[B],replaced: Int): Iterator[B]
+def product[B >: B](implicit num: Numeric[B]): B
+def reduceLeftOption[B >: B](op: (B, B) => B): Option[B]
+def reduceLeft[B >: B](op: (B, B) => B): B
+def reduceOption[A1 >: B](op: (A1, A1) => A1): Option[A1]
+def reduceRightOption[B >: B](op: (B, B) => B): Option[B]
+def reduceRight[B >: B](op: (B, B) => B): B
+def reduce[A1 >: B](op: (A1, A1) => A1): A1
+def remove(): Unit
+def sameElements(that: Iterator[_]): Boolean
+def scanLeft[B](z: B)(op: (B, B) => B): Iterator[B]
+def scanRight[B](z: B)(op: (B, B) => B): Iterator[B]
+def seq: Iterator[B]
+def size: Int
+def slice(from: Int,until: Int): Iterator[B]
+def sliding[B >: B](size: Int,step: Int): Iterator[B]#GroupedIterator[B]
+def span(p: B => Boolean): (Iterator[B], Iterator[B])
+def sum[B >: B](implicit num: Numeric[B]): B
+def take(n: Int): Iterator[B]
+def takeWhile(p: B => Boolean): Iterator[B]
+def toArray[B >: B](implicit evidence$1: scala.reflect.ClassTag[B]): Array[B]
+def toBuffer[B >: B]: scala.collection.mutable.Buffer[B]
+def toIndexedSeq: scala.collection.immutable.IndexedSeq[B]
+def toIterable: Iterable[B]
+def toIterator: Iterator[B]
+def toList: List[B]
+def toMap[T, U](implicit ev: <:<[B,(T, U)]): scala.collection.immutable.Map[T,U]
+def toSeq: Seq[B]
+def toSet[B >: B]: scala.collection.immutable.Set[B]
+def toStream: scala.collection.immutable.Stream[B]
+def toString(): String
+def toTraversable: Traversable[B]
+def toVector: Vector[B]
+def to[Col[_]](implicit cbf: scala.collection.generic.CanBuildFrom[Nothing,B,Col[B]]): Col[B]
+def withFilter(p: B => Boolean): Iterator[B]
+def zipAll[B, A1 >: B, B1 >: B](that: Iterator[B],thisElem: A1,thatElem: B1): Iterator[(A1, B1)]
+def zipWithIndex: Iterator[(B, Int)]
+def zip[B](that: Iterator[B]): Iterator[(B, B)]
+def →[B](y: B): (java.util.Iterator[B], B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: java.util.Iterator[B]
+private[this] val __resultOfEnsuring: java.util.Iterator[B]
+private[this] val __stringToFormat: java.util.Iterator[B]
+private[this] val __thingToAdd: java.util.Iterator[B]
 ================================================================================
diff --git a/test/files/presentation/implicit-member.check b/test/files/presentation/implicit-member.check
index 6a23facc78..92d8e38abe 100644
--- a/test/files/presentation/implicit-member.check
+++ b/test/files/presentation/implicit-member.check
@@ -2,41 +2,41 @@ reload: ImplicitMember.scala
 
 askTypeCompletion at ImplicitMember.scala(7,7)
 ================================================================================
-[response] aksTypeCompletion at (7,7)
+[response] askCompletionAt (7,7)
 retrieved 38 members
-[accessible:  true] `class AppliedImplicitImplicit.AppliedImplicit`
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(Implicit.type, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method AppliedImplicit[A](x: A)Implicit.AppliedImplicit[A]`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method clone()Object`
-[accessible:  true] `method ensuring(cond: Boolean)Implicit.type`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)Implicit.type`
-[accessible:  true] `method ensuring(cond: Implicit.type => Boolean)Implicit.type`
-[accessible:  true] `method ensuring(cond: Implicit.type => Boolean, msg: => Any)Implicit.type`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method finalize()Unit`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(Implicit.type, B)`
-[accessible:  true] `value __leftOfArrowImplicit.type`
-[accessible:  true] `value __resultOfEnsuringImplicit.type`
-[accessible:  true] `value __stringToFormatImplicit.type`
-[accessible:  true] `value __thingToAddImplicit.type`
-[accessible:  true] `value xImplicit.type`
+def +(other: String): String
+def ->[B](y: B): (Implicit.type, B)
+def ensuring(cond: Boolean): Implicit.type
+def ensuring(cond: Boolean,msg: => Any): Implicit.type
+def ensuring(cond: Implicit.type => Boolean): Implicit.type
+def ensuring(cond: Implicit.type => Boolean,msg: => Any): Implicit.type
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def toString(): String
+def →[B](y: B): (Implicit.type, B)
+final class AppliedImplicit[A <: <?>] extends AnyRef
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+implicit def AppliedImplicit[A](x: A): Implicit.AppliedImplicit[A]
+private[this] val __leftOfArrow: Implicit.type
+private[this] val __resultOfEnsuring: Implicit.type
+private[this] val __stringToFormat: Implicit.type
+private[this] val __thingToAdd: Implicit.type
+private[this] val x: Implicit.type
+protected[package lang] def clone(): Object
+protected[package lang] def finalize(): Unit
 ================================================================================
diff --git a/test/files/presentation/ping-pong.check b/test/files/presentation/ping-pong.check
index c7a5d0b5d1..be80601e11 100644
--- a/test/files/presentation/ping-pong.check
+++ b/test/files/presentation/ping-pong.check
@@ -2,101 +2,101 @@ reload: PingPong.scala
 
 askTypeCompletion at PingPong.scala(10,23)
 ================================================================================
-[response] aksTypeCompletion at (10,23)
+[response] askCompletionAt (10,23)
 retrieved 39 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(Pong, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)Pong`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)Pong`
-[accessible:  true] `method ensuring(cond: Pong => Boolean)Pong`
-[accessible:  true] `method ensuring(cond: Pong => Boolean, msg: => Any)Pong`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method poke()Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(Pong, B)`
-[accessible:  true] `value __leftOfArrowPong`
-[accessible:  true] `value __resultOfEnsuringPong`
-[accessible:  true] `value __stringToFormatPong`
-[accessible:  true] `value __thingToAddPong`
-[accessible:  true] `value nameString`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
-[accessible: false] `value pingPing`
+[inaccessible] private[this] val ping: Ping
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (Pong, B)
+def ensuring(cond: Boolean): Pong
+def ensuring(cond: Boolean,msg: => Any): Pong
+def ensuring(cond: Pong => Boolean): Pong
+def ensuring(cond: Pong => Boolean,msg: => Any): Pong
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def poke(): Unit
+def →[B](y: B): (Pong, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+override def toString(): String
+private[this] val __leftOfArrow: Pong
+private[this] val __resultOfEnsuring: Pong
+private[this] val __stringToFormat: Pong
+private[this] val __thingToAdd: Pong
+private[this] val name: String
 ================================================================================
 
 askTypeCompletion at PingPong.scala(19,20)
 ================================================================================
-[response] aksTypeCompletion at (19,20)
+[response] askCompletionAt (19,20)
 retrieved 39 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(Ping, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)Ping`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)Ping`
-[accessible:  true] `method ensuring(cond: Ping => Boolean)Ping`
-[accessible:  true] `method ensuring(cond: Ping => Boolean, msg: => Any)Ping`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method loop=> Unit`
-[accessible:  true] `method name=> String`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method poke=> Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(Ping, B)`
-[accessible:  true] `value __leftOfArrowPing`
-[accessible:  true] `value __resultOfEnsuringPing`
-[accessible:  true] `value __stringToFormatPing`
-[accessible:  true] `value __thingToAddPing`
-[accessible:  true] `value pongPong`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (Ping, B)
+def ensuring(cond: Boolean): Ping
+def ensuring(cond: Boolean,msg: => Any): Ping
+def ensuring(cond: Ping => Boolean): Ping
+def ensuring(cond: Ping => Boolean,msg: => Any): Ping
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def loop: Unit
+def name: String
+def poke: Unit
+def →[B](y: B): (Ping, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+override def toString(): String
+private[this] val __leftOfArrow: Ping
+private[this] val __resultOfEnsuring: Ping
+private[this] val __stringToFormat: Ping
+private[this] val __thingToAdd: Ping
+private[this] val pong: Pong
 ================================================================================
 
 askType at PingPong.scala(8,10)
 ================================================================================
-[response] askTypeAt at (8,10)
+[response] askTypeAt (8,10)
 def loop: Unit = Ping.this.poke()
 ================================================================================
 
 askType at PingPong.scala(10,10)
 ================================================================================
-[response] askTypeAt at (10,10)
+[response] askTypeAt (10,10)
 def poke: Unit = Ping.this.pong.poke()
 ================================================================================
 
 askType at PingPong.scala(17,10)
 ================================================================================
-[response] askTypeAt at (17,10)
+[response] askTypeAt (17,10)
 private[this] val name: String = "pong"
 ================================================================================
diff --git a/test/files/presentation/random.check b/test/files/presentation/random.check
index fce4b69fb3..fb3500aeea 100644
--- a/test/files/presentation/random.check
+++ b/test/files/presentation/random.check
@@ -2,7 +2,7 @@ reload: Random.scala
 
 askType at Random.scala(18,14)
 ================================================================================
-[response] askTypeAt at (18,14)
+[response] askTypeAt (18,14)
 val filter: Int => Boolean = try {
   java.this.lang.Integer.parseInt(args.apply(0)) match {
     case 1 => ((x: Int) => x.%(2).!=(0))
@@ -16,12 +16,12 @@ val filter: Int => Boolean = try {
 
 askType at Random.scala(19,30)
 ================================================================================
-[response] askTypeAt at (19,30)
+[response] askTypeAt (19,30)
 0
 ================================================================================
 
 askType at Random.scala(26,12)
 ================================================================================
-[response] askTypeAt at (26,12)
+[response] askTypeAt (26,12)
 _
 ================================================================================
diff --git a/test/files/presentation/t1207.check b/test/files/presentation/t1207.check
index 0ff7dbcd1e..84bfd79d75 100644
--- a/test/files/presentation/t1207.check
+++ b/test/files/presentation/t1207.check
@@ -2,52 +2,52 @@ reload: Completions.scala
 
 askTypeCompletion at Completions.scala(10,15)
 ================================================================================
-[response] aksTypeCompletion at (10,15)
+[response] askCompletionAt (10,15)
 retrieved 3 members
-[accessible:  true] `package bongoother.bongo.type`
-[accessible:  true] `package langother.lang.type`
-[accessible:  true] `package utilother.util.type`
+final package bongo
+final package lang
+final package util
 ================================================================================
 
 askTypeCompletion at Completions.scala(11,16)
 ================================================================================
-[response] aksTypeCompletion at (11,16)
+[response] askCompletionAt (11,16)
 retrieved 3 members
-[accessible:  true] `package bongoother.bongo.type`
-[accessible:  true] `package langother.lang.type`
-[accessible:  true] `package utilother.util.type`
+final package bongo
+final package lang
+final package util
 ================================================================================
 
 askTypeCompletion at Completions.scala(12,19)
 ================================================================================
-[response] aksTypeCompletion at (12,19)
+[response] askCompletionAt (12,19)
 retrieved 3 members
-[accessible:  true] `package bongoother.bongo.type`
-[accessible:  true] `package langother.lang.type`
-[accessible:  true] `package utilother.util.type`
+final package bongo
+final package lang
+final package util
 ================================================================================
 
 askTypeCompletion at Completions.scala(13,19)
 ================================================================================
-[response] aksTypeCompletion at (13,19)
+[response] askCompletionAt (13,19)
 retrieved 3 members
-[accessible:  true] `package bongoother.bongo.type`
-[accessible:  true] `package langother.lang.type`
-[accessible:  true] `package utilother.util.type`
+final package bongo
+final package lang
+final package util
 ================================================================================
 
 askTypeCompletion at Completions.scala(14,23)
 ================================================================================
-[response] aksTypeCompletion at (14,23)
+[response] askCompletionAt (14,23)
 retrieved 3 members
-[accessible:  true] `package bongoother.bongo.type`
-[accessible:  true] `package langother.lang.type`
-[accessible:  true] `package utilother.util.type`
+final package bongo
+final package lang
+final package util
 ================================================================================
 
 askTypeCompletion at Completions.scala(15,10)
 ================================================================================
-[response] aksTypeCompletion at (15,10)
+[response] askCompletionAt (15,10)
 retrieved 0 members
 
 ================================================================================
diff --git a/test/files/presentation/t5708.check b/test/files/presentation/t5708.check
index 4fc7a56426..b2cedd689f 100644
--- a/test/files/presentation/t5708.check
+++ b/test/files/presentation/t5708.check
@@ -2,46 +2,46 @@ reload: Completions.scala
 
 askTypeCompletion at Completions.scala(17,9)
 ================================================================================
-[response] aksTypeCompletion at (17,9)
+[response] askCompletionAt (17,9)
 retrieved 43 members
-[accessible:  true] `lazy value fooInt`
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(test.Compat.type, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)test.Compat.type`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)test.Compat.type`
-[accessible:  true] `method ensuring(cond: test.Compat.type => Boolean)test.Compat.type`
-[accessible:  true] `method ensuring(cond: test.Compat.type => Boolean, msg: => Any)test.Compat.type`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method pkgPrivateM=> String`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(test.Compat.type, B)`
-[accessible:  true] `value CONST_STRINGString("constant")`
-[accessible:  true] `value __leftOfArrowtest.Compat.type`
-[accessible:  true] `value __resultOfEnsuringtest.Compat.type`
-[accessible:  true] `value __stringToFormattest.Compat.type`
-[accessible:  true] `value __thingToAddtest.Compat.type`
-[accessible:  true] `value pkgPrivateVString`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
-[accessible: false] `method privateM=> String`
-[accessible: false] `method protectedValM=> String`
-[accessible: false] `value privateVString`
-[accessible: false] `value protectedVString`
+[inaccessible] private def privateM: String
+[inaccessible] private[this] val privateV: String
+[inaccessible] private[this] val protectedV: String
+[inaccessible] protected def protectedValM: String
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (test.Compat.type, B)
+def ensuring(cond: Boolean): test.Compat.type
+def ensuring(cond: Boolean,msg: => Any): test.Compat.type
+def ensuring(cond: test.Compat.type => Boolean): test.Compat.type
+def ensuring(cond: test.Compat.type => Boolean,msg: => Any): test.Compat.type
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def toString(): String
+def →[B](y: B): (test.Compat.type, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+final private[this] val CONST_STRING: String("constant")
+lazy private[this] var foo: Int
+private[package test] def pkgPrivateM: String
+private[this] val __leftOfArrow: test.Compat.type
+private[this] val __resultOfEnsuring: test.Compat.type
+private[this] val __stringToFormat: test.Compat.type
+private[this] val __thingToAdd: test.Compat.type
+private[this] val pkgPrivateV: String
 ================================================================================
diff --git a/test/files/presentation/visibility.check b/test/files/presentation/visibility.check
index e9b349ac06..4ba7dbaad9 100644
--- a/test/files/presentation/visibility.check
+++ b/test/files/presentation/visibility.check
@@ -2,220 +2,220 @@ reload: Completions.scala
 
 askTypeCompletion at Completions.scala(14,12)
 ================================================================================
-[response] aksTypeCompletion at (14,12)
+[response] askCompletionAt (14,12)
 retrieved 41 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method clone()Object`
-[accessible:  true] `method ensuring(cond: Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method finalize()Unit`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method secretPrivate()Unit`
-[accessible:  true] `method secretProtected()Unit`
-[accessible:  true] `method secretProtectedInPackage()Unit`
-[accessible:  true] `method secretPublic()Unit`
-[accessible:  true] `method someTests(other: accessibility.Foo)Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `value __leftOfArrowaccessibility.Foo`
-[accessible:  true] `value __resultOfEnsuringaccessibility.Foo`
-[accessible:  true] `value __stringToFormataccessibility.Foo`
-[accessible:  true] `value __thingToAddaccessibility.Foo`
-[accessible: false] `method secretPrivateThis()Unit`
+[inaccessible] private[this] def secretPrivateThis(): Unit
+def +(other: String): String
+def ->[B](y: B): (accessibility.Foo, B)
+def ensuring(cond: Boolean): accessibility.Foo
+def ensuring(cond: Boolean,msg: => Any): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def secretPublic(): Unit
+def someTests(other: accessibility.Foo): Unit
+def toString(): String
+def →[B](y: B): (accessibility.Foo, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private def secretPrivate(): Unit
+private[this] val __leftOfArrow: accessibility.Foo
+private[this] val __resultOfEnsuring: accessibility.Foo
+private[this] val __stringToFormat: accessibility.Foo
+private[this] val __thingToAdd: accessibility.Foo
+protected def secretProtected(): Unit
+protected[package accessibility] def secretProtectedInPackage(): Unit
+protected[package lang] def clone(): Object
+protected[package lang] def finalize(): Unit
 ================================================================================
 
 askTypeCompletion at Completions.scala(16,11)
 ================================================================================
-[response] aksTypeCompletion at (16,11)
+[response] askCompletionAt (16,11)
 retrieved 41 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method clone()Object`
-[accessible:  true] `method ensuring(cond: Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method finalize()Unit`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method secretPrivate()Unit`
-[accessible:  true] `method secretPrivateThis()Unit`
-[accessible:  true] `method secretProtected()Unit`
-[accessible:  true] `method secretProtectedInPackage()Unit`
-[accessible:  true] `method secretPublic()Unit`
-[accessible:  true] `method someTests(other: accessibility.Foo)Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `value __leftOfArrowaccessibility.Foo`
-[accessible:  true] `value __resultOfEnsuringaccessibility.Foo`
-[accessible:  true] `value __stringToFormataccessibility.Foo`
-[accessible:  true] `value __thingToAddaccessibility.Foo`
+def +(other: String): String
+def ->[B](y: B): (accessibility.Foo, B)
+def ensuring(cond: Boolean): accessibility.Foo
+def ensuring(cond: Boolean,msg: => Any): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def secretPublic(): Unit
+def someTests(other: accessibility.Foo): Unit
+def toString(): String
+def →[B](y: B): (accessibility.Foo, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private def secretPrivate(): Unit
+private[this] def secretPrivateThis(): Unit
+private[this] val __leftOfArrow: accessibility.Foo
+private[this] val __resultOfEnsuring: accessibility.Foo
+private[this] val __stringToFormat: accessibility.Foo
+private[this] val __thingToAdd: accessibility.Foo
+protected def secretProtected(): Unit
+protected[package accessibility] def secretProtectedInPackage(): Unit
+protected[package lang] def clone(): Object
+protected[package lang] def finalize(): Unit
 ================================================================================
 
 askTypeCompletion at Completions.scala(22,11)
 ================================================================================
-[response] aksTypeCompletion at (22,11)
+[response] askCompletionAt (22,11)
 retrieved 41 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(accessibility.AccessibilityChecks, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method clone()Object`
-[accessible:  true] `method ensuring(cond: Boolean)accessibility.AccessibilityChecks`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)accessibility.AccessibilityChecks`
-[accessible:  true] `method ensuring(cond: accessibility.AccessibilityChecks => Boolean)accessibility.AccessibilityChecks`
-[accessible:  true] `method ensuring(cond: accessibility.AccessibilityChecks => Boolean, msg: => Any)accessibility.AccessibilityChecks`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method finalize()Unit`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method secretProtected()Unit`
-[accessible:  true] `method secretProtectedInPackage()Unit`
-[accessible:  true] `method secretPublic()Unit`
-[accessible:  true] `method someTests(other: accessibility.Foo)Unit`
-[accessible:  true] `method someTests=> Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(accessibility.AccessibilityChecks, B)`
-[accessible:  true] `value __leftOfArrowaccessibility.AccessibilityChecks`
-[accessible:  true] `value __resultOfEnsuringaccessibility.AccessibilityChecks`
-[accessible:  true] `value __stringToFormataccessibility.AccessibilityChecks`
-[accessible:  true] `value __thingToAddaccessibility.AccessibilityChecks`
-[accessible: false] `method secretPrivate()Unit`
+[inaccessible] private def secretPrivate(): Unit
+def +(other: String): String
+def ->[B](y: B): (accessibility.AccessibilityChecks, B)
+def ensuring(cond: Boolean): accessibility.AccessibilityChecks
+def ensuring(cond: Boolean,msg: => Any): accessibility.AccessibilityChecks
+def ensuring(cond: accessibility.AccessibilityChecks => Boolean): accessibility.AccessibilityChecks
+def ensuring(cond: accessibility.AccessibilityChecks => Boolean,msg: => Any): accessibility.AccessibilityChecks
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def secretPublic(): Unit
+def someTests(other: accessibility.Foo): Unit
+def someTests: Unit
+def toString(): String
+def →[B](y: B): (accessibility.AccessibilityChecks, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: accessibility.AccessibilityChecks
+private[this] val __resultOfEnsuring: accessibility.AccessibilityChecks
+private[this] val __stringToFormat: accessibility.AccessibilityChecks
+private[this] val __thingToAdd: accessibility.AccessibilityChecks
+protected def secretProtected(): Unit
+protected[package accessibility] def secretProtectedInPackage(): Unit
+protected[package lang] def clone(): Object
+protected[package lang] def finalize(): Unit
 ================================================================================
 
 askTypeCompletion at Completions.scala(28,10)
 ================================================================================
-[response] aksTypeCompletion at (28,10)
+[response] askCompletionAt (28,10)
 retrieved 41 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method secretProtectedInPackage()Unit`
-[accessible:  true] `method secretPublic()Unit`
-[accessible:  true] `method someTests(other: accessibility.Foo)Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `value __leftOfArrowaccessibility.Foo`
-[accessible:  true] `value __resultOfEnsuringaccessibility.Foo`
-[accessible:  true] `value __stringToFormataccessibility.Foo`
-[accessible:  true] `value __thingToAddaccessibility.Foo`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
-[accessible: false] `method secretPrivate()Unit`
-[accessible: false] `method secretPrivateThis()Unit`
-[accessible: false] `method secretProtected()Unit`
+[inaccessible] private def secretPrivate(): Unit
+[inaccessible] private[this] def secretPrivateThis(): Unit
+[inaccessible] protected def secretProtected(): Unit
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (accessibility.Foo, B)
+def ensuring(cond: Boolean): accessibility.Foo
+def ensuring(cond: Boolean,msg: => Any): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def secretPublic(): Unit
+def someTests(other: accessibility.Foo): Unit
+def toString(): String
+def →[B](y: B): (accessibility.Foo, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: accessibility.Foo
+private[this] val __resultOfEnsuring: accessibility.Foo
+private[this] val __stringToFormat: accessibility.Foo
+private[this] val __thingToAdd: accessibility.Foo
+protected[package accessibility] def secretProtectedInPackage(): Unit
 ================================================================================
 
 askTypeCompletion at Completions.scala(37,8)
 ================================================================================
-[response] aksTypeCompletion at (37,8)
+[response] askCompletionAt (37,8)
 retrieved 41 members
-[accessible:  true] `method !=(x$1: Any)Boolean`
-[accessible:  true] `method !=(x$1: AnyRef)Boolean`
-[accessible:  true] `method ##()Int`
-[accessible:  true] `method +(other: String)String`
-[accessible:  true] `method ->[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `method ==(x$1: Any)Boolean`
-[accessible:  true] `method ==(x$1: AnyRef)Boolean`
-[accessible:  true] `method asInstanceOf[T0]=> T0`
-[accessible:  true] `method ensuring(cond: Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo`
-[accessible:  true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo`
-[accessible:  true] `method eq(x$1: AnyRef)Boolean`
-[accessible:  true] `method equals(x$1: Any)Boolean`
-[accessible:  true] `method formatted(fmtstr: String)String`
-[accessible:  true] `method hashCode()Int`
-[accessible:  true] `method isInstanceOf[T0]=> Boolean`
-[accessible:  true] `method ne(x$1: AnyRef)Boolean`
-[accessible:  true] `method notify()Unit`
-[accessible:  true] `method notifyAll()Unit`
-[accessible:  true] `method secretPublic()Unit`
-[accessible:  true] `method someTests(other: accessibility.Foo)Unit`
-[accessible:  true] `method synchronized[T0](x$1: T0)T0`
-[accessible:  true] `method toString()String`
-[accessible:  true] `method wait()Unit`
-[accessible:  true] `method wait(x$1: Long)Unit`
-[accessible:  true] `method wait(x$1: Long, x$2: Int)Unit`
-[accessible:  true] `method →[B](y: B)(accessibility.Foo, B)`
-[accessible:  true] `value __leftOfArrowaccessibility.Foo`
-[accessible:  true] `value __resultOfEnsuringaccessibility.Foo`
-[accessible:  true] `value __stringToFormataccessibility.Foo`
-[accessible:  true] `value __thingToAddaccessibility.Foo`
-[accessible: false] `method clone()Object`
-[accessible: false] `method finalize()Unit`
-[accessible: false] `method secretPrivate()Unit`
-[accessible: false] `method secretPrivateThis()Unit`
-[accessible: false] `method secretProtected()Unit`
-[accessible: false] `method secretProtectedInPackage()Unit`
+[inaccessible] private def secretPrivate(): Unit
+[inaccessible] private[this] def secretPrivateThis(): Unit
+[inaccessible] protected def secretProtected(): Unit
+[inaccessible] protected[package accessibility] def secretProtectedInPackage(): Unit
+[inaccessible] protected[package lang] def clone(): Object
+[inaccessible] protected[package lang] def finalize(): Unit
+def +(other: String): String
+def ->[B](y: B): (accessibility.Foo, B)
+def ensuring(cond: Boolean): accessibility.Foo
+def ensuring(cond: Boolean,msg: => Any): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo
+def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo
+def equals(x$1: Any): Boolean
+def formatted(fmtstr: String): String
+def hashCode(): Int
+def secretPublic(): Unit
+def someTests(other: accessibility.Foo): Unit
+def toString(): String
+def →[B](y: B): (accessibility.Foo, B)
+final def !=(x$1: Any): Boolean
+final def !=(x$1: AnyRef): Boolean
+final def ##(): Int
+final def ==(x$1: Any): Boolean
+final def ==(x$1: AnyRef): Boolean
+final def asInstanceOf[T0]: T0
+final def eq(x$1: AnyRef): Boolean
+final def isInstanceOf[T0]: Boolean
+final def ne(x$1: AnyRef): Boolean
+final def notify(): Unit
+final def notifyAll(): Unit
+final def synchronized[T0](x$1: T0): T0
+final def wait(): Unit
+final def wait(x$1: Long): Unit
+final def wait(x$1: Long,x$2: Int): Unit
+private[this] val __leftOfArrow: accessibility.Foo
+private[this] val __resultOfEnsuring: accessibility.Foo
+private[this] val __stringToFormat: accessibility.Foo
+private[this] val __thingToAdd: accessibility.Foo
 ================================================================================