1 files changed, 24 insertions, 9 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index ff0bdf7580..b400743469 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -277,11 +277,6 @@ trait ContextErrors {
         setError(tree)
       }
 
-      def MultiDimensionalArrayError(tree: Tree) = {
-        issueNormalTypeError(tree, "cannot create a generic multi-dimensional array of more than "+ definitions.MaxArrayDims+" dimensions")
-        setError(tree)
-      }
-
       //typedSuper
       def MixinMissingParentClassNameError(tree: Tree, mix: Name, clazz: Symbol) =
         issueNormalTypeError(tree, mix+" does not name a parent class of "+clazz)
@@ -344,6 +339,11 @@ trait ContextErrors {
         setError(tree)
       }
 
+      def MacroEtaError(tree: Tree) = {
+        issueNormalTypeError(tree, "macros cannot be eta-expanded")
+        setError(tree)
+      }
+
       //typedReturn
       def ReturnOutsideOfDefError(tree: Tree) = {
         issueNormalTypeError(tree, "return outside method definition")
@@ -453,6 +453,9 @@ trait ContextErrors {
 
       // doTypeApply
       //tryNamesDefaults
+      def NamedAndDefaultArgumentsNotSupportedForMacros(tree: Tree, fun: Tree) =
+        NormalTypeError(tree, "macros application do not support named and/or default arguments")
+
       def WrongNumberOfArgsError(tree: Tree, fun: Tree) =
         NormalTypeError(tree, "wrong number of arguments for "+ treeSymTypeMsg(fun))
 
@@ -581,9 +584,9 @@ trait ContextErrors {
       def AbstractExistentiallyOverParamerizedTpeError(tree: Tree, tp: Type) =
         issueNormalTypeError(tree, "can't existentially abstract over parameterized type " + tp)
 
-      //manifestTreee
-      def MissingManifestError(tree: Tree, full: Boolean, tp: Type) = {
-        issueNormalTypeError(tree, "cannot find "+(if (full) "" else "class ")+"manifest for element type "+tp)
+      // classTagTree
+      def MissingClassTagError(tree: Tree, tp: Type) = {
+        issueNormalTypeError(tree, "cannot find class tag for element type "+tp)
         setError(tree)
       }
 
@@ -622,7 +625,6 @@ trait ContextErrors {
       def DefDefinedTwiceError(sym0: Symbol, sym1: Symbol) = {
         val isBug = sym0.isAbstractType && sym1.isAbstractType && (sym0.name startsWith "_$")
         issueSymbolTypeError(sym0, sym1+" is defined twice in " + context0.unit
-          + ( if (sym0.isMacro && sym1.isMacro) "\n(note that macros cannot be overloaded)" else "" )
           + ( if (isBug) "\n(this error is likely due to a bug in the scala compiler involving wildcards in package objects)" else "" )
         )
       }
@@ -848,6 +850,19 @@ trait ContextErrors {
 
       def TypeSigError(tree: Tree, ex: TypeError) = {
         ex match {
+          case CyclicReference(_, _) if tree.symbol.isTermMacro =>
+            // say, we have a macro def `foo` and its macro impl `impl`
+            // if impl: 1) omits return type, 2) has anything implicit in its body, 3) sees foo
+            //
+            // then implicit search will trigger an error
+            // (note that this is not a compilation error, it's an artifact of implicit search algorithm)
+            // normally, such "errors" are discarded by `isCyclicOrErroneous` in Implicits.scala
+            // but in our case this won't work, because isCyclicOrErroneous catches CyclicReference exceptions
+            // while our error will manifest itself as a "recursive method needs a return type"
+            //
+            // hence we (together with reportTypeError in TypeDiagnostics) make sure that this CyclicReference
+            // evades all the handlers on its way and successfully reaches `isCyclicOrErroneous` in Implicits
+            throw ex
           case CyclicReference(sym, info: TypeCompleter) =>
             issueNormalTypeError(tree, typer.cyclicReferenceMessage(sym, info.tree) getOrElse ex.getMessage())
           case _ =>