wip

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -517,8 +517,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       val (meth, targs, argss) = decomposeCall(fn)
       (meth, targs, argss :+ args)
     case TypeApply(fn, targs) =>
-      val (meth, targss, args) = decomposeCall(fn)
-      (meth, targs ++ targss, args)
+      val (meth, Nil, Nil) = decomposeCall(fn)
+      (meth, targs, Nil)
     case _ =>
       (tree, Nil, Nil)
   }
@@ -718,4 +718,4 @@ object TreeInfo {
   val Pure = new PurityLevel(2)
   val Idempotent = new PurityLevel(1)
   val Impure = new PurityLevel(0)
-}
+}

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -261,6 +261,9 @@ class TreeChecker extends Phase with SymTransformer {
 
     override def typedUnadapted(tree: untpd.Tree, pt: Type)(implicit ctx: Context): tpd.Tree = {
       val res = tree match {
+        case _: untpd.UnApply =>
+          // can't recheck patterns
+          tree.asInstanceOf[tpd.Tree]
         case _: untpd.TypedSplice | _: untpd.Thicket | _: EmptyValDef[_] =>
           super.typedUnadapted(tree)
         case _ if tree.isType =>
@@ -288,7 +291,7 @@ class TreeChecker extends Phase with SymTransformer {
     }
 
     def checkNotRepeated(tree: Tree)(implicit ctx: Context): tree.type = {
-      def allowedRepeated = tree.tpe.widen.isRepeatedParam
+      def allowedRepeated = (tree.symbol.flags is Case) && tree.tpe.widen.isRepeatedParam
 
       assert(!tree.tpe.widen.isRepeatedParam || allowedRepeated, i"repeated parameter type not allowed here: $tree")
       tree

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

@@ -955,10 +955,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
         val dummyArg = dummyTreeOfType(ownType)
         val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
-        def unapplyImplicits(unapp: Tree): List[Tree] = unapp match {
+        val unapplyImplicits = unapplyApp match {
           case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); args2
           case Apply(unapply, `dummyArg` :: Nil) => Nil
-          case Inlined(u, _, _) => unapplyImplicits(u)
         }
 
         var argTypes = unapplyArgs(unapplyApp.tpe, unapplyFn, args, tree.pos)
@@ -982,7 +981,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             List.fill(argTypes.length - args.length)(WildcardType)
         }
         val unapplyPatterns = (bunchedArgs, argTypes).zipped map (typed(_, _))
-        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(unapplyApp), unapplyPatterns), ownType)
+        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits, unapplyPatterns), ownType)
         unapp.println(s"unapply patterns = $unapplyPatterns")
         if ((ownType eq selType) || ownType.isError) result
         else tryWithClassTag(Typed(result, TypeTree(ownType)), selType)

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

@@ -478,7 +478,7 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
         paramProxy.get(tree.tpe) match {
           case Some(t) if tree.isTerm && t.isSingleton => singleton(t).withPos(tree.pos)
           case Some(t) if tree.isType => TypeTree(t).withPos(tree.pos)
-          case _ => tree
+          case None => tree
         }
       case _ => tree
     }}

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

@@ -5,7 +5,6 @@ import core._
 import Contexts._
 import Types._
 import Symbols._
-import StdNames._
 import Decorators._
 import typer.ProtoTypes._
 import ast.{tpd, untpd}
@@ -25,20 +24,17 @@ import config.Printers.typr
 class ReTyper extends Typer {
   import tpd._
 
-  private def assertTyped(tree: untpd.Tree)(implicit ctx: Context): Unit =
-    assert(tree.hasType, i"$tree ${tree.getClass} ${tree.uniqueId}")
-
   /** Checks that the given tree has been typed */
   protected def promote(tree: untpd.Tree)(implicit ctx: Context): tree.ThisTree[Type] = {
-    assertTyped(tree)
+    assert(tree.hasType, i"$tree ${tree.getClass} ${tree.uniqueId}")
     tree.withType(tree.typeOpt)
   }
 
   override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context): Tree =
     promote(tree)
 
   override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
-    assertTyped(tree)
+    assert(tree.hasType, tree)
     val qual1 = typed(tree.qualifier, AnySelectionProto)
     untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
   }
@@ -52,22 +48,11 @@ class ReTyper extends Typer {
   override def typedSuper(tree: untpd.Super, pt: Type)(implicit ctx: Context): Tree =
     promote(tree)
 
-  override def typedTyped(tree: untpd.Typed, pt: Type)(implicit ctx: Context): Tree = {
-    assertTyped(tree)
-    val tpt1 = checkSimpleKinded(typedType(tree.tpt))
-    val expr1 = tree.expr match {
-      case id: untpd.Ident if (ctx.mode is Mode.Pattern) && untpd.isVarPattern(id) && (id.name == nme.WILDCARD || id.name == nme.WILDCARD_STAR) =>
-        tree.expr.withType(tpt1.tpe)
-      case _ => typed(tree.expr)
-    }
-   untpd.cpy.Typed(tree)(expr1, tpt1).withType(tree.typeOpt)
-  }
-
   override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree =
     promote(tree)
 
   override def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Bind = {
-    assertTyped(tree)
+    assert(tree.hasType)
     val body1 = typed(tree.body, pt)
     untpd.cpy.Bind(tree)(tree.name, body1).withType(tree.typeOpt)
   }
@@ -79,10 +64,6 @@ class ReTyper extends Typer {
     untpd.cpy.UnApply(tree)(fun1, implicits1, patterns1).withType(tree.tpe)
   }
 
-  override def typedUnApply(tree: untpd.Apply, selType: Type)(implicit ctx: Context): Tree = {
-    typedApply(tree, selType)
-  }
-
   override def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context) = impl.symbol
 
   override def retrieveSym(tree: untpd.Tree)(implicit ctx: Context): Symbol = tree.symbol

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

@@ -645,7 +645,13 @@ class Typer extends Namer
 
   def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context) = track("typedBlock") {
     val (exprCtx, stats1) = typedBlockStats(tree.stats)
-    val expr1 = typedExpr(tree.expr, pt.notApplied)(exprCtx)
+    val ept =
+      if (tree.isInstanceOf[untpd.InfixOpBlock])
+        // Right-binding infix operations are expanded to InfixBlocks, which may be followed by arguments.
+        // Example: `(a /: bs)(op)` expands to `{ val x = a; bs./:(x) } (op)` where `{...}` is an InfixBlock.
+        pt
+      else pt.notApplied
+    val expr1 = typedExpr(tree.expr, ept)(exprCtx)
     ensureNoLocalRefs(
       cpy.Block(tree)(stats1, expr1).withType(expr1.tpe), pt, localSyms(stats1))
   }
@@ -976,7 +982,9 @@ class Typer extends Namer
     cases mapconserve (typedCase(_, pt, selType, gadtSyms))
   }
 
-  /** Type a case. */
+  /** Type a case. Overridden in ReTyper, that's why it's separate from
+   *  typedCases.
+   */
   def typedCase(tree: untpd.CaseDef, pt: Type, selType: Type, gadtSyms: Set[Symbol])(implicit ctx: Context): CaseDef = track("typedCase") {
     val originalCtx = ctx