Make PC more resilient to crashes

[rochala]

When working with code that is recovered from errors, we should use typeOpt instead of tpe as it can sometimes be null. The added test cases were the exact snippet that previously failed. I took this opportunity to change all calls to tpe to typeOpt.

[tgodzik]

LGTM! Would be great to set up some kind of linter to report any methods that could throw,

[tgodzik]

Could you port that to Metals also?

[dwijnand]

Why are these typed trees, if they don't have a type? That's half the reason to have the whole typed and untyped trees modelling, so we can define the implementation once and not have to allocate, but define APIs based on whether they're statically known to be typed or not. Some part of the code path must be casting the trees unsafely, somewhere.

But even more importantly, I don't think we should be wrapping the call to allImplicits and silenting throwing away any and all exceptions thrown. That's a recipe for big confusion in the future.

[rochala]

Remember that what we're working is usually trees recovered from error like:

class Wrapper(n: Int):
  extension (x: Int)
    def + (y: Int) = Wrap@@per(x) + y

with its tree after the typer:

package <empty> {
  import scala.collection.immutable.ListSet
  class Wrapper(n: Int) extends Object() {
    private[this] val n: Int
    extension (x: Int) def +(y: Int):
      <error Overloaded or recursive method + needs return type>
     = Wrapper(x).+(y)
  }
}

Even tho it is a typed tree, at cursor position, its type is null. I don't know whether this is a bug in compiler, but in my opinion change to typeOpt is something that should help in these cases.

As of adding try clause, it also slipped through my mind that this is not the best idea. As presentation compiler has raports system, we could use it to notify whether this happens.
Once again doing implicit search is something that can also happen on trees it shouldn't happen like List[Int]. Ideally we should ensure that only trees that can be completed have their completions computed and this is not so easy to achieve. I tried to handle this specific case with List[Int], as there should be no completions on such type applys, but if we call method returning a TypeApply like def asInstanceOf[T]: [T] it should still happen. I didn't succeed in distinguishing which is the case, but i think it can be done with AST analsysis.