lots of absent completions about ammonite

[lihaoyi]

Yeah i dunno. If you could provide a standalone non-psp repro that'd be great, or even a repro with psp but including any @load.ivy commands necessary to pull psp into the classpath. Not the first time the presentation compiler has disappointed me ^_^

[paulp]

This is really easy to reproduce, or more accurately, you can't help but reproduce it.

// build.sbt
       libraryDependencies += "com.lihaoyi" %% "ammonite-repl" % "0.2.7"
initialCommands in console := "ammonite.repl.Repl.main(null)"

// a.scala
package p {
  trait Direct[A] { def map[B](f: A => B): Direct[B] }
  object Direct { def apply[A](xs: A*): Direct[A] = null }
}

// sbt console transcript
/**
@ 5.<tab>  Display all 733 possibilities? (y or n)
@ Direct(5).map(_.<tab>
getClass              ##                    asInstanceOf          isInstanceOf          toString
hashCode              equals                !=                    ==                    %
/                     *                     -                     +                     ^
&                     |                     >=                    >                     <=
<                     >>                    >>>                   <<                    unary_-
unary_+               unary_~               toDouble              toFloat               toLong
toInt                 toChar                toShort               toByte                ensuring
x                     __resultOfEnsuring    compareTo             doubleValue           floatValue
longValue             intValue              shortValue            byteValue             synchronized
ne                    eq                    wait                  notifyAll             notify
→                     ->                    __leftOfArrow         self                  toOctalString
toHexString           toBinaryString        abs                   max                   min
to                    until                 isWhole               ResultWithoutStep     signum
underlying            compare               isValidChar           isValidInt            isValidShort
isValidByte           formatted

Comes in under 733.

[lihaoyi]

Thanks!

Perhaps I can't help but reproduce it, but it's not always obvious when things which should be there are missing. Having concrete repro examples is always nice

[paulp]

It's a blend of things which should be there missing, but more prominently in this example, things which should be absent being there. Unless Int has a, for instance, NoSuchFieldException member. The last few lines of completions on 5. are

Character                         UnsatisfiedLinkError              InstantiationException
UnknownError                      ArrayStoreException               VerifyError
StackTraceElement                 Deprecated                        Package
IllegalAccessException            NoClassDefFoundError              ClassFormatError
NoSuchMethodException             Thread                            ClassValue
Void                              ClassCircularityError             UnsupportedClassVersionError
FunctionalInterface               Object                            SecurityException
ThreadDeath                       LinkageError                      Comparable
InstantiationError                AssertionError                    IllegalStateException
RuntimePermission                 NoSuchMethodError

It's obviously every simple identifier being presented as Int members.

This may have no cause overlap at all with the Direct(Direct(1)).map(_. example originally given, but when the bugs are this close to the surface it's best to handle some of them so as to see the potentially more interesting ones through less static.

[lihaoyi]

Maybe the problem fixed itself? This is what I'm seeing in trunk, and it looks about right

@ trait Direct[A] { def map[B](f: A => B): Direct[B] }; object Direct { def apply[A](xs: A*): Direct[A] = null }
defined trait Direct
defined object Direct
@ 5.
!=                  ##                  %                   &                   *
+                   -                   ->                  /                   <
<<                  <=                  ==                  >                   >=
>>                  >>>                 ResultWithoutStep   ^                   abs
asInstanceOf        byteValue           ceil                compare             compareTo
doubleValue         ensuring            eq                  equals              floatValue
floor               formatted           getClass            hashCode            intValue
isInfinite          isInfinity          isInstanceOf        isNaN               isNegInfinity
isPosInfinity       isValidByte         isValidChar         isValidInt          isValidLong
isValidShort        isWhole             longValue           max                 min
ne                  notify              notifyAll           round               self
shortValue          signum              synchronized        to                  toBinaryString
toByte              toChar              toDegrees           toDouble            toFloat
toHexString         toInt               toLong              toOctalString       toRadians
toShort             toString            unary_+             unary_-             unary_~
underlying          until               wait                |                   →
@ Direct(5).
!=             ##             +              ->             ==             asInstanceOf
ensuring       eq             equals         formatted      getClass       hashCode
isInstanceOf   map            ne             notify         notifyAll      synchronized
toString       wait           →
@ Direct(5).map(_.
!=                  ##                  %                   &                   *
+                   -                   ->                  /                   <
<<                  <=                  ==                  >                   >=
>>                  >>>                 ResultWithoutStep   ^                   abs
asInstanceOf        byteValue           ceil                compare             compareTo
doubleValue         ensuring            eq                  equals              floatValue
floor               formatted           getClass            hashCode            intValue
isInfinite          isInfinity          isInstanceOf        isNaN               isNegInfinity
isPosInfinity       isValidByte         isValidChar         isValidInt          isValidLong
isValidShort        isWhole             longValue           max                 min
ne                  notify              notifyAll           round               self
shortValue          signum              synchronized        to                  toBinaryString
toByte              toChar              toDegrees           toDouble            toFloat
toHexString         toInt               toLong              toOctalString       toRadians
toShort             toString            unary_+             unary_-             unary_~
underlying          until               wait                |                   →
@ Seq(Direct(5)).map(_.)
!=             ##             +              ->             ==             asInstanceOf
ensuring       eq             equals         formatted      getClass       hashCode
isInstanceOf   map            ne             notify         notifyAll      synchronized
toString       wait           →

[lihaoyi]

Probably need some more stuff from your repo for this to manifest, feel free to open with a self-contained example; otherwise I probably won't fix this until i bump into it myself