Clean up lint found by IntelliJ IDEA

Author: HairyFotr

.gitignore

@@ -1,10 +1,12 @@
 .DS_Store
 /target/
 /project/target/
-/project/project/target
+/project/project/
 *~
 *.orig
 *.log
 *.jar
 *.class
 
+.idea
+*.iml

README.md

@@ -222,18 +222,19 @@ Rule lists from other static analysis tools:
 * Scapegoat(Scala) - https://github.com/sksamuel/scalac-scapegoat-plugin#inspections
 * WartRemover(Scala) - https://github.com/typelevel/wartremover#warts
 * Scala Abide(Scala) - https://github.com/scala/scala-abide
-* SuperSafe™(Scala) - http://www.artima.com/supersafe_user_guide.html
+* ($)SuperSafe™(Scala) - http://www.artima.com/supersafe_user_guide.html
+* IntelliJ IDEA(Scala/...) - https://www.jetbrains.com/idea/features/scala.html
 * Findbugs(JVM) - http://findbugs.sourceforge.net/bugDescriptions.html
 * CheckStyle(Java) - http://checkstyle.sourceforge.net/availablechecks.html
 * PMD(Java) - http://pmd.sourceforge.net/snapshot/pmd-java/rules/index.html
 * Error-prone(Java) - https://code.google.com/p/error-prone/wiki/BugPatterns
 * CodeNarc(Groovy) - http://codenarc.sourceforge.net/codenarc-rule-index.html
-* PVS-Studio(C++) - http://www.viva64.com/en/d/
-* Coverity(C++) - http://www.slideshare.net/Coverity/static-analysis-primer-22874326 (6,7)
+* ($)PVS-Studio(C++) - http://www.viva64.com/en/d/
+* ($)Coverity(C++/Java/...) - http://www.slideshare.net/Coverity/static-analysis-primer-22874326 (6,7)
 * CppCheck(C++) - http://sourceforge.net/apps/mediawiki/cppcheck/index.php?title=Main_Page#Checks
 * Clang(C++/ObjC) - http://clang-analyzer.llvm.org/available_checks.html
 * OCLint(C++/ObjC) - http://docs.oclint.org/en/dev/rules/index.html
-* Fortify(Java/C++/...) - http://www.hpenterprisesecurity.com/vulncat/en/vulncat/index.html
+* ($)Fortify(Java/C++/...) - http://www.hpenterprisesecurity.com/vulncat/en/vulncat/index.html
 
 ### Some resources
 * A quick overview of writing compiler plugins: http://www.scala-lang.org/node/140

build.sbt

@@ -15,7 +15,7 @@ libraryDependencies ++= Seq(
   "junit"          % "junit"           % "4.12"   % "test",
   "com.novocode"   % "junit-interface" % "0.11"   % "test")
 
-libraryDependencies <+= (scalaVersion) { (scalaVersion) =>
+libraryDependencies <+= scalaVersion { (scalaVersion) =>
   "org.scala-lang" % "scala-compiler"  % scalaVersion
 }
 

src/main/scala/LinterOptions.scala

@@ -16,7 +16,7 @@
 
 package com.foursquare.lint
 
-import annotation.tailrec
+import scala.annotation.tailrec
 
 case class LinterOptions(disabledWarningNames: Seq[String] = Nil, printWarningNames: Boolean = false)
 
@@ -33,8 +33,8 @@ object LinterOptions {
     case Array(option, warningNames) => 
       val (validNames, invalidNames) = warningNames.split(WarningNameDelimiter).partition(Warning.NameToWarning.contains) 
       if (validNames.nonEmpty && invalidNames.isEmpty) Right(validNames)
-      else Left(s"The '${option}' option referenced invalid warnings: ${invalidNames.mkString(", ")}")
-    case _ => Left(s"The '${fullOption}' option was not of the expected form.")
+      else Left(s"The '$option' option referenced invalid warnings: ${invalidNames.mkString(", ")}")
+    case _ => Left(s"The '$fullOption' option was not of the expected form.")
   }
 
   @tailrec
@@ -48,8 +48,8 @@ object LinterOptions {
     case option :: xs if option.startsWith(PrintWarningNames) => option.split(OptionKeyValueDelimiter) match {
       case Array(_, value @ ("true" | "false")) => Right(linterOptions.copy(printWarningNames = value.toBoolean))
       case Array(_) if option == PrintWarningNames => Right(linterOptions.copy(printWarningNames = true))
-      case _ => Left(s"The '${option}' option was not of the expected form")
+      case _ => Left(s"The '$option' option was not of the expected form")
     }
-    case unknownOption :: _ => Left(s"The option '${unknownOption}' is unrecognized.")
+    case unknownOption :: _ => Left(s"The option '$unknownOption' is unrecognized.")
   }
 }

src/main/scala/LinterPlugin.scala

@@ -16,21 +16,22 @@
 
 package com.foursquare.lint
 
-import scala.tools.nsc.{ Global, Phase }
+import scala.collection.mutable
 import scala.tools.nsc.plugins.{ Plugin, PluginComponent }
-import collection.mutable
+import scala.tools.nsc.{ Global, Phase }
 
 class LinterPlugin(val global: Global) extends Plugin {
+  import com.foursquare.lint.Utils._
   import global._
-  import Utils._
 
   val name = "linter"
   val description = "a static analysis compiler plugin to help protect against bugs and style problems"
   val components = List[PluginComponent](PreTyperComponent, PostTyperComponent, PostTyperInterpreterComponent, PostRefChecksComponent)
 
   override val optionsHelp: Option[String] = Some(Seq(
-    "%s:plus+separated+warning+names".format(LinterOptions.DisableArgument),
-    "%s:plus+separated+warning+names".format(LinterOptions.EnableOnlyArgument)
+    LinterOptions.DisableArgument+":plus+separated+warning+names",
+    LinterOptions.EnableOnlyArgument+":plus+separated+warning+names",
+    LinterOptions.PrintWarningNames+":true|false"
   ).map(" -P:" + name + ":" +  _).mkString("\n"))
 
   override def processOptions(options: List[String], error: String => Unit): Unit = {
@@ -1670,7 +1671,7 @@ class LinterPlugin(val global: Global) extends Plugin {
     class PostTyperInterpreterTraverser(unit: CompilationUnit) extends Traverser {
       implicit val unitt = unit
       var treePosHolder: Tree = null
-      import Utils._
+      import com.foursquare.lint.Utils._
       val utils = new Utils[global.type](global)
       import utils._
 
@@ -2617,11 +2618,11 @@ class LinterPlugin(val global: Global) extends Plugin {
                 str.exactValue
                   .map(v => Values(v.size))
                   .getOrElse(
-                    if(str.getMinLength == str.getMaxLength) 
+                    if(str.getMinLength == str.getMaxLength)
                       Values(str.getMinLength)
                     else if(str.getMinLength == 0 && str.getMaxLength == Int.MaxValue)
                       Values.empty
-                    else 
+                    else
                       Values(str.getMinLength, str.getMaxLength)
                   ).addCondition(_ >= 0).addCondition(_ < str.getMaxLength)
               )
@@ -2854,7 +2855,7 @@ class LinterPlugin(val global: Global) extends Plugin {
                 val posFiltering = treePosHolder.toString matches (".*?[ .]"+ f + """ *[(].*, *("{2}|"{6}) *[)]""")
 
                 val special = """.\^$*+?()\[{\\|"""
-                val plainString = s"""([^${special}]|[\\\\][${special}])+"""
+                val plainString = s"""([^$special]|[\\\\][$special])+"""
 
                 if(posFiltering && (p0 matches plainString+"\\$"))
                   warn(treePosHolder, RegexWarning(s"This $f can be substituted with stripSuffix", error = false))
@@ -3010,15 +3011,12 @@ class LinterPlugin(val global: Global) extends Plugin {
                 }
               } catch {
                 case e: Exception => 
-                  e.printStackTrace
                   empty
               }
 
             case Apply(Ident(name), _params) if defModels contains name.toString =>
               defModels
-                .find(m => m._1 == name.toString && m._2.isRight)
-                .map(_._2.right.get)
-                .getOrElse(empty)
+                .find(m => m._1 == name.toString && m._2.isRight).fold(empty)(_._2.right.get)
 
             case If(_cond, expr1, expr2) =>
               val (e1, e2) = (traverseString(expr1), traverseString(expr2))
@@ -3173,8 +3171,8 @@ class LinterPlugin(val global: Global) extends Plugin {
             knownPieces = knownPieces map { _.reverse })
 
         def trim: StringAttrs = {
-          val newMinLength = exactValue.map(_.trim.size).getOrElse(getTrimmedMinLength)
-          val newMaxLength = exactValue.map(_.trim.size).getOrElse(getTrimmedMaxLength)
+          val newMinLength = exactValue.fold(getTrimmedMinLength)(_.trim.size)
+          val newMaxLength = exactValue.fold(getTrimmedMaxLength)(_.trim.size)
           new StringAttrs(
             exactValue = exactValue.map { _.trim },
             minLength = newMinLength, 
@@ -3212,10 +3210,10 @@ class LinterPlugin(val global: Global) extends Plugin {
         def alwaysIsEmpty: Boolean = getMaxLength == 0
         def alwaysNonEmpty: Boolean = getMinLength > 0
 
-        def getMinLength: Int = exactValue.map(_.size).getOrElse(minLength)
-        def getMaxLength: Int = exactValue.map(_.size).getOrElse(maxLength)
-        def getTrimmedMinLength: Int = exactValue.map(_.trim.size).getOrElse(trimmedMinLength)
-        def getTrimmedMaxLength: Int = exactValue.map(_.trim.size).getOrElse(trimmedMaxLength)
+        def getMinLength: Int = exactValue.fold(minLength)(_.size)
+        def getMaxLength: Int = exactValue.fold(maxLength)(_.size)
+        def getTrimmedMinLength: Int = exactValue.fold(trimmedMinLength)(_.trim.size)
+        def getTrimmedMaxLength: Int = exactValue.fold(trimmedMaxLength)(_.trim.size)
 
         def +(s: String): StringAttrs = 
           new StringAttrs(

src/main/scala/Utils.scala

@@ -16,8 +16,8 @@
 
 package com.foursquare.lint
 
+import scala.collection.mutable
 import scala.tools.nsc.Global
-import collection.mutable
 
 object Utils {
   var linterOptions = LinterOptions()
@@ -60,7 +60,7 @@ class Utils[G <: Global](val global: G) {
     used
   }
 
-  import definitions.{ AnyClass, NothingClass, ObjectClass, Object_==, OptionClass, SeqClass }
+  import definitions.{ AnyClass, OptionClass }
   val JavaConversionsModule: Symbol = rootMirror.getModuleByName(newTermName("scala.collection.JavaConversions"))
   val SeqLikeClass: Symbol = rootMirror.getClassByName(newTermName("scala.collection.SeqLike"))
   val SeqLikeContains: Symbol = SeqLikeClass.info.member(newTermName("contains"))