migrate to strict scalac options

- no procedure syntax
- no value discard
- no view bounds
- no implicit numeric widen
- remove unused imports

magnet pattern relies on adapted args, so can’t disable that

Author: dwhjames

build.sbt

@@ -9,7 +9,24 @@ scalaVersion in ThisBuild := "2.11.6"
 
 crossScalaVersions in ThisBuild := Seq("2.10.5", "2.11.6")
 
-scalacOptions in ThisBuild ++= Seq("-feature", "-deprecation", "-unchecked")
+scalacOptions in ThisBuild ++= Seq(
+    "-deprecation",
+    "-encoding", "UTF-8",
+    "-feature",
+    "-unchecked",
+    "-Xfatal-warnings",
+    "-Xfuture",
+    //"-Xlint",
+    //"-Yno-adapted-args",
+    "-Ywarn-dead-code",
+    "-Ywarn-numeric-widen",
+    "-Ywarn-value-discard"
+  )
+
+scalacOptions in ThisBuild ++= (
+    if (scalaVersion.value.startsWith("2.10")) Nil
+    else List("-Ywarn-unused-import")
+  )
 
 shellPrompt in ThisBuild := CustomShellPrompt.customPrompt
 

integration/src/it/scala/dynamodb/DynamoDBClient.scala

@@ -17,8 +17,6 @@
 
 package com.github.dwhjames.awswrap.dynamodb
 
-import scala.collection.JavaConverters._
-import scala.concurrent._
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 
@@ -48,34 +46,35 @@ trait DynamoDBClient
 
   val tableNames: Seq[String]
 
-  override def beforeAll() {
+  override def beforeAll(): Unit = {
     deleteAllSpecifiedTables()
 
     super.beforeAll()
   }
 
-  override def afterAll() {
+  override def afterAll(): Unit = {
     try {
       super.afterAll()
     } finally {
       deleteAllSpecifiedTables()
     }
   }
 
-  private def deleteAllSpecifiedTables() {
+  private def deleteAllSpecifiedTables(): Unit = {
     tableNames foreach tryDeleteTable
 
     tableNames foreach awaitTableDeletion
   }
 
-  def tryDeleteTable(tableName: String) {
+  def tryDeleteTable(tableName: String): Unit = {
     logger.info(s"Deleting $tableName table")
     await {
       client.deleteTable(tableName) recover { case e: ResourceNotFoundException => () }
     }
+    ()
   }
 
-  def awaitTableDeletion(tableName: String) {
+  def awaitTableDeletion(tableName: String): Unit = {
     logger.info(s"Waiting for $tableName table to be deleted.")
 
     val deadline = 10.minutes.fromNow
@@ -96,11 +95,12 @@ trait DynamoDBClient
     throw new RuntimeException(s"Timed out waiting for $tableName table to be deleted.")
   }
 
-  def tryCreateTable(createTableRequest: CreateTableRequest) {
+  def tryCreateTable(createTableRequest: CreateTableRequest): Unit = {
     logger.info(s"Creating ${createTableRequest.getTableName()} table")
     await {
       client.createTable(createTableRequest)
     }
+    ()
   }
 
   def awaitTableCreation(tableName: String): TableDescription = {

integration/src/it/scala/dynamodb/ReadsOnHashKeyTablesSpec.scala

@@ -18,15 +18,12 @@
 package com.github.dwhjames.awswrap.dynamodb
 
 import scala.collection.JavaConverters._
-import scala.concurrent._
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 
 import org.scalatest.{ FlatSpec, BeforeAndAfterAll, Matchers }
 
 import com.amazonaws.AmazonClientException
-import com.amazonaws.services.dynamodbv2._
-import com.amazonaws.services.dynamodbv2.model._
 
 
 class ReadsOnHashKeyTableSpec
@@ -40,7 +37,7 @@ class ReadsOnHashKeyTableSpec
 
   val mapper = AmazonDynamoDBScalaMapper(client)
 
-  override def beforeAll() {
+  override def beforeAll(): Unit = {
     super.beforeAll()
 
     tryCreateTable(Forum.tableRequest)
@@ -92,10 +89,10 @@ class ReadsOnHashKeyTableSpec
       mapper.batchLoadByKeys[Forum](sampleForums map (_.name))
     }
 
-    forumScan          should have size (sampleForums.size)
-    forumScanOnce      should have size (sampleForums.size)
-    forumScanOnceLimit should have size (sampleForums.size)
-    forumBatch         should have size (sampleForums.size)
+    forumScan          should have size (sampleForums.size.toLong)
+    forumScanOnce      should have size (sampleForums.size.toLong)
+    forumScanOnceLimit should have size (sampleForums.size.toLong)
+    forumBatch         should have size (sampleForums.size.toLong)
 
     for (forum <- sampleForums) {
       forumScan     should contain (forum)

scratch/src/main/scala/Scratch.scala

@@ -353,7 +353,7 @@ object Scratch {
       )
     )
 
-  def main(args: Array[String]) {
+  def main(args: Array[String]): Unit = {
 
     val credentials = new PropertiesCredentials(
         this.getClass()
@@ -384,15 +384,16 @@ object Scratch {
       throw new RuntimeException(s"Timed out waiting for $tableName table to become active.")
     }
 
-    def tryDeleteTable(tableName: String) {
+    def tryDeleteTable(tableName: String): Unit = {
       logger.info(s"Deleting $tableName table")
       Await.result(
         client.deleteTable(tableName) recover { case e: ResourceNotFoundException => () },
         10.seconds
       )
+      ()
     }
 
-    def awaitTableDeletion(tableName: String) {
+    def awaitTableDeletion(tableName: String): Unit = {
       logger.info(s"Waiting for $tableName table to be deleted.")
 
       val deadline = 10.minutes.fromNow
@@ -775,7 +776,7 @@ object ScratchS3 {
 
   import com.github.dwhjames.awswrap.s3._
   import com.amazonaws.event.{ProgressListener, ProgressEvent, ProgressEventType}
-  import com.amazonaws.services.s3._
+  // import com.amazonaws.services.s3._
   import com.amazonaws.services.s3.transfer._
   import java.io.File
 

src/main/scala/dynamodb/ConcurrentBatchWriter.scala

@@ -152,7 +152,7 @@ class ConcurrentBatchWriter(
   private def pause(attempts: Int): Unit =
     if (attempts > 0) {
       // 50, 100, 200, 400, 800
-      val delay = (math.pow(2.0, attempts - 1) * 50.0).toLong
+      val delay = (math.pow(2.0, (attempts - 1).toDouble) * 50.0).toLong
       if (logger.isTraceEnabled) logger.trace(s"backing off for $delay msecs.")
       Thread.sleep(delay)
     }
@@ -363,6 +363,7 @@ class ConcurrentBatchWriter(
             logger.error(s"AWS error occured when attempting to write to table $tableName", e)
             errorQueue.offer(
               FailedBatch[Metadata](tableName, batch.get(tableName), e, metadata))
+            ()
           case e: Throwable =>
             // log and rethrow any other exceptions
             // AmazonClientException should cover all error cases
@@ -457,7 +458,7 @@ class ConcurrentBatchWriter(
         logger.warn(s"batch writer thread pool for table $tableName being forced to shutdown.")
         // Wait a while for tasks to respond to being cancelled
         if (!writerThreadPool.awaitTermination(60, juc.TimeUnit.SECONDS))
-            logger.error("batch writer thread pool for table $tableName did not shutdown!")
+            logger.error(s"batch writer thread pool for table $tableName did not shutdown!")
       }
       dynamoDBClient.shutdown()
       logger.info(s"batch writer DynamoDB client for table $tableName is shutting down.")

src/main/scala/dynamodb/SingleThreadedBatchWriter.scala

@@ -57,7 +57,7 @@ class SingleThreadedBatchWriter(
   private def pause(retries: Int): Unit =
     if (retries > 0) {
       // 50, 100, 200, 400, 800
-      val delay = (math.pow(2.0, retries - 1) * 50.0).toLong
+      val delay = (math.pow(2.0, (retries - 1).toDouble) * 50.0).toLong
       logger.debug(s"backing off for $delay msecs.")
       Thread.sleep(delay)
     }
@@ -144,7 +144,7 @@ class SingleThreadedBatchWriter(
 
     while (source.hasNext) {
       logger.debug(s"pausing for $pauseDuration msecs.")
-      Thread.sleep(pauseDuration)
+      Thread.sleep(pauseDuration.toLong)
 
       // construct a batch of write requests
       val writeRequests = new ju.ArrayList[WriteRequest](batchSize)

src/main/scala/dynamodb/mapper.scala

@@ -42,7 +42,7 @@ package object dynamodb {
     *     the hash key name and the value it must equal.
     * @return a query request
     */
-  def mkHashKeyQuery[K <% AttributeValue](hashAttr: (String, K)): QueryRequest =
+  def mkHashKeyQuery[K](hashAttr: (String, K))(implicit ev: K => AttributeValue): QueryRequest =
     new QueryRequest()
     .withKeyConditions(
       Map(
@@ -65,9 +65,10 @@ package object dynamodb {
     *     an implicit object serializer
     * @return a query request
     */
-  def mkHashKeyQuery[T, K <% AttributeValue]
+  def mkHashKeyQuery[T, K]
                     (hashValue: K)
-                    (implicit serializer: DynamoDBSerializer[T])
+                    (implicit serializer: DynamoDBSerializer[T],
+                              ev: K => AttributeValue)
                     : QueryRequest =
     mkHashKeyQuery(serializer.hashAttributeName -> hashValue)
 
@@ -88,8 +89,9 @@ package object dynamodb {
     * @return a query request
     * @see [[QueryCondition]]
     */
-  def mkHashAndRangeKeyQuery[K <% AttributeValue]
+  def mkHashAndRangeKeyQuery[K]
                             (hashAttr: (String, K), rangeAttr: (String, Condition))
+                            (implicit ev: K => AttributeValue)
                             : QueryRequest =
     new QueryRequest()
     .withKeyConditions(
@@ -117,9 +119,10 @@ package object dynamodb {
     * @return a query request
     * @see [[QueryCondition]]
     */
-  def mkHashAndRangeKeyQuery[T, K <% AttributeValue]
+  def mkHashAndRangeKeyQuery[T, K]
                             (hashValue: K, rangeCondition: Condition)
-                            (implicit serializer: DynamoDBSerializer[T])
+                            (implicit serializer: DynamoDBSerializer[T],
+                                      ev: K => AttributeValue)
                             : QueryRequest =
     mkHashAndRangeKeyQuery(
       serializer.hashAttributeName -> hashValue,

src/main/scala/dynamodb/package.scala

@@ -27,14 +27,14 @@ package object awswrap {
 
   private def promiseToAsyncHandler[Request <: AmazonWebServiceRequest, Result](p: Promise[Result]) =
     new AsyncHandler[Request, Result] {
-      override def onError(exception: Exception): Unit = p.failure(exception)
-      override def onSuccess(request: Request, result: Result): Unit = p.success(result)
+      override def onError(exception: Exception): Unit = { p.failure(exception); () }
+      override def onSuccess(request: Request, result: Result): Unit = { p.success(result); () }
     }
 
   private def promiseToVoidAsyncHandler[Request <: AmazonWebServiceRequest](p: Promise[Unit]) =
     new AsyncHandler[Request, Void] {
-      override def onError(exception: Exception): Unit = p.failure(exception)
-      override def onSuccess(request: Request, result: Void): Unit = p.success(())
+      override def onError(exception: Exception): Unit = { p.failure(exception); () }
+      override def onSuccess(request: Request, result: Void): Unit = { p.success(()); () }
     }
 
   @inline

src/main/scala/package.scala

@@ -186,9 +186,10 @@ class AmazonS3ScalaClient(
     *
     * @see [[http://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/AmazonWebServiceClient.html#shutdown() AmazonWebServiceClient.shutdown()]]
     */
-  def shutdown() {
+  def shutdown(): Unit = {
     client.shutdown()
     executorService.shutdownNow()
+    ()
   }
 
 
@@ -199,12 +200,14 @@ class AmazonS3ScalaClient(
   ): Future[Result] = {
     val p = Promise[Result]
     executorService.execute(new Runnable {
-      override def run() =
+      override def run(): Unit = {
         p complete {
           Try {
             f(request)
           }
         }
+        ()
+      }
     })
     p.future
   }

src/main/scala/s3/s3.scala

@@ -19,7 +19,6 @@ package com.github.dwhjames.awswrap
 package sns
 
 import scala.concurrent.{Future, ExecutionContext}
-import scala.collection.JavaConverters._
 
 import java.util.concurrent.ExecutorService