Merge pull request scala#2577 from scalamacros/pullrequest/paradise

Backport from paradise/macros

Author: xeno-by

lib/scala-compiler-src.jar.desired.sha1

@@ -1 +1 @@
-f9f41fb909df6a0178906c9fd02e5d0efa15c9ed ?scala-compiler-src.jar
+19d04510ac6f25d088da82527d8435b68c00153d ?scala-compiler-src.jar

lib/scala-compiler.jar.desired.sha1

@@ -1 +1 @@
-c4cd524dc29d298a5034637f6b31122dccb300d6 ?scala-compiler.jar
+3585351c6a62186097be55fff88bee88a985f5c0 ?scala-compiler.jar

lib/scala-library-src.jar.desired.sha1

@@ -1 +1 @@
-2cba5a13ef44bf93133be26cc89ba3a640a5c28f ?scala-library-src.jar
+e606934dc00ced6bfac715bbdba427f9c2c18bc7 ?scala-library-src.jar

lib/scala-library.jar.desired.sha1

@@ -1 +1 @@
-d7c6e69eba3dba2f75a0f44e56480cd3dbab8931 ?scala-library.jar
+36456c52b0395fc1e6e367291e45bd503fa019c5 ?scala-library.jar

lib/scala-reflect-src.jar.desired.sha1

@@ -1 +1 @@
-dbc00bd4b09012aa52e802926dee3f8a02a767ff ?scala-reflect-src.jar
+51787a41cae5b0ec6910c5a1a6af392e17550856 ?scala-reflect-src.jar

lib/scala-reflect.jar.desired.sha1

@@ -1 +1 @@
-c0eed5dee0a3204239c9b35134cad8b3ad140121 ?scala-reflect.jar
+d4a4c0aab882412461fbd9d39cf47da5a619855e ?scala-reflect.jar

src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala

@@ -0,0 +1,33 @@
+package scala.reflect.macros
+package compiler
+
+import scala.tools.nsc.Global
+import scala.reflect.macros.contexts.Context
+
+abstract class DefaultMacroCompiler extends Resolvers
+                                       with Validators
+                                       with Errors {
+  val global: Global
+  import global._
+
+  val typer: global.analyzer.Typer
+  private implicit val context0 = typer.context
+  val context = typer.context
+
+  val macroDdef: DefDef
+  lazy val macroDef = macroDdef.symbol
+
+  private case class MacroImplResolutionException(pos: Position, msg: String) extends Exception
+  def abort(pos: Position, msg: String) = throw MacroImplResolutionException(pos, msg)
+
+  def resolveMacroImpl: Tree = {
+    try {
+      validateMacroImplRef()
+      macroImplRef
+    } catch {
+      case MacroImplResolutionException(pos, msg) =>
+        context.error(pos, msg)
+        EmptyTree
+    }
+  }
+}

src/compiler/scala/reflect/macros/compiler/Errors.scala

@@ -0,0 +1,113 @@
+package scala.reflect.macros
+package compiler
+
+import scala.compat.Platform.EOL
+import scala.reflect.macros.util.Traces
+
+trait Errors extends Traces {
+  self: DefaultMacroCompiler =>
+
+  import global._
+  import analyzer._
+  import definitions._
+  import typer.TyperErrorGen._
+  import typer.infer.InferErrorGen._
+  def globalSettings = global.settings
+
+  // sanity check errors
+
+  private def implRefError(message: String) = abort(macroDdef.pos, message)
+
+  def MacroImplReferenceWrongShapeError() = implRefError(
+      "macro implementation reference has wrong shape. required:\n"+
+      "macro [<static object>].<method name>[[<type args>]] or\n" +
+      "macro [<macro bundle>].<method name>[[<type args>]]")
+
+  def MacroImplNotPublicError() = implRefError("macro implementation must be public")
+
+  def MacroImplOverloadedError() = implRefError("macro implementation cannot be overloaded")
+
+  def MacroImplWrongNumberOfTypeArgumentsError() = implRefError(TypedApplyWrongNumberOfTpeParametersErrorMessage(macroImplRef))
+
+  // compatibility errors
+
+  // helpers
+
+  private def lengthMsg(flavor: String, violation: String, extra: Symbol) = {
+    val noun = if (flavor == "value") "parameter" else "type parameter"
+    val message = noun + " lists have different length, " + violation + " extra " + noun
+    val suffix = if (extra ne NoSymbol) " " + extra.defString else ""
+    message + suffix
+  }
+
+  private def abbreviateCoreAliases(s: String): String = List("WeakTypeTag", "Expr").foldLeft(s)((res, x) => res.replace("c.universe." + x, "c." + x))
+
+  private def showMeth(pss: List[List[Symbol]], restpe: Type, abbreviate: Boolean) = {
+    var argsPart = (pss map (ps => ps map (_.defString) mkString ("(", ", ", ")"))).mkString
+    if (abbreviate) argsPart = abbreviateCoreAliases(argsPart)
+    var retPart = restpe.toString
+    if (abbreviate || macroDdef.tpt.tpe == null) retPart = abbreviateCoreAliases(retPart)
+    argsPart + ": " + retPart
+  }
+
+  // not exactly an error generator, but very related
+  // and I dearly wanted to push it away from Macros.scala
+  private def checkConforms(slot: String, rtpe: Type, atpe: Type) = {
+    val verbose = macroDebugVerbose || settings.explaintypes.value
+
+    def check(rtpe: Type, atpe: Type): Boolean = {
+      def success() = { if (verbose) println(rtpe + " <: " + atpe + "?" + EOL + "true"); true }
+      (rtpe, atpe) match {
+        case _ if rtpe eq atpe => success()
+        case (TypeRef(_, RepeatedParamClass, rtpe :: Nil), TypeRef(_, RepeatedParamClass, atpe :: Nil)) => check(rtpe, atpe)
+        case (ExprClassOf(_), TreeType()) => success()
+        case (TreeType(), ExprClassOf(_)) => success()
+        case _ => rtpe <:< atpe
+      }
+    }
+
+    val ok =
+      if (verbose) withTypesExplained(check(rtpe, atpe))
+      else check(rtpe, atpe)
+    if (!ok) {
+      if (!macroDebugVerbose)
+        explainTypes(rtpe, atpe)
+      compatibilityError("type mismatch for %s: %s does not conform to %s".format(slot, abbreviateCoreAliases(rtpe.toString), abbreviateCoreAliases(atpe.toString)))
+    }
+  }
+
+  private def compatibilityError(message: String) =
+    implRefError(
+      "macro implementation has wrong shape:"+
+      "\n required: " + showMeth(rparamss, rret, abbreviate = true) +
+      "\n found   : " + showMeth(aparamss, aret, abbreviate = false) +
+      "\n" + message)
+
+  def MacroImplNonTagImplicitParameters(params: List[Symbol]) = compatibilityError("macro implementations cannot have implicit parameters other than WeakTypeTag evidences")
+
+  def MacroImplParamssMismatchError() = compatibilityError("number of parameter sections differ")
+
+  def MacroImplExtraParamsError(aparams: List[Symbol], rparams: List[Symbol]) = compatibilityError(lengthMsg("value", "found", aparams(rparams.length)))
+
+  def MacroImplMissingParamsError(aparams: List[Symbol], rparams: List[Symbol]) = compatibilityError(abbreviateCoreAliases(lengthMsg("value", "required", rparams(aparams.length))))
+
+  def checkMacroImplParamTypeMismatch(atpe: Type, rparam: Symbol) = checkConforms("parameter " + rparam.name, rparam.tpe, atpe)
+
+  def checkMacroImplResultTypeMismatch(atpe: Type, rret: Type) = checkConforms("return type", atpe, rret)
+
+  def MacroImplParamNameMismatchError(aparam: Symbol, rparam: Symbol) = compatibilityError("parameter names differ: " + rparam.name + " != " + aparam.name)
+
+  def MacroImplVarargMismatchError(aparam: Symbol, rparam: Symbol) = {
+    def fail(paramName: Name) = compatibilityError("types incompatible for parameter " + paramName + ": corresponding is not a vararg parameter")
+    if (isRepeated(rparam) && !isRepeated(aparam)) fail(rparam.name)
+    if (!isRepeated(rparam) && isRepeated(aparam)) fail(aparam.name)
+  }
+
+  def MacroImplTargMismatchError(atargs: List[Type], atparams: List[Symbol]) =
+    compatibilityError(NotWithinBoundsErrorMessage("", atargs, atparams, macroDebugVerbose || settings.explaintypes.value))
+
+  def MacroImplTparamInstantiationError(atparams: List[Symbol], ex: NoInstance) =
+    compatibilityError(
+      "type parameters "+(atparams map (_.defString) mkString ", ")+" cannot be instantiated\n"+
+      ex.getMessage)
+}

src/compiler/scala/reflect/macros/compiler/Resolvers.scala

@@ -0,0 +1,91 @@
+package scala.reflect.macros
+package compiler
+
+import scala.reflect.internal.Flags._
+import scala.reflect.macros.TypecheckException
+
+trait Resolvers {
+  self: DefaultMacroCompiler =>
+
+  import global._
+  import analyzer._
+  import definitions._
+  import treeInfo._
+  import gen._
+
+  /** Determines the type of context implied by the macro def.
+   */
+  val ctxTpe = MacroContextClass.tpe
+
+  /** Resolves a macro impl reference provided in the right-hand side of the given macro definition.
+   *
+   *  Acceptable shapes of the right-hand side:
+   *    1) [<static object>].<method name>[[<type args>]] // vanilla macro def
+   *    2) [<macro bundle>].<method name>[[<type args>]]  // shiny new macro bundle
+   *
+   *  Produces a tree, which represents a reference to a macro implementation if everything goes well,
+   *  otherwise reports found errors and returns EmptyTree. The resulting tree should have the following format:
+   *
+   *    qualifier.method[targs]
+   *
+   *  Qualifier here might be omitted (local macro defs), be a static object (vanilla macro defs)
+   *  or be a dummy instance of a macro bundle (e.g. new MyMacro(???).expand).
+   */
+  lazy val macroImplRef: Tree = {
+    val (maybeBundleRef, methName, targs) = macroDdef.rhs match {
+      case Applied(methRef @ Select(bundleRef @ RefTree(qual, bundleName), methName), targs, Nil) =>
+        (RefTree(qual, bundleName.toTypeName), methName, targs)
+      case Applied(Ident(methName), targs, Nil) =>
+        (Ident(context.owner.enclClass), methName, targs)
+      case _ =>
+        (EmptyTree, TermName(""), Nil)
+    }
+
+    val untypedImplRef = typer.silent(_.typedType(maybeBundleRef)) match {
+      case SilentResultValue(result) if isMacroBundleType(result.tpe) =>
+        val bundleClass = result.tpe.typeSymbol
+        if (!bundleClass.owner.isPackageClass) abort(macroDef.pos, "macro bundles can only be defined as top-level classes or traits")
+
+        // synthesize the invoker, i.e. given a top-level `trait Foo extends Macro { def expand = ... } `
+        // create a top-level definition `class FooInvoker(val c: Context) extends Foo` in MACRO_INVOKER_PACKAGE
+        val invokerPid = gen.mkUnattributedRef(nme.MACRO_INVOKER_PACKAGE)
+        val invokerName = TypeName(bundleClass.fullName.split('.').map(_.capitalize).mkString("") + nme.MACRO_INVOKER_SUFFIX)
+        val invokerFullName = TypeName(s"$invokerPid.$invokerName")
+        val existingInvoker = rootMirror.getClassIfDefined(invokerFullName)
+        if (!currentRun.compiles(existingInvoker)) {
+          def mkContextValDef(flags: Long) = ValDef(Modifiers(flags), nme.c, TypeTree(ctxTpe), EmptyTree)
+          val contextField = mkContextValDef(PARAMACCESSOR)
+          val contextParam = mkContextValDef(PARAM | PARAMACCESSOR)
+          val invokerCtor = DefDef(Modifiers(), nme.CONSTRUCTOR, Nil, List(List(contextParam)), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))
+          val invoker = atPos(bundleClass.pos)(ClassDef(NoMods, invokerName, Nil, Template(List(Ident(bundleClass)), emptyValDef, List(contextField, invokerCtor))))
+          currentRun.compileLate(PackageDef(invokerPid, List(invoker)))
+        }
+
+        // synthesize the macro impl reference, which is going to look like:
+        // `new Foo$invoker(???).expand` plus the optional type arguments
+        val instanceOfInvoker = New(Select(invokerPid, invokerName), List(List(Select(scalaDot(nme.Predef), nme.???))))
+        gen.mkTypeApply(Select(instanceOfInvoker, methName), targs)
+      case _ =>
+        macroDdef.rhs
+    }
+
+    val typedImplRef = typer.silent(_.typed(markMacroImplRef(untypedImplRef)), reportAmbiguousErrors = false)
+    typedImplRef match {
+      case SilentResultValue(success) => success
+      case SilentTypeError(err) => abort(err.errPos, err.errMsg)
+    }
+  }
+
+  // FIXME: cannot write this concisely because of SI-7507
+  // lazy val (isImplBundle, macroImplOwner, macroImpl, macroImplTargs) =
+  private lazy val dissectedMacroImplRef =
+    macroImplRef match {
+      case MacroImplReference(isBundle, owner, meth, targs) => (isBundle, owner, meth, targs)
+      case _ => MacroImplReferenceWrongShapeError()
+    }
+  lazy val isImplBundle = dissectedMacroImplRef._1
+  lazy val isImplMethod = !isImplBundle
+  lazy val macroImplOwner = dissectedMacroImplRef._2
+  lazy val macroImpl = dissectedMacroImplRef._3
+  lazy val targs = dissectedMacroImplRef._4
+}