From fb0c25c7fd004ee5de1a910bdcccc4fd503da3ce Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Fri, 21 Feb 2014 21:40:12 +0100 Subject: more tests for macro bundles Given the recent glaring oversight in macro bundles, I have to have more tests in order to make sure that things are going to work as they should. --- test/files/neg/macro-bundle-need-qualifier.check | 4 + test/files/neg/macro-bundle-need-qualifier.scala | 11 +++ test/files/neg/macro-bundle-nonpublic-c.check | 4 + test/files/neg/macro-bundle-nonpublic-c.scala | 11 +++ test/files/neg/macro-bundle-nonpublic-impl.check | 4 + test/files/neg/macro-bundle-nonpublic-impl.scala | 11 +++ test/files/neg/macro-bundle-nonstatic.check | 13 +++ test/files/neg/macro-bundle-nonstatic.scala | 36 +++++++ test/files/neg/macro-bundle-whitebox-use-raw.check | 17 ++++ .../macro-bundle-whitebox-use-raw/Macros_1.scala | 108 +++++++++++++++++++++ .../neg/macro-bundle-whitebox-use-raw/Test_2.scala | 19 ++++ .../neg/macro-bundle-whitebox-use-refined.check | 17 ++++ .../Macros_1.scala | 108 +++++++++++++++++++++ .../macro-bundle-whitebox-use-refined/Test_2.scala | 19 ++++ test/files/neg/macro-bundle-whitebox-use.check | 17 ---- .../neg/macro-bundle-whitebox-use/Macros_1.scala | 108 --------------------- .../neg/macro-bundle-whitebox-use/Test_2.scala | 19 ---- test/files/run/macro-bundle-context-alias.check | 4 + .../run/macro-bundle-context-alias/Macros_1.scala | 38 ++++++++ .../run/macro-bundle-context-alias/Test_2.scala | 6 ++ .../run/macro-bundle-context-refinement.check | 2 + .../macro-bundle-context-refinement/Macros_1.scala | 19 ++++ .../macro-bundle-context-refinement/Test_2.scala | 4 + test/files/run/macro-bundle-whitebox-use-raw.check | 5 + .../macro-bundle-whitebox-use-raw/Macros_1.scala | 108 +++++++++++++++++++++ .../run/macro-bundle-whitebox-use-raw/Test_2.scala | 19 ++++ .../run/macro-bundle-whitebox-use-refined.check | 5 + .../Macros_1.scala | 108 +++++++++++++++++++++ .../macro-bundle-whitebox-use-refined/Test_2.scala | 19 ++++ test/files/run/macro-bundle-whitebox-use.check | 5 - .../run/macro-bundle-whitebox-use/Macros_1.scala | 108 --------------------- .../run/macro-bundle-whitebox-use/Test_2.scala | 19 ---- 32 files changed, 719 insertions(+), 276 deletions(-) create mode 100644 test/files/neg/macro-bundle-need-qualifier.check create mode 100644 test/files/neg/macro-bundle-need-qualifier.scala create mode 100644 test/files/neg/macro-bundle-nonpublic-c.check create mode 100644 test/files/neg/macro-bundle-nonpublic-c.scala create mode 100644 test/files/neg/macro-bundle-nonpublic-impl.check create mode 100644 test/files/neg/macro-bundle-nonpublic-impl.scala create mode 100644 test/files/neg/macro-bundle-nonstatic.check create mode 100644 test/files/neg/macro-bundle-nonstatic.scala create mode 100644 test/files/neg/macro-bundle-whitebox-use-raw.check create mode 100644 test/files/neg/macro-bundle-whitebox-use-raw/Macros_1.scala create mode 100644 test/files/neg/macro-bundle-whitebox-use-raw/Test_2.scala create mode 100644 test/files/neg/macro-bundle-whitebox-use-refined.check create mode 100644 test/files/neg/macro-bundle-whitebox-use-refined/Macros_1.scala create mode 100644 test/files/neg/macro-bundle-whitebox-use-refined/Test_2.scala delete mode 100644 test/files/neg/macro-bundle-whitebox-use.check delete mode 100644 test/files/neg/macro-bundle-whitebox-use/Macros_1.scala delete mode 100644 test/files/neg/macro-bundle-whitebox-use/Test_2.scala create mode 100644 test/files/run/macro-bundle-context-alias.check create mode 100644 test/files/run/macro-bundle-context-alias/Macros_1.scala create mode 100644 test/files/run/macro-bundle-context-alias/Test_2.scala create mode 100644 test/files/run/macro-bundle-context-refinement.check create mode 100644 test/files/run/macro-bundle-context-refinement/Macros_1.scala create mode 100644 test/files/run/macro-bundle-context-refinement/Test_2.scala create mode 100644 test/files/run/macro-bundle-whitebox-use-raw.check create mode 100644 test/files/run/macro-bundle-whitebox-use-raw/Macros_1.scala create mode 100644 test/files/run/macro-bundle-whitebox-use-raw/Test_2.scala create mode 100644 test/files/run/macro-bundle-whitebox-use-refined.check create mode 100644 test/files/run/macro-bundle-whitebox-use-refined/Macros_1.scala create mode 100644 test/files/run/macro-bundle-whitebox-use-refined/Test_2.scala delete mode 100644 test/files/run/macro-bundle-whitebox-use.check delete mode 100644 test/files/run/macro-bundle-whitebox-use/Macros_1.scala delete mode 100644 test/files/run/macro-bundle-whitebox-use/Test_2.scala (limited to 'test') diff --git a/test/files/neg/macro-bundle-need-qualifier.check b/test/files/neg/macro-bundle-need-qualifier.check new file mode 100644 index 0000000000..6a74ee6aed --- /dev/null +++ b/test/files/neg/macro-bundle-need-qualifier.check @@ -0,0 +1,4 @@ +macro-bundle-need-qualifier.scala:10: error: not found: value impl + def foo: Any = macro impl + ^ +one error found diff --git a/test/files/neg/macro-bundle-need-qualifier.scala b/test/files/neg/macro-bundle-need-qualifier.scala new file mode 100644 index 0000000000..0d021e3537 --- /dev/null +++ b/test/files/neg/macro-bundle-need-qualifier.scala @@ -0,0 +1,11 @@ +import scala.reflect.macros.whitebox._ +import scala.language.experimental.macros + +class Macros(val c: Context) { + import c.universe._ + def impl = q"()" +} + +object Macros { + def foo: Any = macro impl +} \ No newline at end of file diff --git a/test/files/neg/macro-bundle-nonpublic-c.check b/test/files/neg/macro-bundle-nonpublic-c.check new file mode 100644 index 0000000000..1dfcee58b7 --- /dev/null +++ b/test/files/neg/macro-bundle-nonpublic-c.check @@ -0,0 +1,4 @@ +macro-bundle-nonpublic-c.scala:6: error: private value c escapes its defining scope as part of type Macros.this.c.universe.Literal + def impl = q"()" + ^ +one error found diff --git a/test/files/neg/macro-bundle-nonpublic-c.scala b/test/files/neg/macro-bundle-nonpublic-c.scala new file mode 100644 index 0000000000..86a2039743 --- /dev/null +++ b/test/files/neg/macro-bundle-nonpublic-c.scala @@ -0,0 +1,11 @@ +import scala.reflect.macros.whitebox._ +import scala.language.experimental.macros + +class Macros(c: Context) { + import c.universe._ + def impl = q"()" +} + +object Macros { + def foo: Any = macro Macros.impl +} \ No newline at end of file diff --git a/test/files/neg/macro-bundle-nonpublic-impl.check b/test/files/neg/macro-bundle-nonpublic-impl.check new file mode 100644 index 0000000000..7a4e1516f7 --- /dev/null +++ b/test/files/neg/macro-bundle-nonpublic-impl.check @@ -0,0 +1,4 @@ +macro-bundle-nonpublic-impl.scala:10: error: bundle implementation must be public + def foo: Any = macro Macros.impl + ^ +one error found diff --git a/test/files/neg/macro-bundle-nonpublic-impl.scala b/test/files/neg/macro-bundle-nonpublic-impl.scala new file mode 100644 index 0000000000..5857cc6b24 --- /dev/null +++ b/test/files/neg/macro-bundle-nonpublic-impl.scala @@ -0,0 +1,11 @@ +import scala.reflect.macros.whitebox._ +import scala.language.experimental.macros + +class Macros(val c: Context) { + import c.universe._ + private def impl = q"()" +} + +object Macros { + def foo: Any = macro Macros.impl +} \ No newline at end of file diff --git a/test/files/neg/macro-bundle-nonstatic.check b/test/files/neg/macro-bundle-nonstatic.check new file mode 100644 index 0000000000..36bccc54db --- /dev/null +++ b/test/files/neg/macro-bundle-nonstatic.check @@ -0,0 +1,13 @@ +macro-bundle-nonstatic.scala:12: error: value Bundle is not a member of object Module + def foo1 = macro Module.Bundle.impl + ^ +macro-bundle-nonstatic.scala:13: error: value Bundle is not a member of Module + def foo2 = macro new Module().Bundle.impl + ^ +macro-bundle-nonstatic.scala:17: error: macro bundles must be static + def foo = macro Bundle.impl + ^ +macro-bundle-nonstatic.scala:23: error: macro bundles must be static + def foo = macro Bundle.impl + ^ +four errors found diff --git a/test/files/neg/macro-bundle-nonstatic.scala b/test/files/neg/macro-bundle-nonstatic.scala new file mode 100644 index 0000000000..dfba79660a --- /dev/null +++ b/test/files/neg/macro-bundle-nonstatic.scala @@ -0,0 +1,36 @@ +import scala.language.experimental.macros +import scala.reflect.macros.whitebox.Context + +class Module { + class Bundle(val c: Context) { + import c.universe._ + def impl = q"()" + } +} + +object Macros1 { + def foo1 = macro Module.Bundle.impl + def foo2 = macro new Module().Bundle.impl +} + +object Macros2 extends Module { + def foo = macro Bundle.impl +} + +object Macros3 { + val module = new Module + import module._ + def foo = macro Bundle.impl +} + +object Module { + class GoodBundle(val c: Context) { + import c.universe._ + def impl = q"()" + } +} + +object Macros4 { + import Module._ + def foo: Unit = macro GoodBundle.impl +} diff --git a/test/files/neg/macro-bundle-whitebox-use-raw.check b/test/files/neg/macro-bundle-whitebox-use-raw.check new file mode 100644 index 0000000000..5792e317a6 --- /dev/null +++ b/test/files/neg/macro-bundle-whitebox-use-raw.check @@ -0,0 +1,17 @@ +Test_2.scala:2: error: value x is not a member of Any + println(ReturnTypeRefinement.foo.x) + ^ +Test_2.scala:7: error: type mismatch; + found : FundepMaterialization[Test.Foo,(Int, String, Boolean)] + required: FundepMaterialization[Test.Foo,Nothing] +Note: (Int, String, Boolean) >: Nothing, but trait FundepMaterialization is invariant in type U. +You may wish to define U as -U instead. (SLS 4.5) + val equiv = foo(Foo(23, "foo", true)) + ^ +Test_2.scala:13: error: I don't like classes that contain integers + println(implicitly[DynamicMaterialization[C1]]) + ^ +Test_2.scala:17: error: extractor macros can only be whitebox + case ExtractorMacro(x) => println(x) + ^ +four errors found diff --git a/test/files/neg/macro-bundle-whitebox-use-raw/Macros_1.scala b/test/files/neg/macro-bundle-whitebox-use-raw/Macros_1.scala new file mode 100644 index 0000000000..61bf73e481 --- /dev/null +++ b/test/files/neg/macro-bundle-whitebox-use-raw/Macros_1.scala @@ -0,0 +1,108 @@ +import scala.reflect.macros.blackbox.Context +import scala.language.experimental.macros + +// whitebox use case #1: return type refinement + +class ReturnTypeRefinementBundle(val c: Context) { + import c.universe._ + def impl = { + q""" + trait Foo { + def x = 2 + } + new Foo {} + """ + } +} + +object ReturnTypeRefinement { + def foo: Any = macro ReturnTypeRefinementBundle.impl +} + +// whitebox use case #2: fundep materialization + +trait FundepMaterialization[T, U] { + def to(t : T) : U + // def from(u : U) : T +} + +class FundepMaterializationBundle(val c: Context) { + import c.universe._ + import definitions._ + import Flag._ + + def impl[T: c.WeakTypeTag, U: c.WeakTypeTag]: c.Expr[FundepMaterialization[T, U]] = { + val sym = c.weakTypeOf[T].typeSymbol + if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") + val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + + def mkTpt() = { + val core = Ident(TupleClass(fields.length) orElse UnitClass) + if (fields.length == 0) core + else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) + } + + def mkFrom() = { + if (fields.length == 0) Literal(Constant(Unit)) + else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) + } + + val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( + List(AppliedTypeTree(Ident(newTypeName("FundepMaterialization")), List(Ident(sym), mkTpt()))), + emptyValDef, + List( + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) + c.Expr[FundepMaterialization[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) + } +} + +object FundepMaterialization { + implicit def materializeIso[T, U]: FundepMaterialization[T, U] = macro FundepMaterializationBundle.impl[T, U] +} + +// whitebox use case #3: dynamic materialization + +trait DynamicMaterialization[T] + +class C1(val x: Int) +class C2(val x: String) + +trait LowPriority { + implicit def lessSpecific[T]: DynamicMaterialization[T] = null +} + +object DynamicMaterialization extends LowPriority { + implicit def moreSpecific[T]: DynamicMaterialization[T] = macro DynamicMaterializationBundle.impl[T] +} + +class DynamicMaterializationBundle(val c: Context) { + import c.universe._ + def impl[T: c.WeakTypeTag] = { + val tpe = weakTypeOf[T] + if (tpe.members.exists(_.info =:= typeOf[Int])) + c.abort(c.enclosingPosition, "I don't like classes that contain integers") + q"new DynamicMaterialization[$tpe]{ override def toString = ${tpe.toString} }" + } +} + +// whitebox use case #4: extractor macros + +object ExtractorMacro { + def unapply(x: Int): Any = macro ExtractorBundle.unapplyImpl +} + +class ExtractorBundle(val c: Context) { + import c.universe._ + def unapplyImpl(x: Tree) = { + q""" + new { + class Match(x: Int) { + def isEmpty = false + def get = x + } + def unapply(x: Int) = new Match(x) + }.unapply($x) + """ + } +} diff --git a/test/files/neg/macro-bundle-whitebox-use-raw/Test_2.scala b/test/files/neg/macro-bundle-whitebox-use-raw/Test_2.scala new file mode 100644 index 0000000000..3a81700251 --- /dev/null +++ b/test/files/neg/macro-bundle-whitebox-use-raw/Test_2.scala @@ -0,0 +1,19 @@ +object Test extends App { + println(ReturnTypeRefinement.foo.x) + + case class Foo(i: Int, s: String, b: Boolean) + def foo[C, L](c: C)(implicit iso: FundepMaterialization[C, L]): L = iso.to(c) + locally { + val equiv = foo(Foo(23, "foo", true)) + def typed[T](t: => T) {} + typed[(Int, String, Boolean)](equiv) + println(equiv) + } + + println(implicitly[DynamicMaterialization[C1]]) + println(implicitly[DynamicMaterialization[C2]]) + + 42 match { + case ExtractorMacro(x) => println(x) + } +} diff --git a/test/files/neg/macro-bundle-whitebox-use-refined.check b/test/files/neg/macro-bundle-whitebox-use-refined.check new file mode 100644 index 0000000000..5792e317a6 --- /dev/null +++ b/test/files/neg/macro-bundle-whitebox-use-refined.check @@ -0,0 +1,17 @@ +Test_2.scala:2: error: value x is not a member of Any + println(ReturnTypeRefinement.foo.x) + ^ +Test_2.scala:7: error: type mismatch; + found : FundepMaterialization[Test.Foo,(Int, String, Boolean)] + required: FundepMaterialization[Test.Foo,Nothing] +Note: (Int, String, Boolean) >: Nothing, but trait FundepMaterialization is invariant in type U. +You may wish to define U as -U instead. (SLS 4.5) + val equiv = foo(Foo(23, "foo", true)) + ^ +Test_2.scala:13: error: I don't like classes that contain integers + println(implicitly[DynamicMaterialization[C1]]) + ^ +Test_2.scala:17: error: extractor macros can only be whitebox + case ExtractorMacro(x) => println(x) + ^ +four errors found diff --git a/test/files/neg/macro-bundle-whitebox-use-refined/Macros_1.scala b/test/files/neg/macro-bundle-whitebox-use-refined/Macros_1.scala new file mode 100644 index 0000000000..1866044221 --- /dev/null +++ b/test/files/neg/macro-bundle-whitebox-use-refined/Macros_1.scala @@ -0,0 +1,108 @@ +import scala.reflect.macros.blackbox.Context +import scala.language.experimental.macros + +// whitebox use case #1: return type refinement + +class ReturnTypeRefinementBundle(val c: Context { type PrefixType = Nothing }) { + import c.universe._ + def impl = { + q""" + trait Foo { + def x = 2 + } + new Foo {} + """ + } +} + +object ReturnTypeRefinement { + def foo: Any = macro ReturnTypeRefinementBundle.impl +} + +// whitebox use case #2: fundep materialization + +trait FundepMaterialization[T, U] { + def to(t : T) : U + // def from(u : U) : T +} + +class FundepMaterializationBundle(val c: Context { type PrefixType = Nothing }) { + import c.universe._ + import definitions._ + import Flag._ + + def impl[T: c.WeakTypeTag, U: c.WeakTypeTag]: c.Expr[FundepMaterialization[T, U]] = { + val sym = c.weakTypeOf[T].typeSymbol + if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") + val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + + def mkTpt() = { + val core = Ident(TupleClass(fields.length) orElse UnitClass) + if (fields.length == 0) core + else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) + } + + def mkFrom() = { + if (fields.length == 0) Literal(Constant(Unit)) + else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) + } + + val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( + List(AppliedTypeTree(Ident(newTypeName("FundepMaterialization")), List(Ident(sym), mkTpt()))), + emptyValDef, + List( + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) + c.Expr[FundepMaterialization[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) + } +} + +object FundepMaterialization { + implicit def materializeIso[T, U]: FundepMaterialization[T, U] = macro FundepMaterializationBundle.impl[T, U] +} + +// whitebox use case #3: dynamic materialization + +trait DynamicMaterialization[T] + +class C1(val x: Int) +class C2(val x: String) + +trait LowPriority { + implicit def lessSpecific[T]: DynamicMaterialization[T] = null +} + +object DynamicMaterialization extends LowPriority { + implicit def moreSpecific[T]: DynamicMaterialization[T] = macro DynamicMaterializationBundle.impl[T] +} + +class DynamicMaterializationBundle(val c: Context { type PrefixType = Nothing }) { + import c.universe._ + def impl[T: c.WeakTypeTag] = { + val tpe = weakTypeOf[T] + if (tpe.members.exists(_.info =:= typeOf[Int])) + c.abort(c.enclosingPosition, "I don't like classes that contain integers") + q"new DynamicMaterialization[$tpe]{ override def toString = ${tpe.toString} }" + } +} + +// whitebox use case #4: extractor macros + +object ExtractorMacro { + def unapply(x: Int): Any = macro ExtractorBundle.unapplyImpl +} + +class ExtractorBundle(val c: Context { type PrefixType = Nothing }) { + import c.universe._ + def unapplyImpl(x: Tree) = { + q""" + new { + class Match(x: Int) { + def isEmpty = false + def get = x + } + def unapply(x: Int) = new Match(x) + }.unapply($x) + """ + } +} diff --git a/test/files/neg/macro-bundle-whitebox-use-refined/Test_2.scala b/test/files/neg/macro-bundle-whitebox-use-refined/Test_2.scala new file mode 100644 index 0000000000..3a81700251 --- /dev/null +++ b/test/files/neg/macro-bundle-whitebox-use-refined/Test_2.scala @@ -0,0 +1,19 @@ +object Test extends App { + println(ReturnTypeRefinement.foo.x) + + case class Foo(i: Int, s: String, b: Boolean) + def foo[C, L](c: C)(implicit iso: FundepMaterialization[C, L]): L = iso.to(c) + locally { + val equiv = foo(Foo(23, "foo", true)) + def typed[T](t: => T) {} + typed[(Int, String, Boolean)](equiv) + println(equiv) + } + + println(implicitly[DynamicMaterialization[C1]]) + println(implicitly[DynamicMaterialization[C2]]) + + 42 match { + case ExtractorMacro(x) => println(x) + } +} diff --git a/test/files/neg/macro-bundle-whitebox-use.check b/test/files/neg/macro-bundle-whitebox-use.check deleted file mode 100644 index 5792e317a6..0000000000 --- a/test/files/neg/macro-bundle-whitebox-use.check +++ /dev/null @@ -1,17 +0,0 @@ -Test_2.scala:2: error: value x is not a member of Any - println(ReturnTypeRefinement.foo.x) - ^ -Test_2.scala:7: error: type mismatch; - found : FundepMaterialization[Test.Foo,(Int, String, Boolean)] - required: FundepMaterialization[Test.Foo,Nothing] -Note: (Int, String, Boolean) >: Nothing, but trait FundepMaterialization is invariant in type U. -You may wish to define U as -U instead. (SLS 4.5) - val equiv = foo(Foo(23, "foo", true)) - ^ -Test_2.scala:13: error: I don't like classes that contain integers - println(implicitly[DynamicMaterialization[C1]]) - ^ -Test_2.scala:17: error: extractor macros can only be whitebox - case ExtractorMacro(x) => println(x) - ^ -four errors found diff --git a/test/files/neg/macro-bundle-whitebox-use/Macros_1.scala b/test/files/neg/macro-bundle-whitebox-use/Macros_1.scala deleted file mode 100644 index 61bf73e481..0000000000 --- a/test/files/neg/macro-bundle-whitebox-use/Macros_1.scala +++ /dev/null @@ -1,108 +0,0 @@ -import scala.reflect.macros.blackbox.Context -import scala.language.experimental.macros - -// whitebox use case #1: return type refinement - -class ReturnTypeRefinementBundle(val c: Context) { - import c.universe._ - def impl = { - q""" - trait Foo { - def x = 2 - } - new Foo {} - """ - } -} - -object ReturnTypeRefinement { - def foo: Any = macro ReturnTypeRefinementBundle.impl -} - -// whitebox use case #2: fundep materialization - -trait FundepMaterialization[T, U] { - def to(t : T) : U - // def from(u : U) : T -} - -class FundepMaterializationBundle(val c: Context) { - import c.universe._ - import definitions._ - import Flag._ - - def impl[T: c.WeakTypeTag, U: c.WeakTypeTag]: c.Expr[FundepMaterialization[T, U]] = { - val sym = c.weakTypeOf[T].typeSymbol - if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") - val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } - - def mkTpt() = { - val core = Ident(TupleClass(fields.length) orElse UnitClass) - if (fields.length == 0) core - else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) - } - - def mkFrom() = { - if (fields.length == 0) Literal(Constant(Unit)) - else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) - } - - val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( - List(AppliedTypeTree(Ident(newTypeName("FundepMaterialization")), List(Ident(sym), mkTpt()))), - emptyValDef, - List( - DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), - DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) - c.Expr[FundepMaterialization[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) - } -} - -object FundepMaterialization { - implicit def materializeIso[T, U]: FundepMaterialization[T, U] = macro FundepMaterializationBundle.impl[T, U] -} - -// whitebox use case #3: dynamic materialization - -trait DynamicMaterialization[T] - -class C1(val x: Int) -class C2(val x: String) - -trait LowPriority { - implicit def lessSpecific[T]: DynamicMaterialization[T] = null -} - -object DynamicMaterialization extends LowPriority { - implicit def moreSpecific[T]: DynamicMaterialization[T] = macro DynamicMaterializationBundle.impl[T] -} - -class DynamicMaterializationBundle(val c: Context) { - import c.universe._ - def impl[T: c.WeakTypeTag] = { - val tpe = weakTypeOf[T] - if (tpe.members.exists(_.info =:= typeOf[Int])) - c.abort(c.enclosingPosition, "I don't like classes that contain integers") - q"new DynamicMaterialization[$tpe]{ override def toString = ${tpe.toString} }" - } -} - -// whitebox use case #4: extractor macros - -object ExtractorMacro { - def unapply(x: Int): Any = macro ExtractorBundle.unapplyImpl -} - -class ExtractorBundle(val c: Context) { - import c.universe._ - def unapplyImpl(x: Tree) = { - q""" - new { - class Match(x: Int) { - def isEmpty = false - def get = x - } - def unapply(x: Int) = new Match(x) - }.unapply($x) - """ - } -} diff --git a/test/files/neg/macro-bundle-whitebox-use/Test_2.scala b/test/files/neg/macro-bundle-whitebox-use/Test_2.scala deleted file mode 100644 index 3a81700251..0000000000 --- a/test/files/neg/macro-bundle-whitebox-use/Test_2.scala +++ /dev/null @@ -1,19 +0,0 @@ -object Test extends App { - println(ReturnTypeRefinement.foo.x) - - case class Foo(i: Int, s: String, b: Boolean) - def foo[C, L](c: C)(implicit iso: FundepMaterialization[C, L]): L = iso.to(c) - locally { - val equiv = foo(Foo(23, "foo", true)) - def typed[T](t: => T) {} - typed[(Int, String, Boolean)](equiv) - println(equiv) - } - - println(implicitly[DynamicMaterialization[C1]]) - println(implicitly[DynamicMaterialization[C2]]) - - 42 match { - case ExtractorMacro(x) => println(x) - } -} diff --git a/test/files/run/macro-bundle-context-alias.check b/test/files/run/macro-bundle-context-alias.check new file mode 100644 index 0000000000..55e4dfcf92 --- /dev/null +++ b/test/files/run/macro-bundle-context-alias.check @@ -0,0 +1,4 @@ +C +C +C +C diff --git a/test/files/run/macro-bundle-context-alias/Macros_1.scala b/test/files/run/macro-bundle-context-alias/Macros_1.scala new file mode 100644 index 0000000000..354c5e0d92 --- /dev/null +++ b/test/files/run/macro-bundle-context-alias/Macros_1.scala @@ -0,0 +1,38 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.{Context => BlackboxContext} +import scala.reflect.macros.whitebox.{Context => WhiteboxContext} + +object Module { + type BBC = BlackboxContext + type RBBC = BBC { type PrefixType = C } + type WBC = WhiteboxContext + type RWBC = WBC { type PrefixType = C } + + class BlackboxBundle(val c: BBC) { + import c.universe._ + def impl = q"${c.prefix}" + } + + class RefinedBlackboxBundle(val c: RBBC) { + import c.universe._ + def impl = reify(c.prefix.splice) + } + + class WhiteboxBundle(val c: WBC) { + import c.universe._ + def impl = q"${c.prefix}" + } + + class RefinedWhiteboxBundle(val c: RWBC) { + import c.universe._ + def impl = reify(c.prefix.splice) + } +} + +class C { + def blackbox: C = macro Module.BlackboxBundle.impl + def refinedBlackbox: C = macro Module.RefinedBlackboxBundle.impl + def whitebox: C = macro Module.WhiteboxBundle.impl + def refinedWhitebox: C = macro Module.RefinedWhiteboxBundle.impl + override def toString = "C" +} \ No newline at end of file diff --git a/test/files/run/macro-bundle-context-alias/Test_2.scala b/test/files/run/macro-bundle-context-alias/Test_2.scala new file mode 100644 index 0000000000..de499cc111 --- /dev/null +++ b/test/files/run/macro-bundle-context-alias/Test_2.scala @@ -0,0 +1,6 @@ +object Test extends App { + println(new C().blackbox) + println(new C().refinedBlackbox) + println(new C().whitebox) + println(new C().refinedWhitebox) +} \ No newline at end of file diff --git a/test/files/run/macro-bundle-context-refinement.check b/test/files/run/macro-bundle-context-refinement.check new file mode 100644 index 0000000000..10f9ebb617 --- /dev/null +++ b/test/files/run/macro-bundle-context-refinement.check @@ -0,0 +1,2 @@ +C +C diff --git a/test/files/run/macro-bundle-context-refinement/Macros_1.scala b/test/files/run/macro-bundle-context-refinement/Macros_1.scala new file mode 100644 index 0000000000..d3a5d179c6 --- /dev/null +++ b/test/files/run/macro-bundle-context-refinement/Macros_1.scala @@ -0,0 +1,19 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.{Context => BlackboxContext} +import scala.reflect.macros.whitebox.{Context => WhiteboxContext} + +class BlackboxBundle(val c: BlackboxContext { type PrefixType = C }) { + import c.universe._ + def impl = reify(c.prefix.splice) +} + +class WhiteboxBundle(val c: WhiteboxContext { type PrefixType = C }) { + import c.universe._ + def impl = reify(c.prefix.splice) +} + +class C { + def blackbox: C = macro BlackboxBundle.impl + def whitebox: C = macro WhiteboxBundle.impl + override def toString = "C" +} \ No newline at end of file diff --git a/test/files/run/macro-bundle-context-refinement/Test_2.scala b/test/files/run/macro-bundle-context-refinement/Test_2.scala new file mode 100644 index 0000000000..43d641adeb --- /dev/null +++ b/test/files/run/macro-bundle-context-refinement/Test_2.scala @@ -0,0 +1,4 @@ +object Test extends App { + println(new C().blackbox) + println(new C().whitebox) +} \ No newline at end of file diff --git a/test/files/run/macro-bundle-whitebox-use-raw.check b/test/files/run/macro-bundle-whitebox-use-raw.check new file mode 100644 index 0000000000..5679c5faba --- /dev/null +++ b/test/files/run/macro-bundle-whitebox-use-raw.check @@ -0,0 +1,5 @@ +2 +(23,foo,true) +null +C2 +42 diff --git a/test/files/run/macro-bundle-whitebox-use-raw/Macros_1.scala b/test/files/run/macro-bundle-whitebox-use-raw/Macros_1.scala new file mode 100644 index 0000000000..de1863418e --- /dev/null +++ b/test/files/run/macro-bundle-whitebox-use-raw/Macros_1.scala @@ -0,0 +1,108 @@ +import scala.reflect.macros.whitebox.Context +import scala.language.experimental.macros + +// whitebox use case #1: return type refinement + +class ReturnTypeRefinementBundle(val c: Context) { + import c.universe._ + def impl = { + q""" + trait Foo { + def x = 2 + } + new Foo {} + """ + } +} + +object ReturnTypeRefinement { + def foo: Any = macro ReturnTypeRefinementBundle.impl +} + +// whitebox use case #2: fundep materialization + +trait FundepMaterialization[T, U] { + def to(t : T) : U + // def from(u : U) : T +} + +class FundepMaterializationBundle(val c: Context) { + import c.universe._ + import definitions._ + import Flag._ + + def impl[T: c.WeakTypeTag, U: c.WeakTypeTag]: c.Expr[FundepMaterialization[T, U]] = { + val sym = c.weakTypeOf[T].typeSymbol + if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") + val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + + def mkTpt() = { + val core = Ident(TupleClass(fields.length) orElse UnitClass) + if (fields.length == 0) core + else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) + } + + def mkFrom() = { + if (fields.length == 0) Literal(Constant(Unit)) + else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) + } + + val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( + List(AppliedTypeTree(Ident(newTypeName("FundepMaterialization")), List(Ident(sym), mkTpt()))), + emptyValDef, + List( + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) + c.Expr[FundepMaterialization[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) + } +} + +object FundepMaterialization { + implicit def materializeIso[T, U]: FundepMaterialization[T, U] = macro FundepMaterializationBundle.impl[T, U] +} + +// whitebox use case #3: dynamic materialization + +trait DynamicMaterialization[T] + +class C1(val x: Int) +class C2(val x: String) + +trait LowPriority { + implicit def lessSpecific[T]: DynamicMaterialization[T] = null +} + +object DynamicMaterialization extends LowPriority { + implicit def moreSpecific[T]: DynamicMaterialization[T] = macro DynamicMaterializationBundle.impl[T] +} + +class DynamicMaterializationBundle(val c: Context) { + import c.universe._ + def impl[T: c.WeakTypeTag] = { + val tpe = weakTypeOf[T] + if (tpe.members.exists(_.info =:= typeOf[Int])) + c.abort(c.enclosingPosition, "I don't like classes that contain integers") + q"new DynamicMaterialization[$tpe]{ override def toString = ${tpe.toString} }" + } +} + +// whitebox use case #4: extractor macros + +object ExtractorMacro { + def unapply(x: Int): Any = macro ExtractorBundle.unapplyImpl +} + +class ExtractorBundle(val c: Context) { + import c.universe._ + def unapplyImpl(x: Tree) = { + q""" + new { + class Match(x: Int) { + def isEmpty = false + def get = x + } + def unapply(x: Int) = new Match(x) + }.unapply($x) + """ + } +} diff --git a/test/files/run/macro-bundle-whitebox-use-raw/Test_2.scala b/test/files/run/macro-bundle-whitebox-use-raw/Test_2.scala new file mode 100644 index 0000000000..3a81700251 --- /dev/null +++ b/test/files/run/macro-bundle-whitebox-use-raw/Test_2.scala @@ -0,0 +1,19 @@ +object Test extends App { + println(ReturnTypeRefinement.foo.x) + + case class Foo(i: Int, s: String, b: Boolean) + def foo[C, L](c: C)(implicit iso: FundepMaterialization[C, L]): L = iso.to(c) + locally { + val equiv = foo(Foo(23, "foo", true)) + def typed[T](t: => T) {} + typed[(Int, String, Boolean)](equiv) + println(equiv) + } + + println(implicitly[DynamicMaterialization[C1]]) + println(implicitly[DynamicMaterialization[C2]]) + + 42 match { + case ExtractorMacro(x) => println(x) + } +} diff --git a/test/files/run/macro-bundle-whitebox-use-refined.check b/test/files/run/macro-bundle-whitebox-use-refined.check new file mode 100644 index 0000000000..5679c5faba --- /dev/null +++ b/test/files/run/macro-bundle-whitebox-use-refined.check @@ -0,0 +1,5 @@ +2 +(23,foo,true) +null +C2 +42 diff --git a/test/files/run/macro-bundle-whitebox-use-refined/Macros_1.scala b/test/files/run/macro-bundle-whitebox-use-refined/Macros_1.scala new file mode 100644 index 0000000000..de1863418e --- /dev/null +++ b/test/files/run/macro-bundle-whitebox-use-refined/Macros_1.scala @@ -0,0 +1,108 @@ +import scala.reflect.macros.whitebox.Context +import scala.language.experimental.macros + +// whitebox use case #1: return type refinement + +class ReturnTypeRefinementBundle(val c: Context) { + import c.universe._ + def impl = { + q""" + trait Foo { + def x = 2 + } + new Foo {} + """ + } +} + +object ReturnTypeRefinement { + def foo: Any = macro ReturnTypeRefinementBundle.impl +} + +// whitebox use case #2: fundep materialization + +trait FundepMaterialization[T, U] { + def to(t : T) : U + // def from(u : U) : T +} + +class FundepMaterializationBundle(val c: Context) { + import c.universe._ + import definitions._ + import Flag._ + + def impl[T: c.WeakTypeTag, U: c.WeakTypeTag]: c.Expr[FundepMaterialization[T, U]] = { + val sym = c.weakTypeOf[T].typeSymbol + if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") + val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + + def mkTpt() = { + val core = Ident(TupleClass(fields.length) orElse UnitClass) + if (fields.length == 0) core + else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) + } + + def mkFrom() = { + if (fields.length == 0) Literal(Constant(Unit)) + else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) + } + + val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( + List(AppliedTypeTree(Ident(newTypeName("FundepMaterialization")), List(Ident(sym), mkTpt()))), + emptyValDef, + List( + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) + c.Expr[FundepMaterialization[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) + } +} + +object FundepMaterialization { + implicit def materializeIso[T, U]: FundepMaterialization[T, U] = macro FundepMaterializationBundle.impl[T, U] +} + +// whitebox use case #3: dynamic materialization + +trait DynamicMaterialization[T] + +class C1(val x: Int) +class C2(val x: String) + +trait LowPriority { + implicit def lessSpecific[T]: DynamicMaterialization[T] = null +} + +object DynamicMaterialization extends LowPriority { + implicit def moreSpecific[T]: DynamicMaterialization[T] = macro DynamicMaterializationBundle.impl[T] +} + +class DynamicMaterializationBundle(val c: Context) { + import c.universe._ + def impl[T: c.WeakTypeTag] = { + val tpe = weakTypeOf[T] + if (tpe.members.exists(_.info =:= typeOf[Int])) + c.abort(c.enclosingPosition, "I don't like classes that contain integers") + q"new DynamicMaterialization[$tpe]{ override def toString = ${tpe.toString} }" + } +} + +// whitebox use case #4: extractor macros + +object ExtractorMacro { + def unapply(x: Int): Any = macro ExtractorBundle.unapplyImpl +} + +class ExtractorBundle(val c: Context) { + import c.universe._ + def unapplyImpl(x: Tree) = { + q""" + new { + class Match(x: Int) { + def isEmpty = false + def get = x + } + def unapply(x: Int) = new Match(x) + }.unapply($x) + """ + } +} diff --git a/test/files/run/macro-bundle-whitebox-use-refined/Test_2.scala b/test/files/run/macro-bundle-whitebox-use-refined/Test_2.scala new file mode 100644 index 0000000000..3a81700251 --- /dev/null +++ b/test/files/run/macro-bundle-whitebox-use-refined/Test_2.scala @@ -0,0 +1,19 @@ +object Test extends App { + println(ReturnTypeRefinement.foo.x) + + case class Foo(i: Int, s: String, b: Boolean) + def foo[C, L](c: C)(implicit iso: FundepMaterialization[C, L]): L = iso.to(c) + locally { + val equiv = foo(Foo(23, "foo", true)) + def typed[T](t: => T) {} + typed[(Int, String, Boolean)](equiv) + println(equiv) + } + + println(implicitly[DynamicMaterialization[C1]]) + println(implicitly[DynamicMaterialization[C2]]) + + 42 match { + case ExtractorMacro(x) => println(x) + } +} diff --git a/test/files/run/macro-bundle-whitebox-use.check b/test/files/run/macro-bundle-whitebox-use.check deleted file mode 100644 index 5679c5faba..0000000000 --- a/test/files/run/macro-bundle-whitebox-use.check +++ /dev/null @@ -1,5 +0,0 @@ -2 -(23,foo,true) -null -C2 -42 diff --git a/test/files/run/macro-bundle-whitebox-use/Macros_1.scala b/test/files/run/macro-bundle-whitebox-use/Macros_1.scala deleted file mode 100644 index de1863418e..0000000000 --- a/test/files/run/macro-bundle-whitebox-use/Macros_1.scala +++ /dev/null @@ -1,108 +0,0 @@ -import scala.reflect.macros.whitebox.Context -import scala.language.experimental.macros - -// whitebox use case #1: return type refinement - -class ReturnTypeRefinementBundle(val c: Context) { - import c.universe._ - def impl = { - q""" - trait Foo { - def x = 2 - } - new Foo {} - """ - } -} - -object ReturnTypeRefinement { - def foo: Any = macro ReturnTypeRefinementBundle.impl -} - -// whitebox use case #2: fundep materialization - -trait FundepMaterialization[T, U] { - def to(t : T) : U - // def from(u : U) : T -} - -class FundepMaterializationBundle(val c: Context) { - import c.universe._ - import definitions._ - import Flag._ - - def impl[T: c.WeakTypeTag, U: c.WeakTypeTag]: c.Expr[FundepMaterialization[T, U]] = { - val sym = c.weakTypeOf[T].typeSymbol - if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") - val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } - - def mkTpt() = { - val core = Ident(TupleClass(fields.length) orElse UnitClass) - if (fields.length == 0) core - else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) - } - - def mkFrom() = { - if (fields.length == 0) Literal(Constant(Unit)) - else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) - } - - val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( - List(AppliedTypeTree(Ident(newTypeName("FundepMaterialization")), List(Ident(sym), mkTpt()))), - emptyValDef, - List( - DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), - DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) - c.Expr[FundepMaterialization[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) - } -} - -object FundepMaterialization { - implicit def materializeIso[T, U]: FundepMaterialization[T, U] = macro FundepMaterializationBundle.impl[T, U] -} - -// whitebox use case #3: dynamic materialization - -trait DynamicMaterialization[T] - -class C1(val x: Int) -class C2(val x: String) - -trait LowPriority { - implicit def lessSpecific[T]: DynamicMaterialization[T] = null -} - -object DynamicMaterialization extends LowPriority { - implicit def moreSpecific[T]: DynamicMaterialization[T] = macro DynamicMaterializationBundle.impl[T] -} - -class DynamicMaterializationBundle(val c: Context) { - import c.universe._ - def impl[T: c.WeakTypeTag] = { - val tpe = weakTypeOf[T] - if (tpe.members.exists(_.info =:= typeOf[Int])) - c.abort(c.enclosingPosition, "I don't like classes that contain integers") - q"new DynamicMaterialization[$tpe]{ override def toString = ${tpe.toString} }" - } -} - -// whitebox use case #4: extractor macros - -object ExtractorMacro { - def unapply(x: Int): Any = macro ExtractorBundle.unapplyImpl -} - -class ExtractorBundle(val c: Context) { - import c.universe._ - def unapplyImpl(x: Tree) = { - q""" - new { - class Match(x: Int) { - def isEmpty = false - def get = x - } - def unapply(x: Int) = new Match(x) - }.unapply($x) - """ - } -} diff --git a/test/files/run/macro-bundle-whitebox-use/Test_2.scala b/test/files/run/macro-bundle-whitebox-use/Test_2.scala deleted file mode 100644 index 3a81700251..0000000000 --- a/test/files/run/macro-bundle-whitebox-use/Test_2.scala +++ /dev/null @@ -1,19 +0,0 @@ -object Test extends App { - println(ReturnTypeRefinement.foo.x) - - case class Foo(i: Int, s: String, b: Boolean) - def foo[C, L](c: C)(implicit iso: FundepMaterialization[C, L]): L = iso.to(c) - locally { - val equiv = foo(Foo(23, "foo", true)) - def typed[T](t: => T) {} - typed[(Int, String, Boolean)](equiv) - println(equiv) - } - - println(implicitly[DynamicMaterialization[C1]]) - println(implicitly[DynamicMaterialization[C2]]) - - 42 match { - case ExtractorMacro(x) => println(x) - } -} -- cgit v1.2.3