From 931edcc94ebd73b420b2359d989442bf700588eb Mon Sep 17 00:00:00 2001 From: VladimirNik Date: Fri, 7 Feb 2014 02:41:54 +0400 Subject: Attributed val/var processing for syntactics (SI-8180) TypedTreesPrinter added changes based on pull request comments: print root packages flag; tests for syntactics; SyntacticEmptyTypeTree added to Printers --- .../scalacheck/quasiquotes/TypecheckedProps.scala | 29 +++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) (limited to 'test/files/scalacheck/quasiquotes') diff --git a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala index 8b1cb6cc49..14669764d3 100644 --- a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala +++ b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala @@ -65,7 +65,7 @@ object TypecheckedProps extends QuasiquoteProperties("typechecked") { } property("extract UnApply (2)") = test { - val q"object $_ { $_; $_; $m }" = typecheck(q""" + val q"object $_ { $_; $m }" = typecheck(q""" object Test { case class Cell(val x: Int) new Cell(0) match { case Cell(v) => v } @@ -82,4 +82,31 @@ object TypecheckedProps extends QuasiquoteProperties("typechecked") { val q"val x: ${tq""} = 42" = typechecked val q"val x: ${t: Type} = 42" = typechecked } + + property("class with param (1)") = test { + val paramName = TermName("x") + val q"class $_($param)" = typecheck(q"class Test(val $paramName: Int)") + + assert(param.name == paramName) + } + + property("class with param (2)") = test { + val paramName = TermName("y") + val q"{ class $_($param); $_}" = typecheck(q"{ class Test(val $paramName: Int = 3) }") + + assert(param.name == paramName) + assert(param.rhs ≈ q"3") + } + + property("class with params") = test { + val pName1 = TermName("x1") + val pName2 = TermName("x2") + val q"{ class $_($param1)(..$params2); $_}" = typecheck(q"{ class Test(val x0: Float)(val $pName1: Int = 3, $pName2: String) }") + + val List(p1, p2, _*) = params2 + + assert(p1.name == pName1) + assert(p2.name == pName2) + assert(params2.size == 2) + } } -- cgit v1.2.3 From 74b5c928795f0702772e5a33c82a7c72b86a8c9b Mon Sep 17 00:00:00 2001 From: VladimirNik Date: Tue, 18 Feb 2014 01:38:12 +0400 Subject: block processing fixed for syntactics in typechecked trees --- src/reflect/scala/reflect/internal/ReificationSupport.scala | 4 ++-- src/reflect/scala/reflect/internal/TreeInfo.scala | 2 +- src/reflect/scala/reflect/internal/Trees.scala | 3 ++- test/files/scalacheck/quasiquotes/TypecheckedProps.scala | 4 ++-- 4 files changed, 7 insertions(+), 6 deletions(-) (limited to 'test/files/scalacheck/quasiquotes') diff --git a/src/reflect/scala/reflect/internal/ReificationSupport.scala b/src/reflect/scala/reflect/internal/ReificationSupport.scala index 100c4e6c47..ea230a215b 100644 --- a/src/reflect/scala/reflect/internal/ReificationSupport.scala +++ b/src/reflect/scala/reflect/internal/ReificationSupport.scala @@ -465,8 +465,8 @@ trait ReificationSupport { self: SymbolTable => else gen.mkBlock(stats) def unapply(tree: Tree): Option[List[Tree]] = tree match { - case self.Block(stats, SyntheticUnit()) => Some(stats) - case self.Block(stats, expr) => Some(stats :+ expr) + case bl @ self.Block(stats, SyntheticUnit()) => Some(treeInfo.untypecheckedBlockBody(bl)) + case bl @ self.Block(stats, expr) => Some(treeInfo.untypecheckedBlockBody(bl) :+ expr) case EmptyTree => Some(Nil) case _ if tree.isTerm => Some(tree :: Nil) case _ => None diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala index 4dee80afa9..7cf749c048 100644 --- a/src/reflect/scala/reflect/internal/TreeInfo.scala +++ b/src/reflect/scala/reflect/internal/TreeInfo.scala @@ -458,7 +458,7 @@ abstract class TreeInfo { // transform getter mods to field val vdMods = (if (!mods.hasStableFlag) mods | Flags.MUTABLE else mods &~ Flags.STABLE) &~ Flags.ACCESSOR ValDef(vdMods, name, tpt, rhs) - case tree => tree + case tr => tr } if (detectTypecheckedTree(tree)) { diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala index 7a6862a770..cefab8ffa2 100644 --- a/src/reflect/scala/reflect/internal/Trees.scala +++ b/src/reflect/scala/reflect/internal/Trees.scala @@ -1687,7 +1687,8 @@ trait Trees extends api.Trees { // when someone tries to c.typecheck a naked MemberDef def wrappingIntoTerm(tree: Tree)(op: Tree => Tree): Tree = { op(build.SyntacticBlock(tree :: Nil)) match { - case build.SyntacticBlock(tree :: Nil) => tree + case Block(tree :: Nil, build.SyntheticUnit()) => tree + case Block(Nil, tree) => tree case tree => tree } } diff --git a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala index 14669764d3..b4b909e9be 100644 --- a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala +++ b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala @@ -92,7 +92,7 @@ object TypecheckedProps extends QuasiquoteProperties("typechecked") { property("class with param (2)") = test { val paramName = TermName("y") - val q"{ class $_($param); $_}" = typecheck(q"{ class Test(val $paramName: Int = 3) }") + val q"{class $_($param)}" = typecheck(q"class Test(val $paramName: Int = 3)") assert(param.name == paramName) assert(param.rhs ≈ q"3") @@ -101,7 +101,7 @@ object TypecheckedProps extends QuasiquoteProperties("typechecked") { property("class with params") = test { val pName1 = TermName("x1") val pName2 = TermName("x2") - val q"{ class $_($param1)(..$params2); $_}" = typecheck(q"{ class Test(val x0: Float)(val $pName1: Int = 3, $pName2: String) }") + val q"{class $_($param1)(..$params2)}" = typecheck(q"class Test(val x0: Float)(val $pName1: Int = 3, $pName2: String)") val List(p1, p2, _*) = params2 -- cgit v1.2.3 From 0f2ce9254b63eda76de218d1236318b697e6d4f7 Mon Sep 17 00:00:00 2001 From: VladimirNik Date: Tue, 18 Feb 2014 23:36:42 +0400 Subject: block wrapping for trees modified --- src/reflect/scala/reflect/internal/Trees.scala | 12 +++--- .../scalacheck/quasiquotes/TypecheckedProps.scala | 43 ++++++++++++++++++++++ 2 files changed, 50 insertions(+), 5 deletions(-) (limited to 'test/files/scalacheck/quasiquotes') diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala index cefab8ffa2..78a40707e5 100644 --- a/src/reflect/scala/reflect/internal/Trees.scala +++ b/src/reflect/scala/reflect/internal/Trees.scala @@ -1685,11 +1685,13 @@ trait Trees extends api.Trees { // this is necessary to avoid crashes like https://github.com/scalamacros/paradise/issues/1 // when someone tries to c.typecheck a naked MemberDef - def wrappingIntoTerm(tree: Tree)(op: Tree => Tree): Tree = { - op(build.SyntacticBlock(tree :: Nil)) match { - case Block(tree :: Nil, build.SyntheticUnit()) => tree - case Block(Nil, tree) => tree - case tree => tree + def wrappingIntoTerm(tree0: Tree)(op: Tree => Tree): Tree = { + val neededWrapping = !tree0.isTerm + val tree1 = build.SyntacticBlock(tree0 :: Nil) + op(tree1) match { + case Block(tree2 :: Nil, Literal(Constant(()))) if neededWrapping => tree2 + case Block(Nil, tree2) => tree2 + case tree2 => tree2 } } diff --git a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala index b4b909e9be..432c0959c9 100644 --- a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala +++ b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala @@ -109,4 +109,47 @@ object TypecheckedProps extends QuasiquoteProperties("typechecked") { assert(p2.name == pName2) assert(params2.size == 2) } + + property("implicit class") = test { + val clName = TypeName("Test") + val paramName = TermName("x") + val q"{implicit class $name($param)}" = typecheck(q"implicit class $clName(val $paramName: String)") + + assert(name == clName) + assert(param.name == paramName) + } + + property("block with lazy") = test { + val lazyName = TermName("x") + val lazyRhsVal = 42 + val lazyRhs = Literal(Constant(lazyRhsVal)) + val q"{lazy val $pname = $rhs}" = typecheck(q"{lazy val $lazyName = $lazyRhsVal}") + + assert(pname == lazyName) + assert(rhs ≈ lazyRhs) + } + + property("class with lazy") = test { + val clName = TypeName("Test") + val paramName = TermName("x") + val q"class $name{lazy val $pname = $_}" = typecheck(q"class $clName {lazy val $paramName = 42}") + + assert(name == clName) + assert(pname == paramName) + } + + property("case class with object") = test { + val defName = TermName("z") + val defRhsVal = 42 + val defRhs = Literal(Constant(defRhsVal)) + val q"object $_{ $_; object $_ extends ..$_ {def $name = $rhs} }" = + typecheck(q""" + object Test{ + case class C(x: Int) { def y = x }; + object C { def $defName = $defRhsVal } + }""") + + assert(name == defName) + assert(rhs ≈ defRhs) + } } -- cgit v1.2.3