9 files changed, 87 insertions, 6 deletions
diff --git a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
index 54c665fe56..14f47a00fd 100644
--- a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
@@ -50,6 +50,10 @@ trait StdAttachments {
     case _ => false
   }
 
+  /** Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.
+   */
+  def macroExpandee(tree: Tree): Tree = tree.attachments.get[MacroExpansionAttachment].map(_.expandee).getOrElse(EmptyTree)
+
   /** After macro expansion is completed, links the expandee and the expansion result by annotating them both with a `MacroExpansionAttachment`.
    *  The `expanded` parameter is of type `Any`, because macros can expand both into trees and into annotations.
    */
@@ -147,4 +151,18 @@ trait StdAttachments {
    *  because someone has put MacroImplRefAttachment on it.
    */
   def isMacroImplRef(tree: Tree): Boolean = tree.attachments.get[MacroImplRefAttachment.type].isDefined
+
+  /** Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected
+   *  from typedNamedApply, the applyDynamicNamed argument rewriter, the latter
+   *  doesn’t know whether it needs to apply the rewriting because the application
+   *  has just been desugared or it needs to hold on because it’s already performed
+   *  a desugaring on this tree. This has led to SI-8006.
+   *
+   *  This attachment solves the problem by providing a means of communication
+   *  between the two Dynamic desugarers, which solves the aforementioned issue.
+   */
+  case object DynamicRewriteAttachment
+  def markDynamicRewrite(tree: Tree): Tree = tree.updateAttachment(DynamicRewriteAttachment)
+  def unmarkDynamicRewrite(tree: Tree): Tree = tree.removeAttachment[DynamicRewriteAttachment.type]
+  def isDynamicRewrite(tree: Tree): Boolean = tree.attachments.get[DynamicRewriteAttachment.type].isDefined
 }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 5e89440bc0..910da77ca8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3369,7 +3369,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               (args exists isNamedArg) ||     // uses a named argument
               isNamedApplyBlock(fun)) {       // fun was transformed to a named apply block =>
                                               // integrate this application into the block
-            if (dyna.isApplyDynamicNamed(fun)) dyna.typedNamedApply(tree, fun, args, mode, pt)
+            if (dyna.isApplyDynamicNamed(fun) && isDynamicRewrite(fun)) dyna.typedNamedApply(tree, fun, args, mode, pt)
             else tryNamesDefaults
           } else {
             val tparams = context.extractUndetparams()
@@ -3927,7 +3927,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
             gen.mkTuple(List(CODE.LIT(""), arg))
         }
 
-        val t = treeCopy.Apply(orig, fun, args map argToBinding)
+        val t = treeCopy.Apply(orig, unmarkDynamicRewrite(fun), args map argToBinding)
         wrapErrors(t, _.typed(t, mode, pt))
       }
 
@@ -3953,9 +3953,12 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       def mkInvoke(cxTree: Tree, tree: Tree, qual: Tree, name: Name): Option[Tree] = {
         debuglog(s"dyna.mkInvoke($cxTree, $tree, $qual, $name)")
         val treeInfo.Applied(treeSelection, _, _) = tree
-        def isDesugaredApply = treeSelection match {
-          case Select(`qual`, nme.apply) => true
-          case _                         => false
+        def isDesugaredApply = {
+          val protoQual = macroExpandee(qual) orElse qual
+          treeSelection match {
+            case Select(`protoQual`, nme.apply) => true
+            case _                              => false
+          }
         }
         acceptsApplyDynamicWithType(qual, name) map { tp =>
           // If tp == NoType, pass only explicit type arguments to applyXXX.  Not used at all
@@ -3989,7 +3992,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               val nameStringLit = atPos(treeSelection.pos.withStart(treeSelection.pos.point).makeTransparent) {
                 Literal(Constant(name.decode))
               }
-              atPos(qual.pos)(Apply(fun, List(nameStringLit)))
+              markDynamicRewrite(atPos(qual.pos)(Apply(fun, List(nameStringLit))))
             case _ =>
               setError(tree)
           }
diff --git a/test/files/neg/t6920.check b/test/files/neg/t6920.check
new file mode 100644
index 0000000000..ee4eafb83e
--- /dev/null
+++ b/test/files/neg/t6920.check
@@ -0,0 +1,6 @@
+t6920.scala:9: error: too many arguments for method applyDynamicNamed: (values: Seq[(String, Any)])String
+error after rewriting to CompilerError.this.test.applyDynamicNamed("crushTheCompiler")(scala.Tuple2("a", 1), scala.Tuple2("b", 2))
+possible cause: maybe a wrong Dynamic method signature?
+  test.crushTheCompiler(a = 1, b = 2)
+                       ^
+one error found
diff --git a/test/files/neg/t6920.scala b/test/files/neg/t6920.scala
new file mode 100644
index 0000000000..b79d641698
--- /dev/null
+++ b/test/files/neg/t6920.scala
@@ -0,0 +1,10 @@
+import scala.language.dynamics
+
+class DynTest extends Dynamic {
+  def applyDynamicNamed(name: String)(values: Seq[(String, Any)]) = "test"
+}
+
+class CompilerError {
+  val test = new DynTest
+  test.crushTheCompiler(a = 1, b = 2)
+}
+\ No newline at end of file
diff --git a/test/files/neg/t8006.check b/test/files/neg/t8006.check
new file mode 100644
index 0000000000..fbac26e3ad
--- /dev/null
+++ b/test/files/neg/t8006.check
@@ -0,0 +1,6 @@
+t8006.scala:3: error: too many arguments for method applyDynamicNamed: (value: (String, Any))String
+error after rewriting to X.this.d.applyDynamicNamed("meth")(scala.Tuple2("value1", 10), scala.Tuple2("value2", 100))
+possible cause: maybe a wrong Dynamic method signature?
+  d.meth(value1 = 10, value2 = 100) // two arguments here, but only one is allowed
+        ^
+one error found
diff --git a/test/files/neg/t8006.scala b/test/files/neg/t8006.scala
new file mode 100644
index 0000000000..b2f71c1587
--- /dev/null
+++ b/test/files/neg/t8006.scala
@@ -0,0 +1,8 @@
+object X {
+  val d = new D
+  d.meth(value1 = 10, value2 = 100) // two arguments here, but only one is allowed
+}
+import language.dynamics
+class D extends Dynamic {
+  def applyDynamicNamed(name: String)(value: (String, Any)) = name
+}
+\ No newline at end of file
diff --git a/test/files/run/t7777.check b/test/files/run/t7777.check
new file mode 100644
index 0000000000..162ff2d2a2
--- /dev/null
+++ b/test/files/run/t7777.check
@@ -0,0 +1,7 @@
+foo(1, 2)
+bar(4, 5)
+foo(3)
+bar(7)
+apply(6)
+apply(9)
+foo(8)
diff --git a/test/files/run/t7777/Macros_1.scala b/test/files/run/t7777/Macros_1.scala
new file mode 100644
index 0000000000..459ab3edbb
--- /dev/null
+++ b/test/files/run/t7777/Macros_1.scala
@@ -0,0 +1,17 @@
+import scala.language.experimental.macros
+import scala.language.dynamics
+import scala.reflect.macros.WhiteboxContext
+
+class DynMacro extends Dynamic {
+  def applyDynamic(s: String)(xs: Any*): DynMacro =
+    macro DynMacro.applyDynamicMacro
+}
+
+object DynMacro extends DynMacro {
+  def applyDynamicMacro(c: WhiteboxContext)(s: c.Expr[String])(xs: c.Expr[Any]*): c.Expr[DynMacro] = {
+    import c.universe._
+    val Literal(Constant(n: String)) = s.tree
+    val args = xs.map(_.tree.toString).mkString("(", ", ", ")")
+    c.Expr(q"println(${ n + args }); ${c.prefix.tree}")
+  }
+}
+\ No newline at end of file
diff --git a/test/files/run/t7777/Test_2.scala b/test/files/run/t7777/Test_2.scala
new file mode 100644
index 0000000000..1fe8b63bab
--- /dev/null
+++ b/test/files/run/t7777/Test_2.scala
@@ -0,0 +1,6 @@
+object Test extends App {
+  DynMacro.foo(1, 2)         // prints "foo(1, 2)"
+  DynMacro.foo(3).bar(4, 5)  // prints "bar(4, 5)", then "foo(3)"
+  DynMacro(6).bar(7)         // prints "bar(7)", then "apply(6)"
+  DynMacro.foo(8)(9)         // Fails!
+}
+\ No newline at end of file