Make Binds forward-referencable

Make bind-defined symbols forward-referencable. This is necessary
to support more interesting patterns of Binds. E.g. in

   case (bla: List[t])

the bound symbol `bla` refers to the bound type `t` in its info. Previously
we used BindDefinedType for that, but that cannot work in general, because
it does not distinguish between a reference and a binding.

Author: odersky

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -115,7 +115,7 @@ class TreeUnpickler(reader: TastyReader,
       val start = currentAddr
       val tag = readByte()
       tag match {
-        case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | TEMPLATE =>
+        case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | TEMPLATE | BIND =>
           val end = readEnd()
           for (i <- 0 until numRefs(tag)) readNat()
           if (tag == TEMPLATE) scanTrees(buf, end, MemberDefsOnly)
@@ -431,6 +431,8 @@ class TreeUnpickler(reader: TastyReader,
     def createSymbol()(implicit ctx: Context): Symbol = nextByte match {
       case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM =>
         createMemberSymbol()
+      case BIND =>
+        createBindSymbol()
       case TEMPLATE =>
         val localDummy = ctx.newLocalDummy(ctx.owner)
         registerSym(currentAddr, localDummy)
@@ -439,6 +441,25 @@ class TreeUnpickler(reader: TastyReader,
         throw new Error(s"illegal createSymbol at $currentAddr, tag = $tag")
     }
 
+    private def createBindSymbol()(implicit ctx: Context): Symbol = {
+      val start = currentAddr
+      val tag = readByte()
+      val end = readEnd()
+      var name: Name = readName()
+      nextUnsharedTag match {
+        case TYPEBOUNDS | TYPEALIAS => name = name.toTypeName
+        case _ =>
+      }
+      val typeReader = fork
+      val completer = new LazyType {
+        def complete(denot: SymDenotation)(implicit ctx: Context) =
+          denot.info = typeReader.readType()
+      }
+      val sym = ctx.newSymbol(ctx.owner, name, EmptyFlags, completer, coord = coordAt(start))
+      registerSym(start, sym)
+      sym
+    }
+
     /** Create symbol of member definition or parameter node and enter in symAtAddr map
      *  @return  the created symbol
      */
@@ -994,11 +1015,9 @@ class TreeUnpickler(reader: TastyReader,
               val elemtpt = readTpt()
               SeqLiteral(until(end)(readTerm()), elemtpt)
             case BIND =>
-              var name: Name = readName()
-              val info = readType()
-              if (info.isInstanceOf[TypeType]) name = name.toTypeName
-              val sym = ctx.newSymbol(ctx.owner, name, EmptyFlags, info, coord = coordAt(start))
-              registerSym(start, sym)
+              val sym = symAtAddr.getOrElse(start, forkAt(start).createSymbol())
+              readName()
+              readType()
               Bind(sym, readTerm())
             case ALTERNATIVE =>
               Alternative(until(end)(readTerm()))

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1288,7 +1288,6 @@ class Typer extends Namer
         if (tree.name == nme.WILDCARD) body1
         else {
           val sym = ctx.newPatternBoundSymbol(tree.name, body1.tpe.underlyingIfRepeated(isJava = false), tree.pos)
-          if (sym.isType) sym.setFlag(BindDefinedType) // can we get rid of this?
           if (ctx.mode.is(Mode.InPatternAlternative))
             ctx.error(i"Illegal variable ${sym.name} in pattern alternative", tree.pos)
           assignType(cpy.Bind(tree)(tree.name, body1), sym)

tests/neg-tailcall/t1672b.scala

@@ -46,7 +46,7 @@ object Test1772B {
     else 1 + (try {
       throw new RuntimeException
     } catch {
-      case _: Throwable => bar(i - 1) // error: cannot rewrite recursive call
+      case _: Throwable => bar(i - 1) // old error: cannot rewrite recursive call
     })
   }
 }