diff options
Diffstat (limited to 'test')
175 files changed, 1960 insertions, 10 deletions
diff --git a/test/files/presentation/akka.check b/test/disabled/presentation/akka.check index 9cd20ffb1c..9cd20ffb1c 100644 --- a/test/files/presentation/akka.check +++ b/test/disabled/presentation/akka.check diff --git a/test/files/presentation/akka.flags b/test/disabled/presentation/akka.flags index 56d026a62d..56d026a62d 100644 --- a/test/files/presentation/akka.flags +++ b/test/disabled/presentation/akka.flags diff --git a/test/files/presentation/akka/Runner.scala b/test/disabled/presentation/akka/Runner.scala index 14a6aa8350..14a6aa8350 100644 --- a/test/files/presentation/akka/Runner.scala +++ b/test/disabled/presentation/akka/Runner.scala diff --git a/test/files/presentation/akka/src/akka/AkkaException.scala b/test/disabled/presentation/akka/src/akka/AkkaException.scala index 155a7a16b5..155a7a16b5 100644 --- a/test/files/presentation/akka/src/akka/AkkaException.scala +++ b/test/disabled/presentation/akka/src/akka/AkkaException.scala diff --git a/test/files/presentation/akka/src/akka/actor/Actor.scala b/test/disabled/presentation/akka/src/akka/actor/Actor.scala index b955c4c38b..b955c4c38b 100644 --- a/test/files/presentation/akka/src/akka/actor/Actor.scala +++ b/test/disabled/presentation/akka/src/akka/actor/Actor.scala diff --git a/test/files/presentation/akka/src/akka/actor/ActorRef.scala b/test/disabled/presentation/akka/src/akka/actor/ActorRef.scala index 07fa358744..ff67c9468e 100644 --- a/test/files/presentation/akka/src/akka/actor/ActorRef.scala +++ b/test/disabled/presentation/akka/src/akka/actor/ActorRef.scala @@ -471,7 +471,7 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] { scal * <p/> * To be invoked from within the actor itself. */ - @deprecated("Will be removed after 1.1, use use Actor.remote.actorOf instead and then link on success", "1.1") + @deprecated("Will be removed after 1.1, use Actor.remote.actorOf instead and then link on success", "1.1") def spawnLink(clazz: Class[_ <: Actor]): ActorRef /** diff --git a/test/files/presentation/akka/src/akka/actor/ActorRegistry.scala b/test/disabled/presentation/akka/src/akka/actor/ActorRegistry.scala index df335dc8b4..df335dc8b4 100644 --- a/test/files/presentation/akka/src/akka/actor/ActorRegistry.scala +++ b/test/disabled/presentation/akka/src/akka/actor/ActorRegistry.scala diff --git a/test/files/presentation/akka/src/akka/actor/Actors.java b/test/disabled/presentation/akka/src/akka/actor/Actors.java index a5ec9f37dc..a5ec9f37dc 100644 --- a/test/files/presentation/akka/src/akka/actor/Actors.java +++ b/test/disabled/presentation/akka/src/akka/actor/Actors.java diff --git a/test/files/presentation/akka/src/akka/actor/BootableActorLoaderService.scala b/test/disabled/presentation/akka/src/akka/actor/BootableActorLoaderService.scala index a54fca9ac7..a54fca9ac7 100644 --- a/test/files/presentation/akka/src/akka/actor/BootableActorLoaderService.scala +++ b/test/disabled/presentation/akka/src/akka/actor/BootableActorLoaderService.scala diff --git a/test/files/presentation/akka/src/akka/actor/FSM.scala b/test/disabled/presentation/akka/src/akka/actor/FSM.scala index d9cd9a9ca2..d9cd9a9ca2 100644 --- a/test/files/presentation/akka/src/akka/actor/FSM.scala +++ b/test/disabled/presentation/akka/src/akka/actor/FSM.scala diff --git a/test/files/presentation/akka/src/akka/actor/Scheduler.scala b/test/disabled/presentation/akka/src/akka/actor/Scheduler.scala index 128584f3c5..128584f3c5 100644 --- a/test/files/presentation/akka/src/akka/actor/Scheduler.scala +++ b/test/disabled/presentation/akka/src/akka/actor/Scheduler.scala diff --git a/test/files/presentation/akka/src/akka/actor/Supervisor.scala b/test/disabled/presentation/akka/src/akka/actor/Supervisor.scala index 4a1309faef..4a1309faef 100644 --- a/test/files/presentation/akka/src/akka/actor/Supervisor.scala +++ b/test/disabled/presentation/akka/src/akka/actor/Supervisor.scala diff --git a/test/files/presentation/akka/src/akka/actor/UntypedActor.scala b/test/disabled/presentation/akka/src/akka/actor/UntypedActor.scala index cbc43f22f8..cbc43f22f8 100644 --- a/test/files/presentation/akka/src/akka/actor/UntypedActor.scala +++ b/test/disabled/presentation/akka/src/akka/actor/UntypedActor.scala diff --git a/test/files/presentation/akka/src/akka/actor/package.scala b/test/disabled/presentation/akka/src/akka/actor/package.scala index fbeeed49cb..fbeeed49cb 100644 --- a/test/files/presentation/akka/src/akka/actor/package.scala +++ b/test/disabled/presentation/akka/src/akka/actor/package.scala diff --git a/test/files/presentation/akka/src/akka/config/Config.scala b/test/disabled/presentation/akka/src/akka/config/Config.scala index 6578c66f77..6578c66f77 100644 --- a/test/files/presentation/akka/src/akka/config/Config.scala +++ b/test/disabled/presentation/akka/src/akka/config/Config.scala diff --git a/test/files/presentation/akka/src/akka/config/ConfigParser.scala b/test/disabled/presentation/akka/src/akka/config/ConfigParser.scala index 73fac5e31b..73fac5e31b 100644 --- a/test/files/presentation/akka/src/akka/config/ConfigParser.scala +++ b/test/disabled/presentation/akka/src/akka/config/ConfigParser.scala diff --git a/test/files/presentation/akka/src/akka/config/Configuration.scala b/test/disabled/presentation/akka/src/akka/config/Configuration.scala index 81c32fce90..81c32fce90 100644 --- a/test/files/presentation/akka/src/akka/config/Configuration.scala +++ b/test/disabled/presentation/akka/src/akka/config/Configuration.scala diff --git a/test/files/presentation/akka/src/akka/config/Configurator.scala b/test/disabled/presentation/akka/src/akka/config/Configurator.scala index 2818339b0f..2818339b0f 100644 --- a/test/files/presentation/akka/src/akka/config/Configurator.scala +++ b/test/disabled/presentation/akka/src/akka/config/Configurator.scala diff --git a/test/files/presentation/akka/src/akka/config/Importer.scala b/test/disabled/presentation/akka/src/akka/config/Importer.scala index eebda1d4fe..eebda1d4fe 100644 --- a/test/files/presentation/akka/src/akka/config/Importer.scala +++ b/test/disabled/presentation/akka/src/akka/config/Importer.scala diff --git a/test/files/presentation/akka/src/akka/config/SupervisionConfig.scala b/test/disabled/presentation/akka/src/akka/config/SupervisionConfig.scala index 40f61f615f..40f61f615f 100644 --- a/test/files/presentation/akka/src/akka/config/SupervisionConfig.scala +++ b/test/disabled/presentation/akka/src/akka/config/SupervisionConfig.scala diff --git a/test/files/presentation/akka/src/akka/dataflow/DataFlow.scala b/test/disabled/presentation/akka/src/akka/dataflow/DataFlow.scala index bca7936116..bca7936116 100644 --- a/test/files/presentation/akka/src/akka/dataflow/DataFlow.scala +++ b/test/disabled/presentation/akka/src/akka/dataflow/DataFlow.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/Dispatchers.scala b/test/disabled/presentation/akka/src/akka/dispatch/Dispatchers.scala index 7dd1bf6218..7dd1bf6218 100644 --- a/test/files/presentation/akka/src/akka/dispatch/Dispatchers.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/Dispatchers.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenDispatcher.scala b/test/disabled/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenDispatcher.scala index bc3f29ac68..bc3f29ac68 100644 --- a/test/files/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenDispatcher.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenDispatcher.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala b/test/disabled/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala index 4cba8eec8b..4cba8eec8b 100644 --- a/test/files/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/Future.scala b/test/disabled/presentation/akka/src/akka/dispatch/Future.scala index 1ad304d726..1ad304d726 100644 --- a/test/files/presentation/akka/src/akka/dispatch/Future.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/Future.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/MailboxHandling.scala b/test/disabled/presentation/akka/src/akka/dispatch/MailboxHandling.scala index 4c00577157..4c00577157 100644 --- a/test/files/presentation/akka/src/akka/dispatch/MailboxHandling.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/MailboxHandling.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/MessageHandling.scala b/test/disabled/presentation/akka/src/akka/dispatch/MessageHandling.scala index 20887c3867..20887c3867 100644 --- a/test/files/presentation/akka/src/akka/dispatch/MessageHandling.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/MessageHandling.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/ThreadBasedDispatcher.scala b/test/disabled/presentation/akka/src/akka/dispatch/ThreadBasedDispatcher.scala index 3169c70ef9..3169c70ef9 100644 --- a/test/files/presentation/akka/src/akka/dispatch/ThreadBasedDispatcher.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/ThreadBasedDispatcher.scala diff --git a/test/files/presentation/akka/src/akka/dispatch/ThreadPoolBuilder.scala b/test/disabled/presentation/akka/src/akka/dispatch/ThreadPoolBuilder.scala index e847610c4c..e847610c4c 100644 --- a/test/files/presentation/akka/src/akka/dispatch/ThreadPoolBuilder.scala +++ b/test/disabled/presentation/akka/src/akka/dispatch/ThreadPoolBuilder.scala diff --git a/test/files/presentation/akka/src/akka/event/EventHandler.scala b/test/disabled/presentation/akka/src/akka/event/EventHandler.scala index f3176b7c21..f3176b7c21 100644 --- a/test/files/presentation/akka/src/akka/event/EventHandler.scala +++ b/test/disabled/presentation/akka/src/akka/event/EventHandler.scala diff --git a/test/files/presentation/akka/src/akka/event/JavaEventHandler.java b/test/disabled/presentation/akka/src/akka/event/JavaEventHandler.java index 7e6e2d4143..7e6e2d4143 100644 --- a/test/files/presentation/akka/src/akka/event/JavaEventHandler.java +++ b/test/disabled/presentation/akka/src/akka/event/JavaEventHandler.java diff --git a/test/files/presentation/akka/src/akka/japi/JavaAPI.scala b/test/disabled/presentation/akka/src/akka/japi/JavaAPI.scala index f5c4ccdcaa..f5c4ccdcaa 100644 --- a/test/files/presentation/akka/src/akka/japi/JavaAPI.scala +++ b/test/disabled/presentation/akka/src/akka/japi/JavaAPI.scala diff --git a/test/files/presentation/akka/src/akka/remoteinterface/RemoteEventHandler.scala b/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteEventHandler.scala index 1c75618301..1c75618301 100644 --- a/test/files/presentation/akka/src/akka/remoteinterface/RemoteEventHandler.scala +++ b/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteEventHandler.scala diff --git a/test/files/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala b/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala index 0c5da82294..0c5da82294 100644 --- a/test/files/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala +++ b/test/disabled/presentation/akka/src/akka/remoteinterface/RemoteInterface.scala diff --git a/test/files/presentation/akka/src/akka/routing/Iterators.scala b/test/disabled/presentation/akka/src/akka/routing/Iterators.scala index 315e7bea51..315e7bea51 100644 --- a/test/files/presentation/akka/src/akka/routing/Iterators.scala +++ b/test/disabled/presentation/akka/src/akka/routing/Iterators.scala diff --git a/test/files/presentation/akka/src/akka/routing/Listeners.scala b/test/disabled/presentation/akka/src/akka/routing/Listeners.scala index 04f6c1259f..04f6c1259f 100644 --- a/test/files/presentation/akka/src/akka/routing/Listeners.scala +++ b/test/disabled/presentation/akka/src/akka/routing/Listeners.scala diff --git a/test/files/presentation/akka/src/akka/routing/Pool.scala b/test/disabled/presentation/akka/src/akka/routing/Pool.scala index 0fd1bc8f49..d972bb84c8 100644 --- a/test/files/presentation/akka/src/akka/routing/Pool.scala +++ b/test/disabled/presentation/akka/src/akka/routing/Pool.scala @@ -220,7 +220,7 @@ trait BoundedCapacityStrategy extends CapacityStrategy with BoundedCapacitor */ /** - * The basic filter trait that composes ramp-up and and back-off subfiltering. + * The basic filter trait that composes ramp-up and back-off subfiltering. */ trait Filter { def rampup(pressure: Int, capacity: Int): Int diff --git a/test/files/presentation/akka/src/akka/routing/Routers.scala b/test/disabled/presentation/akka/src/akka/routing/Routers.scala index a4c34c5c67..a4c34c5c67 100644 --- a/test/files/presentation/akka/src/akka/routing/Routers.scala +++ b/test/disabled/presentation/akka/src/akka/routing/Routers.scala diff --git a/test/files/presentation/akka/src/akka/routing/Routing.scala b/test/disabled/presentation/akka/src/akka/routing/Routing.scala index befc124248..befc124248 100644 --- a/test/files/presentation/akka/src/akka/routing/Routing.scala +++ b/test/disabled/presentation/akka/src/akka/routing/Routing.scala diff --git a/test/files/presentation/akka/src/akka/util/Address.scala b/test/disabled/presentation/akka/src/akka/util/Address.scala index 65b5c0a834..65b5c0a834 100644 --- a/test/files/presentation/akka/src/akka/util/Address.scala +++ b/test/disabled/presentation/akka/src/akka/util/Address.scala diff --git a/test/files/presentation/akka/src/akka/util/AkkaLoader.scala b/test/disabled/presentation/akka/src/akka/util/AkkaLoader.scala index cb246f2ecf..cb246f2ecf 100644 --- a/test/files/presentation/akka/src/akka/util/AkkaLoader.scala +++ b/test/disabled/presentation/akka/src/akka/util/AkkaLoader.scala diff --git a/test/files/presentation/akka/src/akka/util/Bootable.scala b/test/disabled/presentation/akka/src/akka/util/Bootable.scala index d07643e1ac..d07643e1ac 100644 --- a/test/files/presentation/akka/src/akka/util/Bootable.scala +++ b/test/disabled/presentation/akka/src/akka/util/Bootable.scala diff --git a/test/files/presentation/akka/src/akka/util/BoundedBlockingQueue.scala b/test/disabled/presentation/akka/src/akka/util/BoundedBlockingQueue.scala index f8deda746c..f8deda746c 100644 --- a/test/files/presentation/akka/src/akka/util/BoundedBlockingQueue.scala +++ b/test/disabled/presentation/akka/src/akka/util/BoundedBlockingQueue.scala diff --git a/test/files/presentation/akka/src/akka/util/Crypt.scala b/test/disabled/presentation/akka/src/akka/util/Crypt.scala index 3ce2d559a2..3ce2d559a2 100644 --- a/test/files/presentation/akka/src/akka/util/Crypt.scala +++ b/test/disabled/presentation/akka/src/akka/util/Crypt.scala diff --git a/test/files/presentation/akka/src/akka/util/Duration.scala b/test/disabled/presentation/akka/src/akka/util/Duration.scala index 316cb86689..316cb86689 100644 --- a/test/files/presentation/akka/src/akka/util/Duration.scala +++ b/test/disabled/presentation/akka/src/akka/util/Duration.scala diff --git a/test/files/presentation/akka/src/akka/util/HashCode.scala b/test/disabled/presentation/akka/src/akka/util/HashCode.scala index d015f12f5d..d015f12f5d 100644 --- a/test/files/presentation/akka/src/akka/util/HashCode.scala +++ b/test/disabled/presentation/akka/src/akka/util/HashCode.scala diff --git a/test/files/presentation/akka/src/akka/util/Helpers.scala b/test/disabled/presentation/akka/src/akka/util/Helpers.scala index 48477426c9..48477426c9 100644 --- a/test/files/presentation/akka/src/akka/util/Helpers.scala +++ b/test/disabled/presentation/akka/src/akka/util/Helpers.scala diff --git a/test/files/presentation/akka/src/akka/util/ListenerManagement.scala b/test/disabled/presentation/akka/src/akka/util/ListenerManagement.scala index 7065397a45..863e905d59 100644 --- a/test/files/presentation/akka/src/akka/util/ListenerManagement.scala +++ b/test/disabled/presentation/akka/src/akka/util/ListenerManagement.scala @@ -22,7 +22,7 @@ trait ListenerManagement { protected def manageLifeCycleOfListeners: Boolean = true /** - * Adds the <code>listener</code> this this registry's listener list. + * Adds the <code>listener</code> this registry's listener list. * The <code>listener</code> is started by this method if manageLifeCycleOfListeners yields true. */ def addListener(listener: ActorRef) { @@ -31,7 +31,7 @@ trait ListenerManagement { } /** - * Removes the <code>listener</code> this this registry's listener list. + * Removes the <code>listener</code> this registry's listener list. * The <code>listener</code> is stopped by this method if manageLifeCycleOfListeners yields true. */ def removeListener(listener: ActorRef) { diff --git a/test/files/presentation/akka/src/akka/util/LockUtil.scala b/test/disabled/presentation/akka/src/akka/util/LockUtil.scala index 4aaefadc4a..4aaefadc4a 100644 --- a/test/files/presentation/akka/src/akka/util/LockUtil.scala +++ b/test/disabled/presentation/akka/src/akka/util/LockUtil.scala diff --git a/test/files/presentation/akka/src/akka/util/ReflectiveAccess.scala b/test/disabled/presentation/akka/src/akka/util/ReflectiveAccess.scala index f38d1f9b98..f38d1f9b98 100644 --- a/test/files/presentation/akka/src/akka/util/ReflectiveAccess.scala +++ b/test/disabled/presentation/akka/src/akka/util/ReflectiveAccess.scala diff --git a/test/files/presentation/akka/src/akka/util/package.scala b/test/disabled/presentation/akka/src/akka/util/package.scala index 26a24929c9..26a24929c9 100644 --- a/test/files/presentation/akka/src/akka/util/package.scala +++ b/test/disabled/presentation/akka/src/akka/util/package.scala diff --git a/test/files/presentation/akka/src/com/eaio/util/lang/Hex.java b/test/disabled/presentation/akka/src/com/eaio/util/lang/Hex.java index 7794059517..7794059517 100644 --- a/test/files/presentation/akka/src/com/eaio/util/lang/Hex.java +++ b/test/disabled/presentation/akka/src/com/eaio/util/lang/Hex.java diff --git a/test/files/presentation/akka/src/com/eaio/uuid/MACAddressParser.java b/test/disabled/presentation/akka/src/com/eaio/uuid/MACAddressParser.java index c077147470..c077147470 100644 --- a/test/files/presentation/akka/src/com/eaio/uuid/MACAddressParser.java +++ b/test/disabled/presentation/akka/src/com/eaio/uuid/MACAddressParser.java diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUID.java b/test/disabled/presentation/akka/src/com/eaio/uuid/UUID.java index 6c49bcd1c8..6c49bcd1c8 100644 --- a/test/files/presentation/akka/src/com/eaio/uuid/UUID.java +++ b/test/disabled/presentation/akka/src/com/eaio/uuid/UUID.java diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUIDGen.java b/test/disabled/presentation/akka/src/com/eaio/uuid/UUIDGen.java index 7b63f65447..7b63f65447 100644 --- a/test/files/presentation/akka/src/com/eaio/uuid/UUIDGen.java +++ b/test/disabled/presentation/akka/src/com/eaio/uuid/UUIDGen.java diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUIDHelper.java b/test/disabled/presentation/akka/src/com/eaio/uuid/UUIDHelper.java index 7abbe85895..7abbe85895 100644 --- a/test/files/presentation/akka/src/com/eaio/uuid/UUIDHelper.java +++ b/test/disabled/presentation/akka/src/com/eaio/uuid/UUIDHelper.java diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUIDHolder.java b/test/disabled/presentation/akka/src/com/eaio/uuid/UUIDHolder.java index d5531f5e00..d5531f5e00 100644 --- a/test/files/presentation/akka/src/com/eaio/uuid/UUIDHolder.java +++ b/test/disabled/presentation/akka/src/com/eaio/uuid/UUIDHolder.java diff --git a/test/files/presentation/akka/src/pi.scala b/test/disabled/presentation/akka/src/pi.scala index b4c644052c..b4c644052c 100644 --- a/test/files/presentation/akka/src/pi.scala +++ b/test/disabled/presentation/akka/src/pi.scala diff --git a/test/files/presentation/timeofday.check b/test/disabled/presentation/timeofday.check index 2a09d0bcfc..2a09d0bcfc 100644 --- a/test/files/presentation/timeofday.check +++ b/test/disabled/presentation/timeofday.check diff --git a/test/files/presentation/timeofday/Runner.scala b/test/disabled/presentation/timeofday/Runner.scala index 1c03e3d5ba..1c03e3d5ba 100644 --- a/test/files/presentation/timeofday/Runner.scala +++ b/test/disabled/presentation/timeofday/Runner.scala diff --git a/test/files/presentation/timeofday/src/timeofday.scala b/test/disabled/presentation/timeofday/src/timeofday.scala index d6355097f1..d6355097f1 100644 --- a/test/files/presentation/timeofday/src/timeofday.scala +++ b/test/disabled/presentation/timeofday/src/timeofday.scala diff --git a/test/files/jvm/signum.scala b/test/files/jvm/signum.scala new file mode 100644 index 0000000000..feb28d3e43 --- /dev/null +++ b/test/files/jvm/signum.scala @@ -0,0 +1,15 @@ +object Test { + def main(args: Array[String]) { + assert(math.signum(Long.MaxValue) == 1L) + assert(math.signum(1L) == 1L) + assert(math.signum(0L) == 0L) + assert(math.signum(-1L) == -1L) + assert(math.signum(Long.MinValue) == -1L) + + assert(math.signum(Int.MaxValue) == 1) + assert(math.signum(1) == 1) + assert(math.signum(0) == 0) + assert(math.signum(-1) == -1) + assert(math.signum(Int.MinValue) == -1) + } +} diff --git a/test/files/neg/nopredefs.check b/test/files/neg/nopredefs.check index 0a0ab34482..e6c1af78a0 100644 --- a/test/files/neg/nopredefs.check +++ b/test/files/neg/nopredefs.check @@ -1,4 +1,4 @@ -nopredefs.scala:5: error: not found: value Set +nopredefs.scala:5: error: not found: value Set (similar: Seq) val y = Set(3) ^ one error found diff --git a/test/files/neg/reassignment.check b/test/files/neg/reassignment.check new file mode 100644 index 0000000000..f0effd1459 --- /dev/null +++ b/test/files/neg/reassignment.check @@ -0,0 +1,13 @@ +reassignment.scala:2: error: not found: value x + x = 5 + ^ +reassignment.scala:3: error: not found: value y + y := 45 + ^ +reassignment.scala:4: error: not found: value y + y += 45 + ^ +reassignment.scala:6: error: reassignment to val + z = 51 + ^ +four errors found diff --git a/test/files/neg/reassignment.scala b/test/files/neg/reassignment.scala new file mode 100644 index 0000000000..e31eefbf3f --- /dev/null +++ b/test/files/neg/reassignment.scala @@ -0,0 +1,7 @@ +class A { + x = 5 + y := 45 + y += 45 + val z = 50 + z = 51 +}
\ No newline at end of file diff --git a/test/files/neg/suggest-similar.check b/test/files/neg/suggest-similar.check new file mode 100644 index 0000000000..0a858aaf2e --- /dev/null +++ b/test/files/neg/suggest-similar.check @@ -0,0 +1,10 @@ +suggest-similar.scala:8: error: not found: value flippitx (similar: flippity) + flippitx = 123 + ^ +suggest-similar.scala:9: error: not found: value identiyt (similar: identity) + Nil map identiyt + ^ +suggest-similar.scala:10: error: not found: type Bingus (similar: Dingus) + new Bingus + ^ +three errors found diff --git a/test/files/neg/suggest-similar.scala b/test/files/neg/suggest-similar.scala new file mode 100644 index 0000000000..ff327478fe --- /dev/null +++ b/test/files/neg/suggest-similar.scala @@ -0,0 +1,11 @@ +class Dingus +object Dingus { + var flippity = 1 +} +import Dingus._ + +class A { + flippitx = 123 + Nil map identiyt + new Bingus +} diff --git a/test/files/neg/t0903.check b/test/files/neg/t0903.check index db4cd94d2c..2dd05cd3ee 100644 --- a/test/files/neg/t0903.check +++ b/test/files/neg/t0903.check @@ -1,4 +1,4 @@ -t0903.scala:3: error: reassignment to val +t0903.scala:3: error: value += is not a member of Int x += 1 ^ t0903.scala:4: error: reassignment to val diff --git a/test/files/neg/t2870.check b/test/files/neg/t2870.check index 6577577d3f..72bc0d98a1 100644 --- a/test/files/neg/t2870.check +++ b/test/files/neg/t2870.check @@ -1,4 +1,4 @@ -t2870.scala:1: error: not found: type Jar +t2870.scala:1: error: not found: type Jar (similar: Jars) class Jars(jar: Jar) ^ t2870.scala:6: error: illegal cyclic reference involving value <import> diff --git a/test/files/neg/t3481.check b/test/files/neg/t3481.check new file mode 100644 index 0000000000..48e6ff357b --- /dev/null +++ b/test/files/neg/t3481.check @@ -0,0 +1,29 @@ +t3481.scala:5: error: type mismatch; + found : String("hello") + required: _$1 where type +_$1 + f[A[Int]]("hello") + ^ +t3481.scala:11: error: type mismatch; + found : _$2 where type +_$2 + required: b.T + (which expands to) _$2 + def f[T <: B[_]](a: T#T, b: T) = b.m(a) + ^ +t3481.scala:12: error: type mismatch; + found : String("Hello") + required: _$2 where type +_$2 + f("Hello", new B[Int]) + ^ +t3481.scala:18: error: type mismatch; + found : String("Hello") + required: t3481.ex3.b.T2 + (which expands to) _$3 + b.m("Hello") + ^ +t3481.scala:25: error: type mismatch; + found : String("Hello") + required: t3481.ex4.Test.b.T2 + (which expands to) _$4 + b.m("Hello") + ^ +5 errors found diff --git a/test/files/neg/t3481.scala b/test/files/neg/t3481.scala new file mode 100644 index 0000000000..f4b781ee37 --- /dev/null +++ b/test/files/neg/t3481.scala @@ -0,0 +1,28 @@ +object t3481 { + object ex1 { + trait A[T] { type B = T } + def f[T <: A[_]](a: T#B) = 1 + f[A[Int]]("hello") + } + + object ex2 { + trait A { type T; def m(t: T) = t.toString } + class B[T2] extends A { type T = T2 } + def f[T <: B[_]](a: T#T, b: T) = b.m(a) + f("Hello", new B[Int]) + } + + object ex3 { + class B[T] { type T2 = T; def m(t: T2) = t.toString } + val b: B[_] = new B[Int] + b.m("Hello") + } + + object ex4 { + abstract class B[T] { type T2 = T; def m(t: T2): Any } + object Test { + val b: B[_] = sys.error("") + b.m("Hello") + } + } +}
\ No newline at end of file diff --git a/test/files/pos/t4758.scala b/test/files/pos/t4758.scala new file mode 100644 index 0000000000..627dfd7a23 --- /dev/null +++ b/test/files/pos/t4758.scala @@ -0,0 +1,17 @@ +// /scala/trac/4758/a.scala +// Fri Dec 2 13:41:54 PST 2011 + +package bar { + // works + trait M[F[_]] + class S[X[_] <: M[X], A](val x:X[A]) + object S { + def apply[X[_] <: M[X], A](x: X[A]): S[X, A] = new S[X, A](x) + def unapply[X[_] <: M[X], A](p: S[X, A]) = Some(p.x) + } +} +package foo { + // seemingly equivalent, doesn't work + trait M[F[_]] + case class S[X[_] <: M[X], A](x: X[A]) +} diff --git a/test/files/pos/t5084.scala b/test/files/pos/t5084.scala new file mode 100644 index 0000000000..17d0a68adf --- /dev/null +++ b/test/files/pos/t5084.scala @@ -0,0 +1,5 @@ +case class Search(tpe: Search.Value) + +object Search { + type Value = String +} diff --git a/test/files/run/adding-growing-set.scala b/test/files/run/adding-growing-set.scala index 5903813ed1..ab94b893b2 100644 --- a/test/files/run/adding-growing-set.scala +++ b/test/files/run/adding-growing-set.scala @@ -1,4 +1,4 @@ -/** This will run a a loooong time if Set's builder copies a +/** This will run a loooong time if Set's builder copies a * complete new Set for every element. */ object Test { diff --git a/test/files/run/enums.check b/test/files/run/enums.check index f53aba8794..93eadae6e3 100644 --- a/test/files/run/enums.check +++ b/test/files/run/enums.check @@ -3,3 +3,13 @@ test Test2 was successful test Test3 was successful test Test4 was successful +D1.ValueSet(North, East) +D2.ValueSet(North, East) +D1.ValueSet(North, East, West) +D2.ValueSet(North, East, West) +List(101) +List(101) +D1.ValueSet(North, East) +D2.ValueSet(North, East) +WeekDays.ValueSet(Tue, Wed, Thu, Fri) + diff --git a/test/files/run/enums.scala b/test/files/run/enums.scala index 6dda8cbc6e..9cdeed2691 100644 --- a/test/files/run/enums.scala +++ b/test/files/run/enums.scala @@ -65,6 +65,58 @@ object Test4 { } } +object Test5 { + + object D1 extends Enumeration(0) { + val North, South, East, West = Value; + } + + object D2 extends Enumeration(-2) { + val North, South, East, West = Value; + } + + object WeekDays extends Enumeration { + val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value + } + + def run { + val s1 = D1.ValueSet(D1.North, D1.East) + val s2 = D2.North + D2.East + println(s1) + println(s2) + println(s1 + D1.West) + println(s2 + D2.West) + println(s1.toBitMask.map(_.toBinaryString).toList) + println(s2.toBitMask.map(_.toBinaryString).toList) + println(D1.ValueSet.fromBitMask(s1.toBitMask)) + println(D2.ValueSet.fromBitMask(s2.toBitMask)) + println(WeekDays.values.range(WeekDays.Tue, WeekDays.Sat)) + } +} + +object SerializationTest { + object Types extends Enumeration { val X, Y = Value } + class A extends java.io.Serializable { val types = Types.values } + class B extends java.io.Serializable { val types = Set(Types.X, Types.Y) } + + def serialize(obj: AnyRef) = { + val baos = new java.io.ByteArrayOutputStream() + val oos = new java.io.ObjectOutputStream(baos) + oos.writeObject(obj) + oos.close() + val bais = new java.io.ByteArrayInputStream(baos.toByteArray) + val ois = new java.io.ObjectInputStream(bais) + val prime = ois.readObject() + ois.close() + prime + } + + def run { + serialize(new B()) + serialize(new A()) + } +} + //############################################################################ // Test code @@ -94,6 +146,9 @@ object Test { check_success("Test3", Test3.run, 1); check_success("Test4", Test4.run, 0); Console.println; + Test5.run; + Console.println; + SerializationTest.run; } } diff --git a/test/files/run/json.scala b/test/files/run/json.scala index 7d3b635006..a81f12564c 100644 --- a/test/files/run/json.scala +++ b/test/files/run/json.scala @@ -3,7 +3,7 @@ import scala.collection.immutable.TreeMap object Test extends App { /* This method converts parsed JSON back into real JSON notation with objects in - * sorted-key order. Not required by the spec, but it allows us to to a stable + * sorted-key order. Not required by the spec, but it allows us to do a stable * toString comparison. */ def jsonToString(in : Any) : String = in match { case l : List[_] => "[" + l.map(jsonToString).mkString(", ") + "]" diff --git a/test/files/run/parserFilter.check b/test/files/run/parserFilter.check new file mode 100644 index 0000000000..be04454426 --- /dev/null +++ b/test/files/run/parserFilter.check @@ -0,0 +1,9 @@ +[1.3] failure: Input doesn't match filter: false + +if false + ^ +[1.1] failure: Input doesn't match filter: not + +not true +^ +[1.8] parsed: (if~true) diff --git a/test/files/run/parserFilter.scala b/test/files/run/parserFilter.scala new file mode 100644 index 0000000000..d007d441f4 --- /dev/null +++ b/test/files/run/parserFilter.scala @@ -0,0 +1,15 @@ +object Test extends scala.util.parsing.combinator.RegexParsers { + val keywords = Set("if", "false") + def word: Parser[String] = "\\w+".r + + def keyword: Parser[String] = word filter (keywords.contains) + def ident: Parser[String] = word filter(!keywords.contains(_)) + + def test = keyword ~ ident + + def main(args: Array[String]) { + println(parseAll(test, "if false")) + println(parseAll(test, "not true")) + println(parseAll(test, "if true")) + } +} diff --git a/test/files/run/parserForFilter.check b/test/files/run/parserForFilter.check new file mode 100644 index 0000000000..a53c147719 --- /dev/null +++ b/test/files/run/parserForFilter.check @@ -0,0 +1 @@ +[1.13] parsed: (second,first) diff --git a/test/files/run/parserForFilter.scala b/test/files/run/parserForFilter.scala new file mode 100644 index 0000000000..1bc44f8033 --- /dev/null +++ b/test/files/run/parserForFilter.scala @@ -0,0 +1,12 @@ +object Test extends scala.util.parsing.combinator.RegexParsers { + def word: Parser[String] = "\\w+".r + + def twoWords = for { + (a ~ b) <- word ~ word + } yield (b, a) + + def main(args: Array[String]) { + println(parseAll(twoWords, "first second")) + } +} + diff --git a/test/files/run/parserNoSuccessMessage.check b/test/files/run/parserNoSuccessMessage.check new file mode 100644 index 0000000000..fe00d2fd3a --- /dev/null +++ b/test/files/run/parserNoSuccessMessage.check @@ -0,0 +1,20 @@ +[1.2] failure: string matching regex `\d+' expected but `x' found + +-x + ^ +[1.1] failure: string matching regex `\d+' expected but `x' found + +x +^ +[1.3] parsed: (Some(-)~5) +[1.2] parsed: (None~5) +[1.2] error: Number expected! + +-x + ^ +[1.1] error: Number expected! + +x +^ +[1.3] parsed: (Some(-)~5) +[1.2] parsed: (None~5) diff --git a/test/files/run/parserNoSuccessMessage.scala b/test/files/run/parserNoSuccessMessage.scala new file mode 100644 index 0000000000..93aa252db0 --- /dev/null +++ b/test/files/run/parserNoSuccessMessage.scala @@ -0,0 +1,19 @@ +object Test extends scala.util.parsing.combinator.RegexParsers { + def sign = "-" + def number = "\\d+".r + def p = sign.? ~ number withErrorMessage "Number expected!" + def q = sign.? ~! number withErrorMessage "Number expected!" + + def main(args: Array[String]) { + println(parseAll(p, "-x")) + println(parseAll(p, "x")) + println(parseAll(p, "-5")) + println(parseAll(p, "5")) + println(parseAll(q, "-x")) + println(parseAll(q, "x")) + println(parseAll(q, "-5")) + println(parseAll(q, "5")) + } +} + + diff --git a/test/files/run/reify_anonymous.check b/test/files/run/reify_anonymous.check new file mode 100644 index 0000000000..b8626c4cff --- /dev/null +++ b/test/files/run/reify_anonymous.check @@ -0,0 +1 @@ +4 diff --git a/test/files/run/reify_anonymous.scala b/test/files/run/reify_anonymous.scala new file mode 100644 index 0000000000..1e7f3fe856 --- /dev/null +++ b/test/files/run/reify_anonymous.scala @@ -0,0 +1,14 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + println(new {def x = 2; def y = x * x}.y) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/reify_for1.check b/test/files/run/reify_for1.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/run/reify_for1.check diff --git a/test/files/run/reify_for1.scala b/test/files/run/reify_for1.scala new file mode 100644 index 0000000000..4b03330293 --- /dev/null +++ b/test/files/run/reify_for1.scala @@ -0,0 +1,16 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + val sumOfSquares1 = (for (i <- 1 to 100; if (i % 3 == 0)) yield Math.pow(i, 2)).sum + val sumOfSquares2 = (1 to 100).filter(_ % 3 == 0).map(Math.pow(_, 2)).sum + assert(sumOfSquares1 == sumOfSquares2) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/reify_generic.check b/test/files/run/reify_generic.check new file mode 100644 index 0000000000..b8626c4cff --- /dev/null +++ b/test/files/run/reify_generic.check @@ -0,0 +1 @@ +4 diff --git a/test/files/run/reify_generic.scala b/test/files/run/reify_generic.scala new file mode 100644 index 0000000000..aef038b2d8 --- /dev/null +++ b/test/files/run/reify_generic.scala @@ -0,0 +1,15 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + val product = List(1, 2, 3).head * List[Any](4, 2, 0).head.asInstanceOf[Int] + println(product) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/reify_inheritance.check b/test/files/run/reify_inheritance.check new file mode 100644 index 0000000000..25bf17fc5a --- /dev/null +++ b/test/files/run/reify_inheritance.check @@ -0,0 +1 @@ +18
\ No newline at end of file diff --git a/test/files/run/reify_inheritance.scala b/test/files/run/reify_inheritance.scala new file mode 100644 index 0000000000..2a1b5f764f --- /dev/null +++ b/test/files/run/reify_inheritance.scala @@ -0,0 +1,23 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + class C { + def x = 2 + def y = x * x + } + + class D extends C { + override def x = 3 + } + + println(new D().y * new C().x) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/reify_printf.check b/test/files/run/reify_printf.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/run/reify_printf.check diff --git a/test/files/run/reify_printf.scala b/test/files/run/reify_printf.scala new file mode 100644 index 0000000000..30901b98c2 --- /dev/null +++ b/test/files/run/reify_printf.scala @@ -0,0 +1,75 @@ +import java.io.{ ByteArrayOutputStream, PrintStream } +import scala.reflect.Code +import scala.reflect.mirror._ +import scala.reflect.api._ +import scala.reflect.api.Trees +import scala.reflect.internal.Types +import reflect.runtime.Mirror.ToolBox +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import scala.util.matching.Regex + +object Test extends App { + val tree = tree_printf(Code.lift("hello %s").tree, Code.lift("world").tree) + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter, args mkString " ") + val ttree = toolbox.typeCheck(tree) + + val output = new ByteArrayOutputStream() + Console.setOut(new PrintStream(output)) + val evaluated = toolbox.runExpr(ttree) + + assert(output.toString() == "hello world", output.toString() +" == hello world") + + /* + macro def printf(format: String, params: Any*) : String = tree_printf(format: Tree, (params: Seq[Tree]): _*) + */ + + var i = 0 + def gensym(name: String) = { i += 1; newTermName(name + i) } + + def createTempValDef( value : Tree, tpe : Type ) : (Option[Tree],Tree) = { + val local = gensym("temp") + ( + Some( + ValDef( + Modifiers() + , local + , TypeTree().setType(tpe) + , value + ) + ) + , Ident(local) + ) + } + + def tree_printf(format: Tree, params: Tree*) = { + val Literal(Constant(s_format: String)) = format + val paramsStack = scala.collection.mutable.Stack(params: _*) + val parsed = s_format.split("(?<=%[\\w%])|(?=%[\\w%])") map { + case "%d" => createTempValDef( paramsStack.pop, classToType(classOf[Int]) ) + case "%s" => createTempValDef( paramsStack.pop, classToType(classOf[String]) ) + case "%%" => { + (None:Option[Tree], Literal(Constant("%"))) + } + case part => { + (None:Option[Tree], Literal(Constant(part))) + } + } + + val evals = for ((Some(eval), _) <- parsed if eval != None) yield (eval: Tree) + val prints = for ((_, ref) <- parsed) yield + Apply( + Select( + Select( + Ident( newTermName("scala") ) + , newTermName("Predef") + ) + , newTermName("print") + ) + , List(ref) + ): Tree + Block((evals ++ prints).toList, Literal(Constant(()))) + } +} diff --git a/test/files/run/reify_varargs.check b/test/files/run/reify_varargs.check new file mode 100644 index 0000000000..e300a570a7 --- /dev/null +++ b/test/files/run/reify_varargs.check @@ -0,0 +1 @@ +Message=On the fifth of August there was a disturbance in the Force on planet Hoth. diff --git a/test/files/run/reify_varargs.scala b/test/files/run/reify_varargs.scala new file mode 100644 index 0000000000..d38cbf2aac --- /dev/null +++ b/test/files/run/reify_varargs.scala @@ -0,0 +1,17 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + val msg = java.text.MessageFormat.format( + "On {1} there was {2} on planet {0}.", + "Hoth", "the fifth of August", "a disturbance in the Force") + println("Message="+msg) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/t4658.check b/test/files/run/t4658.check new file mode 100644 index 0000000000..743b0faee3 --- /dev/null +++ b/test/files/run/t4658.check @@ -0,0 +1,80 @@ +Ranges: +1073741824 +1073741824 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 +IntRanges: +Disabled #1 +Disabled #2 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 +LongRanges: +Disabled #1 +Disabled #2 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 +BigIntRanges: +Disabled #1 +Disabled #2 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 diff --git a/test/files/run/t4658.scala b/test/files/run/t4658.scala new file mode 100644 index 0000000000..e1799fae9b --- /dev/null +++ b/test/files/run/t4658.scala @@ -0,0 +1,41 @@ +import scala.collection.immutable.NumericRange +//#4658 +object Test { + + case class R(start: Int, end: Int, step: Int = 1, inclusive: Boolean = true) + + val rangeData = Array( + R(1, Int.MaxValue), R(-Int.MaxValue, -1), R(0, 0), R(0,0, inclusive = false), R(1,10), + R(1,10,2), R(1,10,11), R(-10, -5), R(-10, 0), R(-10, 10), R(-10, -5, 2), R(-10, 0, 2), R(-10, 10, 2), + R(-10, -5, inclusive = false), R(-10, 0, inclusive = false), R(-10, 10, inclusive = false), + R(-10, -5, 2, inclusive = false), R(-10, 0, 2, inclusive = false), R(-10, 10, 2, inclusive = false) + ) + + def ranges = rangeData.map(r => if (r.inclusive) r.start to r.end by r.step else r.start until r.end by r.step) + + def numericIntRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(r.start, r.end, r.step) else NumericRange(r.start, r.end, r.step)) + + def numericLongRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(r.start.toLong, r.end, r.step) else NumericRange(r.start.toLong, r.end, r.step)) + + def numericBigIntRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(BigInt(r.start), BigInt(r.end), BigInt(r.step)) else NumericRange(BigInt(r.start), BigInt(r.end), BigInt(r.step))) + + def main(args: Array[String]) { + // We drop the first two tests for all ranges which don't have a decent sum implementation, + // because it is just too slow. + println("Ranges:") + ranges.foreach{range => println(range.sum)} + println("IntRanges:") + println("Disabled #1") + println("Disabled #2") + numericIntRanges.drop(2).foreach{range => println(range.sum)} + println("LongRanges:") + println("Disabled #1") + println("Disabled #2") + numericLongRanges.drop(2).foreach{range => println(range.sum)} + println("BigIntRanges:") + println("Disabled #1") + println("Disabled #2") + numericBigIntRanges.drop(2).foreach{range => println(range.sum)} + } + +}
\ No newline at end of file diff --git a/test/files/run/t5230.check b/test/files/run/t5230.check new file mode 100644 index 0000000000..5db6ec9b38 --- /dev/null +++ b/test/files/run/t5230.check @@ -0,0 +1,2 @@ +2 +evaluated = null diff --git a/test/pending/run/t5230.scala b/test/files/run/t5230.scala index 5aab8f9290..5aab8f9290 100644 --- a/test/pending/run/t5230.scala +++ b/test/files/run/t5230.scala diff --git a/test/pending/run/reify_addressbook.check b/test/pending/run/reify_addressbook.check new file mode 100644 index 0000000000..4e12f87bdc --- /dev/null +++ b/test/pending/run/reify_addressbook.check @@ -0,0 +1,30 @@ +<html> + <head> + <title> + My Address Book + </title> + <style type="text/css"> table { border-right: 1px solid #cccccc; } + th { background-color: #cccccc; } + td { border-left: 1px solid #acacac; } + td { border-bottom: 1px solid #acacac; + </style> + </head> + <body> + <table cellspacing="0" cellpadding="2"> + <tr> + <th>Name</th> + <th>Age</th> + </tr> + <tr> + <td> Tom </td> + <td> 20 </td> + </tr><tr> + <td> Bob </td> + <td> 22 </td> + </tr><tr> + <td> James </td> + <td> 19 </td> + </tr> + </table> + </body> + </html> diff --git a/test/pending/run/reify_addressbook.scala b/test/pending/run/reify_addressbook.scala new file mode 100644 index 0000000000..225f26b75e --- /dev/null +++ b/test/pending/run/reify_addressbook.scala @@ -0,0 +1,71 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + case class Person(name: String, age: Int) + + /** An AddressBook takes a variable number of arguments + * which are accessed as a Sequence + */ + class AddressBook(a: Person*) { + private val people: List[Person] = a.toList + + /** Serialize to XHTML. Scala supports XML literals + * which may contain Scala expressions between braces, + * which are replaced by their evaluation + */ + def toXHTML = + <table cellpadding="2" cellspacing="0"> + <tr> + <th>Name</th> + <th>Age</th> + </tr> + { for (p <- people) yield + <tr> + <td> { p.name } </td> + <td> { p.age.toString() } </td> + </tr> + } + </table>; + } + + /** We introduce CSS using raw strings (between triple + * quotes). Raw strings may contain newlines and special + * characters (like \) are not interpreted. + */ + val header = + <head> + <title> + { "My Address Book" } + </title> + <style type="text/css"> { + """table { border-right: 1px solid #cccccc; } + th { background-color: #cccccc; } + td { border-left: 1px solid #acacac; } + td { border-bottom: 1px solid #acacac;"""} + </style> + </head>; + + val people = new AddressBook( + Person("Tom", 20), + Person("Bob", 22), + Person("James", 19)); + + val page = + <html> + { header } + <body> + { people.toXHTML } + </body> + </html>; + + println(page) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_brainf_ck.check b/test/pending/run/reify_brainf_ck.check new file mode 100644 index 0000000000..702bb18394 --- /dev/null +++ b/test/pending/run/reify_brainf_ck.check @@ -0,0 +1,4 @@ +---running--- +Hello World! + +---done--- diff --git a/test/pending/run/reify_brainf_ck.scala b/test/pending/run/reify_brainf_ck.scala new file mode 100644 index 0000000000..3bfb76c9ea --- /dev/null +++ b/test/pending/run/reify_brainf_ck.scala @@ -0,0 +1,85 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + import scala.annotation._ + + trait Func[T] { + val zero: T + def inc(t: T): T + def dec(t: T): T + def in: T + def out(t: T): Unit + } + + object ByteFunc extends Func[Byte] { + override val zero: Byte = 0 + override def inc(t: Byte) = ((t + 1) & 0xFF).toByte + override def dec(t: Byte) = ((t - 1) & 0xFF).toByte + override def in: Byte = readByte + override def out(t: Byte) { print(t.toChar) } + } + + case class Tape[T](left: List[T], cell: T, right: List[T])(implicit func: Func[T]) { + private def headOf(list:List[T]) = if (list.isEmpty) func.zero else list.head + private def tailOf(list:List[T]) = if (list.isEmpty) Nil else list.tail + def isZero = cell == func.zero + def execute(ch: Char) = (ch: @switch) match { + case '+' => copy(cell = func.inc(cell)) + case '-' => copy(cell = func.dec(cell)) + case '<' => Tape(tailOf(left), headOf(left), cell :: right) + case '>' => Tape(cell :: left, headOf(right), tailOf(right)) + case '.' => func.out(cell); this + case ',' => copy(cell = func.in) + case '[' | ']' => this + case _ => error("Unexpected token: " + ch) + } + } + + object Tape { + def empty[T](func: Func[T]) = Tape(Nil, func.zero, Nil)(func) + } + + class Brainfuck[T](func:Func[T]) { + + def execute(p: String) { + val prog = p.replaceAll("[^\\+\\-\\[\\]\\.\\,\\>\\<]", "") + + @tailrec def braceMatcher(pos: Int, stack: List[Int], o2c: Map[Int, Int]): Map[Int,Int] = + if(pos == prog.length) o2c else (prog(pos): @switch) match { + case '[' => braceMatcher(pos + 1, pos :: stack, o2c) + case ']' => braceMatcher(pos + 1, stack.tail, o2c + (stack.head -> pos)) + case _ => braceMatcher(pos + 1, stack, o2c) + } + + val open2close = braceMatcher(0, Nil, Map()) + val close2open = open2close.map(_.swap) + + @tailrec def ex(pos:Int, tape:Tape[T]): Unit = + if(pos < prog.length) ex((prog(pos): @switch) match { + case '[' if tape.isZero => open2close(pos) + case ']' if ! tape.isZero => close2open(pos) + case _ => pos + 1 + }, tape.execute(prog(pos))) + + println("---running---") + ex(0, Tape.empty(func)) + println("\n---done---") + } + } + + val bf = new Brainfuck(ByteFunc) + bf.execute(""">+++++++++[<++++++++>-]<.>+++++++[<++ + ++>-]<+.+++++++..+++.[-]>++++++++[<++++>-] + <.#>+++++++++++[<+++++>-]<.>++++++++[<++ + +>-]<.+++.------.--------.[-]>++++++++[<++++> + -]<+.[-]++++++++++.""") + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_callccinterpreter.check b/test/pending/run/reify_callccinterpreter.check new file mode 100644 index 0000000000..ef8fc121df --- /dev/null +++ b/test/pending/run/reify_callccinterpreter.check @@ -0,0 +1,3 @@ +42 +wrong +5 diff --git a/test/pending/run/reify_callccinterpreter.scala b/test/pending/run/reify_callccinterpreter.scala new file mode 100644 index 0000000000..c10f4f0b4e --- /dev/null +++ b/test/pending/run/reify_callccinterpreter.scala @@ -0,0 +1,94 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + type Answer = Value; + + /** + * A continuation monad. + */ + case class M[A](in: (A => Answer) => Answer) { + def bind[B](k: A => M[B]) = M[B](c => in (a => k(a) in c)) + def map[B](f: A => B): M[B] = bind(x => unitM(f(x))) + def flatMap[B](f: A => M[B]): M[B] = bind(f) + } + + def unitM[A](a: A) = M[A](c => c(a)) + + def id[A] = (x: A) => x + def showM(m: M[Value]): String = (m in id).toString() + + def callCC[A](h: (A => M[A]) => M[A]) = + M[A](c => h(a => M[A](d => c(a))) in c) + + type Name = String + + trait Term + case class Var(x: Name) extends Term + case class Con(n: Int) extends Term + case class Add(l: Term, r: Term) extends Term + case class Lam(x: Name, body: Term) extends Term + case class App(fun: Term, arg: Term) extends Term + case class Ccc(x: Name, t: Term) extends Term + + trait Value + case object Wrong extends Value { + override def toString() = "wrong" + } + case class Num(n: Int) extends Value { + override def toString() = n.toString() + } + case class Fun(f: Value => M[Value]) extends Value { + override def toString() = "<function>" + } + + type Environment = List[Pair[Name, Value]]; + + def lookup(x: Name, e: Environment): M[Value] = e match { + case List() => unitM(Wrong) + case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) + } + + def add(a: Value, b: Value): M[Value] = Pair(a, b) match { + case Pair(Num(m), Num(n)) => unitM(Num(m + n)) + case _ => unitM(Wrong) + } + + def apply(a: Value, b: Value): M[Value] = a match { + case Fun(k) => k(b) + case _ => unitM(Wrong) + } + + def interp(t: Term, e: Environment): M[Value] = t match { + case Var(x) => lookup(x, e) + case Con(n) => unitM(Num(n)) + case Add(l, r) => for (a <- interp(l, e); + b <- interp(r, e); + c <- add(a, b)) + yield c + case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e))) + case App(f, t) => for (a <- interp(f, e); + b <- interp(t, e); + c <- apply(a, b)) + yield c + case Ccc(x, t) => callCC(k => interp(t, Pair(x, Fun(k)) :: e)) + } + + def test(t: Term): String = showM(interp(t, List())) + + val term0 = App(Lam("x", Add(Var("x"), Var("x"))), Add(Con(10), Con(11))) + val term1 = App(Con(1), Con(2)) + val term2 = Add(Con(1), Ccc("k", Add(Con(2), App(Var("k"), Con(4))))) + + println(test(term0)) + println(test(term1)) + println(test(term2)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_complex.check b/test/pending/run/reify_complex.check new file mode 100644 index 0000000000..7df35e33a0 --- /dev/null +++ b/test/pending/run/reify_complex.check @@ -0,0 +1 @@ +3.0+4.0*i diff --git a/test/pending/run/reify_complex.scala b/test/pending/run/reify_complex.scala new file mode 100644 index 0000000000..aae4d558cf --- /dev/null +++ b/test/pending/run/reify_complex.scala @@ -0,0 +1,31 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + class Complex(val re: Double, val im: Double) { + def + (that: Complex) = + new Complex(re + that.re, im + that.im) + def - (that: Complex) = + new Complex(re - that.re, im - that.im) + def * (that: Complex) = + new Complex(re * that.re - im * that.im, + re * that.im + im * that.re) + def / (that: Complex) = { + val denom = that.re * that.re + that.im * that.im + new Complex((re * that.re + im * that.im) / denom, + (im * that.re - re * that.im) / denom) + } + override def toString = + re + (if (im < 0) "-" + (-im) else "+" + im) + "*i" + } + val x = new Complex(2, 1); val y = new Complex(1, 3) + println(x + y) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_csv.check b/test/pending/run/reify_csv.check new file mode 100644 index 0000000000..b56f4bb50b --- /dev/null +++ b/test/pending/run/reify_csv.check @@ -0,0 +1,10 @@ +List(phase name, id, description) +record(parser,1,parse source into ASTs, perform simple desugaring) +record(namer,2,resolve names, attach symbols to named trees) +record(packageobjects,3,load package objects) +record(typer,4,the meat and potatoes: type the trees) +record(superaccessors,5,add super accessors in traits and nested classes) +record(pickler,6,serialize symbol tables) +record(refchecks,7,reference/override checking, translate nested objects) +record(selectiveanf,8,) +record(liftcode,9,reify trees) diff --git a/test/pending/run/reify_csv.scala b/test/pending/run/reify_csv.scala new file mode 100644 index 0000000000..a05a3b55d4 --- /dev/null +++ b/test/pending/run/reify_csv.scala @@ -0,0 +1,42 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val csv = """ + | phase name; id; description + | parser; 1; parse source into ASTs, perform simple desugaring + | namer; 2; resolve names, attach symbols to named trees + |packageobjects; 3; load package objects + | typer; 4; the meat and potatoes: type the trees + |superaccessors; 5; add super accessors in traits and nested classes + | pickler; 6; serialize symbol tables + | refchecks; 7; reference/override checking, translate nested objects + | selectiveanf; 8; + | liftcode; 9; reify trees""".stripMargin.split("\n").map{_.trim()}.drop(1).toList + + val fields = csv.head.split(";").map{_.trim()}.toList + println(fields) + + val code = scala.reflect.Code.lift({ + object Csv { + case class record(`phase name`: String, id: String, description: String) + + object record { + def parse(lines: List[String]) = { + lines drop(1) map { line => line.split(";", -1).toList match { + case phase$whitespace$name :: id :: description :: _ => record(phase$whitespace$name.trim(), id.trim(), description.trim()) + case _ => throw new Exception("format error") + }} + } + } + } + + Csv.record.parse(csv) foreach println + }) + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_extendbuiltins.check b/test/pending/run/reify_extendbuiltins.check new file mode 100644 index 0000000000..a48033a30d --- /dev/null +++ b/test/pending/run/reify_extendbuiltins.check @@ -0,0 +1 @@ +10! = 3628800 diff --git a/test/pending/run/reify_extendbuiltins.scala b/test/pending/run/reify_extendbuiltins.scala new file mode 100644 index 0000000000..57acd699ff --- /dev/null +++ b/test/pending/run/reify_extendbuiltins.scala @@ -0,0 +1,21 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + def fact(n: Int): BigInt = + if (n == 0) 1 else fact(n-1) * n + class Factorizer(n: Int) { + def ! = fact(n) + } + implicit def int2fact(n: Int) = new Factorizer(n) + + println("10! = " + (10!)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_fors.check b/test/pending/run/reify_fors.check new file mode 100644 index 0000000000..eefddedc20 --- /dev/null +++ b/test/pending/run/reify_fors.check @@ -0,0 +1,5 @@ +Persons over 20: John Richard +divisors(34) = List(1, 2, 17, 34) +findNums(15) = (4,1) (5,2) (6,1) (7,4) (8,3) (8,5) (9,2) (9,4) (10,1) (10,3) (10,7) (11,2) (11,6) (11,8) (12,1) (12,5) (12,7) (13,4) (13,6) (13,10) (14,3) (14,5) (14,9) +average(List(3.5, 5.0, 4.5)) = 4.333333333333333 +scalProd(List(3.5, 5.0, 4.5), List(2.0, 1.0, 3.0)) = 25.5 diff --git a/test/pending/run/reify_fors.scala b/test/pending/run/reify_fors.scala new file mode 100644 index 0000000000..f3556514a9 --- /dev/null +++ b/test/pending/run/reify_fors.scala @@ -0,0 +1,107 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + object Persons { + /** A list of persons. To create a list, we use Predef.List + * which takes a variable number of arguments and constructs + * a list out of them. + */ + val persons = List( + new Person("Bob", 17), + new Person("John", 40), + new Person("Richard", 68) + ) + + /** A Person class. 'val' constructor parameters become + * public members of the class. + */ + class Person(val name: String, val age: Int) + + /** Return an iterator over persons that are older than 20. + */ + def olderThan20(xs: Seq[Person]): Iterator[String] = + olderThan20(xs.elements) + + /** Return an iterator over persons older than 20, given + * an iterator over persons. + */ + def olderThan20(xs: Iterator[Person]): Iterator[String] = { + + // The first expression is called a 'generator' and makes + // 'p' take values from 'xs'. The second expression is + // called a 'filter' and it is a boolean expression which + // selects only persons older than 20. There can be more than + // one generator and filter. The 'yield' expression is evaluated + // for each 'p' which satisfies the filters and used to assemble + // the resulting iterator + for (p <- xs if p.age > 20) yield p.name + } + } + + /** Some functions over lists of numbers which demonstrate + * the use of for comprehensions. + */ + object Numeric { + + /** Return the divisors of n. */ + def divisors(n: Int): List[Int] = + for (i <- List.range(1, n+1) if n % i == 0) yield i + + /** Is 'n' a prime number? */ + def isPrime(n: Int) = divisors(n).length == 2 + + /** Return pairs of numbers whose sum is prime. */ + def findNums(n: Int): Iterable[(Int, Int)] = { + + // a for comprehension using two generators + for (i <- 1 until n; + j <- 1 until (i-1); + if isPrime(i + j)) yield (i, j) + } + + /** Return the sum of the elements of 'xs'. */ + def sum(xs: List[Double]): Double = + xs.foldLeft(0.0) { (x, y) => x + y } + + /** Return the sum of pairwise product of the two lists. */ + def scalProd(xs: List[Double], ys: List[Double]) = + sum(for((x, y) <- xs zip ys) yield x * y); + + /** Remove duplicate elements in 'xs'. */ + def removeDuplicates[A](xs: List[A]): List[A] = + if (xs.isEmpty) + xs + else + xs.head :: removeDuplicates(for (x <- xs.tail if x != xs.head) yield x) + } + + // import all members of object 'persons' in the current scope + import Persons._ + + print("Persons over 20:") + olderThan20(persons) foreach { x => print(" " + x) } + println + + import Numeric._ + + println("divisors(34) = " + divisors(34)) + + print("findNums(15) =") + findNums(15) foreach { x => print(" " + x) } + println + + val xs = List(3.5, 5.0, 4.5) + println("average(" + xs + ") = " + sum(xs) / xs.length) + + val ys = List(2.0, 1.0, 3.0) + println("scalProd(" + xs + ", " + ys +") = " + scalProd(xs, ys)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_gadts.check b/test/pending/run/reify_gadts.check new file mode 100644 index 0000000000..d81cc0710e --- /dev/null +++ b/test/pending/run/reify_gadts.check @@ -0,0 +1 @@ +42 diff --git a/test/pending/run/reify_gadts.scala b/test/pending/run/reify_gadts.scala new file mode 100644 index 0000000000..7077de735c --- /dev/null +++ b/test/pending/run/reify_gadts.scala @@ -0,0 +1,45 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + /* The syntax tree of a toy language */ + abstract class Term[T] + + /* An integer literal */ + case class Lit(x: Int) extends Term[Int] + + /* Successor of a number */ + case class Succ(t: Term[Int]) extends Term[Int] + + /* Is 't' equal to zero? */ + case class IsZero(t: Term[Int]) extends Term[Boolean] + + /* An 'if' expression. */ + case class If[T](c: Term[Boolean], + t1: Term[T], + t2: Term[T]) extends Term[T] + + /** A type-safe eval function. The right-hand sides can + * make use of the fact that 'T' is a more precise type, + * constraint by the pattern type. + */ + def eval[T](t: Term[T]): T = t match { + case Lit(n) => n + + // the right hand side makes use of the fact + // that T = Int and so it can use '+' + case Succ(u) => eval(u) + 1 + case IsZero(u) => eval(u) == 0 + case If(c, u1, u2) => eval(if (eval(c)) u1 else u2) + } + println( + eval(If(IsZero(Lit(1)), Lit(41), Succ(Lit(41))))) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_implicits.check b/test/pending/run/reify_implicits.check new file mode 100644 index 0000000000..e3aeb20f6b --- /dev/null +++ b/test/pending/run/reify_implicits.check @@ -0,0 +1 @@ +x = List(1, 2, 3, 4) diff --git a/test/pending/run/reify_implicits.scala b/test/pending/run/reify_implicits.scala new file mode 100644 index 0000000000..a15cef9c97 --- /dev/null +++ b/test/pending/run/reify_implicits.scala @@ -0,0 +1,21 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + implicit def arrayWrapper[A : ClassManifest](x: Array[A]) = + new { + def sort(p: (A, A) => Boolean) = { + util.Sorting.stableSort(x, p); x + } + } + val x = Array(2, 3, 1, 4) + println("x = "+ x.sort((x: Int, y: Int) => x < y).toList) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_lazyevaluation.check b/test/pending/run/reify_lazyevaluation.check new file mode 100644 index 0000000000..1c7f96cd96 --- /dev/null +++ b/test/pending/run/reify_lazyevaluation.check @@ -0,0 +1,8 @@ +s = Susp(?) +evaluating... +s() = 3 +s = Susp(3) +2 + s = 5 +sl2 = Susp(?) +sl2() = Some(3) +sl2 = Susp(Some(3)) diff --git a/test/pending/run/reify_lazyevaluation.scala b/test/pending/run/reify_lazyevaluation.scala new file mode 100644 index 0000000000..f38af76751 --- /dev/null +++ b/test/pending/run/reify_lazyevaluation.scala @@ -0,0 +1,65 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + object lazyLib { + + /** Delay the evaluation of an expression until it is needed. */ + def delay[A](value: => A): Susp[A] = new SuspImpl[A](value) + + /** Get the value of a delayed expression. */ + implicit def force[A](s: Susp[A]): A = s() + + /** + * Data type of suspended computations. (The name froms from ML.) + */ + abstract class Susp[+A] extends Function0[A] + + /** + * Implementation of suspended computations, separated from the + * abstract class so that the type parameter can be invariant. + */ + class SuspImpl[A](lazyValue: => A) extends Susp[A] { + private var maybeValue: Option[A] = None + + override def apply() = maybeValue match { + case None => + val value = lazyValue + maybeValue = Some(value) + value + case Some(value) => + value + } + + override def toString() = maybeValue match { + case None => "Susp(?)" + case Some(value) => "Susp(" + value + ")" + } + } + } + + import lazyLib._ + + val s: Susp[Int] = delay { println("evaluating..."); 3 } + + println("s = " + s) // show that s is unevaluated + println("s() = " + s()) // evaluate s + println("s = " + s) // show that the value is saved + println("2 + s = " + (2 + s)) // implicit call to force() + + val sl = delay { Some(3) } + val sl1: Susp[Some[Int]] = sl + val sl2: Susp[Option[Int]] = sl1 // the type is covariant + + println("sl2 = " + sl2) + println("sl2() = " + sl2()) + println("sl2 = " + sl2) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_maps.check b/test/pending/run/reify_maps.check new file mode 100644 index 0000000000..08cbbb1359 --- /dev/null +++ b/test/pending/run/reify_maps.check @@ -0,0 +1,4 @@ +red has code: 16711680 +Unknown color: green +Unknown color: blue +turquoise has code: 65535 diff --git a/test/pending/run/reify_maps.scala b/test/pending/run/reify_maps.scala new file mode 100644 index 0000000000..589b28d049 --- /dev/null +++ b/test/pending/run/reify_maps.scala @@ -0,0 +1,26 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + val colors = Map("red" -> 0xFF0000, + "turquoise" -> 0x00FFFF, + "black" -> 0x000000, + "orange" -> 0xFF8040, + "brown" -> 0x804000) + for (name <- List("red", "green", "blue", "turquoise")) println( + colors.get(name) match { + case Some(code) => + name + " has code: " + code + case None => + "Unknown color: " + name + } + ) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_properties.check b/test/pending/run/reify_properties.check new file mode 100644 index 0000000000..d769bea4b0 --- /dev/null +++ b/test/pending/run/reify_properties.check @@ -0,0 +1,2 @@ +user1: MR. ROBERT <noname> +user2: MR. BOB KUZ diff --git a/test/pending/run/reify_properties.scala b/test/pending/run/reify_properties.scala new file mode 100644 index 0000000000..2115a96715 --- /dev/null +++ b/test/pending/run/reify_properties.scala @@ -0,0 +1,63 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + /** A mutable property whose getter and setter may be customized. */ + case class Property[T](init: T) { + private var value: T = init + + /** The getter function, defaults to identity. */ + private var setter: T => T = identity[T] + + /** The setter function, defaults to identity. */ + private var getter: T => T = identity[T] + + /** Retrive the value held in this property. */ + def apply(): T = getter(value) + + /** Update the value held in this property, through the setter. */ + def update(newValue: T) = value = setter(newValue) + + /** Change the getter. */ + def get(newGetter: T => T) = { getter = newGetter; this } + + /** Change the setter */ + def set(newSetter: T => T) = { setter = newSetter; this } + } + + class User { + // Create a property with custom getter and setter + val firstname = Property("") + .get { v => v.toUpperCase() } + .set { v => "Mr. " + v } + val lastname = Property("<noname>") + + /** Scala provides syntactic sugar for calling 'apply'. Simply + * adding a list of arguments between parenthesis (in this case, + * an empty list) is translated to a call to 'apply' with those + * arguments. + */ + override def toString() = firstname() + " " + lastname() + } + + val user1 = new User + + // Syntactic sugar for 'update': an assignment is translated to a + // call to method 'update' + user1.firstname() = "Robert" + + val user2 = new User + user2.firstname() = "bob" + user2.lastname() = "KUZ" + + println("user1: " + user1) + println("user2: " + user2) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_simpleinterpreter.check b/test/pending/run/reify_simpleinterpreter.check new file mode 100644 index 0000000000..4344dc9009 --- /dev/null +++ b/test/pending/run/reify_simpleinterpreter.check @@ -0,0 +1,2 @@ +42 +wrong diff --git a/test/pending/run/reify_simpleinterpreter.scala b/test/pending/run/reify_simpleinterpreter.scala new file mode 100644 index 0000000000..b39f5583bb --- /dev/null +++ b/test/pending/run/reify_simpleinterpreter.scala @@ -0,0 +1,82 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + case class M[A](value: A) { + def bind[B](k: A => M[B]): M[B] = k(value) + def map[B](f: A => B): M[B] = bind(x => unitM(f(x))) + def flatMap[B](f: A => M[B]): M[B] = bind(f) + } + + def unitM[A](a: A): M[A] = M(a) + + def showM(m: M[Value]): String = m.value.toString(); + + type Name = String + + trait Term; + case class Var(x: Name) extends Term + case class Con(n: Int) extends Term + case class Add(l: Term, r: Term) extends Term + case class Lam(x: Name, body: Term) extends Term + case class App(fun: Term, arg: Term) extends Term + + trait Value + case object Wrong extends Value { + override def toString() = "wrong" + } + case class Num(n: Int) extends Value { + override def toString() = n.toString() + } + case class Fun(f: Value => M[Value]) extends Value { + override def toString() = "<function>" + } + + type Environment = List[Pair[Name, Value]] + + def lookup(x: Name, e: Environment): M[Value] = e match { + case List() => unitM(Wrong) + case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1) + } + + def add(a: Value, b: Value): M[Value] = Pair(a, b) match { + case Pair(Num(m), Num(n)) => unitM(Num(m + n)) + case _ => unitM(Wrong) + } + + def apply(a: Value, b: Value): M[Value] = a match { + case Fun(k) => k(b) + case _ => unitM(Wrong) + } + + def interp(t: Term, e: Environment): M[Value] = t match { + case Var(x) => lookup(x, e) + case Con(n) => unitM(Num(n)) + case Add(l, r) => for (a <- interp(l, e); + b <- interp(r, e); + c <- add(a, b)) + yield c + case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e))) + case App(f, t) => for (a <- interp(f, e); + b <- interp(t, e); + c <- apply(a, b)) + yield c + } + + def test(t: Term): String = + showM(interp(t, List())) + + val term0 = App(Lam("x", Add(Var("x"), Var("x"))), Add(Con(10), Con(11))) + val term1 = App(Con(1), Con(2)) + + println(test(term0)) + println(test(term1)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_sort.check b/test/pending/run/reify_sort.check new file mode 100644 index 0000000000..375536cc29 --- /dev/null +++ b/test/pending/run/reify_sort.check @@ -0,0 +1,2 @@ +[6,2,8,5,1] +[1,2,5,6,8] diff --git a/test/pending/run/reify_sort.scala b/test/pending/run/reify_sort.scala new file mode 100644 index 0000000000..42991fe5d2 --- /dev/null +++ b/test/pending/run/reify_sort.scala @@ -0,0 +1,57 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + /** Nested methods can use and even update everything + * visible in their scope (including local variables or + * arguments of enclosing methods). + */ + def sort(a: Array[Int]) { + + def swap(i: Int, j: Int) { + val t = a(i); a(i) = a(j); a(j) = t + } + + def sort1(l: Int, r: Int) { + val pivot = a((l + r) / 2) + var i = l + var j = r + while (i <= j) { + while (a(i) < pivot) i += 1 + while (a(j) > pivot) j -= 1 + if (i <= j) { + swap(i, j) + i += 1 + j -= 1 + } + } + if (l < j) sort1(l, j) + if (j < r) sort1(i, r) + } + + if (a.length > 0) + sort1(0, a.length - 1) + } + + def println(ar: Array[Int]) { + def print1 = { + def iter(i: Int): String = + ar(i) + (if (i < ar.length-1) "," + iter(i+1) else "") + if (ar.length == 0) "" else iter(0) + } + Console.println("[" + print1 + "]") + } + + val ar = Array(6, 2, 8, 5, 1) + println(ar) + sort(ar) + println(ar) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_sort1.check b/test/pending/run/reify_sort1.check new file mode 100644 index 0000000000..0d30805141 --- /dev/null +++ b/test/pending/run/reify_sort1.check @@ -0,0 +1,2 @@ +List(6, 2, 8, 5, 1) +List(1, 2, 5, 6, 8) diff --git a/test/pending/run/reify_sort1.scala b/test/pending/run/reify_sort1.scala new file mode 100644 index 0000000000..42f4c824a5 --- /dev/null +++ b/test/pending/run/reify_sort1.scala @@ -0,0 +1,27 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + def sort(a: List[Int]): List[Int] = { + if (a.length < 2) + a + else { + val pivot = a(a.length / 2) + sort(a.filter(_ < pivot)) ::: + a.filter(_ == pivot) ::: + sort(a.filter(_ > pivot)) + } + } + + val xs = List(6, 2, 8, 5, 1) + println(xs) + println(sort(xs)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/reify_timeofday.check b/test/pending/run/reify_timeofday.check new file mode 100644 index 0000000000..3fd3b76a62 --- /dev/null +++ b/test/pending/run/reify_timeofday.check @@ -0,0 +1 @@ +DateError diff --git a/test/pending/run/reify_timeofday.scala b/test/pending/run/reify_timeofday.scala new file mode 100644 index 0000000000..6bd11b0d30 --- /dev/null +++ b/test/pending/run/reify_timeofday.scala @@ -0,0 +1,48 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + class DateError extends Exception + + /** Simulating properties in Scala + * (example 4.2.1 in ScalaReference.pdf) + */ + class TimeOfDayVar { + private var h, m, s: Int = 0 + + def hours = h + + /** A method 'ident_=' is a setter for 'ident'. 'code.ident = ...' will + * be translated to a call to 'ident_=' + */ + def hours_= (h: Int) = + if (0 <= h && h < 24) this.h = h + else throw new DateError() + + def minutes = m + def minutes_= (m: Int) = + if (0 <= m && m < 60) this.m = m + else throw new DateError() + + def seconds = s + def seconds_= (s: Int) = + if (0 <= s && s < 60) this.s = s + else throw new DateError() + } + + val d = new TimeOfDayVar + d.hours = 8; d.minutes = 30; d.seconds = 0 + try { d.hours = 25 // throws a DateError exception + } catch { + case de: DateError => println("DateError") + case e: Exception => println("Exception") + } + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5224.check b/test/pending/run/t5224.check new file mode 100644 index 0000000000..2b920773c0 --- /dev/null +++ b/test/pending/run/t5224.check @@ -0,0 +1,9 @@ +{ + @serializable class C extends Object with ScalaObject { + def <init>() = { + super.<init>(); + () + } + }; + () +}
\ No newline at end of file diff --git a/test/pending/run/t5224.scala b/test/pending/run/t5224.scala new file mode 100644 index 0000000000..865ce4bfe9 --- /dev/null +++ b/test/pending/run/t5224.scala @@ -0,0 +1,8 @@ +import scala.reflect._ +import scala.reflect.api._ + +object Test extends App { + println(scala.reflect.Code.lift{ + @serializable class C + }.tree.toString) +}
\ No newline at end of file diff --git a/test/pending/run/t5225_1.check b/test/pending/run/t5225_1.check new file mode 100644 index 0000000000..b29cd9c365 --- /dev/null +++ b/test/pending/run/t5225_1.check @@ -0,0 +1,4 @@ +{ + @transient @volatile var x: Int = 2; + () +}
\ No newline at end of file diff --git a/test/pending/run/t5225_1.scala b/test/pending/run/t5225_1.scala new file mode 100644 index 0000000000..454502e810 --- /dev/null +++ b/test/pending/run/t5225_1.scala @@ -0,0 +1,8 @@ +import scala.reflect._ +import scala.reflect.api._ + +object Test extends App { + println(scala.reflect.Code.lift{ + @transient @volatile var x = 2 + }.tree.toString) +}
\ No newline at end of file diff --git a/test/pending/run/t5225_2.check b/test/pending/run/t5225_2.check new file mode 100644 index 0000000000..88972fd27f --- /dev/null +++ b/test/pending/run/t5225_2.check @@ -0,0 +1,4 @@ +{ + def foo(@cloneable x: Int): String = ""; + () +} diff --git a/test/pending/run/t5225_2.scala b/test/pending/run/t5225_2.scala new file mode 100644 index 0000000000..82bad0f353 --- /dev/null +++ b/test/pending/run/t5225_2.scala @@ -0,0 +1,8 @@ +import scala.reflect._ +import scala.reflect.api._ + +object Test extends App { + println(scala.reflect.Code.lift{ + def foo(@cloneable x: Int) = "" + }.tree.toString) +}
\ No newline at end of file diff --git a/test/pending/run/t5229_1.check b/test/pending/run/t5229_1.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/pending/run/t5229_1.check diff --git a/test/pending/run/t5229_1.scala b/test/pending/run/t5229_1.scala new file mode 100644 index 0000000000..1d7bf0590b --- /dev/null +++ b/test/pending/run/t5229_1.scala @@ -0,0 +1,14 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + object C + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5229_1_nolift.scala b/test/pending/run/t5229_1_nolift.scala new file mode 100644 index 0000000000..33855d2e4f --- /dev/null +++ b/test/pending/run/t5229_1_nolift.scala @@ -0,0 +1 @@ +object C diff --git a/test/pending/run/t5229_2.check b/test/pending/run/t5229_2.check new file mode 100644 index 0000000000..5db6ec9b38 --- /dev/null +++ b/test/pending/run/t5229_2.check @@ -0,0 +1,2 @@ +2 +evaluated = null diff --git a/test/pending/run/t5229_2.scala b/test/pending/run/t5229_2.scala new file mode 100644 index 0000000000..67be7328a6 --- /dev/null +++ b/test/pending/run/t5229_2.scala @@ -0,0 +1,19 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + object C { + val x = 2 + } + + println(C.x) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + val evaluated = toolbox.runExpr(ttree) + println("evaluated = " + evaluated) +} diff --git a/test/pending/run/t5230.check b/test/pending/run/t5230.check deleted file mode 100644 index 5ef4ff4d04..0000000000 --- a/test/pending/run/t5230.check +++ /dev/null @@ -1 +0,0 @@ -evaluated = 2 diff --git a/test/pending/run/t5266_1.check b/test/pending/run/t5266_1.check new file mode 100644 index 0000000000..3feac16a0b --- /dev/null +++ b/test/pending/run/t5266_1.check @@ -0,0 +1,2 @@ +2 +evaluated = null
\ No newline at end of file diff --git a/test/pending/run/t5266_1.scala b/test/pending/run/t5266_1.scala new file mode 100644 index 0000000000..06a81a04ea --- /dev/null +++ b/test/pending/run/t5266_1.scala @@ -0,0 +1,23 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + def x = 2 + println(x) + }; + + val settings = new Settings + settings.debug.value = true + settings.Xshowtrees.value = true + settings.Xprint.value = List("typer") + settings.printtypes.value = true + settings.Ytyperdebug.value = true + + val reporter = new ConsoleReporter(settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + val evaluated = toolbox.runExpr(ttree) + println("evaluated = " + evaluated) +}
\ No newline at end of file diff --git a/test/pending/run/t5266_2.check b/test/pending/run/t5266_2.check new file mode 100644 index 0000000000..3feac16a0b --- /dev/null +++ b/test/pending/run/t5266_2.check @@ -0,0 +1,2 @@ +2 +evaluated = null
\ No newline at end of file diff --git a/test/pending/run/t5266_2.scala b/test/pending/run/t5266_2.scala new file mode 100644 index 0000000000..cd841da021 --- /dev/null +++ b/test/pending/run/t5266_2.scala @@ -0,0 +1,17 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + def x = 2 + def y = x + println(y) + }; + + val reporter = new ConsoleReporter(settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + val evaluated = toolbox.runExpr(ttree) + println("evaluated = " + evaluated) +} diff --git a/test/pending/run/t5269.check b/test/pending/run/t5269.check new file mode 100644 index 0000000000..0cfbf08886 --- /dev/null +++ b/test/pending/run/t5269.check @@ -0,0 +1 @@ +2 diff --git a/test/pending/run/t5269.scala b/test/pending/run/t5269.scala new file mode 100644 index 0000000000..a30509f3fe --- /dev/null +++ b/test/pending/run/t5269.scala @@ -0,0 +1,22 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + trait Z { + val z = 2 + } + + class X extends Z { + def println() = Predef.println(z) + } + + new X().println() + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5270.check b/test/pending/run/t5270.check new file mode 100644 index 0000000000..08839f6bb2 --- /dev/null +++ b/test/pending/run/t5270.check @@ -0,0 +1 @@ +200 diff --git a/test/pending/run/t5270.scala b/test/pending/run/t5270.scala new file mode 100644 index 0000000000..10f79790b0 --- /dev/null +++ b/test/pending/run/t5270.scala @@ -0,0 +1,26 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + class Y { + def y = 100 + } + + trait Z { this: Y => + val z = 2 * y + } + + class X extends Y with Z { + def println() = Predef.println(z) + } + + new X().println() + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5271_1.check b/test/pending/run/t5271_1.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/pending/run/t5271_1.check diff --git a/test/pending/run/t5271_1.scala b/test/pending/run/t5271_1.scala new file mode 100644 index 0000000000..5f10e64528 --- /dev/null +++ b/test/pending/run/t5271_1.scala @@ -0,0 +1,14 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + case class C(foo: Int, bar: Int) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5271_2.check b/test/pending/run/t5271_2.check new file mode 100644 index 0000000000..b8626c4cff --- /dev/null +++ b/test/pending/run/t5271_2.check @@ -0,0 +1 @@ +4 diff --git a/test/pending/run/t5271_2.scala b/test/pending/run/t5271_2.scala new file mode 100644 index 0000000000..71967c04ed --- /dev/null +++ b/test/pending/run/t5271_2.scala @@ -0,0 +1,16 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + case class C(foo: Int, bar: Int) + val c = C(2, 2) + println(c.foo * c.bar) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5272.check b/test/pending/run/t5272.check new file mode 100644 index 0000000000..dcf02b2fb6 --- /dev/null +++ b/test/pending/run/t5272.check @@ -0,0 +1 @@ +okay diff --git a/test/pending/run/t5272.scala b/test/pending/run/t5272.scala new file mode 100644 index 0000000000..3f44d05fb3 --- /dev/null +++ b/test/pending/run/t5272.scala @@ -0,0 +1,17 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + 2 match { + case 2 => println("okay") + case _ => println("not okay") + } + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5273_1.check b/test/pending/run/t5273_1.check new file mode 100644 index 0000000000..c551774ca5 --- /dev/null +++ b/test/pending/run/t5273_1.check @@ -0,0 +1 @@ +name = American Dollar, shortname = USD, value = 2,8567 diff --git a/test/pending/run/t5273_1.scala b/test/pending/run/t5273_1.scala new file mode 100644 index 0000000000..8b75084463 --- /dev/null +++ b/test/pending/run/t5273_1.scala @@ -0,0 +1,16 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + val RegexParser = """(.*) \d+([A-Z]+) \| (.*) \|.*""".r + val RegexParser(name, shortname, value) = "American Dollar 1USD | 2,8567 | sometext" + println("name = %s, shortname = %s, value = %s".format(name, shortname, value)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5273_2.check b/test/pending/run/t5273_2.check new file mode 100644 index 0000000000..0cfbf08886 --- /dev/null +++ b/test/pending/run/t5273_2.check @@ -0,0 +1 @@ +2 diff --git a/test/pending/run/t5273_2.scala b/test/pending/run/t5273_2.scala new file mode 100644 index 0000000000..1175881c9f --- /dev/null +++ b/test/pending/run/t5273_2.scala @@ -0,0 +1,17 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + List(1, 2, 3) match { + case foo :: bar :: _ => println(foo * bar) + case _ => println("this is getting out of hand!") + } + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5274_1.check b/test/pending/run/t5274_1.check new file mode 100644 index 0000000000..fca8bc3d3e --- /dev/null +++ b/test/pending/run/t5274_1.check @@ -0,0 +1,3 @@ +50! = 30414093201713378043612608166064768844377641568960512000000000000 +49! = 608281864034267560872252163321295376887552831379210240000000000 +50!/49! = 50 diff --git a/test/pending/run/t5274_1.scala b/test/pending/run/t5274_1.scala new file mode 100644 index 0000000000..c501172518 --- /dev/null +++ b/test/pending/run/t5274_1.scala @@ -0,0 +1,20 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + def factorial(n: BigInt): BigInt = + if (n == 0) 1 else n * factorial(n-1) + + val f50 = factorial(50); val f49 = factorial(49) + println("50! = " + f50) + println("49! = " + f49) + println("50!/49! = " + (f50 / f49)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5274_2.check b/test/pending/run/t5274_2.check new file mode 100644 index 0000000000..375536cc29 --- /dev/null +++ b/test/pending/run/t5274_2.check @@ -0,0 +1,2 @@ +[6,2,8,5,1] +[1,2,5,6,8] diff --git a/test/pending/run/t5274_2.scala b/test/pending/run/t5274_2.scala new file mode 100644 index 0000000000..42991fe5d2 --- /dev/null +++ b/test/pending/run/t5274_2.scala @@ -0,0 +1,57 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + /** Nested methods can use and even update everything + * visible in their scope (including local variables or + * arguments of enclosing methods). + */ + def sort(a: Array[Int]) { + + def swap(i: Int, j: Int) { + val t = a(i); a(i) = a(j); a(j) = t + } + + def sort1(l: Int, r: Int) { + val pivot = a((l + r) / 2) + var i = l + var j = r + while (i <= j) { + while (a(i) < pivot) i += 1 + while (a(j) > pivot) j -= 1 + if (i <= j) { + swap(i, j) + i += 1 + j -= 1 + } + } + if (l < j) sort1(l, j) + if (j < r) sort1(i, r) + } + + if (a.length > 0) + sort1(0, a.length - 1) + } + + def println(ar: Array[Int]) { + def print1 = { + def iter(i: Int): String = + ar(i) + (if (i < ar.length-1) "," + iter(i+1) else "") + if (ar.length == 0) "" else iter(0) + } + Console.println("[" + print1 + "]") + } + + val ar = Array(6, 2, 8, 5, 1) + println(ar) + sort(ar) + println(ar) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5275.check b/test/pending/run/t5275.check new file mode 100644 index 0000000000..0cfbf08886 --- /dev/null +++ b/test/pending/run/t5275.check @@ -0,0 +1 @@ +2 diff --git a/test/pending/run/t5275.scala b/test/pending/run/t5275.scala new file mode 100644 index 0000000000..d419834ded --- /dev/null +++ b/test/pending/run/t5275.scala @@ -0,0 +1,15 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + class C(val foo: Int) + println(new C(2).foo) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5276.check b/test/pending/run/t5276.check new file mode 100644 index 0000000000..0cfbf08886 --- /dev/null +++ b/test/pending/run/t5276.check @@ -0,0 +1 @@ +2 diff --git a/test/pending/run/t5276.scala b/test/pending/run/t5276.scala new file mode 100644 index 0000000000..432fdb91e4 --- /dev/null +++ b/test/pending/run/t5276.scala @@ -0,0 +1,15 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + lazy x = 2 + println(x) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5277_1.check b/test/pending/run/t5277_1.check new file mode 100644 index 0000000000..a48033a30d --- /dev/null +++ b/test/pending/run/t5277_1.check @@ -0,0 +1 @@ +10! = 3628800 diff --git a/test/pending/run/t5277_1.scala b/test/pending/run/t5277_1.scala new file mode 100644 index 0000000000..57acd699ff --- /dev/null +++ b/test/pending/run/t5277_1.scala @@ -0,0 +1,21 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + def fact(n: Int): BigInt = + if (n == 0) 1 else fact(n-1) * n + class Factorizer(n: Int) { + def ! = fact(n) + } + implicit def int2fact(n: Int) = new Factorizer(n) + + println("10! = " + (10!)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5277_2.check b/test/pending/run/t5277_2.check new file mode 100644 index 0000000000..5f1d0ecea5 --- /dev/null +++ b/test/pending/run/t5277_2.check @@ -0,0 +1,2 @@ +2 +1 diff --git a/test/pending/run/t5277_2.scala b/test/pending/run/t5277_2.scala new file mode 100644 index 0000000000..67b6b000bc --- /dev/null +++ b/test/pending/run/t5277_2.scala @@ -0,0 +1,18 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + def p(implicit i: Int) = print(i) + implicit val v = 2 + + println(p) + println(p(1)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/pending/run/t5279.check b/test/pending/run/t5279.check new file mode 100644 index 0000000000..f599e28b8a --- /dev/null +++ b/test/pending/run/t5279.check @@ -0,0 +1 @@ +10 diff --git a/test/pending/run/t5279.scala b/test/pending/run/t5279.scala new file mode 100644 index 0000000000..39e7dd2c66 --- /dev/null +++ b/test/pending/run/t5279.scala @@ -0,0 +1,14 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + println(new Integer(10)) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} |