ApplyToImplicitArgs is Applied attachment

som-snytt · som-snytt · commit 15b6afb1bdbe · 2024-11-18T00:01:49.000-08:00
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -516,7 +516,7 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL {
         !elemtpt.tpe.typeSymbol.isBottomClass && !elemtpt.tpe.typeSymbol.isPrimitiveValueClass /* can happen via specialization.*/
       =>
         classTagEvidence.attachments.get[analyzer.MacroExpansionAttachment] match {
-          case Some(att) if att.expandee.symbol.name == nme.materializeClassTag && tree.isInstanceOf[ApplyToImplicitArgs] =>
+          case Some(att) if att.expandee.symbol.name == nme.materializeClassTag && tree.hasAttachment[AppliedToImplicitArgs.type] =>
             super.transform(arg)
           case _ =>
             typedWithPos(tree.pos) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
@@ -35,7 +35,7 @@ trait StdAttachments {
   def macroExpanderAttachment(tree: Tree): MacroExpanderAttachment =
     tree.attachments.get[MacroExpanderAttachment] getOrElse {
       tree match {
-        case Apply(fn, _) if tree.isInstanceOf[ApplyToImplicitArgs] => macroExpanderAttachment(fn)
+        case Apply(fn, _) if tree.hasAttachment[AppliedToImplicitArgs.type] => macroExpanderAttachment(fn)
         case _ => MacroExpanderAttachment(tree, EmptyTree)
       }
     }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -283,7 +283,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           for (arg <- args) ar.subst traverse arg
         }
 
-        new ApplyToImplicitArgs(fun, args) setPos fun.pos
+        ApplyToImplicitArgs(fun, args).setPos(fun.pos)
       case ErrorType =>
         fun
       case x => throw new MatchError(x)
@@ -5290,7 +5290,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
               val tree1: Tree = resolveClassTag(tree.pos, tagType) match {
                 case EmptyTree => MissingClassTagError(tree, tagType)
-                case tag       => atPos(tree.pos)(new ApplyToImplicitArgs(Select(tag, nme.newArray), arg :: Nil))
+                case tag       => atPos(tree.pos)(ApplyToImplicitArgs(Select(tag, nme.newArray), arg :: Nil))
               }
               if (tree1.isErrorTyped) tree1 else typed(tree1, mode, pt)
             case Apply(Select(fun, nme.apply), _) if treeInfo.isSuperConstrCall(fun) => TooManyArgumentListsForConstructor(tree) //scala/bug#5696
@@ -5347,7 +5347,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               mkAssign(Select(qq1, qual.symbol) setPos qual.pos)
             }
 
-          case Apply(fn, extra) if qual.isInstanceOf[ApplyToImplicitArgs] =>
+          case Apply(fn, extra) if qual.hasAttachment[AppliedToImplicitArgs.type] =>
             fn match {
               case treeInfo.Applied(Select(table, nme.apply), _, indices :: Nil) =>
                 // table(indices)(implicits)
diff --git a/src/reflect/scala/reflect/internal/Importers.scala b/src/reflect/scala/reflect/internal/Importers.scala
@@ -379,12 +379,8 @@ trait Importers { to: SymbolTable =>
         new Typed(importTree(expr), importTree(tpt))
       case from.TypeApply(fun, args) =>
         new TypeApply(importTree(fun), args map importTree)
-      case from.Apply(fun, args) => their match {
-        case _: from.ApplyToImplicitArgs =>
-          new ApplyToImplicitArgs(importTree(fun), args map importTree)
-        case _ =>
-          new Apply(importTree(fun), args map importTree)
-      }
+      case from.Apply(fun, args) =>
+        new Apply(importTree(fun), args map importTree)
       case from.ApplyDynamic(qual, args) =>
         new ApplyDynamic(importTree(qual), args map importTree)
       case from.Super(qual, mix) =>
diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala
@@ -191,4 +191,6 @@ trait StdAttachments {
 
   /** Application is an implicit view. */
   case object AppliedImplicitView extends PlainAttachment
+
+  case object AppliedToImplicitArgs extends PlainAttachment
 }
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
@@ -805,9 +805,7 @@ trait Trees extends api.Trees {
   }
   object Apply extends ApplyExtractor
 
-  // TODO remove this class, add a tree attachment to Apply to track whether implicits were involved
-  // copying trees will all too easily forget to distinguish subclasses
-  class ApplyToImplicitArgs(fun: Tree, args: List[Tree]) extends Apply(fun, args)
+  def ApplyToImplicitArgs(fun: Tree, args: List[Tree]) = Apply(fun, args).updateAttachment(AppliedToImplicitArgs)
 
   def ApplyImplicitView(fun: Tree, args: List[Tree]) = Apply(fun, args).updateAttachment(AppliedImplicitView)
 
@@ -1110,8 +1108,7 @@ trait Trees extends api.Trees {
     def TypeApply(tree: Tree, fun: Tree, args: List[Tree]) =
       new TypeApply(fun, args).copyAttrs(tree)
     def Apply(tree: Tree, fun: Tree, args: List[Tree]) =
-      (tree match { // TODO: use a tree attachment to track whether this is an apply to implicit args or a view
-        case _: ApplyToImplicitArgs => new ApplyToImplicitArgs(fun, args)
+      (tree match {
         // TODO: ApplyConstructor ???
         case self.pendingSuperCall => self.pendingSuperCall
         case _ => new Apply(fun, args)
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
@@ -94,6 +94,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     this.RightAssociative
     this.RightAssociativeArg
     this.AppliedImplicitView
+    this.AppliedToImplicitArgs
     this.noPrint
     this.typeDebug
     // inaccessible: this.posAssigner

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ trait StdAttachments {`
`35`	`35`	`def macroExpanderAttachment(tree: Tree): MacroExpanderAttachment =`
`36`	`36`	`tree.attachments.get[MacroExpanderAttachment] getOrElse {`
`37`	`37`	`tree match {`
`38`		`- case Apply(fn, _) if tree.isInstanceOf[ApplyToImplicitArgs] => macroExpanderAttachment(fn)`
	`38`	`+ case Apply(fn, _) if tree.hasAttachment[AppliedToImplicitArgs.type] => macroExpanderAttachment(fn)`
`39`	`39`	`case _ => MacroExpanderAttachment(tree, EmptyTree)`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -191,4 +191,6 @@ trait StdAttachments {`
`191`	`191`
`192`	`192`	`/** Application is an implicit view. */`
`193`	`193`	`case object AppliedImplicitView extends PlainAttachment`
	`194`	`+`
	`195`	`+ case object AppliedToImplicitArgs extends PlainAttachment`
`194`	`196`	`}`