Drop IntegratedTypeArgs

Author: odersky

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -645,8 +645,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case TypSplice(tree) =>
         keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
-      case tree: Applications.IntegratedTypeArgs =>
-        toText(tree.app) ~ Str("(with integrated type args)").provided(printDebug)
       case tree: Applications.ExtMethodApply =>
         toText(tree.app) ~ Str("(ext method apply)").provided(printDebug)
       case Thicket(trees) =>

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

@@ -206,26 +206,6 @@ object Applications {
     def productElement(n: Int): Any = app.productElement(n)
   }
 
-  /** A wrapper indicating that its `app` argument has already integrated the type arguments
-   *  of the expected type, provided that type is a (possibly ignored) PolyProto.
-   *  I.e., if the expected type is a PolyProto, then `app` will be a `TypeApply(_, args)` where
-   *  `args` are the type arguments of the expected type.
-   */
-  class IntegratedTypeArgs(val app: Tree)(implicit @constructorOnly src: SourceFile) extends AppProxy
-
-  /** The unapply method of this extractor also recognizes IntegratedTypeArgs in closure blocks.
-   *  This is necessary to deal with closures as left arguments of extension method applications.
-   *  A test case is i5606.scala
-   */
-  object IntegratedTypeArgs {
-    def apply(app: Tree)(using Context) = new IntegratedTypeArgs(app)
-    def unapply(tree: Tree)(using Context): Option[Tree] = tree match {
-      case tree: IntegratedTypeArgs => Some(tree.app)
-      case Block(stats, IntegratedTypeArgs(app)) => Some(tpd.cpy.Block(tree)(stats, app))
-      case _ => None
-    }
-  }
-
   /** A wrapper indicating that its argument is an application of an extension method.
    */
   class ExtMethodApply(val app: Tree)(implicit @constructorOnly src: SourceFile) extends AppProxy:
@@ -1061,8 +1041,6 @@ trait Applications extends Compatibility {
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
     typedExpr(tree.fun, PolyProto(typedArgs, pt)) match {
-      case IntegratedTypeArgs(app) =>
-        app
       case _: TypeApply if !ctx.isAfterTyper =>
         errorTree(tree, "illegal repeated type application")
       case typedFn =>

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

@@ -30,7 +30,7 @@ import TypeComparer.CompareResult
 import util.Spans._
 import util.common._
 import util.{Property, SimpleIdentityMap, SrcPos}
-import Applications.{ExtMethodApply, IntegratedTypeArgs, productSelectorTypes, wrapDefs}
+import Applications.{ExtMethodApply, productSelectorTypes, wrapDefs}
 
 import collection.mutable
 import annotation.tailrec
@@ -548,11 +548,6 @@ class Typer extends Namer
       report.error(StableIdentPattern(tree, pt), tree.srcPos)
 
   def typedSelect(tree: untpd.Select, pt: Type, qual: Tree)(using Context): Tree = qual match {
-    case qual @ IntegratedTypeArgs(app) =>
-      pt.revealIgnored match {
-        case _: PolyProto => qual // keep the IntegratedTypeArgs to strip at next typedTypeApply
-        case _ => app
-      }
     case qual: ExtMethodApply =>
       qual.app
     case qual =>
@@ -3638,10 +3633,7 @@ class Typer extends Namer
               if tree.symbol.isAllOf(ApplyProxyFlags) then newExpr
               else adaptToArgs(wtp, pt)
             case pt: PolyProto =>
-              tree match {
-                case _: IntegratedTypeArgs => tree
-                case _ =>  tryInsertApplyOrImplicit(tree, pt, locked)(tree) // error will be reported in typedTypeApply
-              }
+              tryInsertApplyOrImplicit(tree, pt, locked)(tree) // error will be reported in typedTypeApply
             case pt: SelectionProto if tree.isInstanceOf[ExtMethodApply] =>
               tree
             case _ =>