From fce622a1d3969676725391c85102f89bfd11b9c4 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 11 Nov 2012 00:09:08 +0100 Subject: Minor refactorings --- src/main/scala/scala/async/Async.scala | 4 ++-- src/main/scala/scala/async/ExprBuilder.scala | 34 ++++++++++++++-------------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/Async.scala index 13cca71..d69fd95 100644 --- a/src/main/scala/scala/async/Async.scala +++ b/src/main/scala/scala/async/Async.scala @@ -107,7 +107,7 @@ abstract class AsyncBase extends AsyncUtils { } */ val nonFatalModule = builder.defn.NonFatalClass - val resumeFunTree: c.Tree = DefDef(Modifiers(), name.resume, List(), List(List()), Ident(definitions.UnitClass), + val resumeFunTree: c.Tree = DefDef(Modifiers(), name.resume, Nil, List(Nil), Ident(definitions.UnitClass), Try( reify { combinedHander.splice.apply(c.Expr[Int](Ident(name.state)).splice) @@ -129,7 +129,7 @@ abstract class AsyncBase extends AsyncUtils { futureSystemOps.future[Unit] { c.Expr[Unit](Block( localVarTrees :+ resumeFunTree, - Apply(Ident(name.resume), List()))) + Apply(Ident(name.resume), Nil))) }(futureSystemOps.execContext).splice result$async } diff --git a/src/main/scala/scala/async/ExprBuilder.scala b/src/main/scala/scala/async/ExprBuilder.scala index 0fdcb79..6e8827d 100644 --- a/src/main/scala/scala/async/ExprBuilder.scala +++ b/src/main/scala/scala/async/ExprBuilder.scala @@ -20,16 +20,19 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy import defn._ object name { - // TODO do we need to freshen any of these? def suffix(string: String) = string + "$async" def expandedTermName(prefix: String) = newTermName(suffix(prefix)) def expandedTypeName(prefix: String) = newTypeName(suffix(prefix)) - val resume = expandedTermName("resume") + val state = expandedTermName("state") val result = expandedTermName("result") val tr = newTermName("tr") + + // TODO do we need to freshen any of these? + val resume = expandedTermName("resume") val any = newTermName("any") val x1 = newTermName("x$1") + val apply = newTermName("apply") val isDefinedAt = newTermName("isDefinedAt") @@ -42,7 +45,7 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy private val awaitMethod = awaitSym(c) - private def mkResumeApply = Apply(Ident(name.resume), List()) + private def mkResumeApply = Apply(Ident(name.resume), Nil) def mkStateTree(nextState: Int): c.Tree = mkStateTree(c.literal(nextState).tree) @@ -77,35 +80,36 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy ) private def paramValDef(name: TermName, sym: Symbol) = ValDef(Modifiers(PARAM), name, Ident(sym), EmptyTree) + private def paramValDef(name: TermName, tpe: Type) = ValDef(Modifiers(PARAM), name, TypeTree(tpe), EmptyTree) def mkHandlerTreeFor(cases: List[(CaseDef, Int)]): c.Tree = { val partFunIdent = Ident(defn.PartialFunctionClass) -// val partFunTpe = appliedType(defn.PartialFunctionClass.tpe, definitions.IntTpe, definitions.UnitTpe) val intIdent = Ident(definitions.IntClass) val unitIdent = Ident(definitions.UnitClass) + val (caseDefs, states) = cases.unzip val caseCheck = - defn.mkList_contains(defn.mkList_apply(cases.map(p => c.literal(p._2))))(c.Expr(Ident(name.x1))) + defn.mkList_contains(defn.mkList_apply(states map c.literal))(c.Expr(Ident(name.x1))) val handlerName = name.asyncHander Block(List( // anonymous subclass of PartialFunction[Int, Unit] // TODO subclass AbstractPartialFunction - ClassDef(Modifiers(FINAL), handlerName, List(), Template(List(AppliedTypeTree(partFunIdent, List(intIdent, unitIdent))), + ClassDef(Modifiers(FINAL), handlerName, Nil, Template(List(AppliedTypeTree(partFunIdent, List(intIdent, unitIdent))), emptyValDef, List( - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), - Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), c.literalUnit.tree)), + DefDef(NoMods, nme.CONSTRUCTOR, Nil, List(Nil), TypeTree(), + Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), Nil)), c.literalUnit.tree)), - DefDef(Modifiers(), name.isDefinedAt, List(), List(List(paramValDef(name.x1, definitions.IntClass))), TypeTree(), + DefDef(NoMods, name.isDefinedAt, Nil, List(List(paramValDef(name.x1, definitions.IntClass))), TypeTree(), caseCheck.tree), - DefDef(Modifiers(), name.apply, List(), List(List(paramValDef(name.x1, definitions.IntClass))), TypeTree(), - Match(Ident(name.x1), cases.map(_._1)) // combine all cases into a single match + DefDef(NoMods, name.apply, Nil, List(List(paramValDef(name.x1, definitions.IntClass))), TypeTree(), + Match(Ident(name.x1), caseDefs) // combine all cases into a single match ) )) )), - Apply(Select(New(Ident(handlerName)), nme.CONSTRUCTOR), List()) + Apply(Select(New(Ident(handlerName)), nme.CONSTRUCTOR), Nil) ) } @@ -115,7 +119,7 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy case _ => Block(stats: _*) } - val varDefs: List[(TermName, Type)] = List() + val varDefs: List[(TermName, Type)] = Nil def mkHandlerCaseForState(): CaseDef = mkHandlerCase(state, stats :+ mkStateTree(nextState) :+ mkResumeApply) @@ -461,10 +465,6 @@ final class ExprBuilder[C <: Context, FS <: FutureSystem](val c: C, val futureSy def mkList_contains[A](self: Expr[List[A]])(elem: Expr[Any]) = reify(self.splice.contains(elem.splice)) - def mkPartialFunction_orElse[A, B](self: Expr[PartialFunction[A, B]])(other: Expr[PartialFunction[A, B]]) = reify { - self.splice.orElse(other.splice) - } - def mkFunction_apply[A, B](self: Expr[Function1[A, B]])(arg: Expr[A]) = reify { self.splice.apply(arg.splice) } -- cgit v1.2.3