adapted to Scala-2.10.0-M7

slick · Aug 28, 2012 · 7e74d4c · 7e74d4c
1 parent c17ba8d
commit 7e74d4c
Show file tree

Hide file tree

Showing 5 changed files with 30 additions and 28 deletions.
diff --git a/build.sbt b/build.sbt
@@ -8,7 +8,7 @@ version := "1.0.0-SNAPSHOT"
 
 //scalaVersion := "2.10.0-unknown-unknown"
 //scalaVersion := "2.10.0-SNAPSHOT"
-scalaVersion := "2.10.0-M6"
+scalaVersion := "2.10.0-M7"
 
 scalaBinaryVersion in Global := "2.10.0-M6"
 

diff --git a/src/main/scala/scala/slick/direct/ImplicitQueryable.scala b/src/main/scala/scala/slick/direct/ImplicitQueryable.scala
@@ -2,7 +2,7 @@ package scala.slick.direct
 
 import scala.language.experimental.macros
 
-import scala.reflect.makro.Context
+import scala.reflect.macros.Context
 import scala.slick.SlickException
 
 import scala.reflect.runtime.{universe => ru}
@@ -38,7 +38,7 @@ object ImplicitQueryableMacros{
       ), session.splice)
     }
   }
-  private def _helper[C <: Context,S:c.TypeTag,T]( c:C )( name:String, projection:c.Expr[_] ) : c.Expr[ImplicitQueryable[S]] = {
+  private def _helper[C <: Context,S:c.AbsTypeTag,T]( c:C )( name:String, projection:c.Expr[_] ) : c.Expr[ImplicitQueryable[S]] = {
     val utils = new ImplicitQueryableUtils[c.type](c)
     import utils._
     c.universe.reify{
@@ -47,17 +47,17 @@ object ImplicitQueryableMacros{
       , backend.splice, session.splice )
     }
   }
-  def flatMap[T,S:c.TypeTag]
-    (c: scala.reflect.makro.Context)
+  def flatMap[T,S:c.AbsTypeTag]
+    (c: scala.reflect.macros.Context)
     (projection: c.Expr[T => ImplicitQueryable[S]]): c.Expr[ImplicitQueryable[S]] = _helper[c.type,S,T]( c )( "flatMap", projection )
   def length[T]
-      (c: scala.reflect.makro.Context)
+      (c: scala.reflect.macros.Context)
       : c.Expr[Int] = _scalar_helper[c.type,Int]( c )( "length" )
-  def map[T,S:c.TypeTag]
-    (c: scala.reflect.makro.Context)
+  def map[T,S:c.AbsTypeTag]
+    (c: scala.reflect.macros.Context)
     (projection: c.Expr[T => S]): c.Expr[ImplicitQueryable[S]] = _helper[c.type,S,T]( c )( "map", projection )
-  def filter[T:c.TypeTag]
-    (c: scala.reflect.makro.Context)
+  def filter[T:c.AbsTypeTag]
+    (c: scala.reflect.macros.Context)
     (projection: c.Expr[T => Boolean]): c.Expr[ImplicitQueryable[T]] = _helper[c.type,T,T]( c )( "filter", projection )
 }
 

diff --git a/src/main/scala/scala/slick/direct/Queryable.scala b/src/main/scala/scala/slick/direct/Queryable.scala
@@ -2,7 +2,7 @@ package scala.slick.direct
 
 import scala.language.experimental.macros
 
-import scala.reflect.makro.Context
+import scala.reflect.macros.Context
 import scala.slick.SlickException
 
 import scala.reflect.runtime.{universe => ru}
@@ -69,23 +69,23 @@ object QueryableMacros{
     c.universe.reify{ new QueryableValue( reifiedExpression.splice ) }
   }
   def length
-      (c: scala.reflect.makro.Context)
+      (c: scala.reflect.macros.Context)
       : c.Expr[QueryableValue[Int]] = _scalar_helper[c.type]( c )( "length" )
 
-  private def _helper[C <: Context,S:c.TypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
+  private def _helper[C <: Context,S:c.AbsTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
     val utils = new QueryableUtils[c.type](c)
     val reifiedExpression = utils.apply[Queryable[S]]( c.prefix.tree, name, projection.tree )
     c.universe.reify{ Queryable.factory[S]( reifiedExpression.splice )}
   }
 
-  def map[T:c.TypeTag, S:c.TypeTag]
-  (c: scala.reflect.makro.Context)
+  def map[T:c.AbsTypeTag, S:c.AbsTypeTag]
+  (c: scala.reflect.macros.Context)
   (projection: c.Expr[T => S]): c.Expr[scala.slick.direct.Queryable[S]] = _helper[c.type,S]( c )( "map", projection )
-  def flatMap[T:c.TypeTag, S:c.TypeTag]
-  (c: scala.reflect.makro.Context)
+  def flatMap[T:c.AbsTypeTag, S:c.AbsTypeTag]
+  (c: scala.reflect.macros.Context)
   (projection: c.Expr[T => Queryable[S]]): c.Expr[scala.slick.direct.Queryable[S]] = _helper[c.type,S]( c )( "flatMap", projection )
-  def filter[T:c.TypeTag]
-  (c: scala.reflect.makro.Context)
+  def filter[T:c.AbsTypeTag]
+  (c: scala.reflect.macros.Context)
   (projection: c.Expr[T => Boolean]): c.Expr[scala.slick.direct.Queryable[T]] = _helper[c.type,T]( c )( "filter", projection )
 }
 

diff --git a/src/main/scala/scala/slick/direct/SlickBackend.scala b/src/main/scala/scala/slick/direct/SlickBackend.scala
@@ -12,6 +12,7 @@ import scala.slick.util.{CollectionLinearizer,RecordLinearizer,ValueLinearizer}
 import scala.slick.session.{Session}
 import scala.reflect.ClassTag
 import scala.slick.compiler.CompilationState
+import scala.reflect.runtime.universe.TypeRef
 
 trait QueryableBackend
 
@@ -29,7 +30,7 @@ class SlickBackend( driver:BasicDriver, mapper:Mapper ) extends QueryableBackend
     ,"java.lang.String" /*typeOf[String]*/ -> TypeMapper.StringTypeMapper // FIXME: typeOf[String] leads to java.lang.String, but param.typeSignature to String
   )
 
-  //def resolveSym( lhs:Type, name:String, rhs:Type* ) = lhs.member(newTermName(name).encodedName).asTermSymbol.resolveOverloaded(actuals = rhs.toList)
+  //def resolveSym( lhs:Type, name:String, rhs:Type* ) = lhs.member(newTermName(name).encodedName).asTerm.resolveOverloaded(actuals = rhs.toList)
 
   val operatorMap : Vector[ (Map[String, FunctionSymbol], List[List[Type]]) ] = {
     import Library._
@@ -112,11 +113,11 @@ class SlickBackend( driver:BasicDriver, mapper:Mapper ) extends QueryableBackend
   private def eval( tree:Tree ) :Any = tree match {
     case Select(from,name) => {
       val i = cm.reflect( eval(from) )
-      val m = i.symbol.typeSignature.member( name ).asMethodSymbol
+      val m = i.symbol.typeSignature.member( name ).asMethod
       val mm = i.reflectMethod( m )
       mm()
     }
-    case ident:Ident => ident.symbol.asFreeTermSymbol.value
+    case ident:Ident => ident.symbol.asFreeTerm.value
   }
 
   private def scala2scalaquery_typed( tree:Tree, scope : Scope ) : Query = {
@@ -130,7 +131,7 @@ class SlickBackend( driver:BasicDriver, mapper:Mapper ) extends QueryableBackend
         case Literal(Constant(x:String)) => ConstColumn[String](x)
         case Literal(Constant(x:Double)) => ConstColumn[Double](x)
         case ident@Ident(name) if !scope.contains(ident.symbol) => // TODO: move this into a separate inlining step in queryable
-          ident.symbol.asFreeTermSymbol.value match {
+          ident.symbol.asFreeTerm.value match {
             case q:BaseQueryable[_] => val (tpe,query) = toQuery( q ); query
             case x => s2sq( Literal(Constant(x)) )
           }
@@ -254,19 +255,20 @@ class SlickBackend( driver:BasicDriver, mapper:Mapper ) extends QueryableBackend
 
   protected def resultByType( expectedType : Type, rs: PositionedResult, session:Session) : Any = {
     def createInstance( args:Seq[Any] ) = {
-      val constructor = expectedType.member( nme.CONSTRUCTOR ).asMethodSymbol
+      val constructor = expectedType.member( nme.CONSTRUCTOR ).asMethod
       val cls = cm.reflectClass( cm.classSymbol(cm.runtimeClass(expectedType)) )
       cls.reflectConstructor( constructor )( args:_* )
     }
     import TupleTypes.tupleTypes
     (expectedType match {
       case t if typeMappers.isDefinedAt(expectedType.toString) => typeMappers( expectedType.toString )(driver).nextValue(rs)
       case t if tupleTypes.exists( expectedType <:< _ ) =>
-        val args = expectedType.typeArguments.map{
+        val typeArgs = expectedType match { case TypeRef(_,_,args_) => args_ } 
+        val args = typeArgs.map{
           tpe => resultByType( tpe, rs, session )
         }
         createInstance( args )
-      case t if t.typeSymbol.hasFlag( Flag.CASE ) =>
+      case t if t.typeSymbol.asClass.isCaseClass =>
         val args = expectedType.member( nme.CONSTRUCTOR ).typeSignature match {
           case MethodType( params, resultType ) => params.map{ // TODO check that the field order is correct
             param =>  resultByType( param.typeSignature, rs, session )
@@ -306,7 +308,8 @@ class SlickBackend( driver:BasicDriver, mapper:Mapper ) extends QueryableBackend
     case Right((typetag,classtag)) => (typetag.tpe, this.typetagToQuery( typetag ))
     case Left(expr_)    =>
         val (tpe,query) = this.toQuery(expr_.tree)
-        (tpe.typeArguments(0), query)
+        val args = tpe match { case TypeRef(_,_,args_) => args_ } 
+        (args(0), query)
   }
 
   def toList[T]( queryable:BaseQueryable[T] ) : List[T] = {

diff --git a/src/test/scala/scala/slick/test/direct/QueryableTest.scala b/src/test/scala/scala/slick/test/direct/QueryableTest.scala
@@ -86,7 +86,6 @@ class QueryableTest(val tdb: TestDB) extends DBTest {
 
     db withSession {
       // create test table
-      import scala.slick.jdbc.StaticQuery.Interpolation
       implicit val session_ = session
       sqlu"create table COFFEES(COF_NAME varchar(255), SALES int)".execute
       (for {