From ce37ae45e22463a3f1a2d659d6699f2977b26c6b Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Wed, 2 Oct 2013 16:47:11 +0200 Subject: [PATCH] blackbox and whitebox macros This is the first commit in the series. This commit only: 1) Splits Context into BlackboxContext and WhiteboxContext 2) Splits Macro into BlackboxMacro and WhiteboxMacro 3) Introduces the isBundle property in the macro impl binding Here we just teach the compiler that macros can now be blackbox and whitebox, without actually imposing any restrictions on blackbox macros. These restrictions will come in subsequent commits. For description and documentation of the blackbox/whitebox separation see the official macro guide at the scaladoc website: http://docs.scala-lang.org/overviews/macros/blackbox-whitebox.html Some infrastructure work to make evolving macros easier: compile partest-extras with quick so they can use latest library/reflect/... --- build.xml | 19 ++--- .../reflect/macros/compiler/Errors.scala | 2 +- .../reflect/macros/compiler/Resolvers.scala | 20 +++-- .../reflect/macros/compiler/Validators.scala | 16 ++-- .../reflect/macros/contexts/Context.scala | 3 +- .../macros/runtime/MacroRuntimes.scala | 2 +- .../scala/reflect/macros/util/Helpers.scala | 10 +-- .../tools/nsc/typechecker/ContextErrors.scala | 3 + .../tools/nsc/typechecker/Implicits.scala | 2 +- .../scala/tools/nsc/typechecker/Macros.scala | 78 ++++++++++--------- .../scala/tools/nsc/typechecker/Typers.scala | 2 +- .../scala/tools/reflect/StdTags.scala | 2 +- .../scala/tools/partest/Util.scala | 4 +- src/reflect/scala/reflect/api/Exprs.scala | 2 +- src/reflect/scala/reflect/api/Importers.scala | 2 +- src/reflect/scala/reflect/api/Mirrors.scala | 6 +- src/reflect/scala/reflect/api/Universe.scala | 5 +- .../scala/reflect/internal/Definitions.scala | 56 ++++++++++--- .../scala/reflect/internal/TreeInfo.scala | 14 +++- .../scala/reflect/macros/Aliases.scala | 4 +- .../{Context.scala => BlackboxContext.scala} | 36 +++++---- .../{Macro.scala => BlackboxMacro.scala} | 15 ++-- .../scala/reflect/macros/Enclosures.scala | 6 +- src/reflect/scala/reflect/macros/Evals.scala | 8 +- .../scala/reflect/macros/ExprUtils.scala | 4 +- .../scala/reflect/macros/FrontEnds.scala | 4 +- .../scala/reflect/macros/Infrastructure.scala | 4 +- src/reflect/scala/reflect/macros/Names.scala | 4 +- .../scala/reflect/macros/Parsers.scala | 4 +- .../scala/reflect/macros/Reifiers.scala | 4 +- src/reflect/scala/reflect/macros/Typers.scala | 6 +- .../reflect/macros/WhiteboxContext.scala | 43 ++++++++++ .../scala/reflect/macros/WhiteboxMacro.scala | 36 +++++++++ .../scala/reflect/macros/package.scala | 14 +++- .../reflect/runtime/JavaUniverseForce.scala | 7 +- .../scala/reflect/runtime/package.scala | 2 +- test/files/neg/macro-abort/Macros_1.scala | 4 +- .../Impls_Macros_Test_1.scala | 2 +- test/files/neg/macro-bundle-abstract.check | 4 +- test/files/neg/macro-bundle-abstract.scala | 5 +- test/files/neg/macro-bundle-class.check | 2 +- test/files/neg/macro-bundle-class.scala | 6 +- test/files/neg/macro-bundle-mixbox.check | 4 + test/files/neg/macro-bundle-mixbox.scala | 10 +++ test/files/neg/macro-bundle-object.check | 6 +- test/files/neg/macro-bundle-object.scala | 7 +- test/files/neg/macro-bundle-polymorphic.check | 6 +- test/files/neg/macro-bundle-polymorphic.scala | 5 +- test/files/neg/macro-bundle-trait.check | 2 +- test/files/neg/macro-bundle-trait.scala | 8 +- .../neg/macro-cyclic/Impls_Macros_1.scala | 4 +- .../Impls_Macros_1.scala | 4 +- test/files/neg/macro-exception/Macros_1.scala | 4 +- .../Impls_Macros_1.scala | 4 +- test/files/neg/macro-invalidimpl.check | 20 ++--- .../files/neg/macro-invalidimpl/Impls_1.scala | 20 ++--- .../neg/macro-invalidimpl/Macros_Test_2.scala | 4 +- test/files/neg/macro-invalidret.check | 12 +-- test/files/neg/macro-invalidret/Impls_1.scala | 6 +- .../neg/macro-invalidshape/Impls_1.scala | 2 +- .../macro-invalidshape/Macros_Test_2.scala | 2 +- .../neg/macro-invalidsig-params-badtype.check | 6 +- .../Impls_Macros_1.scala | 2 +- test/files/neg/macro-invalidsig.check | 70 ++++++++--------- test/files/neg/macro-invalidsig/Impls_1.scala | 30 +++---- .../macro-invalidusage-badargs/Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../macro-invalidusage-badtargs/Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../macro-invalidusage-presuper/Impls_1.scala | 4 +- test/files/neg/macro-noexpand/Impls_1.scala | 2 +- .../neg/macro-nontypeablebody/Impls_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../Impls_Macros_1.scala | 4 +- .../Impls_1.scala | 2 +- .../neg/macro-quasiquotes/Macros_1.scala | 4 +- .../neg/macro-without-xmacros-a/Impls_1.scala | 2 +- .../neg/macro-without-xmacros-b/Impls_1.scala | 2 +- test/files/neg/t5689.check | 6 +- test/files/neg/t5689.scala | 4 +- test/files/neg/t5753/Impls_Macros_1.scala | 2 +- test/files/neg/t5753/Test_2.scala | 2 +- test/files/neg/t5903a/Macros_1.scala | 4 +- test/files/neg/t5903b/Macros_1.scala | 4 +- test/files/neg/t5903c/Macros_1.scala | 4 +- test/files/neg/t5903d/Macros_1.scala | 4 +- test/files/neg/t5903e/Macros_1.scala | 4 +- .../files/neg/t6123-explaintypes-macros.check | 6 +- .../t6123-explaintypes-macros/BadMac_2.scala | 4 +- .../t6123-explaintypes-macros/Macros.scala | 4 +- test/files/neg/t6539/Macro_1.scala | 4 +- test/files/neg/t7157/Impls_Macros_1.scala | 26 +++---- test/files/pos/annotated-original/M_1.scala | 4 +- .../annotated-treecopy/Impls_Macros_1.scala | 4 +- .../Impls_1.scala | 4 +- .../pos/attachments-typed-ident/Impls_1.scala | 4 +- test/files/pos/t5692a/Macros_1.scala | 4 +- test/files/pos/t5692b/Macros_1.scala | 4 +- test/files/pos/t5706.scala | 13 +++- test/files/pos/t5744/Macros_1.scala | 6 +- test/files/pos/t6047.scala | 4 +- test/files/pos/t6447.scala | 8 +- test/files/pos/t6485a/Macros_1.scala | 4 +- test/files/pos/t6485b/Test.scala | 4 +- test/files/pos/t6516.scala | 6 +- test/files/pos/t7377/Macro_1.scala | 4 +- test/files/pos/t7461/Macros_1.scala | 4 +- test/files/pos/t7649.scala | 2 +- .../run/macro-abort-fresh/Macros_1.scala | 4 +- .../run/macro-auto-duplicate/Macros_1.scala | 4 +- .../run/macro-basic-ma-md-mi/Impls_1.scala | 2 +- .../macro-basic-ma-mdmi/Impls_Macros_1.scala | 2 +- .../run/macro-basic-mamd-mi/Impls_1.scala | 2 +- .../run/macro-bodyexpandstoimpl/Impls_1.scala | 7 +- .../Macros_Test_2.scala | 2 +- test/files/run/macro-bundle-repl.check | 8 +- test/files/run/macro-bundle-repl.scala | 8 +- .../macro-bundle-static/Impls_Macros_1.scala | 7 +- .../Impls_Macros_1.scala | 7 +- .../macro-def-infer-return-type/Impls_1.scala | 8 +- .../run/macro-def-path-dependent/Test_1.scala | 2 +- .../run/macro-def-path-dependent/Test_2.scala | 2 +- .../run/macro-def-path-dependent/Test_3.scala | 2 +- .../run/macro-def-path-dependent/Test_4.scala | 4 +- .../run/macro-def-path-dependent/Test_5.scala | 4 +- .../run/macro-def-path-dependent/Test_6.scala | 2 +- .../Impls_Macros_1.scala | 4 +- .../run/macro-duplicate/Impls_Macros_1.scala | 4 +- .../run/macro-enclosures/Impls_Macros_1.scala | 4 +- .../Macros_1.scala | 4 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../run/macro-expand-overload/Impls_1.scala | 2 +- .../run/macro-expand-override/Impls_1.scala | 2 +- .../run/macro-expand-recursive/Impls_1.scala | 2 +- .../run/macro-expand-tparams-bounds.check | 2 + .../macro-expand-tparams-bounds/Impls_1.scala | 6 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../macro-expand-tparams-prefix/Impls_1.scala | 8 +- .../Impls_Macros_1.scala | 4 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../run/macro-impl-relaxed/Macros_1.scala | 10 +-- .../Impls_Macros_1.scala | 2 +- .../run/macro-impl-tparam-only-in-impl.check | 1 + .../Impls_1.scala | 4 +- .../Impls_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../run/macro-openmacros/Impls_Macros_1.scala | 4 +- .../macro-parse-position/Impls_Macros_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../run/macro-quasiquotes/Macros_1.scala | 4 +- test/files/run/macro-range/Common_1.scala | 4 +- .../macro-range/Expansion_Impossible_2.scala | 4 +- .../Impls_Macros_1.scala | 2 +- .../Impls_1.scala | 2 +- .../run/macro-reify-basic/Macros_1.scala | 2 +- .../run/macro-reify-freevars/Macros_1.scala | 2 +- .../macro-reify-nested-a/Impls_Macros_1.scala | 8 +- .../macro-reify-nested-b/Impls_Macros_1.scala | 8 +- .../Impls_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../macro-reify-splice-splice/Macros_1.scala | 2 +- .../run/macro-reify-staticXXX/Macros_1.scala | 6 +- .../run/macro-reify-tagful-a/Macros_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../files/run/macro-reify-type/Macros_1.scala | 4 +- .../run/macro-reify-unreify/Macros_1.scala | 2 +- test/files/run/macro-repl-basic.check | 4 +- test/files/run/macro-repl-basic.scala | 2 +- test/files/run/macro-repl-dontexpand.check | 14 +++- test/files/run/macro-repl-dontexpand.scala | 6 +- .../run/macro-settings/Impls_Macros_1.scala | 4 +- .../macro-sip19-revised/Impls_Macros_1.scala | 4 +- .../run/macro-sip19/Impls_Macros_1.scala | 4 +- test/files/run/macro-system-properties.check | 6 +- test/files/run/macro-system-properties.scala | 4 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_Macros_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_1.scala | 2 +- .../Impls_Macros_1.scala | 6 +- .../Impls_Macros_1.scala | 6 +- .../Impls_Macros_1.scala | 6 +- .../Impls_Macros_1.scala | 6 +- .../Impls_Macros_1.scala | 4 +- .../Macros_1.scala | 6 +- test/files/run/repl-term-macros.check | 16 ++-- test/files/run/repl-term-macros.scala | 8 +- test/files/run/t5713/Impls_Macros_1.scala | 4 +- test/files/run/t5753_1/Impls_Macros_1.scala | 4 +- test/files/run/t5753_2/Impls_Macros_1.scala | 2 +- test/files/run/t5894.scala | 2 +- test/files/run/t5903a/Macros_1.scala | 4 +- test/files/run/t5903b/Macros_1.scala | 4 +- test/files/run/t5903c/Macros_1.scala | 4 +- test/files/run/t5903d/Macros_1.scala | 4 +- test/files/run/t5923a/Macros_1.scala | 4 +- test/files/run/t5923c/Macros_1.scala | 4 +- test/files/run/t5923d/Macros_1.scala | 4 +- test/files/run/t5940.scala | 6 +- test/files/run/t6187.check | 8 +- test/files/run/t6187.scala | 4 +- test/files/run/t6221/Macros_1.scala | 4 +- test/files/run/t6381.check | 4 +- test/files/run/t6381.scala | 2 +- test/files/run/t6394a/Macros_1.scala | 4 +- test/files/run/t6394b/Macros_1.scala | 4 +- test/files/run/t6662/Macro_1.scala | 4 +- .../t7008-scala-defined/Impls_Macros_2.scala | 4 +- test/files/run/t7008/Impls_Macros_2.scala | 4 +- test/files/run/t7047/Impls_Macros_1.scala | 4 +- test/files/run/t7157/Impls_Macros_1.scala | 4 +- test/files/run/t7240/Macros_1.scala | 4 +- test/files/run/t7375b/Macros_1.scala | 4 +- test/files/run/t7617a/Macros_1.scala | 6 +- test/files/run/t7617b/Macros_1.scala | 4 +- test/files/run/t7657/Macros_1.scala | 4 +- .../run/toolbox_current_run_compiles.scala | 4 +- test/files/run/typed-annotated/Macros_1.scala | 4 +- 246 files changed, 788 insertions(+), 619 deletions(-) rename src/reflect/scala/reflect/macros/{Context.scala => BlackboxContext.scala} (73%) rename src/reflect/scala/reflect/macros/{Macro.scala => BlackboxMacro.scala} (65%) create mode 100644 src/reflect/scala/reflect/macros/WhiteboxContext.scala create mode 100644 src/reflect/scala/reflect/macros/WhiteboxMacro.scala create mode 100644 test/files/neg/macro-bundle-mixbox.check create mode 100644 test/files/neg/macro-bundle-mixbox.scala create mode 100644 test/files/run/macro-expand-tparams-bounds.check create mode 100644 test/files/run/macro-impl-tparam-only-in-impl.check diff --git a/build.xml b/build.xml index 37d894e7d3a6..ad18e25f3d84 100755 --- a/build.xml +++ b/build.xml @@ -1406,13 +1406,6 @@ TODO: - - - - - - @@ -1504,10 +1497,14 @@ TODO: - - - + + + + + + + diff --git a/src/compiler/scala/reflect/macros/compiler/Errors.scala b/src/compiler/scala/reflect/macros/compiler/Errors.scala index 30ba082a81dc..9799428b40c9 100644 --- a/src/compiler/scala/reflect/macros/compiler/Errors.scala +++ b/src/compiler/scala/reflect/macros/compiler/Errors.scala @@ -33,7 +33,7 @@ trait Errors extends Traces { def MacroBundleNonStaticError() = implRefError("macro bundles must be static") - def MacroBundleWrongShapeError() = implRefError("macro bundles must be monomorphic traits extending scala.reflect.macros.Macro and not implementing its `val c: Context` member") + def MacroBundleWrongShapeError() = implRefError("macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member") // compatibility errors diff --git a/src/compiler/scala/reflect/macros/compiler/Resolvers.scala b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala index 9c4db1990b2f..03d306f59331 100644 --- a/src/compiler/scala/reflect/macros/compiler/Resolvers.scala +++ b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala @@ -15,10 +15,6 @@ trait Resolvers { private val runDefinitions = currentRun.runDefinitions import runDefinitions.{Predef_???, _} - /** 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: @@ -44,14 +40,14 @@ trait Resolvers { } val untypedImplRef = typer.silent(_.typedTypeConstructor(maybeBundleRef)) match { - case SilentResultValue(result) if result.tpe.baseClasses.contains(MacroClass) => + case SilentResultValue(result) if mightBeMacroBundleType(result.tpe) => val bundleProto = result.tpe.typeSymbol val bundlePkg = bundleProto.enclosingPackageClass if (!isMacroBundleProtoType(bundleProto.tpe)) MacroBundleWrongShapeError() if (!bundleProto.owner.isStaticOwner) MacroBundleNonStaticError() // synthesize the bundle, i.e. given a static `trait Foo extends Macro { def expand = ... } ` - // create a top-level definition `class Foo$Bundle(val c: Context) extends Foo` in a package next to `Foo` + // create a top-level definition `class Foo$Bundle(val c: BlackboxContext/WhiteboxContext) extends Foo` in a package next to `Foo` val bundlePid = gen.mkUnattributedRef(bundlePkg) val bundlePrefix = if (bundlePkg == EmptyPackageClass) bundleProto.fullName('$') @@ -59,7 +55,8 @@ trait Resolvers { val bundleName = TypeName(bundlePrefix + tpnme.MACRO_BUNDLE_SUFFIX) val existingBundle = bundleProto.enclosingPackageClass.info.decl(bundleName) if (!currentRun.compiles(existingBundle)) { - def mkContextValDef(flags: Long) = ValDef(Modifiers(flags), nme.c, TypeTree(ctxTpe), EmptyTree) + val contextType = if (isBlackboxMacroBundleType(bundleProto.tpe)) BlackboxContextClass.tpe else WhiteboxContextClass.tpe + def mkContextValDef(flags: Long) = ValDef(Modifiers(flags), nme.c, TypeTree(contextType), EmptyTree) val contextField = mkContextValDef(PARAMACCESSOR) val contextParam = mkContextValDef(PARAM | PARAMACCESSOR) val bundleCtor = DefDef(Modifiers(), nme.CONSTRUCTOR, Nil, List(List(contextParam)), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))) @@ -88,12 +85,13 @@ trait Resolvers { // lazy val (isImplBundle, macroImplOwner, macroImpl, macroImplTargs) = private lazy val dissectedMacroImplRef = macroImplRef match { - case MacroImplReference(isBundle, owner, meth, targs) => (isBundle, owner, meth, targs) + case MacroImplReference(isBundle, isBlackbox, owner, meth, targs) => (isBundle, isBlackbox, 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 + lazy val isImplBlackbox = dissectedMacroImplRef._2 + lazy val macroImplOwner = dissectedMacroImplRef._3 + lazy val macroImpl = dissectedMacroImplRef._4 + lazy val targs = dissectedMacroImplRef._5 } diff --git a/src/compiler/scala/reflect/macros/compiler/Validators.scala b/src/compiler/scala/reflect/macros/compiler/Validators.scala index 088b108844a8..e77c129c5193 100644 --- a/src/compiler/scala/reflect/macros/compiler/Validators.scala +++ b/src/compiler/scala/reflect/macros/compiler/Validators.scala @@ -49,8 +49,8 @@ trait Validators { map2(aparamss.flatten, rparamss.flatten)((aparam, rparam) => { if (aparam.name != rparam.name && !rparam.isSynthetic) MacroImplParamNameMismatchError(aparam, rparam) if (isRepeated(aparam) ^ isRepeated(rparam)) MacroImplVarargMismatchError(aparam, rparam) - val aparamtpe = aparam.tpe.dealias match { - case RefinedType(List(tpe), Scope(sym)) if tpe =:= ctxTpe && sym.allOverriddenSymbols.contains(MacroContextPrefixType) => tpe + val aparamtpe = aparam.tpe match { + case MacroContextType(tpe) => tpe case tpe => tpe } checkMacroImplParamTypeMismatch(atpeToRtpe(aparamtpe), rparam) @@ -93,20 +93,20 @@ trait Validators { * * For the following macro impl: * def fooBar[T: c.WeakTypeTag] - * (c: scala.reflect.macros.Context) + * (c: scala.reflect.macros.BlackboxContext) * (xs: c.Expr[List[T]]) * : c.Expr[T] = ... * * This function will return: - * (c: scala.reflect.macros.Context)(xs: c.Expr[List[T]])c.Expr[T] + * (c: scala.reflect.macros.BlackboxContext)(xs: c.Expr[List[T]])c.Expr[T] * * Note that type tag evidence parameters are not included into the result. * Type tag context bounds for macro impl tparams are optional. * Therefore compatibility checks ignore such parameters, and we don't need to bother about them here. * * This method cannot be reduced to just macroImpl.info, because macro implementations might - * come in different shapes. If the implementation is an apply method of a Macro-compatible object, - * then it won't have (c: Context) in its parameters, but will rather refer to Macro.c. + * come in different shapes. If the implementation is an apply method of a BlackboxMacro/WhiteboxMacro-compatible object, + * then it won't have (c: BlackboxContext/WhiteboxContext) in its parameters, but will rather refer to BlackboxMacro/WhiteboxMacro.c. * * @param macroImpl The macro implementation symbol */ @@ -123,7 +123,8 @@ trait Validators { * def foo[T](xs: List[T]): T = macro fooBar * * This function will return: - * (c: scala.reflect.macros.Context)(xs: c.Expr[List[T]])c.Expr[T] + * (c: scala.reflect.macros.BlackboxContext)(xs: c.Expr[List[T]])c.Expr[T] or + * (c: scala.reflect.macros.WhiteboxContext)(xs: c.Expr[List[T]])c.Expr[T] * * Note that type tag evidence parameters are not included into the result. * Type tag context bounds for macro impl tparams are optional. @@ -145,6 +146,7 @@ trait Validators { // had to move method's body to an object because of the recursive dependencies between sigma and param object SigGenerator { val cache = scala.collection.mutable.Map[Symbol, Symbol]() + val ctxTpe = if (isImplBlackbox) BlackboxContextClass.tpe else WhiteboxContextClass.tpe val ctxPrefix = if (isImplMethod) singleType(NoPrefix, makeParam(nme.macroContext, macroDdef.pos, ctxTpe, SYNTHETIC)) else singleType(ThisType(macroImpl.owner), macroImpl.owner.tpe.member(nme.c)) diff --git a/src/compiler/scala/reflect/macros/contexts/Context.scala b/src/compiler/scala/reflect/macros/contexts/Context.scala index 1355a839d935..7b79b52a18bc 100644 --- a/src/compiler/scala/reflect/macros/contexts/Context.scala +++ b/src/compiler/scala/reflect/macros/contexts/Context.scala @@ -3,7 +3,8 @@ package contexts import scala.tools.nsc.Global -abstract class Context extends scala.reflect.macros.Context +abstract class Context extends scala.reflect.macros.BlackboxContext + with scala.reflect.macros.WhiteboxContext with Aliases with Enclosures with Names diff --git a/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala index ffdbe11151eb..7de33413045b 100644 --- a/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala +++ b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala @@ -45,7 +45,7 @@ trait MacroRuntimes extends JavaReflectionRuntimes with ScalaReflectionRuntimes type MacroRuntime = MacroArgs => Any class MacroRuntimeResolver(val macroDef: Symbol) extends JavaReflectionResolvers with ScalaReflectionResolvers { - val binding = loadMacroImplBinding(macroDef) + val binding = loadMacroImplBinding(macroDef).get val isBundle = binding.isBundle val className = binding.className val methName = binding.methName diff --git a/src/compiler/scala/reflect/macros/util/Helpers.scala b/src/compiler/scala/reflect/macros/util/Helpers.scala index bb4f2055ade0..ff03696524d6 100644 --- a/src/compiler/scala/reflect/macros/util/Helpers.scala +++ b/src/compiler/scala/reflect/macros/util/Helpers.scala @@ -27,13 +27,13 @@ trait Helpers { import runDefinitions._ val MacroContextUniverse = definitions.MacroContextUniverse - val treeInfo.MacroImplReference(isBundle, _, macroImpl, _) = macroImplRef + val treeInfo.MacroImplReference(isBundle, _, _, macroImpl, _) = macroImplRef val paramss = macroImpl.paramss val ContextParam = paramss match { - case Nil | _ :+ Nil => NoSymbol // no implicit parameters in the signature => nothing to do - case _ if isBundle => macroImpl.owner.tpe member nme.c - case (cparam :: _) :: _ if cparam.tpe <:< MacroContextClass.tpe => cparam - case _ => NoSymbol // no context parameter in the signature => nothing to do + case Nil | _ :+ Nil => NoSymbol // no implicit parameters in the signature => nothing to do + case _ if isBundle => macroImpl.owner.tpe member nme.c + case (cparam :: _) :: _ if isMacroContextType(cparam.tpe) => cparam + case _ => NoSymbol // no context parameter in the signature => nothing to do } def transformTag(param: Symbol): Symbol = param.tpe.dealias match { case TypeRef(SingleType(SingleType(_, ContextParam), MacroContextUniverse), WeakTypeTagClass, targ :: Nil) => transform(param, targ.typeSymbol) diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 92f95e282bbd..7ecc2be9beab 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -527,6 +527,9 @@ trait ContextErrors { def TooManyArgsPatternError(fun: Tree) = NormalTypeError(fun, "too many arguments for unapply pattern, maximum = "+definitions.MaxTupleArity) + def BlackboxExtractorExpansion(fun: Tree) = + NormalTypeError(fun, "extractor macros can only be whitebox") + def WrongShapeExtractorExpansion(fun: Tree) = NormalTypeError(fun, "extractor macros can only expand into extractor calls") diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index b1a48f747827..c9dbdb93ff58 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -1147,7 +1147,7 @@ trait Implicits { gen.mkAttributedThis(thisSym) case _ => // if `pre` is not a PDT, e.g. if someone wrote - // implicitly[scala.reflect.macros.Context#TypeTag[Int]] + // implicitly[scala.reflect.macros.BlackboxContext#TypeTag[Int]] // then we need to fail, because we don't know the prefix to use during type reification // upd. we also need to fail silently, because this is a very common situation // e.g. quite often we're searching for BaseUniverse#TypeTag, e.g. for a type tag in any universe diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index 02fb70f3e5e5..f1b9bd483300 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -29,7 +29,7 @@ import Fingerprint._ * Then fooBar needs to point to a static method of the following form: * * def fooBar[T: c.WeakTypeTag] // type tag annotation is optional - * (c: scala.reflect.macros.Context) + * (c: scala.reflect.macros.BlackboxContext) * (xs: c.Expr[List[T]]) * : c.Expr[T] = { * ... @@ -67,7 +67,7 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { * * This solution is very simple, but unfortunately it's also lacking. If we use it, then * signatures of macro defs become transitively dependent on scala-reflect.jar - * (because they refer to macro impls, and macro impls refer to scala.reflect.macros.Context defined in scala-reflect.jar). + * (because they refer to macro impls, and macro impls refer to scala.reflect.macros.BlackboxContext/WhiteboxContext defined in scala-reflect.jar). * More details can be found in comments to https://issues.scala-lang.org/browse/SI-5940. * * Therefore we have to avoid putting macro impls into binding pickles and come up with our own serialization format. @@ -81,40 +81,42 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { * and various accounting information necessary when composing an argument list for the reflective invocation. */ case class MacroImplBinding( - // Is this macro impl a bundle (a trait extending Macro) or a vanilla def? - val isBundle: Boolean, - // Java class name of the class that contains the macro implementation - // is used to load the corresponding object with Java reflection - className: String, - // method name of the macro implementation - // `className` and `methName` are all we need to reflectively invoke a macro implementation - // because macro implementations cannot be overloaded - methName: String, - // flattens the macro impl's parameter lists having symbols replaced with their fingerprints - // currently fingerprints are calculated solely from types of the symbols: - // * c.Expr[T] => LiftedTyped - // * c.Tree => LiftedUntyped - // * c.WeakTypeTag[T] => Tagged(index of the type parameter corresponding to that type tag) - // * everything else (e.g. scala.reflect.macros.Context) => Other - // f.ex. for: def impl[T: WeakTypeTag, U, V: WeakTypeTag](c: Context)(x: c.Expr[T], y: c.Tree): (U, V) = ??? - // `signature` will be equal to List(List(Other), List(LiftedTyped, LiftedUntyped), List(Tagged(0), Tagged(2))) - signature: List[List[Fingerprint]], - // type arguments part of a macro impl ref (the right-hand side of a macro definition) - // these trees don't refer to a macro impl, so we can pickle them as is - targs: List[Tree]) { - + // Is this macro impl a bundle (a trait extending BlackboxMacro or WhiteboxMacro) or a vanilla def? + val isBundle: Boolean, + // Is this macro impl blackbox (i.e. having BlackboxContext in its signature)? + val isBlackbox: Boolean, + // Java class name of the class that contains the macro implementation + // is used to load the corresponding object with Java reflection + className: String, + // method name of the macro implementation + // `className` and `methName` are all we need to reflectively invoke a macro implementation + // because macro implementations cannot be overloaded + methName: String, + // flattens the macro impl's parameter lists having symbols replaced with their fingerprints + // currently fingerprints are calculated solely from types of the symbols: + // * c.Expr[T] => LiftedTyped + // * c.Tree => LiftedUntyped + // * c.WeakTypeTag[T] => Tagged(index of the type parameter corresponding to that type tag) + // * everything else (e.g. scala.reflect.macros.BlackboxContext/WhiteboxContext) => Other + // f.ex. for: def impl[T: WeakTypeTag, U, V: WeakTypeTag](c: BlackboxContext)(x: c.Expr[T], y: c.Tree): (U, V) = ??? + // `signature` will be equal to List(List(Other), List(LiftedTyped, LiftedUntyped), List(Tagged(0), Tagged(2))) + signature: List[List[Fingerprint]], + // type arguments part of a macro impl ref (the right-hand side of a macro definition) + // these trees don't refer to a macro impl, so we can pickle them as is + targs: List[Tree]) { // Was this binding derived from a `def ... = macro ???` definition? def is_??? = { val Predef_??? = currentRun.runDefinitions.Predef_??? className == Predef_???.owner.javaClassName && methName == Predef_???.name.encoded } + def isWhitebox = !isBlackbox } /** Macro def -> macro impl bindings are serialized into a `macroImpl` annotation * with synthetic content that carries the payload described in `MacroImplBinding`. * * For example, for a pair of macro definition and macro implementation: - * def impl(c: scala.reflect.macros.Context): c.Expr[Unit] = ??? + * def impl(c: scala.reflect.macros.BlackboxContext): c.Expr[Unit] = ??? * def foo: Unit = macro impl * * We will have the following annotation added on the macro definition `foo`: @@ -122,13 +124,14 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { * @scala.reflect.macros.internal.macroImpl( * `macro`( * "isBundle" = false, + * "isBlackbox" = true, * "signature" = List(Other), * "methodName" = "impl", * "versionFormat" = , * "className" = "Macros$")) */ object MacroImplBinding { - val versionFormat = 5.0 + val versionFormat = 6.0 def pickleAtom(obj: Any): Tree = obj match { @@ -151,7 +154,7 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { def pickle(macroImplRef: Tree): Tree = { val runDefinitions = currentRun.runDefinitions import runDefinitions._ - val MacroImplReference(isBundle, owner, macroImpl, targs) = macroImplRef + val MacroImplReference(isBundle, isBlackbox, owner, macroImpl, targs) = macroImplRef // todo. refactor when fixing SI-5498 def className: String = { @@ -182,6 +185,7 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { val payload = List[(String, Any)]( "versionFormat" -> versionFormat, "isBundle" -> isBundle, + "isBlackbox" -> isBlackbox, "className" -> className, "methodName" -> macroImpl.name.toString, "signature" -> signature @@ -237,10 +241,11 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { if (versionFormat != pickleVersionFormat) fail(s"expected version format $versionFormat, actual $pickleVersionFormat") val isBundle = unpickle("isBundle", classOf[Boolean]) + val isBlackbox = unpickle("isBlackbox", classOf[Boolean]) val className = unpickle("className", classOf[String]) val methodName = unpickle("methodName", classOf[String]) val signature = unpickle("signature", classOf[List[List[Fingerprint]]]) - MacroImplBinding(isBundle, className, methodName, signature, targs) + MacroImplBinding(isBundle, isBlackbox, className, methodName, signature, targs) } } @@ -249,14 +254,17 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { macroDef withAnnotation AnnotationInfo(MacroImplAnnotation.tpe, List(pickle), Nil) } - def loadMacroImplBinding(macroDef: Symbol): MacroImplBinding = { - val Some(AnnotationInfo(_, List(pickle), _)) = macroDef.getAnnotation(MacroImplAnnotation) - MacroImplBinding.unpickle(pickle) - } + def loadMacroImplBinding(macroDef: Symbol): Option[MacroImplBinding] = + macroDef.getAnnotation(MacroImplAnnotation) collect { + case AnnotationInfo(_, List(pickle), _) => MacroImplBinding.unpickle(pickle) + } + + def isBlackbox(expandee: Tree): Boolean = isBlackbox(dissectApplied(expandee).core.symbol) + def isBlackbox(macroDef: Symbol): Boolean = loadMacroImplBinding(macroDef).map(_.isBlackbox).getOrElse(false) def computeMacroDefTypeFromMacroImplRef(macroDdef: DefDef, macroImplRef: Tree): Type = { macroImplRef match { - case MacroImplReference(_, _, macroImpl, targs) => + case MacroImplReference(_, _, _, macroImpl, targs) => // Step I. Transform c.Expr[T] to T and everything else to Any var runtimeType = decreaseMetalevel(macroImpl.info.finalResultType) @@ -450,7 +458,7 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { (trees :+ tags).flatten } - val binding = loadMacroImplBinding(macroDef) + val binding = loadMacroImplBinding(macroDef).get if (binding.is_???) Nil else calculateMacroArgs(binding) } @@ -459,7 +467,7 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { } /** Keeps track of macros in-flight. - * See more informations in comments to `openMacros` in `scala.reflect.macros.Context`. + * See more informations in comments to `openMacros` in `scala.reflect.macros.WhiteboxContext`. */ private var _openMacros = List[MacroContext]() def openMacros = _openMacros diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index a9bb81c69145..fa704adde28b 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1111,7 +1111,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } if (tree.isType) adaptType() - else if (mode.typingExprNotFun && treeInfo.isMacroApplication(tree)) + else if (mode.typingExprNotFun && treeInfo.isMacroApplication(tree) && !isMacroExpansionSuppressed(tree)) macroExpandApply(this, tree, mode, pt) else if (mode.typingConstructorPattern) typedConstructorPattern(tree, pt) diff --git a/src/compiler/scala/tools/reflect/StdTags.scala b/src/compiler/scala/tools/reflect/StdTags.scala index 6c1821f8aa0c..5c53c81e8b15 100644 --- a/src/compiler/scala/tools/reflect/StdTags.scala +++ b/src/compiler/scala/tools/reflect/StdTags.scala @@ -49,7 +49,7 @@ object StdRuntimeTags extends StdTags { } abstract class StdContextTags extends StdTags { - val tc: scala.reflect.macros.Context + val tc: scala.reflect.macros.contexts.Context val u: tc.universe.type = tc.universe val m = tc.mirror } diff --git a/src/partest-extras/scala/tools/partest/Util.scala b/src/partest-extras/scala/tools/partest/Util.scala index 114658b0cde9..82143962918f 100644 --- a/src/partest-extras/scala/tools/partest/Util.scala +++ b/src/partest-extras/scala/tools/partest/Util.scala @@ -16,8 +16,8 @@ object Util { */ def trace[A](a: A) = macro traceImpl[A] - import scala.reflect.macros.Context - def traceImpl[A: c.WeakTypeTag](c: Context)(a: c.Expr[A]): c.Expr[A] = { + import scala.reflect.macros.BlackboxContext + def traceImpl[A: c.WeakTypeTag](c: BlackboxContext)(a: c.Expr[A]): c.Expr[A] = { import c.universe._ import definitions._ diff --git a/src/reflect/scala/reflect/api/Exprs.scala b/src/reflect/scala/reflect/api/Exprs.scala index 5b6ff2325c9e..50c8aa87793d 100644 --- a/src/reflect/scala/reflect/api/Exprs.scala +++ b/src/reflect/scala/reflect/api/Exprs.scala @@ -106,7 +106,7 @@ trait Exprs { self: Universe => * * The corresponding macro implementation should have the following signature (note how the return type denotes path-dependency on x): * {{{ - * object Impls { def foo_impl(c: Context)(x: c.Expr[X]): c.Expr[x.value.T] = ... } + * object Impls { def foo_impl(c: BlackboxContext)(x: c.Expr[X]): c.Expr[x.value.T] = ... } * }}} */ @compileTimeOnly("cannot use value except for signatures of macro implementations") diff --git a/src/reflect/scala/reflect/api/Importers.scala b/src/reflect/scala/reflect/api/Importers.scala index 4182b7d0bae2..e239b86452bf 100644 --- a/src/reflect/scala/reflect/api/Importers.scala +++ b/src/reflect/scala/reflect/api/Importers.scala @@ -34,7 +34,7 @@ package api * {{{ * def staticEval[T](x: T) = macro staticEval[T] * - * def staticEval[T](c: scala.reflect.macros.Context)(x: c.Expr[T]) = { + * def staticEval[T](c: scala.reflect.macros.BlackboxContext)(x: c.Expr[T]) = { * // creates a runtime reflection universe to host runtime compilation * import scala.reflect.runtime.{universe => ru} * val mirror = ru.runtimeMirror(c.libraryClassLoader) diff --git a/src/reflect/scala/reflect/api/Mirrors.scala b/src/reflect/scala/reflect/api/Mirrors.scala index ec128e31a3ed..a4cd531053b6 100644 --- a/src/reflect/scala/reflect/api/Mirrors.scala +++ b/src/reflect/scala/reflect/api/Mirrors.scala @@ -29,19 +29,19 @@ package api * Compile-time `Mirror`s make use of only classloader `Mirror`s to load `Symbol`s * by name. * - * The entry point to classloader `Mirror`s is via [[scala.reflect.macros.Context#mirror]]. + * The entry point to classloader `Mirror`s is via [[scala.reflect.macros.BlackboxContext#mirror]] or [[scala.reflect.macros.WhiteboxContext#mirror]]. * Typical methods which use classloader `Mirror`s include [[scala.reflect.api.Mirror#staticClass]], * [[scala.reflect.api.Mirror#staticModule]], and [[scala.reflect.api.Mirror#staticPackage]]. For * example: * {{{ - * import scala.reflect.macros.Context + * import scala.reflect.macros.BlackboxContext * * case class Location(filename: String, line: Int, column: Int) * * object Macros { * def currentLocation: Location = macro impl * - * def impl(c: Context): c.Expr[Location] = { + * def impl(c: BlackboxContext): c.Expr[Location] = { * import c.universe._ * val pos = c.macroApplication.pos * val clsLocation = c.mirror.staticModule("Location") // get symbol of "Location" object diff --git a/src/reflect/scala/reflect/api/Universe.scala b/src/reflect/scala/reflect/api/Universe.scala index 77b4827eab7d..534f69a23e1a 100644 --- a/src/reflect/scala/reflect/api/Universe.scala +++ b/src/reflect/scala/reflect/api/Universe.scala @@ -41,10 +41,11 @@ package api * res1: reflect.runtime.universe.Type = scala.Either[String,Int] * }}} * - * To obtain a `Universe` for use within a Scala macro, use [[scala.reflect.macros.Context#universe]]. For example: + * To obtain a `Universe` for use within a Scala macro, use [[scala.reflect.macros.BlackboxContext#universe]]. + * or [[scala.reflect.macros.WhiteboxContext#universe]]. For example: * {{{ * def printf(format: String, params: Any*): Unit = macro impl - * def impl(c: Context)(format: c.Expr[String], params: c.Expr[Any]*): c.Expr[Unit] = { + * def impl(c: BlackboxContext)(format: c.Expr[String], params: c.Expr[Any]*): c.Expr[Unit] = { * import c.universe._ * ... * } diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala index 7cb051c63d0c..563f23cb3bfe 100644 --- a/src/reflect/scala/reflect/internal/Definitions.scala +++ b/src/reflect/scala/reflect/internal/Definitions.scala @@ -495,15 +495,18 @@ trait Definitions extends api.StandardDefinitions { lazy val TreeCreatorClass = getClassIfDefined("scala.reflect.api.TreeCreator") // defined in scala-reflect.jar, so we need to be careful lazy val LiftableClass = getClassIfDefined("scala.reflect.api.Liftable") // defined in scala-reflect.jar, so we need to be careful - lazy val MacroClass = getClassIfDefined("scala.reflect.macros.Macro") // defined in scala-reflect.jar, so we need to be careful - def MacroContextValue = MacroClass.map(sym => getMemberValue(sym, nme.c)) - lazy val MacroContextClass = getClassIfDefined("scala.reflect.macros.Context") // defined in scala-reflect.jar, so we need to be careful - def MacroContextPrefix = MacroContextClass.map(sym => getMemberMethod(sym, nme.prefix)) - def MacroContextPrefixType = MacroContextClass.map(sym => getTypeMember(sym, tpnme.PrefixType)) - def MacroContextUniverse = MacroContextClass.map(sym => getMemberMethod(sym, nme.universe)) - def MacroContextExprClass = MacroContextClass.map(sym => getTypeMember(sym, tpnme.Expr)) - def MacroContextWeakTypeTagClass = MacroContextClass.map(sym => getTypeMember(sym, tpnme.WeakTypeTag)) - def MacroContextTreeType = MacroContextClass.map(sym => getTypeMember(sym, tpnme.Tree)) + lazy val BlackboxMacroClass = getClassIfDefined("scala.reflect.macros.BlackboxMacro") // defined in scala-reflect.jar, so we need to be careful + def BlackboxMacroContextValue = BlackboxMacroClass.map(sym => getMemberValue(sym, nme.c)) + lazy val WhiteboxMacroClass = getClassIfDefined("scala.reflect.macros.WhiteboxMacro") // defined in scala-reflect.jar, so we need to be careful + def WhiteboxMacroContextValue = WhiteboxMacroClass.map(sym => getMemberValue(sym, nme.c)) + lazy val BlackboxContextClass = getClassIfDefined("scala.reflect.macros.BlackboxContext") // defined in scala-reflect.jar, so we need to be careful + lazy val WhiteboxContextClass = getClassIfDefined("scala.reflect.macros.WhiteboxContext") // defined in scala-reflect.jar, so we need to be careful + def MacroContextPrefix = BlackboxContextClass.map(sym => getMemberMethod(sym, nme.prefix)) + def MacroContextPrefixType = BlackboxContextClass.map(sym => getTypeMember(sym, tpnme.PrefixType)) + def MacroContextUniverse = BlackboxContextClass.map(sym => getMemberMethod(sym, nme.universe)) + def MacroContextExprClass = BlackboxContextClass.map(sym => getTypeMember(sym, tpnme.Expr)) + def MacroContextWeakTypeTagClass = BlackboxContextClass.map(sym => getTypeMember(sym, tpnme.WeakTypeTag)) + def MacroContextTreeType = BlackboxContextClass.map(sym => getTypeMember(sym, tpnme.Tree)) lazy val MacroImplAnnotation = requiredClass[scala.reflect.macros.internal.macroImpl] lazy val StringContextClass = requiredClass[scala.StringContext] @@ -593,18 +596,47 @@ trait Definitions extends api.StandardDefinitions { def unspecializedTypeArgs(tp: Type): List[Type] = (tp baseType unspecializedSymbol(tp.typeSymbolDirect)).typeArgs + object MacroContextType { + def unapply(tp: Type) = { + def isOneOfContextTypes(tp: Type) = + tp =:= BlackboxContextClass.tpe || tp =:= WhiteboxContextClass.tpe + def isPrefix(sym: Symbol) = + sym.allOverriddenSymbols.contains(MacroContextPrefixType) + + tp.dealias match { + case RefinedType(List(tp), Scope(sym)) if isOneOfContextTypes(tp) && isPrefix(sym) => Some(tp) + case tp if isOneOfContextTypes(tp) => Some(tp) + case _ => None + } + } + } + + def isMacroContextType(tp: Type) = MacroContextType.unapply(tp).isDefined + + def isWhiteboxContextType(tp: Type) = + isMacroContextType(tp) && (tp <:< WhiteboxContextClass.tpe) + + def mightBeMacroBundleType(tp: Type) = + tp.baseClasses.contains(WhiteboxMacroClass) || + tp.baseClasses.contains(BlackboxMacroClass) + def isMacroBundleType(tp: Type) = tp.baseClasses match { case _ :: proto :: _ if isMacroBundleProtoType(proto.tpe) => true case _ => false } + def isBlackboxMacroBundleType(tp: Type) = + isMacroBundleType(tp) && (tp <:< BlackboxMacroClass.tpe) && !(tp <:< WhiteboxMacroClass.tpe) + def isMacroBundleProtoType(tp: Type) = { val sym = tp.typeSymbol val isNonTrivial = tp != ErrorType && tp != NothingTpe && tp != NullTpe - val isMacroCompatible = MacroClass != NoSymbol && tp.baseClasses.contains(MacroClass) - val isBundlePrototype = sym != MacroClass && sym.isTrait && { + def subclasses(sym: Symbol) = sym != NoSymbol && tp.baseClasses.contains(sym) + val isMacroCompatible = subclasses(BlackboxMacroClass) ^ subclasses(WhiteboxMacroClass) + val isBundlePrototype = sym != BlackboxMacroClass && sym != WhiteboxMacroClass && sym.isTrait && { val c = sym.info.member(nme.c) - val cIsOk = c.overrideChain.contains(MacroContextValue) && c.isDeferred + def overrides(sym: Symbol) = c.overrideChain.contains(sym) + val cIsOk = (overrides(BlackboxMacroContextValue) || overrides(WhiteboxMacroContextValue)) && c.isDeferred cIsOk && sym.isMonomorphicType } isNonTrivial && isMacroCompatible && isBundlePrototype diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala index 025965ad47b1..8982fd4246e6 100644 --- a/src/reflect/scala/reflect/internal/TreeInfo.scala +++ b/src/reflect/scala/reflect/internal/TreeInfo.scala @@ -18,7 +18,7 @@ abstract class TreeInfo { val global: SymbolTable import global._ - import definitions.{ isTupleSymbol, isVarArgsList, isCastSymbol, ThrowableClass, TupleClass, MacroContextClass, MacroContextPrefixType, uncheckedStableClass } + import definitions.{ isTupleSymbol, isVarArgsList, isCastSymbol, ThrowableClass, TupleClass, uncheckedStableClass, isBlackboxMacroBundleType, isWhiteboxContextType } /* Does not seem to be used. Not sure what it does anyway. def isOwnerDefinition(tree: Tree): Boolean = tree match { @@ -822,13 +822,19 @@ abstract class TreeInfo { case ref: RefTree => { val qual = ref.qualifier val isBundle = definitions.isMacroBundleType(qual.tpe) + val isBlackbox = + if (isBundle) isBlackboxMacroBundleType(qual.tpe) + else ref.symbol.paramss match { + case (c :: Nil) :: _ if isWhiteboxContextType(c.info) => false + case _ => true + } val owner = if (isBundle) qual.tpe.typeSymbol else { - val sym = if (qual.hasSymbolField) qual.symbol else NoSymbol - if (sym.isModule) sym.moduleClass else sym + val qualSym = if (qual.hasSymbolField) qual.symbol else NoSymbol + if (qualSym.isModule) qualSym.moduleClass else qualSym } - Some((isBundle, owner, ref.symbol, dissectApplied(tree).targs)) + Some((isBundle, isBlackbox, owner, ref.symbol, dissectApplied(tree).targs)) } case _ => None } diff --git a/src/reflect/scala/reflect/macros/Aliases.scala b/src/reflect/scala/reflect/macros/Aliases.scala index 9e05f343e679..ca599dbd491c 100644 --- a/src/reflect/scala/reflect/macros/Aliases.scala +++ b/src/reflect/scala/reflect/macros/Aliases.scala @@ -5,11 +5,11 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that defines shorthands for the + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that defines shorthands for the * most frequently used types and functions of the underlying compiler universe. */ trait Aliases { - self: Context => + self: BlackboxContext => /** The type of symbols representing declarations. */ type Symbol = universe.Symbol diff --git a/src/reflect/scala/reflect/macros/Context.scala b/src/reflect/scala/reflect/macros/BlackboxContext.scala similarity index 73% rename from src/reflect/scala/reflect/macros/Context.scala rename to src/reflect/scala/reflect/macros/BlackboxContext.scala index b0c816f4ad05..2c7728986609 100644 --- a/src/reflect/scala/reflect/macros/Context.scala +++ b/src/reflect/scala/reflect/macros/BlackboxContext.scala @@ -2,14 +2,10 @@ package scala package reflect package macros -// todo. introduce context hierarchy -// the most lightweight context should just expose the stuff from the SIP -// the full context should include all traits from scala.reflect.macros (and probably reside in scala-compiler.jar) - /** * EXPERIMENTAL * - * The Scala macros context. + * The blackbox Scala macros context. * * See [[scala.reflect.macros.package the overview page]] for a description of how macros work. This documentation * entry provides information on the API available to macro writers. @@ -27,17 +23,25 @@ package macros * Other than that, macro contexts provide facilities for typechecking, exploring the compiler's symbol table and * enclosing trees and compilation units, evaluating trees, logging warnings/errors and much more. * Refer to the documentation of top-level traits in this package to learn the details. + * + * If a macro def refers to a macro impl that uses `BlackboxContext`, then this macro def becomes a blackbox macro, + * which means that its expansion will be upcast to its return type, enforcing faithfullness of that macro to its + * type signature. Whitebox macros, i.e. the ones defined with `WhiteboxContext`, aren't bound by this restriction, + * which enables a number of important use cases, but they are also going to enjoy less support than blackbox macros, + * so choose wisely. See the [[http://docs.scala-lang.org/overviews/macros.html Macros Guide]] for more information. + * + * @see `scala.reflect.macros.WhiteboxContext` */ -trait Context extends Aliases - with Enclosures - with Names - with Reifiers - with FrontEnds - with Infrastructure - with Typers - with Parsers - with Evals - with ExprUtils { +trait BlackboxContext extends Aliases + with Enclosures + with Names + with Reifiers + with FrontEnds + with Infrastructure + with Typers + with Parsers + with Evals + with ExprUtils { /** The compile-time universe. */ val universe: Universe @@ -59,7 +63,7 @@ trait Context extends Aliases * scala> class Coll[T] { * | def filter(p: T => Boolean): Coll[T] = macro M.filter[T] * | }; object M { - * | def filter[T](c: Context { type PrefixType = Coll[T] }) + * | def filter[T](c: BlackboxContext { type PrefixType = Coll[T] }) * | (p: c.Expr[T => Boolean]): c.Expr[Coll[T]] = * | { * | println(c.prefix.tree) diff --git a/src/reflect/scala/reflect/macros/Macro.scala b/src/reflect/scala/reflect/macros/BlackboxMacro.scala similarity index 65% rename from src/reflect/scala/reflect/macros/Macro.scala rename to src/reflect/scala/reflect/macros/BlackboxMacro.scala index 44bedf483d6d..df142e92386e 100644 --- a/src/reflect/scala/reflect/macros/Macro.scala +++ b/src/reflect/scala/reflect/macros/BlackboxMacro.scala @@ -6,15 +6,15 @@ package macros * * Traditionally macro implementations are defined as methods, * but this trait provides an alternative way of encoding macro impls as - * bundles, traits which extend `scala.reflect.macros.Macro`. + * bundles, traits which extend `scala.reflect.macros.BlackboxMacro` or`scala.reflect.macros.WhiteboxMacro` . * * Instead of: * - * def impl[T: c.WeakTypeTag](c: Context)(x: c.Expr[Int]) = ... + * def impl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Expr[Int]) = ... * * One can write: * - * trait Impl extends Macro { + * trait Impl extends BlackboxMacro { * def apply[T: c.WeakTypeTag](x: c.Expr[Int]) = ... * } * @@ -24,16 +24,13 @@ package macros * are complex and need to be modularized. State of the art technique of addressing this need is quite heavyweight: * http://docs.scala-lang.org/overviews/macros/overview.html#writing_bigger_macros. * - * However utility of this approach to writing macros isn't limited to just convenience. - * When a macro implementation becomes not just a function, but a full-fledged module, - * it can define callbacks that will be called by the compiler upon interesting events. - * In subsequent commits I will add support for programmable type inference + * @see `scala.reflect.macros.WhiteboxMacro` */ -trait Macro { +trait BlackboxMacro { /** The context to be used by the macro implementation. * * Vanilla macro implementations have to carry it in their signatures, however when a macro is a full-fledged module, * it can define the context next to the implementation, makes implementation signature more lightweight. */ - val c: Context + val c: BlackboxContext } diff --git a/src/reflect/scala/reflect/macros/Enclosures.scala b/src/reflect/scala/reflect/macros/Enclosures.scala index d6ba5f39cd44..c3d019ccf355 100644 --- a/src/reflect/scala/reflect/macros/Enclosures.scala +++ b/src/reflect/scala/reflect/macros/Enclosures.scala @@ -7,13 +7,13 @@ import scala.language.existentials // SI-6541 /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that exposes + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that exposes * enclosing trees (method, class, compilation unit and currently compiled application), * the enclosing position of the macro expansion, as well as macros and implicits * that are currently in-flight. */ trait Enclosures { - self: Context => + self: BlackboxContext => /** The tree that undergoes macro expansion. * Can be useful to get an offset or a range position of the entire tree being processed. @@ -43,7 +43,7 @@ trait Enclosures { * Unlike `openMacros`, this is a val, which means that it gets initialized when the context is created * and always stays the same regardless of whatever happens during macro expansion. */ - def enclosingMacros: List[Context] + def enclosingMacros: List[BlackboxContext] /** Information about one of the currently considered implicit candidates. * Candidates are used in plural form, because implicit parameters may themselves have implicit parameters, diff --git a/src/reflect/scala/reflect/macros/Evals.scala b/src/reflect/scala/reflect/macros/Evals.scala index 70b2ab58d454..eb37e83cadb4 100644 --- a/src/reflect/scala/reflect/macros/Evals.scala +++ b/src/reflect/scala/reflect/macros/Evals.scala @@ -5,11 +5,11 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that provides + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that provides * a facility to evaluate trees. */ trait Evals { - self: Context => + self: BlackboxContext => /** Takes a typed wrapper for a tree of type `T` and evaluates it to a value of type `T`. * @@ -21,12 +21,12 @@ trait Evals { * mutates the tree in place, therefore the conventional approach is to `duplicate` the tree first. * * {{{ - * scala> def impl(c: Context)(x: c.Expr[String]) = { + * scala> def impl(c: BlackboxContext)(x: c.Expr[String]) = { * | val x1 = c.Expr[String](c.resetAllAttrs(x.tree.duplicate)) * | println(s"compile-time value is: \${c.eval(x1)}") * | x * | } - * impl: (c: Context)(x: c.Expr[String])c.Expr[String] + * impl: (c: BlackboxContext)(x: c.Expr[String])c.Expr[String] * * scala> def test(x: String) = macro impl * test: (x: String)String diff --git a/src/reflect/scala/reflect/macros/ExprUtils.scala b/src/reflect/scala/reflect/macros/ExprUtils.scala index 76a8392b9cf9..58b61e446a55 100644 --- a/src/reflect/scala/reflect/macros/ExprUtils.scala +++ b/src/reflect/scala/reflect/macros/ExprUtils.scala @@ -5,11 +5,11 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that defines shorthands for the + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that defines shorthands for the * most common `Expr`-creating functions. */ trait ExprUtils { - self: Context => + self: BlackboxContext => /** Shorthand for `Literal(Constant(null))` in the underlying `universe`. */ @deprecated("Use quasiquotes instead", "2.11.0") diff --git a/src/reflect/scala/reflect/macros/FrontEnds.scala b/src/reflect/scala/reflect/macros/FrontEnds.scala index 6abd8c335bc5..3a910d89ad2a 100644 --- a/src/reflect/scala/reflect/macros/FrontEnds.scala +++ b/src/reflect/scala/reflect/macros/FrontEnds.scala @@ -5,12 +5,12 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that * provides facilities to communicate with the compiler's front end * (emit warnings, errors and other sorts of messages). */ trait FrontEnds { - self: Context => + self: BlackboxContext => /** For sending a message which should not be labeled as a warning/error, * but also shouldn't require -verbose to be visible. diff --git a/src/reflect/scala/reflect/macros/Infrastructure.scala b/src/reflect/scala/reflect/macros/Infrastructure.scala index eb63fb7b7fc9..b6585f94d2db 100644 --- a/src/reflect/scala/reflect/macros/Infrastructure.scala +++ b/src/reflect/scala/reflect/macros/Infrastructure.scala @@ -5,11 +5,11 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that * provides facilities to communicate with the compiler's infrastructure. */ trait Infrastructure { - self: Context => + self: BlackboxContext => /** Exposes macro-specific settings as a list of strings. * These settings are passed to the compiler via the "-Xmacro-settings:setting1,setting2...,settingN" command-line option. diff --git a/src/reflect/scala/reflect/macros/Names.scala b/src/reflect/scala/reflect/macros/Names.scala index 8773175561da..6bd3e1a199ec 100644 --- a/src/reflect/scala/reflect/macros/Names.scala +++ b/src/reflect/scala/reflect/macros/Names.scala @@ -5,11 +5,11 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that * provides functions that generate unique names. */ trait Names { - self: Context => + self: BlackboxContext => /** Creates a unique string. */ @deprecated("Use freshName instead", "2.11.0") diff --git a/src/reflect/scala/reflect/macros/Parsers.scala b/src/reflect/scala/reflect/macros/Parsers.scala index 4232b05f8ca4..cbfb30f02286 100644 --- a/src/reflect/scala/reflect/macros/Parsers.scala +++ b/src/reflect/scala/reflect/macros/Parsers.scala @@ -5,12 +5,12 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that * exposes functions to parse strings with Scala code into trees. */ @deprecated("Use quasiquotes instead", "2.11.0") trait Parsers { - self: Context => + self: BlackboxContext => /** Parses a string with a Scala expression into an abstract syntax tree. * Only works for expressions, i.e. parsing a package declaration will fail. diff --git a/src/reflect/scala/reflect/macros/Reifiers.scala b/src/reflect/scala/reflect/macros/Reifiers.scala index 6ebd2db730ce..67d10dc10a21 100644 --- a/src/reflect/scala/reflect/macros/Reifiers.scala +++ b/src/reflect/scala/reflect/macros/Reifiers.scala @@ -5,11 +5,11 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that * exposes functions to save reflection artifacts for runtime. */ trait Reifiers { - self: Context => + self: BlackboxContext => /** Given a tree, generate a tree that when compiled and executed produces the original tree. * For more information and examples see the documentation for `Universe.reify`. diff --git a/src/reflect/scala/reflect/macros/Typers.scala b/src/reflect/scala/reflect/macros/Typers.scala index d7aec9b3ef40..ec90ee8fe6d4 100644 --- a/src/reflect/scala/reflect/macros/Typers.scala +++ b/src/reflect/scala/reflect/macros/Typers.scala @@ -5,11 +5,11 @@ package macros /** * EXPERIMENTAL * - * A slice of [[scala.reflect.macros.Context the Scala macros context]] that + * A slice of [[scala.reflect.macros.BlackboxContext the Scala macros context]] that * partially exposes the type checker to macro writers. */ trait Typers { - self: Context => + self: BlackboxContext => /** Contexts that represent macros in-flight, including the current one. Very much like a stack trace, but for macros only. * Can be useful for interoperating with other macros and for imposing compiler-friendly limits on macro expansion. @@ -21,7 +21,7 @@ trait Typers { * Unlike `enclosingMacros`, this is a def, which means that it gets recalculated on every invocation, * so it might change depending on what is going on during macro expansion. */ - def openMacros: List[Context] + def openMacros: List[BlackboxContext] /** Information about one of the currently considered implicit candidates. * Candidates are used in plural form, because implicit parameters may themselves have implicit parameters, diff --git a/src/reflect/scala/reflect/macros/WhiteboxContext.scala b/src/reflect/scala/reflect/macros/WhiteboxContext.scala new file mode 100644 index 000000000000..76bc17746c96 --- /dev/null +++ b/src/reflect/scala/reflect/macros/WhiteboxContext.scala @@ -0,0 +1,43 @@ +package scala +package reflect +package macros + +/** + * EXPERIMENTAL + * + * The whitebox Scala macros context. + * + * See [[scala.reflect.macros.package the overview page]] for a description of how macros work. This documentation + * entry provides information on the API available to macro writers. + * + * A macro context wraps a compiler universe exposed in `universe` and having type [[scala.reflect.macros.Universe]]. + * This type is a refinement over the generic reflection API provided in [[scala.reflect.api.Universe]]. The + * extended Universe provides mutability for reflection artifacts (e.g. macros can change types of compiler trees, + * add annotation to symbols representing definitions, etc) and exposes some internal compiler functionality + * such as `Symbol.deSkolemize` or `Tree.attachments`. + * + * Another fundamental part of a macro context is `macroApplication`, which provides access to the tree undergoing + * macro expansion. Parts of this tree can be found in arguments of the corresponding macro implementations and + * in `prefix`, but `macroApplication` gives the full picture. + * + * Other than that, macro contexts provide facilities for typechecking, exploring the compiler's symbol table and + * enclosing trees and compilation units, evaluating trees, logging warnings/errors and much more. + * Refer to the documentation of top-level traits in this package to learn the details. + * + * If a macro def refers to a macro impl that uses `WhiteboxContext`, then this macro def becomes a whitebox macro, + * gaining the ability to refine the type of its expansion beyond its official return type, which enables a number of important use cases. + * Blackbox macros, i.e. the ones defined with `BlackboxContext`, can't do that, so they are less powerful. + * However blackbox macros are also going to enjoy better support than whitebox macros, so choose wisely. + * See the [[http://docs.scala-lang.org/overviews/macros.html Macros Guide]] for more information. + * + * @see `scala.reflect.macros.BlackboxContext` + */ +trait WhiteboxContext extends BlackboxContext { + /** @inheritdoc + */ + def openMacros: List[WhiteboxContext] + + /** @inheritdoc + */ + def enclosingMacros: List[WhiteboxContext] +} \ No newline at end of file diff --git a/src/reflect/scala/reflect/macros/WhiteboxMacro.scala b/src/reflect/scala/reflect/macros/WhiteboxMacro.scala new file mode 100644 index 000000000000..1c581313eb83 --- /dev/null +++ b/src/reflect/scala/reflect/macros/WhiteboxMacro.scala @@ -0,0 +1,36 @@ +package scala.reflect +package macros + +/** + * EXPERIMENTAL + * + * Traditionally macro implementations are defined as methods, + * but this trait provides an alternative way of encoding macro impls as + * bundles, traits which extend `scala.reflect.macros.BlackboxMacro` or`scala.reflect.macros.WhiteboxMacro` . + * + * Instead of: + * + * def impl[T: c.WeakTypeTag](c: WhiteboxContext)(x: c.Expr[Int]) = ... + * + * One can write: + * + * trait Impl extends WhiteboxMacro { + * def apply[T: c.WeakTypeTag](x: c.Expr[Int]) = ... + * } + * + * Without changing anything else at all. + * + * This language feature is useful in itself in cases when macro implementations + * are complex and need to be modularized. State of the art technique of addressing this need is quite heavyweight: + * http://docs.scala-lang.org/overviews/macros/overview.html#writing_bigger_macros. + * + * @see `scala.reflect.macros.BlackboxMacro` + */ +trait WhiteboxMacro { + /** The context to be used by the macro implementation. + * + * Vanilla macro implementations have to carry it in their signatures, however when a macro is a full-fledged module, + * it can define the context next to the implementation, makes implementation signature more lightweight. + */ + val c: WhiteboxContext +} diff --git a/src/reflect/scala/reflect/macros/package.scala b/src/reflect/scala/reflect/macros/package.scala index 2e2e8e79f841..6a8434a163a6 100644 --- a/src/reflect/scala/reflect/macros/package.scala +++ b/src/reflect/scala/reflect/macros/package.scala @@ -7,10 +7,22 @@ package reflect * The base package for Scala macros. * * Macros are functions that are called by the compiler during compilation. - * Within these functions the programmer has access to compiler APIs exposed in [[scala.reflect.macros.Context]]. + * Within these functions the programmer has access to compiler APIs. * For example, it is possible to generate, analyze and typecheck code. * * See the [[http://docs.scala-lang.org/overviews/macros.html Macros Guide]] on how to get started with Scala macros. */ package object macros { + /** The Scala macros context. + * + * In Scala 2.11, macros that were once the one are split into blackbox and whitebox macros, + * with the former being better supported and the latter being more powerful. You can read about + * the details of the split and the associated trade-offs in the [[http://docs.scala-lang.org/overviews/macros.html Macros Guide]]. + * + * `scala.reflect.macros.Context` follows this tendency and turns into `scala.reflect.macros.BlackboxContext` + * and `scala.reflect.macros.WhiteboxContext`. The original `Context` is left in place for compatibility reasons, + * but it is now deprecated, nudging the users to choose between blackbox and whitebox macros. + */ + @deprecated("Use BlackboxContext or WhiteboxContext instead", "2.11.0") + type Context = WhiteboxContext } \ No newline at end of file diff --git a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala index 4d69a6673ce8..50b5843c5978 100644 --- a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala +++ b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala @@ -314,8 +314,10 @@ trait JavaUniverseForce { self: runtime.JavaUniverse => definitions.TypeCreatorClass definitions.TreeCreatorClass definitions.LiftableClass - definitions.MacroClass - definitions.MacroContextClass + definitions.BlackboxMacroClass + definitions.WhiteboxMacroClass + definitions.BlackboxContextClass + definitions.WhiteboxContextClass definitions.MacroImplAnnotation definitions.StringContextClass definitions.QuasiquoteClass @@ -334,6 +336,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse => definitions.TupleClass definitions.FunctionClass definitions.AbstractFunctionClass + definitions.MacroContextType definitions.ProductRootClass definitions.Any_$eq$eq definitions.Any_$bang$eq diff --git a/src/reflect/scala/reflect/runtime/package.scala b/src/reflect/scala/reflect/runtime/package.scala index 41c1310e17d1..3a7688aa2cfb 100644 --- a/src/reflect/scala/reflect/runtime/package.scala +++ b/src/reflect/scala/reflect/runtime/package.scala @@ -26,7 +26,7 @@ package object runtime { package runtime { private[scala] object Macros { - def currentMirror(c: scala.reflect.macros.Context): c.Expr[universe.Mirror] = { + def currentMirror(c: scala.reflect.macros.BlackboxContext): c.Expr[universe.Mirror] = { import c.universe._ val runtimeClass = c.reifyEnclosingRuntimeClass if (runtimeClass.isEmpty) c.abort(c.enclosingPosition, "call site does not have an enclosing class") diff --git a/test/files/neg/macro-abort/Macros_1.scala b/test/files/neg/macro-abort/Macros_1.scala index 676c11209822..577e6400892a 100644 --- a/test/files/neg/macro-abort/Macros_1.scala +++ b/test/files/neg/macro-abort/Macros_1.scala @@ -1,8 +1,8 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { c.abort(c.enclosingPosition, "aborted") } def abort = macro impl diff --git a/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala b/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala index 97780ef50359..ae34815d375f 100644 --- a/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala +++ b/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = { diff --git a/test/files/neg/macro-bundle-abstract.check b/test/files/neg/macro-bundle-abstract.check index 4b07adcc9530..8ef59106b89f 100644 --- a/test/files/neg/macro-bundle-abstract.check +++ b/test/files/neg/macro-bundle-abstract.check @@ -1,4 +1,4 @@ -macro-bundle-abstract.scala:5: error: class Bundle$Bundle needs to be abstract, since method deferred in trait Bundle of type => Int is not defined -trait Bundle extends Macro { +macro-bundle-abstract.scala:4: error: class Bundle$Bundle needs to be abstract, since method deferred in trait Bundle of type => Int is not defined +trait Bundle extends BlackboxMacro { ^ one error found diff --git a/test/files/neg/macro-bundle-abstract.scala b/test/files/neg/macro-bundle-abstract.scala index 2b302045da45..f7778d03be2a 100644 --- a/test/files/neg/macro-bundle-abstract.scala +++ b/test/files/neg/macro-bundle-abstract.scala @@ -1,8 +1,7 @@ import scala.language.experimental.macros -import scala.reflect.macros.Macro -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxMacro -trait Bundle extends Macro { +trait Bundle extends BlackboxMacro { def deferred: Int def impl = ??? } diff --git a/test/files/neg/macro-bundle-class.check b/test/files/neg/macro-bundle-class.check index 92695390ab1c..8fd04f13030b 100644 --- a/test/files/neg/macro-bundle-class.check +++ b/test/files/neg/macro-bundle-class.check @@ -1,4 +1,4 @@ -macro-bundle-class.scala:10: error: macro bundles must be monomorphic traits extending scala.reflect.macros.Macro and not implementing its `val c: Context` member +macro-bundle-class.scala:10: error: macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member def foo = macro Bundle.impl ^ one error found diff --git a/test/files/neg/macro-bundle-class.scala b/test/files/neg/macro-bundle-class.scala index 4b92cdd40f81..024e2dbaaa4e 100644 --- a/test/files/neg/macro-bundle-class.scala +++ b/test/files/neg/macro-bundle-class.scala @@ -1,8 +1,8 @@ import scala.language.experimental.macros -import scala.reflect.macros.Macro -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxMacro +import scala.reflect.macros.BlackboxContext -class Bundle(val c: Context) extends Macro { +class Bundle(val c: BlackboxContext) extends BlackboxMacro { def impl = ??? } diff --git a/test/files/neg/macro-bundle-mixbox.check b/test/files/neg/macro-bundle-mixbox.check new file mode 100644 index 000000000000..4f8cedceceb2 --- /dev/null +++ b/test/files/neg/macro-bundle-mixbox.check @@ -0,0 +1,4 @@ +macro-bundle-mixbox.scala:9: error: macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member + def foo = macro Bundle.impl + ^ +one error found diff --git a/test/files/neg/macro-bundle-mixbox.scala b/test/files/neg/macro-bundle-mixbox.scala new file mode 100644 index 000000000000..1e36f3d94ccf --- /dev/null +++ b/test/files/neg/macro-bundle-mixbox.scala @@ -0,0 +1,10 @@ +import scala.language.experimental.macros +import scala.reflect.macros.{BlackboxMacro, WhiteboxMacro} + +trait Bundle extends BlackboxMacro with WhiteboxMacro { + def impl = ??? +} + +object Macros { + def foo = macro Bundle.impl +} \ No newline at end of file diff --git a/test/files/neg/macro-bundle-object.check b/test/files/neg/macro-bundle-object.check index 8c19271b5167..e148e8696970 100644 --- a/test/files/neg/macro-bundle-object.check +++ b/test/files/neg/macro-bundle-object.check @@ -1,6 +1,6 @@ -macro-bundle-object.scala:11: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree +macro-bundle-object.scala:10: error: macro implementation has wrong shape: + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree found : : Nothing number of parameter sections differ def foo = macro Bundle.impl diff --git a/test/files/neg/macro-bundle-object.scala b/test/files/neg/macro-bundle-object.scala index 98c4238a6248..105c81f1f51f 100644 --- a/test/files/neg/macro-bundle-object.scala +++ b/test/files/neg/macro-bundle-object.scala @@ -1,9 +1,8 @@ import scala.language.experimental.macros -import scala.reflect.macros.Macro -import scala.reflect.macros.Context +import scala.reflect.macros.{BlackboxMacro, BlackboxContext} -object Bundle extends Macro { - val c: Context = ??? +object Bundle extends BlackboxMacro { + val c: BlackboxContext = ??? def impl = ??? } diff --git a/test/files/neg/macro-bundle-polymorphic.check b/test/files/neg/macro-bundle-polymorphic.check index 204bd30bca99..07c5f551b15c 100644 --- a/test/files/neg/macro-bundle-polymorphic.check +++ b/test/files/neg/macro-bundle-polymorphic.check @@ -1,10 +1,10 @@ -macro-bundle-polymorphic.scala:10: error: macro bundles must be monomorphic traits extending scala.reflect.macros.Macro and not implementing its `val c: Context` member +macro-bundle-polymorphic.scala:9: error: macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member def foo = macro Bundle.impl ^ -macro-bundle-polymorphic.scala:11: error: macro bundles must be monomorphic traits extending scala.reflect.macros.Macro and not implementing its `val c: Context` member +macro-bundle-polymorphic.scala:10: error: macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member def foo = macro Bundle[Int].impl ^ -macro-bundle-polymorphic.scala:12: error: macro bundles must be monomorphic traits extending scala.reflect.macros.Macro and not implementing its `val c: Context` member +macro-bundle-polymorphic.scala:11: error: macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member def foo = macro Bundle[Int, Nothing].impl ^ three errors found diff --git a/test/files/neg/macro-bundle-polymorphic.scala b/test/files/neg/macro-bundle-polymorphic.scala index 0468d841bd17..faf1e2e9e525 100644 --- a/test/files/neg/macro-bundle-polymorphic.scala +++ b/test/files/neg/macro-bundle-polymorphic.scala @@ -1,8 +1,7 @@ import scala.language.experimental.macros -import scala.reflect.macros.Macro -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxMacro -trait Bundle[T] extends Macro { +trait Bundle[T] extends BlackboxMacro { def impl = ??? } diff --git a/test/files/neg/macro-bundle-trait.check b/test/files/neg/macro-bundle-trait.check index 972788c57716..bf906a531084 100644 --- a/test/files/neg/macro-bundle-trait.check +++ b/test/files/neg/macro-bundle-trait.check @@ -1,4 +1,4 @@ -macro-bundle-trait.scala:11: error: macro bundles must be monomorphic traits extending scala.reflect.macros.Macro and not implementing its `val c: Context` member +macro-bundle-trait.scala:11: error: macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member def foo = macro Bundle.impl ^ one error found diff --git a/test/files/neg/macro-bundle-trait.scala b/test/files/neg/macro-bundle-trait.scala index ddc87f6db361..62ade4995398 100644 --- a/test/files/neg/macro-bundle-trait.scala +++ b/test/files/neg/macro-bundle-trait.scala @@ -1,9 +1,9 @@ import scala.language.experimental.macros -import scala.reflect.macros.Macro -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxMacro +import scala.reflect.macros.BlackboxContext -trait Bundle extends Macro { - val c: Context = ??? +trait Bundle extends BlackboxMacro { + val c: BlackboxContext = ??? def impl = ??? } diff --git a/test/files/neg/macro-cyclic/Impls_Macros_1.scala b/test/files/neg/macro-cyclic/Impls_Macros_1.scala index ac9b7938db63..ba08345bcca5 100644 --- a/test/files/neg/macro-cyclic/Impls_Macros_1.scala +++ b/test/files/neg/macro-cyclic/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { c.universe.reify { implicitly[SourceLocation] } } diff --git a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala index 3983f590dca6..23fcdd6445a8 100644 --- a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala +++ b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros trait Complex[T] @@ -6,7 +6,7 @@ trait Complex[T] class Foo(val foo: Foo) object Complex { - def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = { + def impl[T: c.WeakTypeTag](c: BlackboxContext): c.Expr[Complex[T]] = { import c.universe._ val tpe = weakTypeOf[T] for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { diff --git a/test/files/neg/macro-exception/Macros_1.scala b/test/files/neg/macro-exception/Macros_1.scala index 60e4020aec4c..7bd8415e4fe0 100644 --- a/test/files/neg/macro-exception/Macros_1.scala +++ b/test/files/neg/macro-exception/Macros_1.scala @@ -1,8 +1,8 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { throw new Exception() } def exception = macro impl diff --git a/test/files/neg/macro-false-deprecation-warning/Impls_Macros_1.scala b/test/files/neg/macro-false-deprecation-warning/Impls_Macros_1.scala index 6dc2ea114b99..1bd808d55d47 100644 --- a/test/files/neg/macro-false-deprecation-warning/Impls_Macros_1.scala +++ b/test/files/neg/macro-false-deprecation-warning/Impls_Macros_1.scala @@ -1,11 +1,11 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Helper { def unapplySeq[T](x: List[T]): Option[Seq[T]] = } object Macros { - def impl[T: c.WeakTypeTag](c: Context)(x: c.Expr[List[T]]) = { + def impl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Expr[List[T]]) = { c.universe.reify(Helper.unapplySeq(x.splice)) } diff --git a/test/files/neg/macro-invalidimpl.check b/test/files/neg/macro-invalidimpl.check index e39cc8105b7d..432da4d00bda 100644 --- a/test/files/neg/macro-invalidimpl.check +++ b/test/files/neg/macro-invalidimpl.check @@ -19,28 +19,28 @@ macro [].[[]] def foo(x: Any) = macro Impls4.foo ^ Macros_Test_2.scala:26: error: ambiguous reference to overloaded definition, -both method foo in object Impls5 of type (c: scala.reflect.macros.Context)(x: c.Expr[Any], y: c.Expr[Any])Nothing -and method foo in object Impls5 of type (c: scala.reflect.macros.Context)(x: c.Expr[Any])Nothing +both method foo in object Impls5 of type (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Any], y: c.Expr[Any])Nothing +and method foo in object Impls5 of type (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Any])Nothing match expected type ? def foo(x: Any) = macro Impls5.foo ^ Macros_Test_2.scala:27: error: ambiguous reference to overloaded definition, -both method foo in object Impls5 of type (c: scala.reflect.macros.Context)(x: c.Expr[Any], y: c.Expr[Any])Nothing -and method foo in object Impls5 of type (c: scala.reflect.macros.Context)(x: c.Expr[Any])Nothing +both method foo in object Impls5 of type (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Any], y: c.Expr[Any])Nothing +and method foo in object Impls5 of type (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Any])Nothing match expected type ? def foo(x: Any, y: Any) = macro Impls5.foo ^ Macros_Test_2.scala:31: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Unit] - or : (c: scala.reflect.macros.Context): c.Tree - found : (c: scala.reflect.macros.Context)(): c.Expr[Unit] + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Unit] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(): c.Expr[Unit] number of parameter sections differ def foo1 = macro Impls6.fooEmpty ^ Macros_Test_2.scala:32: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(): c.Expr[Unit] - or : (c: scala.reflect.macros.Context)(): c.Tree - found : (c: scala.reflect.macros.Context): c.Expr[Unit] + required: (c: scala.reflect.macros.BlackboxContext)(): c.Expr[Unit] + or : (c: scala.reflect.macros.BlackboxContext)(): c.Tree + found : (c: scala.reflect.macros.BlackboxContext): c.Expr[Unit] number of parameter sections differ def bar1() = macro Impls6.fooNullary ^ diff --git a/test/files/neg/macro-invalidimpl/Impls_1.scala b/test/files/neg/macro-invalidimpl/Impls_1.scala index 9f48ab7ad9b4..b85ac9ee43b9 100644 --- a/test/files/neg/macro-invalidimpl/Impls_1.scala +++ b/test/files/neg/macro-invalidimpl/Impls_1.scala @@ -1,39 +1,39 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext class Impls1 { - def foo(c: Context)(x: c.Expr[Any]) = ??? + def foo(c: BlackboxContext)(x: c.Expr[Any]) = ??? } object Impls2 { - def foo(c: Context)(x: c.Expr[Any]) = ??? + def foo(c: BlackboxContext)(x: c.Expr[Any]) = ??? } trait MacroHelpers { object Impls4 { - def foo(c: Context)(x: c.Expr[Any]) = x + def foo(c: BlackboxContext)(x: c.Expr[Any]) = x } } object Impls5 { - def foo(c: Context)(x: c.Expr[Any]) = ??? - def foo(c: Context)(x: c.Expr[Any], y: c.Expr[Any]) = ??? + def foo(c: BlackboxContext)(x: c.Expr[Any]) = ??? + def foo(c: BlackboxContext)(x: c.Expr[Any], y: c.Expr[Any]) = ??? } object Impls6 { - def fooNullary(c: Context) = { + def fooNullary(c: BlackboxContext) = { import c.universe._ c.Expr[Unit](q"""Predef.println("it works")""") } - def fooEmpty(c: Context)() = fooNullary(c) + def fooEmpty(c: BlackboxContext)() = fooNullary(c) } object Impls7 { - def foo[U <: Int](c: Context) = ??? + def foo[U <: Int](c: BlackboxContext) = ??? } package foo { object Impls8 { - private[foo] def impl(c: Context) = ??? + private[foo] def impl(c: BlackboxContext) = ??? } } \ No newline at end of file diff --git a/test/files/neg/macro-invalidimpl/Macros_Test_2.scala b/test/files/neg/macro-invalidimpl/Macros_Test_2.scala index 8aae9553f599..0df7d2e0c5aa 100644 --- a/test/files/neg/macro-invalidimpl/Macros_Test_2.scala +++ b/test/files/neg/macro-invalidimpl/Macros_Test_2.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros1 { val impls = new Impls1 @@ -12,7 +12,7 @@ object Macros2 { class Macros3 { object Impls3 { - def foo(c: Context)(x: c.Expr[Any]) = ??? + def foo(c: BlackboxContext)(x: c.Expr[Any]) = ??? } def foo(x: Any) = macro Impls3.foo diff --git a/test/files/neg/macro-invalidret.check b/test/files/neg/macro-invalidret.check index 6cf62c292b40..19adc70fb30f 100644 --- a/test/files/neg/macro-invalidret.check +++ b/test/files/neg/macro-invalidret.check @@ -1,14 +1,14 @@ Macros_Test_2.scala:2: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree - found : (c: scala.reflect.macros.Context): Int + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree + found : (c: scala.reflect.macros.BlackboxContext): Int type mismatch for return type: Int does not conform to c.Expr[Any] def foo1 = macro Impls.foo1 ^ Macros_Test_2.scala:3: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree - found : (c: scala.reflect.macros.Context): reflect.runtime.universe.Literal + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree + found : (c: scala.reflect.macros.BlackboxContext): reflect.runtime.universe.Literal type mismatch for return type: reflect.runtime.universe.Literal does not conform to c.Expr[Any] def foo2 = macro Impls.foo2 ^ diff --git a/test/files/neg/macro-invalidret/Impls_1.scala b/test/files/neg/macro-invalidret/Impls_1.scala index a58af1a23c16..d957b74512a6 100644 --- a/test/files/neg/macro-invalidret/Impls_1.scala +++ b/test/files/neg/macro-invalidret/Impls_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import scala.reflect.runtime.{universe => ru} object Impls { - def foo1(c: Context) = 2 - def foo2(c: Context) = ru.Literal(ru.Constant(42)) + def foo1(c: BlackboxContext) = 2 + def foo2(c: BlackboxContext) = ru.Literal(ru.Constant(42)) } diff --git a/test/files/neg/macro-invalidshape/Impls_1.scala b/test/files/neg/macro-invalidshape/Impls_1.scala index 4467021545ef..3d5da9a2ed29 100644 --- a/test/files/neg/macro-invalidshape/Impls_1.scala +++ b/test/files/neg/macro-invalidshape/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Any]) = ??? diff --git a/test/files/neg/macro-invalidshape/Macros_Test_2.scala b/test/files/neg/macro-invalidshape/Macros_Test_2.scala index 819844b9f17a..8f643ab28130 100644 --- a/test/files/neg/macro-invalidshape/Macros_Test_2.scala +++ b/test/files/neg/macro-invalidshape/Macros_Test_2.scala @@ -3,7 +3,7 @@ object Macros { def foo2(x: Any) = macro Impls.foo(null)(null) def foo3(x: Any) = macro {2; Impls.foo} { - def impl(c: scala.reflect.macros.Context) = { import c.universe._; c.Expr[Unit](q"()") } + def impl(c: scala.reflect.macros.BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } def foo = macro impl foo } diff --git a/test/files/neg/macro-invalidsig-params-badtype.check b/test/files/neg/macro-invalidsig-params-badtype.check index 86aa08291f1f..e0cd63fbe4a3 100644 --- a/test/files/neg/macro-invalidsig-params-badtype.check +++ b/test/files/neg/macro-invalidsig-params-badtype.check @@ -1,7 +1,7 @@ Impls_Macros_1.scala:8: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(x: c.Expr[Int]): c.Expr[Any] - or : (c: scala.reflect.macros.Context)(x: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context)(x: Int): Nothing + required: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int]): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext)(x: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(x: Int): Nothing type mismatch for parameter x: c.Expr[Int] does not conform to Int def foo(x: Int) = macro Impls.foo ^ diff --git a/test/files/neg/macro-invalidsig-params-badtype/Impls_Macros_1.scala b/test/files/neg/macro-invalidsig-params-badtype/Impls_Macros_1.scala index 175683d6d30c..5f468424bd8c 100644 --- a/test/files/neg/macro-invalidsig-params-badtype/Impls_Macros_1.scala +++ b/test/files/neg/macro-invalidsig-params-badtype/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: Int) = ??? diff --git a/test/files/neg/macro-invalidsig.check b/test/files/neg/macro-invalidsig.check index 732380d4b347..42b8db562859 100644 --- a/test/files/neg/macro-invalidsig.check +++ b/test/files/neg/macro-invalidsig.check @@ -1,77 +1,77 @@ Macros_Test_2.scala:2: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree - found : (c: scala.reflect.macros.Context)(implicit evidence$2: Numeric[U]): c.universe.Literal + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(implicit evidence$2: Numeric[U]): c.universe.Literal macro implementations cannot have implicit parameters other than WeakTypeTag evidences def foo[U] = macro Impls1.foo[U] ^ Macros_Test_2.scala:6: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree found : : Nothing number of parameter sections differ def foo = macro Impls2.foo ^ Macros_Test_2.scala:10: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree found : (c: scala.reflect.api.Universe): Nothing -type mismatch for parameter c: scala.reflect.macros.Context does not conform to scala.reflect.api.Universe +type mismatch for parameter c: scala.reflect.macros.BlackboxContext does not conform to scala.reflect.api.Universe def foo = macro Impls3.foo ^ Macros_Test_2.scala:14: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree - found : (cs: scala.reflect.macros.Context*): Nothing + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree + found : (cs: scala.reflect.macros.BlackboxContext*): Nothing types incompatible for parameter cs: corresponding is not a vararg parameter def foo = macro Impls4.foo ^ Macros_Test_2.scala:18: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(x: c.Expr[Any]): c.Expr[Any] - or : (c: scala.reflect.macros.Context)(x: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context): Nothing + required: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Any]): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext)(x: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext): Nothing number of parameter sections differ def foo(x: Any) = macro Impls5.foo ^ Macros_Test_2.scala:22: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(x: c.Expr[Int]): c.Expr[Unit] - or : (c: scala.reflect.macros.Context)(x: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context)(implicit x: c.Expr[Int]): c.Expr[Unit] + required: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int]): c.Expr[Unit] + or : (c: scala.reflect.macros.BlackboxContext)(x: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(implicit x: c.Expr[Int]): c.Expr[Unit] macro implementations cannot have implicit parameters other than WeakTypeTag evidences def foo[U](x: Int) = macro Impls6.foo[T, U] ^ Macros_Test_2.scala:26: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(x: c.Expr[Int]): c.Expr[Any] - or : (c: scala.reflect.macros.Context)(x: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context)(x: c.Expr[Int], y: c.Expr[Int]): Nothing + required: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int]): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext)(x: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int], y: c.Expr[Int]): Nothing parameter lists have different length, found extra parameter y: c.Expr[Int] def foo(x: Int) = macro Impls7.foo ^ Macros_Test_2.scala:30: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(x: c.Expr[Int]): c.Expr[Any] - or : (c: scala.reflect.macros.Context)(x: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context)(x: c.universe.Symbol): Nothing + required: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int]): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext)(x: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(x: c.universe.Symbol): Nothing type mismatch for parameter x: c.Expr[Int] does not conform to c.universe.Symbol def foo(x: Int) = macro Impls8.foo ^ Macros_Test_2.scala:34: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(x: c.Expr[Int], y: c.Expr[Int]): c.Expr[Any] - or : (c: scala.reflect.macros.Context)(x: c.Tree, y: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context)(xs: c.Expr[Int]*): Nothing + required: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int], y: c.Expr[Int]): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext)(x: c.Tree, y: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(xs: c.Expr[Int]*): Nothing parameter lists have different length, required extra parameter y: c.Expr[Int] def foo(x: Int, y: Int) = macro Impls9.foo ^ Macros_Test_2.scala:38: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(x: c.Expr[Int], y: c.Expr[Int]): c.Expr[Any] - or : (c: scala.reflect.macros.Context)(x: c.Tree, y: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context)(y: c.Expr[Int], x: c.Expr[Int]): Nothing + required: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int], y: c.Expr[Int]): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext)(x: c.Tree, y: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(y: c.Expr[Int], x: c.Expr[Int]): Nothing parameter names differ: x != y def foo(x: Int, y: Int) = macro Impls10.foo ^ Macros_Test_2.scala:42: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context): c.Expr[Any] - or : (c: scala.reflect.macros.Context): c.Tree - found : (c: scala.reflect.macros.Context)(U: c.universe.Type): Nothing + required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any] + or : (c: scala.reflect.macros.BlackboxContext): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(U: c.universe.Type): Nothing number of parameter sections differ def foo[U] = macro Impls11.foo[U] ^ @@ -81,13 +81,13 @@ Macros_Test_2.scala:46: error: type arguments [U] do not conform to method foo's Macros_Test_2.scala:50: error: type arguments [U] do not conform to method foo's type parameter bounds [U <: String] def foo[U <: Int] = macro Impls13.foo[U] ^ -Macros_Test_2.scala:54: error: wrong number of type parameters for method foo: [U](c: scala.reflect.macros.Context)(implicit evidence$4: c.WeakTypeTag[U])Nothing +Macros_Test_2.scala:54: error: wrong number of type parameters for method foo: [U](c: scala.reflect.macros.BlackboxContext)(implicit evidence$4: c.WeakTypeTag[U])Nothing def foo = macro Impls14.foo ^ -Macros_Test_2.scala:59: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.Context)(implicit evidence$5: c.WeakTypeTag[T], implicit evidence$6: c.WeakTypeTag[U], implicit V: c.WeakTypeTag[V])c.Expr[Unit] +Macros_Test_2.scala:59: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.BlackboxContext)(implicit evidence$5: c.WeakTypeTag[T], implicit evidence$6: c.WeakTypeTag[U], implicit V: c.WeakTypeTag[V])c.Expr[Unit] def foo15[V] = macro Impls15.foo ^ -Macros_Test_2.scala:60: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.Context)(implicit evidence$7: c.WeakTypeTag[T], implicit evidence$8: c.WeakTypeTag[U], implicit V: c.WeakTypeTag[V])c.Expr[Unit] +Macros_Test_2.scala:60: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.BlackboxContext)(implicit evidence$7: c.WeakTypeTag[T], implicit evidence$8: c.WeakTypeTag[U], implicit V: c.WeakTypeTag[V])c.Expr[Unit] def foo16[V] = macro Impls16.foo[V] ^ 16 errors found diff --git a/test/files/neg/macro-invalidsig/Impls_1.scala b/test/files/neg/macro-invalidsig/Impls_1.scala index d16ed263862c..7c9816092550 100644 --- a/test/files/neg/macro-invalidsig/Impls_1.scala +++ b/test/files/neg/macro-invalidsig/Impls_1.scala @@ -1,8 +1,8 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Impls1 { - def foo[U: c.WeakTypeTag: Numeric](c: Context) = { import c.universe._; q"42" } + def foo[U: c.WeakTypeTag: Numeric](c: BlackboxContext) = { import c.universe._; q"42" } } object Impls2 { @@ -14,15 +14,15 @@ object Impls3 { } object Impls4 { - def foo(cs: Context*) = ??? + def foo(cs: BlackboxContext*) = ??? } object Impls5 { - def foo(c: Context) = ??? + def foo(c: BlackboxContext) = ??? } object Impls6 { - def foo[T, U: c.WeakTypeTag](c: Context)(implicit x: c.Expr[Int]) = { + def foo[T, U: c.WeakTypeTag](c: BlackboxContext)(implicit x: c.Expr[Int]) = { import c.{prefix => prefix} import c.universe._ c.Expr[Unit](q""" @@ -34,39 +34,39 @@ object Impls6 { } object Impls7 { - def foo(c: Context)(x: c.Expr[Int], y: c.Expr[Int]) = ??? + def foo(c: BlackboxContext)(x: c.Expr[Int], y: c.Expr[Int]) = ??? } object Impls8 { - def foo(c: Context)(x: c.universe.Symbol) = ??? + def foo(c: BlackboxContext)(x: c.universe.Symbol) = ??? } object Impls9 { - def foo(c: Context)(xs: c.Expr[Int]*) = ??? + def foo(c: BlackboxContext)(xs: c.Expr[Int]*) = ??? } object Impls10 { - def foo(c: Context)(y: c.Expr[Int], x: c.Expr[Int]) = ??? + def foo(c: BlackboxContext)(y: c.Expr[Int], x: c.Expr[Int]) = ??? } object Impls11 { - def foo[U](c: Context)(U: c.universe.Type) = ??? + def foo[U](c: BlackboxContext)(U: c.universe.Type) = ??? } object Impls12 { - def foo[U <: String](c: Context) = ??? + def foo[U <: String](c: BlackboxContext) = ??? } object Impls13 { - def foo[U <: String](c: Context) = ??? + def foo[U <: String](c: BlackboxContext) = ??? } object Impls14 { - def foo[U: c.WeakTypeTag](c: Context) = ??? + def foo[U: c.WeakTypeTag](c: BlackboxContext) = ??? } object Impls15 { - def foo[T: c.WeakTypeTag, U: c.WeakTypeTag, V](c: Context)(implicit V: c.WeakTypeTag[V]): c.Expr[Unit] = { + def foo[T: c.WeakTypeTag, U: c.WeakTypeTag, V](c: BlackboxContext)(implicit V: c.WeakTypeTag[V]): c.Expr[Unit] = { import c.universe._ println(implicitly[c.WeakTypeTag[T]]) println(implicitly[c.WeakTypeTag[U]]) @@ -76,7 +76,7 @@ object Impls15 { } object Impls16 { - def foo[T: c.WeakTypeTag, U: c.WeakTypeTag, V](c: Context)(implicit V: c.WeakTypeTag[V]): c.Expr[Unit] = { + def foo[T: c.WeakTypeTag, U: c.WeakTypeTag, V](c: BlackboxContext)(implicit V: c.WeakTypeTag[V]): c.Expr[Unit] = { import c.universe._ println(implicitly[c.WeakTypeTag[T]]) println(implicitly[c.WeakTypeTag[U]]) diff --git a/test/files/neg/macro-invalidusage-badargs/Impls_1.scala b/test/files/neg/macro-invalidusage-badargs/Impls_1.scala index 52c9f9c3e924..678cb53929da 100644 --- a/test/files/neg/macro-invalidusage-badargs/Impls_1.scala +++ b/test/files/neg/macro-invalidusage-badargs/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = x diff --git a/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala b/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala index 74c163596ae0..393f7de976de 100644 --- a/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala +++ b/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo[U <: String](c: Ctx) = { import c.universe._; c.Expr[Unit](q"()") } diff --git a/test/files/neg/macro-invalidusage-badtargs/Impls_1.scala b/test/files/neg/macro-invalidusage-badtargs/Impls_1.scala index 52c9f9c3e924..678cb53929da 100644 --- a/test/files/neg/macro-invalidusage-badtargs/Impls_1.scala +++ b/test/files/neg/macro-invalidusage-badtargs/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = x diff --git a/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala b/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala index 11b6a8c3b0da..15894efb6859 100644 --- a/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala +++ b/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/neg/macro-invalidusage-nontypeable/Impls_Macros_1.scala b/test/files/neg/macro-invalidusage-nontypeable/Impls_Macros_1.scala index 869a5a41fa92..44e508a1c684 100644 --- a/test/files/neg/macro-invalidusage-nontypeable/Impls_Macros_1.scala +++ b/test/files/neg/macro-invalidusage-nontypeable/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/neg/macro-invalidusage-presuper/Impls_1.scala b/test/files/neg/macro-invalidusage-presuper/Impls_1.scala index c4b57233c94b..02c87b5a81e6 100644 --- a/test/files/neg/macro-invalidusage-presuper/Impls_1.scala +++ b/test/files/neg/macro-invalidusage-presuper/Impls_1.scala @@ -1,5 +1,5 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Impls { - def impl(c: Context) = { import c.universe._; c.Expr[Unit](q"()") } + def impl(c: BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } } \ No newline at end of file diff --git a/test/files/neg/macro-noexpand/Impls_1.scala b/test/files/neg/macro-noexpand/Impls_1.scala index 4467021545ef..3d5da9a2ed29 100644 --- a/test/files/neg/macro-noexpand/Impls_1.scala +++ b/test/files/neg/macro-noexpand/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Any]) = ??? diff --git a/test/files/neg/macro-nontypeablebody/Impls_1.scala b/test/files/neg/macro-nontypeablebody/Impls_1.scala index 4467021545ef..3d5da9a2ed29 100644 --- a/test/files/neg/macro-nontypeablebody/Impls_1.scala +++ b/test/files/neg/macro-nontypeablebody/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Any]) = ??? diff --git a/test/files/neg/macro-override-macro-overrides-abstract-method-a/Impls_Macros_1.scala b/test/files/neg/macro-override-macro-overrides-abstract-method-a/Impls_Macros_1.scala index e43264f52f7e..0e8a5f3b01e7 100644 --- a/test/files/neg/macro-override-macro-overrides-abstract-method-a/Impls_Macros_1.scala +++ b/test/files/neg/macro-override-macro-overrides-abstract-method-a/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def impl(c: Ctx)(x: c.Expr[Int]) = x diff --git a/test/files/neg/macro-override-macro-overrides-abstract-method-b/Impls_Macros_1.scala b/test/files/neg/macro-override-macro-overrides-abstract-method-b/Impls_Macros_1.scala index f5b2555aa57e..c98279b2b818 100644 --- a/test/files/neg/macro-override-macro-overrides-abstract-method-b/Impls_Macros_1.scala +++ b/test/files/neg/macro-override-macro-overrides-abstract-method-b/Impls_Macros_1.scala @@ -1,8 +1,8 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros trait T { def t(): Unit } trait A { def t(): Unit = () } -object Macro { def t(c: Context)(): c.Expr[Unit] = c.universe.reify(()) } +object Macro { def t(c: BlackboxContext)(): c.Expr[Unit] = c.universe.reify(()) } trait C extends T { self: A => override def t(): Unit = macro Macro.t } diff --git a/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala b/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala index 64a9299ee6fb..f2d3f67ccca9 100644 --- a/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala +++ b/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def impl(c: Ctx)(tag: String, x: c.Expr[_]) = { diff --git a/test/files/neg/macro-quasiquotes/Macros_1.scala b/test/files/neg/macro-quasiquotes/Macros_1.scala index 17c10347206f..7f0219e6ac2e 100644 --- a/test/files/neg/macro-quasiquotes/Macros_1.scala +++ b/test/files/neg/macro-quasiquotes/Macros_1.scala @@ -1,7 +1,7 @@ import language.experimental.macros -import scala.reflect.macros.Macro +import scala.reflect.macros.BlackboxMacro -trait Impls extends Macro { +trait Impls extends BlackboxMacro { import c.universe._ def impl1(x: Expr[Int]) = q"println(x)" def impl2(x: Tree) = q"println(x)" diff --git a/test/files/neg/macro-without-xmacros-a/Impls_1.scala b/test/files/neg/macro-without-xmacros-a/Impls_1.scala index 868616aaceec..6b73a9618457 100644 --- a/test/files/neg/macro-without-xmacros-a/Impls_1.scala +++ b/test/files/neg/macro-without-xmacros-a/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = { diff --git a/test/files/neg/macro-without-xmacros-b/Impls_1.scala b/test/files/neg/macro-without-xmacros-b/Impls_1.scala index 868616aaceec..6b73a9618457 100644 --- a/test/files/neg/macro-without-xmacros-b/Impls_1.scala +++ b/test/files/neg/macro-without-xmacros-b/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = { diff --git a/test/files/neg/t5689.check b/test/files/neg/t5689.check index 8cf0534e7731..e74de40280f5 100644 --- a/test/files/neg/t5689.check +++ b/test/files/neg/t5689.check @@ -1,7 +1,7 @@ t5689.scala:4: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(i: c.Expr[Double]): c.Expr[String] - or : (c: scala.reflect.macros.Context)(i: c.Tree): c.Tree - found : (c: scala.reflect.macros.Context)(i: c.Expr[Double]): c.Expr[Int] + required: (c: scala.reflect.macros.BlackboxContext)(i: c.Expr[Double]): c.Expr[String] + or : (c: scala.reflect.macros.BlackboxContext)(i: c.Tree): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(i: c.Expr[Double]): c.Expr[Int] type mismatch for return type: c.Expr[Int] does not conform to c.Expr[String] def returnsString(i: Double): String = macro returnsIntImpl ^ diff --git a/test/files/neg/t5689.scala b/test/files/neg/t5689.scala index 3266039c35ea..d0e468849d08 100644 --- a/test/files/neg/t5689.scala +++ b/test/files/neg/t5689.scala @@ -1,6 +1,6 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { def returnsString(i: Double): String = macro returnsIntImpl - def returnsIntImpl(c: Context)(i: c.Expr[Double]): c.Expr[Int] = ??? + def returnsIntImpl(c: BlackboxContext)(i: c.Expr[Double]): c.Expr[Int] = ??? } diff --git a/test/files/neg/t5753/Impls_Macros_1.scala b/test/files/neg/t5753/Impls_Macros_1.scala index 1d9c26458c48..f93d731d40fc 100644 --- a/test/files/neg/t5753/Impls_Macros_1.scala +++ b/test/files/neg/t5753/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} trait Impls { def impl(c: Ctx)(x: c.Expr[Any]) = x diff --git a/test/files/neg/t5753/Test_2.scala b/test/files/neg/t5753/Test_2.scala index 2369b18e7625..f1cad67fed57 100644 --- a/test/files/neg/t5753/Test_2.scala +++ b/test/files/neg/t5753/Test_2.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros extends Impls { def foo(x: Any) = macro impl diff --git a/test/files/neg/t5903a/Macros_1.scala b/test/files/neg/t5903a/Macros_1.scala index e82be0fc68c3..9fc3bfe2616e 100644 --- a/test/files/neg/t5903a/Macros_1.scala +++ b/test/files/neg/t5903a/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros trait Tree @@ -13,7 +13,7 @@ object NewQuasiquotes { } object QuasiquoteMacros { - def unapplyImpl(c: Context)(t: c.Tree) = { + def unapplyImpl(c: BlackboxContext)(t: c.Tree) = { import c.universe._ q""" new { diff --git a/test/files/neg/t5903b/Macros_1.scala b/test/files/neg/t5903b/Macros_1.scala index b1b875969d4c..46f0eee0f196 100644 --- a/test/files/neg/t5903b/Macros_1.scala +++ b/test/files/neg/t5903b/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Interpolation { @@ -10,7 +10,7 @@ object Interpolation { } object Macros { - def unapplyImpl[T: c.WeakTypeTag](c: Context)(x: c.Tree) = { + def unapplyImpl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Tree) = { import c.universe._ q""" new { diff --git a/test/files/neg/t5903c/Macros_1.scala b/test/files/neg/t5903c/Macros_1.scala index 70efab31012e..281a06e93c7f 100644 --- a/test/files/neg/t5903c/Macros_1.scala +++ b/test/files/neg/t5903c/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Interpolation { @@ -10,7 +10,7 @@ object Interpolation { } object Macros { - def unapplyImpl[T: c.WeakTypeTag](c: Context)(x: c.Tree) = { + def unapplyImpl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Tree) = { import c.universe._ if (!(c.weakTypeOf[Int] =:= c.weakTypeOf[T])) c.abort(c.enclosingPosition, s"${c.weakTypeOf[T]} is not supported") else { diff --git a/test/files/neg/t5903d/Macros_1.scala b/test/files/neg/t5903d/Macros_1.scala index 15ff226cff5b..5dd6220e1acb 100644 --- a/test/files/neg/t5903d/Macros_1.scala +++ b/test/files/neg/t5903d/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Interpolation { @@ -10,7 +10,7 @@ object Interpolation { } object Macros { - def unapplyImpl(c: Context)(x: c.Tree) = { + def unapplyImpl(c: BlackboxContext)(x: c.Tree) = { import c.universe._ q""" class Match(x: Int) { diff --git a/test/files/neg/t5903e/Macros_1.scala b/test/files/neg/t5903e/Macros_1.scala index 4e1ce89c9fe9..13e168d52937 100644 --- a/test/files/neg/t5903e/Macros_1.scala +++ b/test/files/neg/t5903e/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Interpolation { @@ -10,7 +10,7 @@ object Interpolation { } object Macros { - def unapplyImpl(c: Context)(x: c.Tree) = { + def unapplyImpl(c: BlackboxContext)(x: c.Tree) = { import c.universe._ q""" new { diff --git a/test/files/neg/t6123-explaintypes-macros.check b/test/files/neg/t6123-explaintypes-macros.check index 43f83713268f..9a0402039bd8 100644 --- a/test/files/neg/t6123-explaintypes-macros.check +++ b/test/files/neg/t6123-explaintypes-macros.check @@ -1,9 +1,9 @@ c.universe.Expr[Any]* <: c.universe.Expr[String]*? false BadMac_2.scala:6: error: macro implementation has wrong shape: - required: (c: scala.reflect.macros.Context)(format: c.Expr[String], params: c.Expr[Any]*): c.Expr[Unit] - or : (c: scala.reflect.macros.Context)(format: c.Tree, params: Tree*): c.Tree - found : (c: scala.reflect.macros.Context)(format: c.Expr[String], params: c.Expr[String]*): c.Expr[Unit] + required: (c: scala.reflect.macros.BlackboxContext)(format: c.Expr[String], params: c.Expr[Any]*): c.Expr[Unit] + or : (c: scala.reflect.macros.BlackboxContext)(format: c.Tree, params: Tree*): c.Tree + found : (c: scala.reflect.macros.BlackboxContext)(format: c.Expr[String], params: c.Expr[String]*): c.Expr[Unit] type mismatch for parameter params: c.Expr[Any]* does not conform to c.Expr[String]* def printf(format: String, params: Any*): Unit = macro printf_impl ^ diff --git a/test/files/neg/t6123-explaintypes-macros/BadMac_2.scala b/test/files/neg/t6123-explaintypes-macros/BadMac_2.scala index 38b8e24444fe..456e7538930e 100644 --- a/test/files/neg/t6123-explaintypes-macros/BadMac_2.scala +++ b/test/files/neg/t6123-explaintypes-macros/BadMac_2.scala @@ -1,8 +1,8 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext // explain some macro types to me object BadMac { def printf(format: String, params: Any*): Unit = macro printf_impl - def printf_impl(c: Context)(format: c.Expr[String], params: c.Expr[String]*): c.Expr[Unit] = ??? + def printf_impl(c: BlackboxContext)(format: c.Expr[String], params: c.Expr[String]*): c.Expr[Unit] = ??? } diff --git a/test/files/neg/t6123-explaintypes-macros/Macros.scala b/test/files/neg/t6123-explaintypes-macros/Macros.scala index a12c277c861d..cdcea34272dd 100644 --- a/test/files/neg/t6123-explaintypes-macros/Macros.scala +++ b/test/files/neg/t6123-explaintypes-macros/Macros.scala @@ -1,9 +1,9 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { def printf(format: String, params: Any*): Unit = macro printf_impl - def printf_impl(c: Context)(format: c.Expr[String], params: c.Expr[Any]*): c.Expr[Unit] = ??? + def printf_impl(c: BlackboxContext)(format: c.Expr[String], params: c.Expr[Any]*): c.Expr[Unit] = ??? } // something trivial to run diff --git a/test/files/neg/t6539/Macro_1.scala b/test/files/neg/t6539/Macro_1.scala index 4f7d289e2e4a..454489752c30 100644 --- a/test/files/neg/t6539/Macro_1.scala +++ b/test/files/neg/t6539/Macro_1.scala @@ -1,9 +1,9 @@ import language.experimental.macros -import reflect.macros.Context +import reflect.macros.BlackboxContext object M { def m(a: Any, b: Any): Any = macro mImpl - def mImpl(c: Context)(a: c.Expr[Any], b: c.Expr[Any]) = a + def mImpl(c: BlackboxContext)(a: c.Expr[Any], b: c.Expr[Any]) = c.universe.reify(println(a.splice)) @reflect.internal.annotations.compileTimeOnly("cto may only be used as an argument to " + "m") def cto = 0 diff --git a/test/files/neg/t7157/Impls_Macros_1.scala b/test/files/neg/t7157/Impls_Macros_1.scala index 9069d26e6ecf..16cb00142272 100644 --- a/test/files/neg/t7157/Impls_Macros_1.scala +++ b/test/files/neg/t7157/Impls_Macros_1.scala @@ -1,31 +1,31 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Macros { - def impl1_0_0(c: Context)() = { import c.universe._; c.Expr[Unit](q"()") } - def impl1_1_1(c: Context)(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } - def impl1_2_2(c: Context)(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } + def impl1_0_0(c: BlackboxContext)() = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl1_1_1(c: BlackboxContext)(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl1_2_2(c: BlackboxContext)(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } def m1_0_0() = macro impl1_0_0 def m1_1_1(x: Int) = macro impl1_1_1 def m1_2_2(x: Int, y: Int) = macro impl1_2_2 - def impl1_0_inf(c: Context)(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") } - def impl1_1_inf(c: Context)(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") } - def impl1_2_inf(c: Context)(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") } + def impl1_0_inf(c: BlackboxContext)(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl1_1_inf(c: BlackboxContext)(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl1_2_inf(c: BlackboxContext)(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } def m1_0_inf(x: Int*) = macro impl1_0_inf def m1_1_inf(x: Int, y: Int*) = macro impl1_1_inf def m1_2_inf(x: Int, y: Int, z: Int*) = macro impl1_2_inf - def impl2_0_0(c: Context)()() = { import c.universe._; c.Expr[Unit](q"()") } - def impl2_1_1(c: Context)()(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } - def impl2_2_2(c: Context)()(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } + def impl2_0_0(c: BlackboxContext)()() = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl2_1_1(c: BlackboxContext)()(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl2_2_2(c: BlackboxContext)()(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } def m2_0_0()() = macro impl2_0_0 def m2_1_1()(x: Int) = macro impl2_1_1 def m2_2_2()(x: Int, y: Int) = macro impl2_2_2 - def impl2_0_inf(c: Context)()(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") } - def impl2_1_inf(c: Context)()(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") } - def impl2_2_inf(c: Context)()(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") } + def impl2_0_inf(c: BlackboxContext)()(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl2_1_inf(c: BlackboxContext)()(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } + def impl2_2_inf(c: BlackboxContext)()(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } def m2_0_inf()(x: Int*) = macro impl2_0_inf def m2_1_inf()(x: Int, y: Int*) = macro impl2_1_inf def m2_2_inf()(x: Int, y: Int, z: Int*) = macro impl2_2_inf diff --git a/test/files/pos/annotated-original/M_1.scala b/test/files/pos/annotated-original/M_1.scala index 01654e02cf1b..089a3a13c575 100644 --- a/test/files/pos/annotated-original/M_1.scala +++ b/test/files/pos/annotated-original/M_1.scala @@ -1,7 +1,7 @@ import language.experimental.macros -import reflect.macros.Context +import reflect.macros.BlackboxContext object M { - def impl(c: Context)(a: c.Expr[Any]) = c.Expr[Any](c.resetLocalAttrs(a.tree)) + def impl(c: BlackboxContext)(a: c.Expr[Any]) = c.Expr[Any](c.resetLocalAttrs(a.tree)) def m(a: Any) = macro impl } diff --git a/test/files/pos/annotated-treecopy/Impls_Macros_1.scala b/test/files/pos/annotated-treecopy/Impls_Macros_1.scala index 9b7af0c3b8d9..50c671707dd9 100644 --- a/test/files/pos/annotated-treecopy/Impls_Macros_1.scala +++ b/test/files/pos/annotated-treecopy/Impls_Macros_1.scala @@ -1,5 +1,5 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import collection.mutable.ListBuffer import collection.mutable.Stack @@ -12,7 +12,7 @@ object Macros { def tree[T,U](f:Function1[T,U]): Function1[T,U] = macro tree_impl[T,U] - def tree_impl[T:c.WeakTypeTag,U:c.WeakTypeTag](c: Context) + def tree_impl[T:c.WeakTypeTag,U:c.WeakTypeTag](c: BlackboxContext) (f:c.Expr[Function1[T,U]]): c.Expr[Function1[T,U]] = { import c.universe._ val ttag = c.weakTypeTag[U] diff --git a/test/files/pos/attachments-typed-another-ident/Impls_1.scala b/test/files/pos/attachments-typed-another-ident/Impls_1.scala index c3f541075e2f..f84e56d71423 100644 --- a/test/files/pos/attachments-typed-another-ident/Impls_1.scala +++ b/test/files/pos/attachments-typed-another-ident/Impls_1.scala @@ -1,10 +1,10 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object MyAttachment object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val ident = Ident(TermName("bar")) updateAttachment MyAttachment assert(ident.attachments.get[MyAttachment.type].isDefined, ident.attachments) diff --git a/test/files/pos/attachments-typed-ident/Impls_1.scala b/test/files/pos/attachments-typed-ident/Impls_1.scala index c382cabc5947..11d0f6584482 100644 --- a/test/files/pos/attachments-typed-ident/Impls_1.scala +++ b/test/files/pos/attachments-typed-ident/Impls_1.scala @@ -1,10 +1,10 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object MyAttachment object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val ident = Ident(TermName("bar")) updateAttachment MyAttachment assert(ident.attachments.get[MyAttachment.type].isDefined, ident.attachments) diff --git a/test/files/pos/t5692a/Macros_1.scala b/test/files/pos/t5692a/Macros_1.scala index e530713bb0aa..0e91f4d6a0c3 100644 --- a/test/files/pos/t5692a/Macros_1.scala +++ b/test/files/pos/t5692a/Macros_1.scala @@ -1,6 +1,6 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl[T](c: Context) = { import c.universe._; c.Expr[Unit](q"()") } + def impl[T](c: BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } def foo[T] = macro impl[T] } \ No newline at end of file diff --git a/test/files/pos/t5692b/Macros_1.scala b/test/files/pos/t5692b/Macros_1.scala index 45c672cfcea2..1034a1ea4a1e 100644 --- a/test/files/pos/t5692b/Macros_1.scala +++ b/test/files/pos/t5692b/Macros_1.scala @@ -1,6 +1,6 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl[T, U](c: Context) = { import c.universe._; c.Expr[Unit](q"()") } + def impl[T, U](c: BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } def foo[T, U] = macro impl[T, U] } \ No newline at end of file diff --git a/test/files/pos/t5706.scala b/test/files/pos/t5706.scala index 20a8b255cc10..1970f5971f21 100644 --- a/test/files/pos/t5706.scala +++ b/test/files/pos/t5706.scala @@ -1,10 +1,15 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext +import scala.reflect.macros.WhiteboxContext class Logger { - def error(message: String) = macro Impls.error + def error1(message: String) = macro Impls.error1 + def error2(message: String) = macro Impls.error2 } object Impls { - type LoggerContext = Context { type PrefixType = Logger } - def error(c: LoggerContext)(message: c.Expr[String]): c.Expr[Unit] = ??? + type LoggerContext1 = BlackboxContext { type PrefixType = Logger } + def error1(c: LoggerContext1)(message: c.Expr[String]): c.Expr[Unit] = ??? + + type LoggerContext2 = WhiteboxContext { type PrefixType = Logger } + def error2(c: LoggerContext2)(message: c.Expr[String]): c.Expr[Unit] = ??? } diff --git a/test/files/pos/t5744/Macros_1.scala b/test/files/pos/t5744/Macros_1.scala index 288a88653d6f..0fc13c12d79c 100644 --- a/test/files/pos/t5744/Macros_1.scala +++ b/test/files/pos/t5744/Macros_1.scala @@ -1,18 +1,18 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { def foo[U: Numeric](x: U) = macro foo_impl[U] def bar[U: Numeric : Equiv, Y <% String](x: U)(implicit s: String) = macro bar_impl[U, Y] - def foo_impl[U](c: Context)(x: c.Expr[U])(numeric: c.Expr[Numeric[U]]) = { + def foo_impl[U](c: BlackboxContext)(x: c.Expr[U])(numeric: c.Expr[Numeric[U]]) = { import c.universe._ val plusOne = Apply(Select(numeric.tree, newTermName("plus")), List(x.tree, Literal(Constant(1)))) val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(plusOne)) c.Expr[Unit](body) } - def bar_impl[U, Y](c: Context)(x: c.Expr[U])(numeric: c.Expr[Numeric[U]], equiv: c.Expr[Equiv[U]], viewAsString: c.Expr[Y => String], s: c.Expr[String]) = { + def bar_impl[U, Y](c: BlackboxContext)(x: c.Expr[U])(numeric: c.Expr[Numeric[U]], equiv: c.Expr[Equiv[U]], viewAsString: c.Expr[Y => String], s: c.Expr[String]) = { import c.universe._ val plusOne = Apply(Select(numeric.tree, newTermName("plus")), List(x.tree, Literal(Constant(1)))) val plusLen = Apply(Select(numeric.tree, newTermName("plus")), List(plusOne, Select(s.tree, newTermName("length")))) diff --git a/test/files/pos/t6047.scala b/test/files/pos/t6047.scala index bc5f856bd2a6..c5bb44d87e82 100644 --- a/test/files/pos/t6047.scala +++ b/test/files/pos/t6047.scala @@ -1,10 +1,10 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import java.io.InputStream object Macros { def unpack[A](input: InputStream): A = macro unpack_impl[A] - def unpack_impl[A: c.WeakTypeTag](c: Context)(input: c.Expr[InputStream]): c.Expr[A] = { + def unpack_impl[A: c.WeakTypeTag](c: BlackboxContext)(input: c.Expr[InputStream]): c.Expr[A] = { import c.universe._ def unpackcode(tpe: c.Type): c.Expr[_] = { diff --git a/test/files/pos/t6447.scala b/test/files/pos/t6447.scala index 1c0c0f2a318b..8203c0cdddc5 100644 --- a/test/files/pos/t6447.scala +++ b/test/files/pos/t6447.scala @@ -1,18 +1,18 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext class X { type T } object X { // this works def foo(x: X): x.T = macro fooImpl - def fooImpl(c: Context)(x: c.Expr[X]): c.Expr[x.value.T] = ??? + def fooImpl(c: BlackboxContext)(x: c.Expr[X]): c.Expr[x.value.T] = ??? // this doesn't def bar(x: X, y: X): (x.T, y.T) = macro barImpl - def barImpl(c: Context)(x: c.Expr[X], y: c.Expr[X]): c.Expr[(x.value.T, y.value.T)] = ??? + def barImpl(c: BlackboxContext)(x: c.Expr[X], y: c.Expr[X]): c.Expr[(x.value.T, y.value.T)] = ??? // neither does this def baz(x: X)(xs: List[x.T]): Unit = macro bazImpl - def bazImpl(c: Context)(x: c.Expr[X])(xs: c.Expr[List[x.value.T]]): c.Expr[Unit] = ??? + def bazImpl(c: BlackboxContext)(x: c.Expr[X])(xs: c.Expr[List[x.value.T]]): c.Expr[Unit] = ??? } diff --git a/test/files/pos/t6485a/Macros_1.scala b/test/files/pos/t6485a/Macros_1.scala index 85c2d5dbdba0..c637c2cfee41 100644 --- a/test/files/pos/t6485a/Macros_1.scala +++ b/test/files/pos/t6485a/Macros_1.scala @@ -1,5 +1,5 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def crash(c: Context): c.Expr[Unit] = c.universe.reify(()) + def crash(c: BlackboxContext): c.Expr[Unit] = c.universe.reify(()) } \ No newline at end of file diff --git a/test/files/pos/t6485b/Test.scala b/test/files/pos/t6485b/Test.scala index 382df1c45327..989798751695 100644 --- a/test/files/pos/t6485b/Test.scala +++ b/test/files/pos/t6485b/Test.scala @@ -1,10 +1,10 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext final class Ops[T](val x: T) extends AnyVal { def f = macro Macros.crash } object Macros { - def crash(c: Context): c.Expr[Unit] = c.universe.reify(()) + def crash(c: BlackboxContext): c.Expr[Unit] = c.universe.reify(()) } \ No newline at end of file diff --git a/test/files/pos/t6516.scala b/test/files/pos/t6516.scala index c004055de21e..aed359976eea 100644 --- a/test/files/pos/t6516.scala +++ b/test/files/pos/t6516.scala @@ -1,17 +1,17 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import scala.collection.TraversableLike // This one compiles object Test { - type Alias[T, CC[_]] = Context { type PrefixType = TraversableLike[T, CC[T]] } + type Alias[T, CC[_]] = BlackboxContext { type PrefixType = TraversableLike[T, CC[T]] } def f() = macro f_impl def f_impl(c: Alias[Int, List])() = ??? } // This one doesn't object Test2 { - type Ctx = scala.reflect.macros.Context + type Ctx = scala.reflect.macros.BlackboxContext type Alias[T, CC[_]] = Ctx { type PrefixType = TraversableLike[T, CC[T]] } def f() = macro f_impl diff --git a/test/files/pos/t7377/Macro_1.scala b/test/files/pos/t7377/Macro_1.scala index a0ec1d84afc9..bb7ffb0f1069 100644 --- a/test/files/pos/t7377/Macro_1.scala +++ b/test/files/pos/t7377/Macro_1.scala @@ -1,7 +1,7 @@ import language.experimental._ -import reflect.macros.Context +import reflect.macros.BlackboxContext object M { - def noopImpl[A](c: Context)(expr: c.Expr[A]): c.Expr[A] = c.Expr(c.typeCheck(c.resetLocalAttrs(expr.tree))) + def noopImpl[A](c: BlackboxContext)(expr: c.Expr[A]): c.Expr[A] = c.Expr(c.typeCheck(c.resetLocalAttrs(expr.tree))) def noop[A](expr: A): A = macro noopImpl[A] } diff --git a/test/files/pos/t7461/Macros_1.scala b/test/files/pos/t7461/Macros_1.scala index 8621650f77ed..126e9c067a8e 100644 --- a/test/files/pos/t7461/Macros_1.scala +++ b/test/files/pos/t7461/Macros_1.scala @@ -1,8 +1,8 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val wut = c.typeCheck(Select(Literal(Constant(10)), newTermName("$minus")), silent = true) // println(showRaw(wut, printIds = true, printTypes = true)) diff --git a/test/files/pos/t7649.scala b/test/files/pos/t7649.scala index ff3c626fcaa2..fa5d13369f12 100644 --- a/test/files/pos/t7649.scala +++ b/test/files/pos/t7649.scala @@ -1,5 +1,5 @@ object Test { - val c: reflect.macros.Context = ??? + val c: reflect.macros.BlackboxContext = ??? import c.universe._ reify { // The lookup of the implicit WeakTypeTag[Any] diff --git a/test/files/run/macro-abort-fresh/Macros_1.scala b/test/files/run/macro-abort-fresh/Macros_1.scala index 415b76852f1a..350d7b41aaa3 100644 --- a/test/files/run/macro-abort-fresh/Macros_1.scala +++ b/test/files/run/macro-abort-fresh/Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Impls { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ println(c.fresh()) println(c.fresh("qwe")) diff --git a/test/files/run/macro-auto-duplicate/Macros_1.scala b/test/files/run/macro-auto-duplicate/Macros_1.scala index e3df05ba5041..255dafd47e67 100644 --- a/test/files/run/macro-auto-duplicate/Macros_1.scala +++ b/test/files/run/macro-auto-duplicate/Macros_1.scala @@ -1,8 +1,8 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val x = Ident(newTermName("x")) def defAndUseX(rhs: Tree) = { diff --git a/test/files/run/macro-basic-ma-md-mi/Impls_1.scala b/test/files/run/macro-basic-ma-md-mi/Impls_1.scala index ce30366c610d..c63353164e3b 100644 --- a/test/files/run/macro-basic-ma-md-mi/Impls_1.scala +++ b/test/files/run/macro-basic-ma-md-mi/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = { diff --git a/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala b/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala index a601af6ddea2..3cdd5313164b 100644 --- a/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala +++ b/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = { diff --git a/test/files/run/macro-basic-mamd-mi/Impls_1.scala b/test/files/run/macro-basic-mamd-mi/Impls_1.scala index 6e5983bdecbf..3feddd2786f3 100644 --- a/test/files/run/macro-basic-mamd-mi/Impls_1.scala +++ b/test/files/run/macro-basic-mamd-mi/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = { diff --git a/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala b/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala index 56c5252f313b..9af3b18ccb0a 100644 --- a/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala +++ b/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala @@ -1,10 +1,11 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.language.experimental.macros +import scala.reflect.macros.BlackboxContext object Impls { - def foo(c: Ctx)(x: c.Expr[Int]) = x + def foo(c: BlackboxContext)(x: c.Expr[Int]) = x def refToFoo(dummy: Int) = macro refToFoo_impl - def refToFoo_impl(c: Ctx)(dummy: c.Expr[Int]) = { + def refToFoo_impl(c: BlackboxContext)(dummy: c.Expr[Int]) = { import c.universe._ val body = Select(Ident(TermName("Impls")), TermName("foo")) val global = c.universe.asInstanceOf[scala.tools.nsc.Global] diff --git a/test/files/run/macro-bodyexpandstoimpl/Macros_Test_2.scala b/test/files/run/macro-bodyexpandstoimpl/Macros_Test_2.scala index b589d4be03d1..cfcb59c17b2c 100644 --- a/test/files/run/macro-bodyexpandstoimpl/Macros_Test_2.scala +++ b/test/files/run/macro-bodyexpandstoimpl/Macros_Test_2.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.language.experimental.macros object Macros { def foo(x: Int) = macro Impls.refToFoo(42) diff --git a/test/files/run/macro-bundle-repl.check b/test/files/run/macro-bundle-repl.check index c11c48dc55b2..795debded7fa 100644 --- a/test/files/run/macro-bundle-repl.check +++ b/test/files/run/macro-bundle-repl.check @@ -4,16 +4,16 @@ Type :help for more information. scala> import scala.language.experimental.macros import scala.language.experimental.macros -scala> import scala.reflect.macros.Macro -import scala.reflect.macros.Macro +scala> import scala.reflect.macros.BlackboxMacro +import scala.reflect.macros.BlackboxMacro -scala> trait Bar extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } };def bar = macro Bar.impl +scala> trait Bar extends BlackboxMacro { def impl = { import c.universe._; c.Expr[Unit](q"()") } };def bar = macro Bar.impl defined trait Bar defined term macro bar: Unit scala> bar -scala> trait Foo extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } } +scala> trait Foo extends BlackboxMacro { def impl = { import c.universe._; c.Expr[Unit](q"()") } } defined trait Foo scala> def foo = macro Foo.impl diff --git a/test/files/run/macro-bundle-repl.scala b/test/files/run/macro-bundle-repl.scala index 3171aaacc2a0..50811cdb6568 100644 --- a/test/files/run/macro-bundle-repl.scala +++ b/test/files/run/macro-bundle-repl.scala @@ -3,11 +3,11 @@ import scala.tools.partest.ReplTest object Test extends ReplTest { def code = """ import scala.language.experimental.macros -import scala.reflect.macros.Macro -trait Bar extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } };def bar = macro Bar.impl +import scala.reflect.macros.BlackboxMacro +trait Bar extends BlackboxMacro { def impl = { import c.universe._; c.Expr[Unit](q"()") } };def bar = macro Bar.impl bar -trait Foo extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } } +trait Foo extends BlackboxMacro { def impl = { import c.universe._; c.Expr[Unit](q"()") } } def foo = macro Foo.impl foo """ -} \ No newline at end of file +} diff --git a/test/files/run/macro-bundle-static/Impls_Macros_1.scala b/test/files/run/macro-bundle-static/Impls_Macros_1.scala index e81fd0dbd60a..b859411325f8 100644 --- a/test/files/run/macro-bundle-static/Impls_Macros_1.scala +++ b/test/files/run/macro-bundle-static/Impls_Macros_1.scala @@ -1,9 +1,8 @@ -import scala.reflect.macros.Context -import scala.reflect.macros.Macro +import scala.reflect.macros.BlackboxMacro import scala.language.experimental.macros object Enclosing { - trait Impl extends Macro { + trait Impl extends BlackboxMacro { def mono = { import c.universe._; c.Expr[Unit](q"()") } def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString}") } def weird = macro mono @@ -17,7 +16,7 @@ object Macros { package pkg { object Enclosing { - trait Impl extends Macro { + trait Impl extends BlackboxMacro { def mono = { import c.universe._; c.Expr[Boolean](q"true") } def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString + c.weakTypeOf[T].toString}") } def weird = macro mono diff --git a/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala b/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala index 8c7df2cdc5fb..e0267686423e 100644 --- a/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala +++ b/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala @@ -1,7 +1,6 @@ -import scala.reflect.macros.Context -import scala.reflect.macros.Macro +import scala.reflect.macros.BlackboxMacro -trait Impl extends Macro { +trait Impl extends BlackboxMacro { def mono = { import c.universe._; c.Expr[Unit](q"()") } def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString}") } def weird = macro mono @@ -13,7 +12,7 @@ object Macros { } package pkg { - trait Impl extends Macro { + trait Impl extends BlackboxMacro { def mono = { import c.universe._; c.Expr[Boolean](q"true") } def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString + c.weakTypeOf[T].toString}") } def weird = macro mono diff --git a/test/files/run/macro-def-infer-return-type/Impls_1.scala b/test/files/run/macro-def-infer-return-type/Impls_1.scala index f8636fe72527..c670b1e57e4e 100644 --- a/test/files/run/macro-def-infer-return-type/Impls_1.scala +++ b/test/files/run/macro-def-infer-return-type/Impls_1.scala @@ -1,14 +1,14 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Impls1 { - def foo(c: Context)(x: c.Expr[Int]) = x + def foo(c: BlackboxContext)(x: c.Expr[Int]) = x } object Impls2 { - def foo[T](c: Context)(x: c.Expr[T]) = + def foo[T](c: BlackboxContext)(x: c.Expr[T]) = throw new Error("an implementation is missing") } object Impls3 { - def foo[T](c: Context)(x: c.Expr[T]): c.Expr[T] = x + def foo[T](c: BlackboxContext)(x: c.Expr[T]): c.Expr[T] = x } diff --git a/test/files/run/macro-def-path-dependent/Test_1.scala b/test/files/run/macro-def-path-dependent/Test_1.scala index 06c15e16c9ea..f9aa13c334a9 100644 --- a/test/files/run/macro-def-path-dependent/Test_1.scala +++ b/test/files/run/macro-def-path-dependent/Test_1.scala @@ -1,6 +1,6 @@ package test1 -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} trait Exprs { self: Universe => diff --git a/test/files/run/macro-def-path-dependent/Test_2.scala b/test/files/run/macro-def-path-dependent/Test_2.scala index f1e99099816a..cdedaf27326e 100644 --- a/test/files/run/macro-def-path-dependent/Test_2.scala +++ b/test/files/run/macro-def-path-dependent/Test_2.scala @@ -1,6 +1,6 @@ package test2 -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} trait Exprs { self: Universe => diff --git a/test/files/run/macro-def-path-dependent/Test_3.scala b/test/files/run/macro-def-path-dependent/Test_3.scala index 9f5efe5e471d..6d856d145043 100644 --- a/test/files/run/macro-def-path-dependent/Test_3.scala +++ b/test/files/run/macro-def-path-dependent/Test_3.scala @@ -1,6 +1,6 @@ package test3 -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} trait Exprs { self: Universe => diff --git a/test/files/run/macro-def-path-dependent/Test_4.scala b/test/files/run/macro-def-path-dependent/Test_4.scala index 3af920d73913..e8a8cf39090c 100644 --- a/test/files/run/macro-def-path-dependent/Test_4.scala +++ b/test/files/run/macro-def-path-dependent/Test_4.scala @@ -1,11 +1,11 @@ package test4 import scala.reflect.runtime.universe._ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import scala.reflect.api.Universe object Test { def materializeTypeTag[T](u: Universe)(e: T) = macro materializeTypeTag_impl[T] - def materializeTypeTag_impl[T: c.WeakTypeTag](c: Context)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ??? + def materializeTypeTag_impl[T: c.WeakTypeTag](c: BlackboxContext)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ??? } \ No newline at end of file diff --git a/test/files/run/macro-def-path-dependent/Test_5.scala b/test/files/run/macro-def-path-dependent/Test_5.scala index bc32fb92de57..22407b850c9a 100644 --- a/test/files/run/macro-def-path-dependent/Test_5.scala +++ b/test/files/run/macro-def-path-dependent/Test_5.scala @@ -1,9 +1,9 @@ package test56 import scala.reflect.runtime.universe._ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import scala.reflect.api.Universe object Impls { - def materializeTypeTag_impl[T: c.WeakTypeTag](c: Context)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ??? + def materializeTypeTag_impl[T: c.WeakTypeTag](c: BlackboxContext)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ??? } \ No newline at end of file diff --git a/test/files/run/macro-def-path-dependent/Test_6.scala b/test/files/run/macro-def-path-dependent/Test_6.scala index 6267743473ea..c8ddffc14380 100644 --- a/test/files/run/macro-def-path-dependent/Test_6.scala +++ b/test/files/run/macro-def-path-dependent/Test_6.scala @@ -1,7 +1,7 @@ package test56 import scala.reflect.runtime.universe._ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import scala.reflect.api.Universe object Macros { diff --git a/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala index 53511ebc72ff..4bafa84128b3 100644 --- a/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala +++ b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros trait Complex[T] @@ -7,7 +7,7 @@ class Foo(val bar: Bar) class Bar(val s: String) object Complex { - def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = { + def impl[T: c.WeakTypeTag](c: BlackboxContext): c.Expr[Complex[T]] = { import c.universe._ val tpe = weakTypeOf[T] for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { diff --git a/test/files/run/macro-duplicate/Impls_Macros_1.scala b/test/files/run/macro-duplicate/Impls_Macros_1.scala index 85a581585ffd..e9bcaf5d8d38 100644 --- a/test/files/run/macro-duplicate/Impls_Macros_1.scala +++ b/test/files/run/macro-duplicate/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val Expr(Block((cdef: ClassDef) :: Nil, _)) = reify { class C { def x = 2 } } val cdef1 = diff --git a/test/files/run/macro-enclosures/Impls_Macros_1.scala b/test/files/run/macro-enclosures/Impls_Macros_1.scala index 68f1920cddb7..dfffb48e736f 100644 --- a/test/files/run/macro-enclosures/Impls_Macros_1.scala +++ b/test/files/run/macro-enclosures/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ reify { println("enclosingPackage = " + c.Expr[String](Literal(Constant(c.enclosingPackage.toString))).splice) diff --git a/test/files/run/macro-expand-implicit-argument/Macros_1.scala b/test/files/run/macro-expand-implicit-argument/Macros_1.scala index b2c7b4d6ca40..7ac30e3ff2a9 100644 --- a/test/files/run/macro-expand-implicit-argument/Macros_1.scala +++ b/test/files/run/macro-expand-implicit-argument/Macros_1.scala @@ -5,7 +5,7 @@ import scala.{specialized => spec} import language.experimental.macros import scala.reflect.ClassTag -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { def alloc[@spec A:ClassTag](src:Array[A], s1:Int, len:Int) = { @@ -35,7 +35,7 @@ object Macros { * arr * } */ - def arrayMacro[A:c.WeakTypeTag](c:Context)(as:c.Expr[A]*)(ct: c.Expr[ClassTag[A]]): c.Expr[Array[A]] = { + def arrayMacro[A:c.WeakTypeTag](c:BlackboxContext)(as:c.Expr[A]*)(ct: c.Expr[ClassTag[A]]): c.Expr[Array[A]] = { import c.mirror._ import c.universe._ def const(x:Int) = Literal(Constant(x)) diff --git a/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala b/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala index ac1e55c9b2a2..c56489e61c32 100644 --- a/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala +++ b/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = { diff --git a/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala b/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala index aa1fc7a358da..f93d9100e844 100644 --- a/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala +++ b/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[String]): c.Expr[Option[Int]] = { diff --git a/test/files/run/macro-expand-implicit-macro-is-val/Impls_1.scala b/test/files/run/macro-expand-implicit-macro-is-val/Impls_1.scala index fa717b232741..a8b478e9f26d 100644 --- a/test/files/run/macro-expand-implicit-macro-is-val/Impls_1.scala +++ b/test/files/run/macro-expand-implicit-macro-is-val/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala b/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala index aa1fc7a358da..f93d9100e844 100644 --- a/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala +++ b/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[String]): c.Expr[Option[Int]] = { diff --git a/test/files/run/macro-expand-multiple-arglists/Impls_1.scala b/test/files/run/macro-expand-multiple-arglists/Impls_1.scala index 4fddc13d68e7..bc3d768a672f 100644 --- a/test/files/run/macro-expand-multiple-arglists/Impls_1.scala +++ b/test/files/run/macro-expand-multiple-arglists/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int])(y: c.Expr[Int]) = { diff --git a/test/files/run/macro-expand-nullary-generic/Impls_1.scala b/test/files/run/macro-expand-nullary-generic/Impls_1.scala index 5dfdd5c53999..e0a048046f09 100644 --- a/test/files/run/macro-expand-nullary-generic/Impls_1.scala +++ b/test/files/run/macro-expand-nullary-generic/Impls_1.scala @@ -1,5 +1,5 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def impl[T: c.WeakTypeTag](c: Ctx)(meth: String) = { diff --git a/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala b/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala index d23c671c8431..5da33babd34a 100644 --- a/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala +++ b/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala @@ -1,5 +1,5 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def impl(c: Ctx)(meth: String) = { diff --git a/test/files/run/macro-expand-overload/Impls_1.scala b/test/files/run/macro-expand-overload/Impls_1.scala index 1c672f604097..ea68e9eb937f 100644 --- a/test/files/run/macro-expand-overload/Impls_1.scala +++ b/test/files/run/macro-expand-overload/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def impl(c: Ctx)(tag: String, x: c.Expr[_]) = { diff --git a/test/files/run/macro-expand-override/Impls_1.scala b/test/files/run/macro-expand-override/Impls_1.scala index 69ef57d18d5e..648641f578cd 100644 --- a/test/files/run/macro-expand-override/Impls_1.scala +++ b/test/files/run/macro-expand-override/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def impl(c: Ctx)(tag: String, x: c.Expr[_]) = { diff --git a/test/files/run/macro-expand-recursive/Impls_1.scala b/test/files/run/macro-expand-recursive/Impls_1.scala index 47dd39845412..8ba1a2454054 100644 --- a/test/files/run/macro-expand-recursive/Impls_1.scala +++ b/test/files/run/macro-expand-recursive/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-expand-tparams-bounds.check b/test/files/run/macro-expand-tparams-bounds.check new file mode 100644 index 000000000000..317e9677c3bc --- /dev/null +++ b/test/files/run/macro-expand-tparams-bounds.check @@ -0,0 +1,2 @@ +hello +hello diff --git a/test/files/run/macro-expand-tparams-bounds/Impls_1.scala b/test/files/run/macro-expand-tparams-bounds/Impls_1.scala index d63f034e9b44..a255072774d7 100644 --- a/test/files/run/macro-expand-tparams-bounds/Impls_1.scala +++ b/test/files/run/macro-expand-tparams-bounds/Impls_1.scala @@ -1,12 +1,12 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Impls1 { - def foo[U <: String](c: Context): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"()") } + def foo[U <: String](c: BlackboxContext): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"""println("hello")""") } } class C class D extends C object Impls2 { - def foo[U <: C](c: Context): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"()") } + def foo[U <: C](c: BlackboxContext): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"""println("hello")""") } } diff --git a/test/files/run/macro-expand-tparams-explicit/Impls_1.scala b/test/files/run/macro-expand-tparams-explicit/Impls_1.scala index f748ab855f3e..e95d61a36a89 100644 --- a/test/files/run/macro-expand-tparams-explicit/Impls_1.scala +++ b/test/files/run/macro-expand-tparams-explicit/Impls_1.scala @@ -1,5 +1,5 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo[U: c.WeakTypeTag](c: Ctx) = { diff --git a/test/files/run/macro-expand-tparams-implicit/Impls_1.scala b/test/files/run/macro-expand-tparams-implicit/Impls_1.scala index c729aada517f..37cf785c0df1 100644 --- a/test/files/run/macro-expand-tparams-implicit/Impls_1.scala +++ b/test/files/run/macro-expand-tparams-implicit/Impls_1.scala @@ -1,5 +1,5 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo[U: c.WeakTypeTag](c: Ctx)(x: c.Expr[U]) = { diff --git a/test/files/run/macro-expand-tparams-prefix/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix/Impls_1.scala index a98c4abe785b..8f85ffff4a7a 100644 --- a/test/files/run/macro-expand-tparams-prefix/Impls_1.scala +++ b/test/files/run/macro-expand-tparams-prefix/Impls_1.scala @@ -1,8 +1,8 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Impls1 { - def foo[U: c.WeakTypeTag](c: Context)(x: c.Expr[U]) = { + def foo[U: c.WeakTypeTag](c: BlackboxContext)(x: c.Expr[U]) = { import c.universe._ val U = implicitly[c.WeakTypeTag[U]] c.Expr[Unit](q"println(${U.toString})") @@ -10,7 +10,7 @@ object Impls1 { } object Impls2 { - def foo[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context)(x: c.Expr[U]) = { + def foo[T: c.WeakTypeTag, U: c.WeakTypeTag](c: BlackboxContext)(x: c.Expr[U]) = { import c.universe._ val T = implicitly[c.WeakTypeTag[T]] val U = implicitly[c.WeakTypeTag[U]] @@ -20,7 +20,7 @@ object Impls2 { } object Impls345 { - def foo[T, U: c.WeakTypeTag, V](c: Context)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = { + def foo[T, U: c.WeakTypeTag, V](c: BlackboxContext)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = { import c.universe._ c.Expr(q""" println(${T.toString}) diff --git a/test/files/run/macro-expand-unapply-a/Impls_Macros_1.scala b/test/files/run/macro-expand-unapply-a/Impls_Macros_1.scala index 61d6345f16d5..b837ffc43bca 100644 --- a/test/files/run/macro-expand-unapply-a/Impls_Macros_1.scala +++ b/test/files/run/macro-expand-unapply-a/Impls_Macros_1.scala @@ -1,11 +1,11 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Helper { def unapplySeq[T](x: List[T]): Option[Seq[T]] = List.unapplySeq[T](x) } object Macros { - def impl[T: c.WeakTypeTag](c: Context)(x: c.Expr[List[T]]) = { + def impl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Expr[List[T]]) = { c.universe.reify(Helper.unapplySeq(x.splice)) } diff --git a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala index f6c1d27d54e4..2480af61adaa 100644 --- a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala +++ b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(xs: c.Expr[Int]*) = { diff --git a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala index 363ff0e0aa6d..a31c92a01c21 100644 --- a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala +++ b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(xs: c.Expr[Int]*) = { diff --git a/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala b/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala index 0b61ab2f9b45..889240d62821 100644 --- a/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala +++ b/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def myprintln(xs: Int*) = { diff --git a/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala b/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala index f6c1d27d54e4..2480af61adaa 100644 --- a/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala +++ b/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(xs: c.Expr[Int]*) = { diff --git a/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala b/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala index 0b61ab2f9b45..889240d62821 100644 --- a/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala +++ b/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def myprintln(xs: Int*) = { diff --git a/test/files/run/macro-impl-default-params/Impls_Macros_1.scala b/test/files/run/macro-impl-default-params/Impls_Macros_1.scala index 043675ec000e..aa76a410eaab 100644 --- a/test/files/run/macro-impl-default-params/Impls_Macros_1.scala +++ b/test/files/run/macro-impl-default-params/Impls_Macros_1.scala @@ -1,5 +1,5 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo_targs[T, U: c.WeakTypeTag](c: Ctx = null)(x: c.Expr[Int] = null) = { diff --git a/test/files/run/macro-impl-relaxed/Macros_1.scala b/test/files/run/macro-impl-relaxed/Macros_1.scala index af62646b4e06..3cf5090ec8f9 100644 --- a/test/files/run/macro-impl-relaxed/Macros_1.scala +++ b/test/files/run/macro-impl-relaxed/Macros_1.scala @@ -1,11 +1,11 @@ import language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def implUU(c: Context)(x: c.Tree): c.Tree = x - def implTU(c: Context)(x: c.Expr[Int]): c.Tree = x.tree - def implUT(c: Context)(x: c.Tree): c.Expr[Int] = c.Expr[Int](x) - def implTT(c: Context)(x: c.Expr[Int]): c.Expr[Int] = x + def implUU(c: BlackboxContext)(x: c.Tree): c.Tree = x + def implTU(c: BlackboxContext)(x: c.Expr[Int]): c.Tree = x.tree + def implUT(c: BlackboxContext)(x: c.Tree): c.Expr[Int] = c.Expr[Int](x) + def implTT(c: BlackboxContext)(x: c.Expr[Int]): c.Expr[Int] = x def fooUU(x: Int): Int = macro implUU def fooTU(x: Int): Int = macro implTU diff --git a/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala b/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala index 5f3bbac719a5..c79fc3062812 100644 --- a/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala +++ b/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(unconventionalName: Ctx)(x: unconventionalName.Expr[Int]) = { diff --git a/test/files/run/macro-impl-tparam-only-in-impl.check b/test/files/run/macro-impl-tparam-only-in-impl.check new file mode 100644 index 000000000000..3b18e512dba7 --- /dev/null +++ b/test/files/run/macro-impl-tparam-only-in-impl.check @@ -0,0 +1 @@ +hello world diff --git a/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala b/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala index 24eacb36de71..55cf0dcafa19 100644 --- a/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala +++ b/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala @@ -1,5 +1,5 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { - def foo[U <: String](c: Ctx): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"()") } + def foo[U <: String](c: Ctx): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"""println("hello world")""") } } diff --git a/test/files/run/macro-impl-tparam-typetag-is-optional/Impls_1.scala b/test/files/run/macro-impl-tparam-typetag-is-optional/Impls_1.scala index ace7a6cd266f..bcc746e39ab6 100644 --- a/test/files/run/macro-impl-tparam-typetag-is-optional/Impls_1.scala +++ b/test/files/run/macro-impl-tparam-typetag-is-optional/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo[U](c: Ctx) = { diff --git a/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Impls_Macros_1.scala b/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Impls_Macros_1.scala index b3babd88482b..5a51d27b24dc 100644 --- a/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Impls_Macros_1.scala +++ b/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx): c.Expr[Int] = { diff --git a/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala b/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala index 869a5a41fa92..44e508a1c684 100644 --- a/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala +++ b/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-invalidusage-badret/Impls_Macros_1.scala b/test/files/run/macro-invalidusage-badret/Impls_Macros_1.scala index 0d840eed3f19..a54eaa4001f9 100644 --- a/test/files/run/macro-invalidusage-badret/Impls_Macros_1.scala +++ b/test/files/run/macro-invalidusage-badret/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = x diff --git a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala index 8a93161af5a8..a67a296335ec 100644 --- a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala +++ b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo[T: c.WeakTypeTag](c: Ctx)(x: c.Expr[T]) = { diff --git a/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala b/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala index 3ac9cd2a8d8c..88929df27aa9 100644 --- a/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala +++ b/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int])(y: c.Expr[Int]) = { diff --git a/test/files/run/macro-openmacros/Impls_Macros_1.scala b/test/files/run/macro-openmacros/Impls_Macros_1.scala index 884d7f88258d..22e94f32cd90 100644 --- a/test/files/run/macro-openmacros/Impls_Macros_1.scala +++ b/test/files/run/macro-openmacros/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context): c.Expr[Unit] = { + def impl(c: BlackboxContext): c.Expr[Unit] = { // we're macros, so we can reflect against our source path // so we don't need any partests to clean up after us! val dir = c.enclosingUnit.source.file.file.getCanonicalFile.getParentFile diff --git a/test/files/run/macro-parse-position/Impls_Macros_1.scala b/test/files/run/macro-parse-position/Impls_Macros_1.scala index b6f1ebbcd5cc..92f64a8e7028 100644 --- a/test/files/run/macro-parse-position/Impls_Macros_1.scala +++ b/test/files/run/macro-parse-position/Impls_Macros_1.scala @@ -1,5 +1,5 @@ import scala.language.experimental.macros -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros { def impl(c: Ctx)() = { diff --git a/test/files/run/macro-quasiinvalidbody-c/Impls_Macros_1.scala b/test/files/run/macro-quasiinvalidbody-c/Impls_Macros_1.scala index 6c1442843702..04aa11b8fe0f 100644 --- a/test/files/run/macro-quasiinvalidbody-c/Impls_Macros_1.scala +++ b/test/files/run/macro-quasiinvalidbody-c/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros { object Impls { diff --git a/test/files/run/macro-quasiquotes/Macros_1.scala b/test/files/run/macro-quasiquotes/Macros_1.scala index b64eec874396..c42baafdf4fd 100644 --- a/test/files/run/macro-quasiquotes/Macros_1.scala +++ b/test/files/run/macro-quasiquotes/Macros_1.scala @@ -1,7 +1,7 @@ import language.experimental.macros -import scala.reflect.macros.Macro +import scala.reflect.macros.BlackboxMacro -trait Impls extends Macro { +trait Impls extends BlackboxMacro { import c.universe._ def impl1 = q"println(1)" def impl2 = q"{ println(2); println(3) }" diff --git a/test/files/run/macro-range/Common_1.scala b/test/files/run/macro-range/Common_1.scala index 4083e6126eab..1ad2a6c6eb88 100644 --- a/test/files/run/macro-range/Common_1.scala +++ b/test/files/run/macro-range/Common_1.scala @@ -1,4 +1,4 @@ -import reflect.macros.Context +import reflect.macros.BlackboxContext abstract class RangeDefault { val from, to: Int @@ -10,7 +10,7 @@ abstract class RangeDefault { /** This class should go into reflect.macro once it is a bit more stable. */ abstract class Utils { - val context: Context + val context: BlackboxContext import context.universe._ class TreeSubstituter(from: List[Symbol], to: List[Tree]) extends Transformer { diff --git a/test/files/run/macro-range/Expansion_Impossible_2.scala b/test/files/run/macro-range/Expansion_Impossible_2.scala index ca0db48822f4..fa869a25690a 100644 --- a/test/files/run/macro-range/Expansion_Impossible_2.scala +++ b/test/files/run/macro-range/Expansion_Impossible_2.scala @@ -1,7 +1,7 @@ -import reflect.macros.Context +import reflect.macros.BlackboxContext object Impls { - def foreach(c: Context)(f: c.Expr[Int => Unit]): c.Expr[Unit] = { + def foreach(c: BlackboxContext)(f: c.Expr[Int => Unit]): c.Expr[Unit] = { // todo. read the compiler config and print if -Ydebug is set //println("macro-expand, _this = "+ _this) object utils extends Utils { val context: c.type = c } diff --git a/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala b/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala index 51e0264ed50c..53b96691e986 100644 --- a/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala +++ b/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = { diff --git a/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala b/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala index 4261a6d45d05..81ad5cae0beb 100644 --- a/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala +++ b/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = { diff --git a/test/files/run/macro-reify-basic/Macros_1.scala b/test/files/run/macro-reify-basic/Macros_1.scala index 3f6720f10a41..e1a6d8abfb64 100644 --- a/test/files/run/macro-reify-basic/Macros_1.scala +++ b/test/files/run/macro-reify-basic/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros { def foo(s: String) = macro Impls.foo diff --git a/test/files/run/macro-reify-freevars/Macros_1.scala b/test/files/run/macro-reify-freevars/Macros_1.scala index 20f80c06d126..2cd94f600a4d 100644 --- a/test/files/run/macro-reify-freevars/Macros_1.scala +++ b/test/files/run/macro-reify-freevars/Macros_1.scala @@ -2,7 +2,7 @@ package scala.collection.slick object QueryableMacros{ def map[T:c.WeakTypeTag, S:c.WeakTypeTag] - (c: scala.reflect.macros.Context) + (c: scala.reflect.macros.BlackboxContext) (projection: c.Expr[T => S]) : c.Expr[scala.collection.slick.Queryable[S]] = { import c.universe._ diff --git a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala index bb6a45e11e58..ebd80c02babd 100644 --- a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala +++ b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala @@ -1,8 +1,8 @@ import scala.reflect.runtime.universe._ import scala.reflect.runtime.{universe => ru} -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext -case class Utils[C <: Context]( c:C ) { +case class Utils[C <: BlackboxContext]( c:C ) { import c.universe._ import c.{Tree=>_} object removeDoubleReify extends c.universe.Transformer { @@ -21,7 +21,7 @@ case class Utils[C <: Context]( c:C ) { } } object QueryableMacros{ - def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = { + def _helper[C <: BlackboxContext,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = { import c.universe._ import treeBuild._ val element_type = implicitly[c.WeakTypeTag[S]].tpe @@ -34,7 +34,7 @@ object QueryableMacros{ c.universe.reify{ Queryable.factory[S]( foo.splice )} } def map[T:c.WeakTypeTag, S:c.WeakTypeTag] - (c: scala.reflect.macros.Context) + (c: scala.reflect.macros.BlackboxContext) (projection: c.Expr[T => S]): c.Expr[Queryable[S]] = _helper[c.type,S]( c )( "_map", projection ) } class Queryable[T]{ diff --git a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala index bb6a45e11e58..ebd80c02babd 100644 --- a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala +++ b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala @@ -1,8 +1,8 @@ import scala.reflect.runtime.universe._ import scala.reflect.runtime.{universe => ru} -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext -case class Utils[C <: Context]( c:C ) { +case class Utils[C <: BlackboxContext]( c:C ) { import c.universe._ import c.{Tree=>_} object removeDoubleReify extends c.universe.Transformer { @@ -21,7 +21,7 @@ case class Utils[C <: Context]( c:C ) { } } object QueryableMacros{ - def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = { + def _helper[C <: BlackboxContext,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = { import c.universe._ import treeBuild._ val element_type = implicitly[c.WeakTypeTag[S]].tpe @@ -34,7 +34,7 @@ object QueryableMacros{ c.universe.reify{ Queryable.factory[S]( foo.splice )} } def map[T:c.WeakTypeTag, S:c.WeakTypeTag] - (c: scala.reflect.macros.Context) + (c: scala.reflect.macros.BlackboxContext) (projection: c.Expr[T => S]): c.Expr[Queryable[S]] = _helper[c.type,S]( c )( "_map", projection ) } class Queryable[T]{ diff --git a/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala b/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala index f19fd239f9aa..bc0015774ed6 100644 --- a/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala +++ b/test/files/run/macro-reify-ref-to-packageless/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { val `Answer to the Ultimate Question of Life, the Universe, and Everything` = 42 diff --git a/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala b/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala index f454fc430af5..d89a5e380da5 100644 --- a/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala +++ b/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = { diff --git a/test/files/run/macro-reify-splice-splice/Macros_1.scala b/test/files/run/macro-reify-splice-splice/Macros_1.scala index efdd5dbaa2b8..691f22ad079e 100644 --- a/test/files/run/macro-reify-splice-splice/Macros_1.scala +++ b/test/files/run/macro-reify-splice-splice/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros { def foo = macro Impls.foo diff --git a/test/files/run/macro-reify-staticXXX/Macros_1.scala b/test/files/run/macro-reify-staticXXX/Macros_1.scala index f12c8f7dcc6c..077271d582a6 100644 --- a/test/files/run/macro-reify-staticXXX/Macros_1.scala +++ b/test/files/run/macro-reify-staticXXX/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object B { override def toString = "object" } class C { override def toString = "class" } @@ -14,7 +14,7 @@ object foo { } object packageless { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ reify { println(B) @@ -31,7 +31,7 @@ object packageless { package packageful { object Test { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ reify { println(B) diff --git a/test/files/run/macro-reify-tagful-a/Macros_1.scala b/test/files/run/macro-reify-tagful-a/Macros_1.scala index f2512dcfaf0b..56d43c1c53d1 100644 --- a/test/files/run/macro-reify-tagful-a/Macros_1.scala +++ b/test/files/run/macro-reify-tagful-a/Macros_1.scala @@ -1,5 +1,5 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros { def foo[T](s: T) = macro Impls.foo[T] diff --git a/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala b/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala index 96cfb7585217..27acaa16269b 100644 --- a/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala +++ b/test/files/run/macro-reify-tagless-a/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros { def foo[T](s: T) = macro Impls.foo[T] diff --git a/test/files/run/macro-reify-type/Macros_1.scala b/test/files/run/macro-reify-type/Macros_1.scala index c4d1d9f8ad56..04634b649a50 100644 --- a/test/files/run/macro-reify-type/Macros_1.scala +++ b/test/files/run/macro-reify-type/Macros_1.scala @@ -1,10 +1,10 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import scala.reflect.runtime.{universe => ru} object StaticReflect { def method[A](name: String): ru.Type = macro methodImpl[A] - def methodImpl[A: c.WeakTypeTag](c: Context)(name: c.Expr[String]): c.Expr[ru.Type] = { + def methodImpl[A: c.WeakTypeTag](c: BlackboxContext)(name: c.Expr[String]): c.Expr[ru.Type] = { import c.universe._ val nameName: TermName = name.tree match { diff --git a/test/files/run/macro-reify-unreify/Macros_1.scala b/test/files/run/macro-reify-unreify/Macros_1.scala index 25ed352cca17..d1e71b3311d2 100644 --- a/test/files/run/macro-reify-unreify/Macros_1.scala +++ b/test/files/run/macro-reify-unreify/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Macros { def foo(s: String) = macro Impls.foo diff --git a/test/files/run/macro-repl-basic.check b/test/files/run/macro-repl-basic.check index 46ea1f64051f..cc974897f2e8 100644 --- a/test/files/run/macro-repl-basic.check +++ b/test/files/run/macro-repl-basic.check @@ -4,8 +4,8 @@ Type :help for more information. scala> import language.experimental.macros import language.experimental.macros -scala> import scala.reflect.macros.{Context => Ctx} -import scala.reflect.macros.{Context=>Ctx} +scala> import scala.reflect.macros.{BlackboxContext => Ctx} +import scala.reflect.macros.{BlackboxContext=>Ctx} scala> diff --git a/test/files/run/macro-repl-basic.scala b/test/files/run/macro-repl-basic.scala index 3c22c13dc7b2..dea36c481ca5 100644 --- a/test/files/run/macro-repl-basic.scala +++ b/test/files/run/macro-repl-basic.scala @@ -3,7 +3,7 @@ import scala.tools.partest.ReplTest object Test extends ReplTest { def code = """ |import language.experimental.macros - |import scala.reflect.macros.{Context => Ctx} + |import scala.reflect.macros.{BlackboxContext => Ctx} | |object Impls { | def foo(c: Ctx)(x: c.Expr[Int]) = { diff --git a/test/files/run/macro-repl-dontexpand.check b/test/files/run/macro-repl-dontexpand.check index 9c35aad6b172..3ba877b59d35 100644 --- a/test/files/run/macro-repl-dontexpand.check +++ b/test/files/run/macro-repl-dontexpand.check @@ -1,10 +1,16 @@ Type in expressions to have them evaluated. Type :help for more information. -scala> def bar(c: scala.reflect.macros.Context) = ??? -bar: (c: scala.reflect.macros.Context)Nothing +scala> def bar1(c: scala.reflect.macros.BlackboxContext) = ??? +bar1: (c: scala.reflect.macros.BlackboxContext)Nothing -scala> def foo = macro bar -defined term macro foo: Any +scala> def foo1 = macro bar1 +defined term macro foo1: Any + +scala> def bar2(c: scala.reflect.macros.WhiteboxContext) = ??? +bar2: (c: scala.reflect.macros.WhiteboxContext)Nothing + +scala> def foo2 = macro bar2 +defined term macro foo2: Any scala> diff --git a/test/files/run/macro-repl-dontexpand.scala b/test/files/run/macro-repl-dontexpand.scala index f3422d88de01..733288e513d4 100644 --- a/test/files/run/macro-repl-dontexpand.scala +++ b/test/files/run/macro-repl-dontexpand.scala @@ -3,7 +3,9 @@ import scala.tools.partest.ReplTest object Test extends ReplTest { override def extraSettings = "-language:experimental.macros" def code = """ - |def bar(c: scala.reflect.macros.Context) = ??? - |def foo = macro bar + |def bar1(c: scala.reflect.macros.BlackboxContext) = ??? + |def foo1 = macro bar1 + |def bar2(c: scala.reflect.macros.WhiteboxContext) = ??? + |def foo2 = macro bar2 |""".stripMargin } diff --git a/test/files/run/macro-settings/Impls_Macros_1.scala b/test/files/run/macro-settings/Impls_Macros_1.scala index 9257784cf256..c9cecfa99f43 100644 --- a/test/files/run/macro-settings/Impls_Macros_1.scala +++ b/test/files/run/macro-settings/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Impls { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ reify { println(c.Expr[String](Literal(Constant(c.settings.toString))).splice) diff --git a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala index 1b914ac797db..870930c7e5f5 100644 --- a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala +++ b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val inscope = c.inferImplicitValue(c.mirror.staticClass("SourceLocation").toType) diff --git a/test/files/run/macro-sip19/Impls_Macros_1.scala b/test/files/run/macro-sip19/Impls_Macros_1.scala index 95e19c4fd186..72a3c2568da9 100644 --- a/test/files/run/macro-sip19/Impls_Macros_1.scala +++ b/test/files/run/macro-sip19/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val Apply(fun, args) = c.enclosingImplicits(0).tree val fileName = fun.pos.source.file.file.getName diff --git a/test/files/run/macro-system-properties.check b/test/files/run/macro-system-properties.check index c61fe7f2cfbe..ea4c5a664a68 100644 --- a/test/files/run/macro-system-properties.check +++ b/test/files/run/macro-system-properties.check @@ -1,14 +1,14 @@ Type in expressions to have them evaluated. Type :help for more information. -scala> import language.experimental._, reflect.macros.Context +scala> import language.experimental._, reflect.macros.BlackboxContext import language.experimental._ -import reflect.macros.Context +import reflect.macros.BlackboxContext scala> object GrabContext { def lastContext = Option(System.getProperties.get("lastContext").asInstanceOf[reflect.macros.runtime.Context]) // System.properties lets you stash true globals (unlike statics which are classloader scoped) - def impl(c: Context)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](q"()") } + def impl(c: BlackboxContext)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](q"()") } def grab() = macro impl } defined object GrabContext diff --git a/test/files/run/macro-system-properties.scala b/test/files/run/macro-system-properties.scala index 9dcd044dbd03..73a3ef5910d4 100644 --- a/test/files/run/macro-system-properties.scala +++ b/test/files/run/macro-system-properties.scala @@ -3,11 +3,11 @@ import scala.tools.partest.ReplTest object Test extends ReplTest { def code = """ - import language.experimental._, reflect.macros.Context + import language.experimental._, reflect.macros.BlackboxContext object GrabContext { def lastContext = Option(System.getProperties.get("lastContext").asInstanceOf[reflect.macros.runtime.Context]) // System.properties lets you stash true globals (unlike statics which are classloader scoped) - def impl(c: Context)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](q"()") } + def impl(c: BlackboxContext)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](q"()") } def grab() = macro impl } object Test { class C(implicit a: Any) { GrabContext.grab } } diff --git a/test/files/run/macro-term-declared-in-annotation/Impls_1.scala b/test/files/run/macro-term-declared-in-annotation/Impls_1.scala index 1ea06de6799a..df3509731bfc 100644 --- a/test/files/run/macro-term-declared-in-annotation/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-annotation/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-anonymous/Impls_1.scala b/test/files/run/macro-term-declared-in-anonymous/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-anonymous/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-anonymous/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-block/Impls_1.scala b/test/files/run/macro-term-declared-in-block/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-block/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-block/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-class-class/Impls_1.scala b/test/files/run/macro-term-declared-in-class-class/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-class-class/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-class-class/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-class-object/Impls_1.scala b/test/files/run/macro-term-declared-in-class-object/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-class-object/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-class-object/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-class/Impls_1.scala b/test/files/run/macro-term-declared-in-class/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-class/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-class/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-default-param/Impls_1.scala b/test/files/run/macro-term-declared-in-default-param/Impls_1.scala index 4380f40b04c5..4fae9b200f7d 100644 --- a/test/files/run/macro-term-declared-in-default-param/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-default-param/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-implicit-class/Impls_Macros_1.scala b/test/files/run/macro-term-declared-in-implicit-class/Impls_Macros_1.scala index 4c009cc367bc..053af625a246 100644 --- a/test/files/run/macro-term-declared-in-implicit-class/Impls_Macros_1.scala +++ b/test/files/run/macro-term-declared-in-implicit-class/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def toOptionOfInt(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-method/Impls_1.scala b/test/files/run/macro-term-declared-in-method/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-method/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-method/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-object-class/Impls_1.scala b/test/files/run/macro-term-declared-in-object-class/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-object-class/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-object-class/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-object-object/Impls_1.scala b/test/files/run/macro-term-declared-in-object-object/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-object-object/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-object-object/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-object/Impls_1.scala b/test/files/run/macro-term-declared-in-object/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-object/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-object/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-package-object/Impls_1.scala b/test/files/run/macro-term-declared-in-package-object/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-package-object/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-package-object/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-refinement/Impls_1.scala b/test/files/run/macro-term-declared-in-refinement/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-refinement/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-refinement/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-term-declared-in-trait/Impls_1.scala b/test/files/run/macro-term-declared-in-trait/Impls_1.scala index 348f3420f2a0..d69422872b5d 100644 --- a/test/files/run/macro-term-declared-in-trait/Impls_1.scala +++ b/test/files/run/macro-term-declared-in-trait/Impls_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} object Impls { def foo(c: Ctx) = { diff --git a/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala b/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala index cd37c269b55b..9f7d6f641cdf 100644 --- a/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala +++ b/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl_with_implicits_enabled(c: Context) = { + def impl_with_implicits_enabled(c: BlackboxContext) = { import c.universe._ val tree1 = Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2)))) @@ -11,7 +11,7 @@ object Macros { def foo_with_implicits_enabled = macro impl_with_implicits_enabled - def impl_with_implicits_disabled(c: Context) = { + def impl_with_implicits_disabled(c: BlackboxContext) = { import c.universe._ try { diff --git a/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala b/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala index 2532cfd2b92d..41e58e0e4d95 100644 --- a/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala +++ b/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl_with_macros_enabled(c: Context) = { + def impl_with_macros_enabled(c: BlackboxContext) = { import c.universe._ val ru = Select(Select(Select(Select(Ident(TermName("scala")), TermName("reflect")), TermName("runtime")), TermName("package")), TermName("universe")) @@ -12,7 +12,7 @@ object Macros { def foo_with_macros_enabled = macro impl_with_macros_enabled - def impl_with_macros_disabled(c: Context) = { + def impl_with_macros_disabled(c: BlackboxContext) = { import c.universe._ val rupkg = c.mirror.staticModule("scala.reflect.runtime.package") diff --git a/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala b/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala index 7b22793df95d..3d1202010924 100644 --- a/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala +++ b/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl_with_macros_enabled(c: Context) = { + def impl_with_macros_enabled(c: BlackboxContext) = { import c.universe._ val ru = Select(Select(Select(Select(Ident(TermName("scala")), TermName("reflect")), TermName("runtime")), TermName("package")), TermName("universe")) @@ -12,7 +12,7 @@ object Macros { def foo_with_macros_enabled = macro impl_with_macros_enabled - def impl_with_macros_disabled(c: Context) = { + def impl_with_macros_disabled(c: BlackboxContext) = { import c.universe._ val rupkg = c.mirror.staticModule("scala.reflect.runtime.package") diff --git a/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala b/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala index 6695a297ea4e..1af0579abcd0 100644 --- a/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala +++ b/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala @@ -1,8 +1,8 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def cons_impl[A: c.WeakTypeTag](c: Context)(x: c.Expr[A], xs: c.Expr[List[A]]): c.Expr[List[A]] = { + def cons_impl[A: c.WeakTypeTag](c: BlackboxContext)(x: c.Expr[A], xs: c.Expr[List[A]]): c.Expr[List[A]] = { import c.universe._ reify { println("A = " + c.Expr[String](Literal(Constant(implicitly[c.WeakTypeTag[A]].toString))).splice) @@ -10,7 +10,7 @@ object Macros { } } - def nil_impl[B: c.WeakTypeTag](c: Context): c.Expr[List[B]] = { + def nil_impl[B: c.WeakTypeTag](c: BlackboxContext): c.Expr[List[B]] = { import c.universe._ reify { println("B = " + c.Expr[String](Literal(Constant(implicitly[c.WeakTypeTag[B]].toString))).splice) diff --git a/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala b/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala index 85877b3f13af..f698320579ae 100644 --- a/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala +++ b/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala @@ -1,8 +1,8 @@ import scala.reflect.runtime.universe._ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl[T: c.WeakTypeTag](c: Context)(foo: c.Expr[T]): c.Expr[Unit] = { + def impl[T: c.WeakTypeTag](c: BlackboxContext)(foo: c.Expr[T]): c.Expr[Unit] = { import c.universe._ reify { println(c.Expr[String](Literal(Constant(implicitly[c.WeakTypeTag[T]].toString))).splice) } } diff --git a/test/files/run/macro-vampire-false-warning/Macros_1.scala b/test/files/run/macro-vampire-false-warning/Macros_1.scala index 2d384fbb85f5..5907461c84b9 100644 --- a/test/files/run/macro-vampire-false-warning/Macros_1.scala +++ b/test/files/run/macro-vampire-false-warning/Macros_1.scala @@ -1,20 +1,20 @@ // As per http://meta.plasm.us/posts/2013/08/31/feeding-our-vampires/ import scala.annotation.StaticAnnotation -import scala.reflect.macros.Context +import scala.reflect.macros.WhiteboxContext import scala.language.experimental.macros class body(tree: Any) extends StaticAnnotation object Macros { - def selFieldImpl(c: Context) = { + def selFieldImpl(c: WhiteboxContext) = { import c.universe._ val field = c.macroApplication.symbol val bodyAnn = field.annotations.filter(_.tpe <:< typeOf[body]).head c.Expr[Any](bodyAnn.scalaArgs.head) } - def mkObjectImpl(c: Context)(xs: c.Expr[Any]*) = { + def mkObjectImpl(c: WhiteboxContext)(xs: c.Expr[Any]*) = { import c.universe._ import Flag._ // val kvps = xs.toList map { case q"${_}(${Literal(Constant(name: String))}).->[${_}]($value)" => name -> value } diff --git a/test/files/run/repl-term-macros.check b/test/files/run/repl-term-macros.check index 63bafe401bdf..64c46392a357 100644 --- a/test/files/run/repl-term-macros.check +++ b/test/files/run/repl-term-macros.check @@ -1,16 +1,16 @@ Type in expressions to have them evaluated. Type :help for more information. -scala> import scala.reflect.macros.Context -import scala.reflect.macros.Context +scala> import scala.reflect.macros.BlackboxContext +import scala.reflect.macros.BlackboxContext scala> import language.experimental.macros import language.experimental.macros scala> -scala> def impl1(c: Context) = { import c.universe._; c.Expr[Unit](q"()") } -impl1: (c: scala.reflect.macros.Context)c.Expr[Unit] +scala> def impl1(c: BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } +impl1: (c: scala.reflect.macros.BlackboxContext)c.Expr[Unit] scala> def foo1 = macro impl1 defined term macro foo1: Unit @@ -19,8 +19,8 @@ scala> foo1 scala> -scala> def impl2(c: Context)() = { import c.universe._; c.Expr[Unit](q"()") } -impl2: (c: scala.reflect.macros.Context)()c.Expr[Unit] +scala> def impl2(c: BlackboxContext)() = { import c.universe._; c.Expr[Unit](q"()") } +impl2: (c: scala.reflect.macros.BlackboxContext)()c.Expr[Unit] scala> def foo2() = macro impl2 defined term macro foo2: ()Unit @@ -29,8 +29,8 @@ scala> foo2() scala> -scala> def impl3(c: Context)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } -impl3: (c: scala.reflect.macros.Context)(x: c.Expr[Int])(y: c.Expr[Int])c.Expr[Unit] +scala> def impl3(c: BlackboxContext)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } +impl3: (c: scala.reflect.macros.BlackboxContext)(x: c.Expr[Int])(y: c.Expr[Int])c.Expr[Unit] scala> def foo3(x: Int)(y: Int) = macro impl3 defined term macro foo3: (x: Int)(y: Int)Unit diff --git a/test/files/run/repl-term-macros.scala b/test/files/run/repl-term-macros.scala index 125e397b223a..a779638c00f9 100644 --- a/test/files/run/repl-term-macros.scala +++ b/test/files/run/repl-term-macros.scala @@ -2,18 +2,18 @@ import scala.tools.partest.ReplTest object Test extends ReplTest { def code = """ - import scala.reflect.macros.Context + import scala.reflect.macros.BlackboxContext import language.experimental.macros -def impl1(c: Context) = { import c.universe._; c.Expr[Unit](q"()") } +def impl1(c: BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } def foo1 = macro impl1 foo1 -def impl2(c: Context)() = { import c.universe._; c.Expr[Unit](q"()") } +def impl2(c: BlackboxContext)() = { import c.universe._; c.Expr[Unit](q"()") } def foo2() = macro impl2 foo2() -def impl3(c: Context)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } +def impl3(c: BlackboxContext)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") } def foo3(x: Int)(y: Int) = macro impl3 foo3(2)(3) """ diff --git a/test/files/run/t5713/Impls_Macros_1.scala b/test/files/run/t5713/Impls_Macros_1.scala index 12c3da2ff0f4..bfe2fc4efde4 100644 --- a/test/files/run/t5713/Impls_Macros_1.scala +++ b/test/files/run/t5713/Impls_Macros_1.scala @@ -1,7 +1,7 @@ package m import language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Level extends Enumeration { val Error = Value(5) @@ -13,7 +13,7 @@ object Logger { private object LoggerMacros { - type LoggerContext = Context { type PrefixType = Logger.type } + type LoggerContext = BlackboxContext { type PrefixType = Logger.type } def error(c: LoggerContext)(message: c.Expr[String]): c.Expr[Unit] = log(c)(c.universe.reify(Level.Error), message) diff --git a/test/files/run/t5753_1/Impls_Macros_1.scala b/test/files/run/t5753_1/Impls_Macros_1.scala index 1664301f5fc9..3ddff56c386d 100644 --- a/test/files/run/t5753_1/Impls_Macros_1.scala +++ b/test/files/run/t5753_1/Impls_Macros_1.scala @@ -1,8 +1,8 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros trait Impls { - def impl(c: Context)(x: c.Expr[Any]) = x + def impl(c: BlackboxContext)(x: c.Expr[Any]) = x } object Macros extends Impls { diff --git a/test/files/run/t5753_2/Impls_Macros_1.scala b/test/files/run/t5753_2/Impls_Macros_1.scala index 41d584d0ac5e..c95c9a41b36b 100644 --- a/test/files/run/t5753_2/Impls_Macros_1.scala +++ b/test/files/run/t5753_2/Impls_Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.{Context => Ctx} +import scala.reflect.macros.{BlackboxContext => Ctx} trait Macro_T { def foo[T](c: Ctx)(s: c.Expr[T]) = s diff --git a/test/files/run/t5894.scala b/test/files/run/t5894.scala index 5deda34489c0..55767d8889ed 100644 --- a/test/files/run/t5894.scala +++ b/test/files/run/t5894.scala @@ -4,7 +4,7 @@ class Test object Test { def foo = macro fooImpl - def fooImpl(c: reflect.macros.Context) = { import c.universe._; c.Expr[Unit](q"()") } + def fooImpl(c: reflect.macros.BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } def main(args: Array[String]) { try { diff --git a/test/files/run/t5903a/Macros_1.scala b/test/files/run/t5903a/Macros_1.scala index e82be0fc68c3..9fc3bfe2616e 100644 --- a/test/files/run/t5903a/Macros_1.scala +++ b/test/files/run/t5903a/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros trait Tree @@ -13,7 +13,7 @@ object NewQuasiquotes { } object QuasiquoteMacros { - def unapplyImpl(c: Context)(t: c.Tree) = { + def unapplyImpl(c: BlackboxContext)(t: c.Tree) = { import c.universe._ q""" new { diff --git a/test/files/run/t5903b/Macros_1.scala b/test/files/run/t5903b/Macros_1.scala index c0124850b896..ae491e2207d9 100644 --- a/test/files/run/t5903b/Macros_1.scala +++ b/test/files/run/t5903b/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Interpolation { @@ -10,7 +10,7 @@ object Interpolation { } object Macros { - def unapplyImpl[T: c.WeakTypeTag](c: Context)(x: c.Tree) = { + def unapplyImpl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Tree) = { import c.universe._ q""" new { diff --git a/test/files/run/t5903c/Macros_1.scala b/test/files/run/t5903c/Macros_1.scala index f8baa2275b8b..da7dd5281c8e 100644 --- a/test/files/run/t5903c/Macros_1.scala +++ b/test/files/run/t5903c/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Interpolation { @@ -10,7 +10,7 @@ object Interpolation { } object Macros { - def unapplyImpl[T: c.WeakTypeTag](c: Context)(x: c.Tree) = { + def unapplyImpl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Tree) = { import c.universe._ q""" new { diff --git a/test/files/run/t5903d/Macros_1.scala b/test/files/run/t5903d/Macros_1.scala index 88d714e17bbd..e3a9c3b39e63 100644 --- a/test/files/run/t5903d/Macros_1.scala +++ b/test/files/run/t5903d/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Interpolation { @@ -10,7 +10,7 @@ object Interpolation { } object Macros { - def unapplyImpl(c: Context)(x: c.Tree) = { + def unapplyImpl(c: BlackboxContext)(x: c.Tree) = { import c.universe._ q""" new { diff --git a/test/files/run/t5923a/Macros_1.scala b/test/files/run/t5923a/Macros_1.scala index 741379cf3481..f86e6b1add9b 100644 --- a/test/files/run/t5923a/Macros_1.scala +++ b/test/files/run/t5923a/Macros_1.scala @@ -1,4 +1,4 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros case class C[T](t: String) @@ -7,7 +7,7 @@ object C { } object Macros { - def impl[T](c: Context)(ttag: c.WeakTypeTag[T]) = { + def impl[T](c: BlackboxContext)(ttag: c.WeakTypeTag[T]) = { import c.universe._ val ttag0 = ttag; { diff --git a/test/files/run/t5923c/Macros_1.scala b/test/files/run/t5923c/Macros_1.scala index 0b7a3399e205..c980f243d45c 100644 --- a/test/files/run/t5923c/Macros_1.scala +++ b/test/files/run/t5923c/Macros_1.scala @@ -1,5 +1,5 @@ import language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext trait Iso[T, U] { def to(t : T) : U @@ -8,7 +8,7 @@ trait Iso[T, U] { object Iso { implicit def materializeIso[T, U]: Iso[T, U] = macro impl[T, U] - def impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context): c.Expr[Iso[T, U]] = { + def impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: BlackboxContext): c.Expr[Iso[T, U]] = { import c.universe._ import definitions._ import Flag._ diff --git a/test/files/run/t5923d/Macros_1.scala b/test/files/run/t5923d/Macros_1.scala index f32d1af704a6..b6e7134b9511 100644 --- a/test/files/run/t5923d/Macros_1.scala +++ b/test/files/run/t5923d/Macros_1.scala @@ -1,9 +1,9 @@ import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext trait MappedRow trait RowMapper[T <: MappedRow] object RowMapper { implicit def mapper[T <: MappedRow]: RowMapper[T] = macro impl[T] - def impl[T <: MappedRow : c.WeakTypeTag](c: Context) = c.universe.reify(new RowMapper[T]{}) + def impl[T <: MappedRow : c.WeakTypeTag](c: BlackboxContext) = c.universe.reify(new RowMapper[T]{}) } \ No newline at end of file diff --git a/test/files/run/t5940.scala b/test/files/run/t5940.scala index 9c8f702c68c2..d98f2671233c 100644 --- a/test/files/run/t5940.scala +++ b/test/files/run/t5940.scala @@ -4,15 +4,15 @@ object Test extends DirectTest { def code = ??? def macros_1 = """ - import scala.reflect.macros.Context + import scala.reflect.macros.BlackboxContext object Impls { - def impl(c: Context) = { import c.universe._; c.Expr[Unit](q"()") } + def impl(c: BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } } object Macros { //import Impls._ - def impl(c: Context) = { import c.universe._; c.Expr[Unit](q"()") } + def impl(c: BlackboxContext) = { import c.universe._; c.Expr[Unit](q"()") } def foo = macro impl } """ diff --git a/test/files/run/t6187.check b/test/files/run/t6187.check index 621306b2ef84..c833b454431a 100644 --- a/test/files/run/t6187.check +++ b/test/files/run/t6187.check @@ -1,15 +1,15 @@ Type in expressions to have them evaluated. Type :help for more information. -scala> import language.experimental.macros, reflect.macros.Context +scala> import language.experimental.macros, reflect.macros.BlackboxContext import language.experimental.macros -import reflect.macros.Context +import reflect.macros.BlackboxContext -scala> def macroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[List[T]] = { +scala> def macroImpl[T: c.WeakTypeTag](c: BlackboxContext)(t: c.Expr[T]): c.Expr[List[T]] = { val r = c.universe.reify { List(t.splice) } c.Expr[List[T]]( c.resetLocalAttrs(r.tree) ) } -macroImpl: [T](c: scala.reflect.macros.Context)(t: c.Expr[T])(implicit evidence$1: c.WeakTypeTag[T])c.Expr[List[T]] +macroImpl: [T](c: scala.reflect.macros.BlackboxContext)(t: c.Expr[T])(implicit evidence$1: c.WeakTypeTag[T])c.Expr[List[T]] scala> def demo[T](t: T): List[T] = macro macroImpl[T] defined term macro demo: [T](t: T)List[T] diff --git a/test/files/run/t6187.scala b/test/files/run/t6187.scala index ae642917e7e1..fc6fa6e9a7f8 100644 --- a/test/files/run/t6187.scala +++ b/test/files/run/t6187.scala @@ -2,8 +2,8 @@ import scala.tools.partest.ReplTest object Test extends ReplTest { override def code = """ -import language.experimental.macros, reflect.macros.Context -def macroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[List[T]] = { +import language.experimental.macros, reflect.macros.BlackboxContext +def macroImpl[T: c.WeakTypeTag](c: BlackboxContext)(t: c.Expr[T]): c.Expr[List[T]] = { val r = c.universe.reify { List(t.splice) } c.Expr[List[T]]( c.resetLocalAttrs(r.tree) ) } diff --git a/test/files/run/t6221/Macros_1.scala b/test/files/run/t6221/Macros_1.scala index c9500626d8ce..60ed0aa3e350 100644 --- a/test/files/run/t6221/Macros_1.scala +++ b/test/files/run/t6221/Macros_1.scala @@ -1,6 +1,6 @@ import language.experimental.macros import language.implicitConversions -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import scala.reflect.runtime.universe.Tree class ReflectiveClosure[A, B](val tree: Tree, fn: A => B) extends (A => B) { @@ -12,7 +12,7 @@ object ReflectiveClosure { } object Macros { - def reflectiveClosureImpl[A, B](c: Context)(f: c.Expr[A => B]): c.Expr[ReflectiveClosure[A, B]] = { + def reflectiveClosureImpl[A, B](c: BlackboxContext)(f: c.Expr[A => B]): c.Expr[ReflectiveClosure[A, B]] = { import c.universe._ val u = treeBuild.mkRuntimeUniverseRef val m = EmptyTree diff --git a/test/files/run/t6381.check b/test/files/run/t6381.check index c9d4713aa81a..dfc9d44850cc 100644 --- a/test/files/run/t6381.check +++ b/test/files/run/t6381.check @@ -4,11 +4,11 @@ Type :help for more information. scala> import language.experimental.macros import language.experimental.macros -scala> def pos_impl(c: reflect.macros.Context): c.Expr[String] = { +scala> def pos_impl(c: reflect.macros.BlackboxContext): c.Expr[String] = { import c.universe._ c.Expr[String](Literal(Constant(c.enclosingPosition.getClass.toString))) } -pos_impl: (c: scala.reflect.macros.Context)c.Expr[String] +pos_impl: (c: scala.reflect.macros.BlackboxContext)c.Expr[String] scala> def pos = macro pos_impl defined term macro pos: String diff --git a/test/files/run/t6381.scala b/test/files/run/t6381.scala index 4c2a40fe87a3..0e2264d8fad6 100644 --- a/test/files/run/t6381.scala +++ b/test/files/run/t6381.scala @@ -3,7 +3,7 @@ import scala.tools.partest.ReplTest object Test extends ReplTest { def code = """ |import language.experimental.macros - |def pos_impl(c: reflect.macros.Context): c.Expr[String] = { + |def pos_impl(c: reflect.macros.BlackboxContext): c.Expr[String] = { | import c.universe._ | c.Expr[String](Literal(Constant(c.enclosingPosition.getClass.toString))) |} diff --git a/test/files/run/t6394a/Macros_1.scala b/test/files/run/t6394a/Macros_1.scala index 5aa07e7f41ea..b934b5ebb11e 100644 --- a/test/files/run/t6394a/Macros_1.scala +++ b/test/files/run/t6394a/Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c:Context): c.Expr[Any] = { + def impl(c:BlackboxContext): c.Expr[Any] = { import c.universe._ val selfTree = This(c.enclosingImpl.symbol.asModule.moduleClass) diff --git a/test/files/run/t6394b/Macros_1.scala b/test/files/run/t6394b/Macros_1.scala index 5d93e1cda866..01fbc4f09eee 100644 --- a/test/files/run/t6394b/Macros_1.scala +++ b/test/files/run/t6394b/Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c:Context): c.Expr[Any] = { + def impl(c:BlackboxContext): c.Expr[Any] = { import c.universe._ val selfTree = This(tpnme.EMPTY) diff --git a/test/files/run/t6662/Macro_1.scala b/test/files/run/t6662/Macro_1.scala index f373eaaf9450..cecf242f665c 100644 --- a/test/files/run/t6662/Macro_1.scala +++ b/test/files/run/t6662/Macro_1.scala @@ -1,8 +1,8 @@ import language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Demo { def id[T](a: T): T = macro idImpl[T] - def idImpl[T: c.WeakTypeTag](c: Context)(a: c.Expr[T]): c.Expr[T] = a + def idImpl[T: c.WeakTypeTag](c: BlackboxContext)(a: c.Expr[T]): c.Expr[T] = a } diff --git a/test/files/run/t7008-scala-defined/Impls_Macros_2.scala b/test/files/run/t7008-scala-defined/Impls_Macros_2.scala index 477829f20003..0ce5daf0d058 100644 --- a/test/files/run/t7008-scala-defined/Impls_Macros_2.scala +++ b/test/files/run/t7008-scala-defined/Impls_Macros_2.scala @@ -1,8 +1,8 @@ import language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val decls = c.typeOf[ScalaClassWithCheckedExceptions_1[_]].declarations.toList val s = decls.sortBy(_.name.toString).map(decl => (s"${decl.name}: ${decl.annotations}")).mkString(scala.compat.Platform.EOL) diff --git a/test/files/run/t7008/Impls_Macros_2.scala b/test/files/run/t7008/Impls_Macros_2.scala index 63c3f9d696a2..6da9dca913ee 100644 --- a/test/files/run/t7008/Impls_Macros_2.scala +++ b/test/files/run/t7008/Impls_Macros_2.scala @@ -1,8 +1,8 @@ import language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ val decls = c.typeOf[JavaClassWithCheckedExceptions_1[_]].declarations.toList val s = decls.sortBy(_.name.toString).map(decl => (s"${decl.name}: ${decl.annotations}")).mkString(scala.compat.Platform.EOL) diff --git a/test/files/run/t7047/Impls_Macros_1.scala b/test/files/run/t7047/Impls_Macros_1.scala index a5d55c3a428e..0d64729791c0 100644 --- a/test/files/run/t7047/Impls_Macros_1.scala +++ b/test/files/run/t7047/Impls_Macros_1.scala @@ -1,10 +1,10 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros class Foo object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ try { c.inferImplicitValue(typeOf[Foo], silent = false) diff --git a/test/files/run/t7157/Impls_Macros_1.scala b/test/files/run/t7157/Impls_Macros_1.scala index ad3d96eb8563..e48fbcaed39d 100644 --- a/test/files/run/t7157/Impls_Macros_1.scala +++ b/test/files/run/t7157/Impls_Macros_1.scala @@ -1,9 +1,9 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Macros { object AImpl { - def a(ctx: Context)(args: ctx.Expr[Any]*): ctx.Expr[Unit] = { + def a(ctx: BlackboxContext)(args: ctx.Expr[Any]*): ctx.Expr[Unit] = { import ctx.universe._ ctx.Expr[Unit](Apply(Ident(TermName("println")), List(Literal(Constant(1))))) } diff --git a/test/files/run/t7240/Macros_1.scala b/test/files/run/t7240/Macros_1.scala index 6465e1876021..84ad231043ea 100644 --- a/test/files/run/t7240/Macros_1.scala +++ b/test/files/run/t7240/Macros_1.scala @@ -1,7 +1,7 @@ package bakery import scala.language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext trait FailureCake { implicit def liftAnyFails[T: Manifest]: Any = ??? @@ -13,7 +13,7 @@ trait FailureCake { object Bakery { def failure: Any = macro failureImpl - def failureImpl(c: Context): c.Expr[Any] = { + def failureImpl(c: BlackboxContext): c.Expr[Any] = { import c.universe._ def dslTrait(dslName: String) = { diff --git a/test/files/run/t7375b/Macros_1.scala b/test/files/run/t7375b/Macros_1.scala index 7a307805db9c..bcd8e5217299 100644 --- a/test/files/run/t7375b/Macros_1.scala +++ b/test/files/run/t7375b/Macros_1.scala @@ -1,5 +1,5 @@ import language.experimental.macros -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext class C1(val n: Int) extends AnyVal class C2(val n: Int) extends AnyRef @@ -9,7 +9,7 @@ object Macros { type F2 = C2 def foo = macro impl - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ def test[T: c.TypeTag] = reify(println(c.Expr[String](Literal(Constant(c.reifyRuntimeClass(c.typeOf[T]).toString))).splice)).tree def tests = Block(List(test[C1], test[C2], test[F1], test[F2]), Literal(Constant(()))) diff --git a/test/files/run/t7617a/Macros_1.scala b/test/files/run/t7617a/Macros_1.scala index f9772c83c0dc..d19f112bf478 100644 --- a/test/files/run/t7617a/Macros_1.scala +++ b/test/files/run/t7617a/Macros_1.scala @@ -1,12 +1,12 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros object Macros { - def getValueImpl[T](c: Context): c.Expr[T] = { + def getValueImpl[T](c: BlackboxContext): c.Expr[T] = { import c.universe._ c.Expr[T](Apply(Select(c.prefix.tree, newTermName("getVal")), Nil)) } - def setValueImpl[T](c: Context)(value: c.Expr[T]): c.Expr[Unit] = { + def setValueImpl[T](c: BlackboxContext)(value: c.Expr[T]): c.Expr[Unit] = { import c.universe._ c.Expr[Unit](Apply(Select(c.prefix.tree, newTermName("setVal")), List(value.tree))) } diff --git a/test/files/run/t7617b/Macros_1.scala b/test/files/run/t7617b/Macros_1.scala index bc919935c908..b1406f30bb47 100644 --- a/test/files/run/t7617b/Macros_1.scala +++ b/test/files/run/t7617b/Macros_1.scala @@ -1,7 +1,7 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext object Macros { - def impl(c: Context)(name: c.Expr[String])(value: c.Expr[Any]) = { + def impl(c: BlackboxContext)(name: c.Expr[String])(value: c.Expr[Any]) = { import c.universe._ reify(println(s"${name.splice} = ${value.splice}")) } diff --git a/test/files/run/t7657/Macros_1.scala b/test/files/run/t7657/Macros_1.scala index b1e31aa2ddb1..9aac02031db4 100644 --- a/test/files/run/t7657/Macros_1.scala +++ b/test/files/run/t7657/Macros_1.scala @@ -1,8 +1,8 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros trait T { def t(): Unit } abstract class A extends T { override def t(): Unit = () } -object Macro { def t(c: Context)(): c.Expr[Unit] = c.universe.reify(()) } +object Macro { def t(c: BlackboxContext)(): c.Expr[Unit] = c.universe.reify(()) } class C extends A { override def t(): Unit = macro Macro.t } diff --git a/test/files/run/toolbox_current_run_compiles.scala b/test/files/run/toolbox_current_run_compiles.scala index b48c998e647a..bc6a9d343efc 100644 --- a/test/files/run/toolbox_current_run_compiles.scala +++ b/test/files/run/toolbox_current_run_compiles.scala @@ -1,9 +1,9 @@ package pkg { - import scala.reflect.macros.Context + import scala.reflect.macros.BlackboxContext import scala.language.experimental.macros object Macros { - def impl[T: c.WeakTypeTag](c: Context) = { + def impl[T: c.WeakTypeTag](c: BlackboxContext) = { import c.universe._ val sym = c.weakTypeOf[T].typeSymbol val g = c.universe.asInstanceOf[scala.tools.nsc.Global] diff --git a/test/files/run/typed-annotated/Macros_1.scala b/test/files/run/typed-annotated/Macros_1.scala index dd18c63d90b2..42478cb988e7 100644 --- a/test/files/run/typed-annotated/Macros_1.scala +++ b/test/files/run/typed-annotated/Macros_1.scala @@ -1,10 +1,10 @@ -import scala.reflect.macros.Context +import scala.reflect.macros.BlackboxContext import language.experimental.macros class ann extends scala.annotation.StaticAnnotation object Macros { - def impl(c: Context) = { + def impl(c: BlackboxContext) = { import c.universe._ // val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), Ident(newTypeName("Int"))) val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), TypeTree(weakTypeOf[Int]))