Scala fixes

Author: Dominik Helm

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/InfiniteRecursions.scala

@@ -117,7 +117,7 @@ object InfiniteRecursions extends ProjectsAnalysisApplication {
                 nextCallOperands: domain.Operands = operandsArray(pc).take(parametersCount)
             } {
                 // IntegerRangeValues and ReferenceValues have useable equals semantics
-                if (!callOperandsList.exists { _ == nextCallOperands })
+                if (!callOperandsList.contains(nextCallOperands))
                     callOperandsList = nextCallOperands :: callOperandsList
             }
             callOperandsList

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/domain/l1/IfNullParameterAnalysis.scala

@@ -122,9 +122,10 @@ object IfNullParameterAnalysis extends ProjectsAnalysisApplication {
                                     domain1,
                                     // We need to keep the original location, otherwise
                                     // the correlation analysis would miserably fail!
-                                    ex.asInstanceOf[domain2.DomainSingleOriginReferenceValue].origin
+                                    ex.asInstanceOf[domain2.DomainSingleOriginReferenceValue]
+                                        .origin
                                 ).asInstanceOf[domain1.ExceptionValue]
-                            ).toSet[domain1.DomainReferenceValue]
+                            )
                         val diff =
                             d1thrownException.diff(adaptedD2ThrownException) ++
                                 adaptedD2ThrownException.diff(d1thrownException)

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/domain/l1/MethodReturnValuesAnalysis.scala

@@ -146,7 +146,7 @@ object MethodReturnValuesAnalysis extends ProjectsAnalysisApplication {
 
 case class RefinedReturnType(method: Method, refinedType: Option[Domain#DomainValue]) {
 
-    override def toString(): String = {
+    override def toString: String = {
         import Console.*
         "Refined the return type of " + BOLD + BLUE + method.toJava + " => " +
             GREEN + refinedType.getOrElse("\"NONE\" (the method does not return normally)") + RESET

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ba/SimpleInstrumentationDemo.scala

@@ -10,14 +10,14 @@ class SimpleInstrumentationDemo {
     }
 
     def callsToString(): Unit = {
-        println("the length of the toString representation is: " + this.toString().length())
+        println("the length of the toString representation is: " + this.toString.length())
     }
 
     def returnsValue(i: Int): Int = {
         if (i % 2 == 0)
-            return -1;
+            -1
         else
-            return 2;
+            2
     }
 
     def playingWithTypes(a: AnyRef): Unit = {

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/bc/HelloWorldClass.scala

@@ -206,5 +206,5 @@ object HelloWorldClass extends App {
         attributes = ArraySeq(SourceFile_attribute(32, 33))
     )
 
-    println("Created class file: " + Files.write(Paths.get("Test.class"), Assembler(cf)).toAbsolutePath())
+    println("Created class file: " + Files.write(Paths.get("Test.class"), Assembler(cf)).toAbsolutePath)
 }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/br/analyses/MoreCheckers.scala

@@ -127,7 +127,7 @@ object MoreCheckers {
                 field <- classFile.fields if field.isProtected
             } yield (classFile, field)
         } { t => collect("CI_CONFUSED_INHERITANCE", t /*nsToSecs(t)*/ ) }
-        println(", " /*"\tViolations: "*/ + protectedFields.size)
+        println(", " /*"\tViolations: "*/ + protectedFields.length)
 
         // FINDBUGS: CN: Class implements Cloneable but does not define or use clone method (CN_IDIOM)
         val cloneableNoClone = time {
@@ -174,7 +174,7 @@ object MoreCheckers {
                 if classHierarchy.isASubtypeOf(classFile.thisType, ClassType.Cloneable).isYesOrUnknown
             } yield (classFile.thisType.fqn, method.name)
         }(t => collect("CN_IMPLEMENTS_CLONE_BUT_NOT_CLONEABLE", t /*nsToSecs(t)*/ ))
-        println(", " /*"\tViolations: "*/ /*+cloneButNotCloneable.mkString(", ")*/ + cloneButNotCloneable.size)
+        println(", " /*"\tViolations: "*/ /*+cloneButNotCloneable.mkString(", ")*/ + cloneButNotCloneable.length)
 
         // FINDBUGS: Co: Abstract class defines covariant compareTo() method (CO_ABSTRACT_SELF)
         // FINDBUGS: Co: Covariant compareTo() method defined (CO_SELF_NO_OBJECT)
@@ -201,7 +201,7 @@ object MoreCheckers {
             for { // we don't care about gc calls in java.lang and also about gc calls that happen inside of methods related to garbage collection (heuristic)
                 classFile <- classFiles if !classFile.thisType.fqn.startsWith("java/lang");
                 method <- classFile.methods
-                if method.body.isDefined && !"(^gc)|(gc$)".r.findFirstIn(method.name).isDefined;
+                if method.body.isDefined && "(^gc)|(gc$)".r.findFirstIn(method.name).isEmpty;
                 instruction <- method.body.get.instructions
             } {
                 instruction match {
@@ -255,7 +255,7 @@ object MoreCheckers {
                 ) <- classFile.methods if method.isAbstract
             } yield (classFile, method);
         }(t => collect("EQ_ABSTRACT_SELF", t /*nsToSecs(t)*/ ))
-        println(", " /*"\tViolations: "*/ + abstractCovariantEquals.size)
+        println(", " /*"\tViolations: "*/ + abstractCovariantEquals.length)
 
         // FINDBUGS: FI: Finalizer should be protected, not public (FI_PUBLIC_SHOULD_BE_PROTECTED)
         val classesWithPublicFinalizeMethods = time {
@@ -292,7 +292,7 @@ object MoreCheckers {
                 if getClassFile.isDefinedAt(superclass) // the class file of some supertypes (defined in libraries, which we do not analyze) may not be available
                 superClassFile = getClassFile(superclass)
                 if !superClassFile.isInterfaceDeclaration
-                if !superClassFile.constructors.exists(_.descriptor.parameterTypes.length == 0)
+                if !superClassFile.constructors.exists(_.descriptor.parameterTypes.isEmpty)
             } yield superclass // there can be at most one method
         }(t => collect("SE_NO_SUITABLE_CONSTRUCTOR", t /*nsToSecs(t)*/ ))
         println(", " /*"\tViolations: "*/ + classesWithoutDefaultConstructor.size);
@@ -313,7 +313,7 @@ object MoreCheckers {
                         case _                                    =>
                     }
                 }
-                if (privateFields.size > 0)
+                if (privateFields.nonEmpty)
                     unusedFields = (classFile, privateFields) :: unusedFields
             }
         }(t => collect("UUF_UNUSED_FIELD", t /*nsToSecs(t)*/ ))
@@ -354,9 +354,9 @@ object MoreCheckers {
                 classFile <- classFiles if classFile.isClassDeclaration
                 case method @ MethodWithBody(body) <- classFile.methods
                 exceptionHandler <- body.exceptionHandlers
-                if exceptionHandler.catchType == Some(IllegalMonitorStateExceptionType)
+                if exceptionHandler.catchType.contains(IllegalMonitorStateExceptionType)
             } yield (classFile, method)
         }(t => collect("IMSE_DONT_CATCH_IMSE", t /*nsToSecs(t)*/ ))
-        println(", " /*"\tViolations: "*/ + catchesIllegalMonitorStateException.size)
+        println(", " /*"\tViolations: "*/ + catchesIllegalMonitorStateException.length)
     }
 }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/br/analyses/SimpleProjectStatistics.scala

@@ -42,26 +42,17 @@ object SimpleProjectStatistics extends ProjectsAnalysisApplication {
                     (group, es.size)
                 }
 
-        val maxInstanceFieldsInAClass =
-            project.allClassFiles.map(_.fields.filter(f => !f.isStatic).size).max
-        val classWithMaxInstanceFields =
-            project.allClassFiles.find(
-                _.fields.filter(f => !f.isStatic).size == maxInstanceFieldsInAClass
-            ).map(_.thisType.toJava)
-
-        val maxClassFieldsInAClass =
-            project.allClassFiles.map(_.fields.filter(f => f.isStatic).size).max
-        val classWithMaxClassFields =
-            project.allClassFiles.find(
-                _.fields.filter(f => f.isStatic).size == maxClassFieldsInAClass
-            ).map(_.thisType.toJava)
-
-        val maxMethodsInAClass =
-            project.allClassFiles.map(_.methods.size).max
-        val classWithMaxMethods =
-            project.allClassFiles.find(
-                _.methods.size == maxMethodsInAClass
-            ).map(_.thisType.toJava)
+        val maxInstanceFieldsInAClass = project.allClassFiles.map(_.fields.count(f => !f.isStatic)).max
+        val classWithMaxInstanceFields = project.allClassFiles
+            .find(_.fields.count(f => !f.isStatic) == maxInstanceFieldsInAClass).map(_.thisType.toJava)
+
+        val maxClassFieldsInAClass = project.allClassFiles.map(_.fields.count(f => f.isStatic)).max
+        val classWithMaxClassFields = project.allClassFiles
+            .find(_.fields.count(f => f.isStatic) == maxClassFieldsInAClass).map(_.thisType.toJava)
+
+        val maxMethodsInAClass = project.allClassFiles.map(_.methods.size).max
+        val classWithMaxMethods = project.allClassFiles
+            .find(_.methods.size == maxMethodsInAClass).map(_.thisType.toJava)
 
         val (longestMethodInAClass, theLongestMethod) = {
             var max = 0

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/br/analyses/observers/ObserverPatternUsage.scala

@@ -38,8 +38,8 @@ object ObserverPatternUsage extends ProjectsAnalysisApplication {
         val appClassFiles = project.allProjectClassFiles
         val libClassFiles = project.allLibraryClassFiles
         println("Application:\n\tClasses:" + appClassFiles.size)
-        println("\tMethods:" + appClassFiles.foldLeft(0)(_ + _.methods.filter(!_.isSynthetic).size))
-        println("\tNon-final Fields:" + appClassFiles.foldLeft(0)(_ + _.fields.filter(!_.isFinal).size))
+        println("\tMethods:" + appClassFiles.foldLeft(0)(_ + _.methods.count(!_.isSynthetic)))
+        println("\tNon-final Fields:" + appClassFiles.foldLeft(0)(_ + _.fields.count(!_.isFinal)))
         println("Library:\n\tClasses:" + libClassFiles.size)
         println("Overall " + project.statistics)
 

DEVELOPING_OPAL/tools/src/main/scala/org/opalj/support/debug/ClassHierarchyVisualizer.scala

@@ -34,7 +34,8 @@ object ClassHierarchyVisualizer extends ProjectsAnalysisApplication {
 
         val (project, _) = analysisConfig.setupProject(cp)
 
-        val dotGraph = toDot(Set(project.classHierarchy.toGraph()), "back")
+        val dotGraph = toDot(Set(project.classHierarchy.toGraph), "back")
+
         val file = writeAndOpen(dotGraph, "ClassHierarchy", ".gv")
         println(s"Wrote class hierarchy graph to: $file.")
     }

DEVELOPING_OPAL/tools/src/main/scala/org/opalj/support/debug/ConsoleTracer.scala

@@ -9,8 +9,8 @@ import org.opalj.ai.Domain
 import org.opalj.ai.NoUpdate
 import org.opalj.ai.SomeUpdate
 import org.opalj.ai.Update
-import org.opalj.ai.domain
 import org.opalj.ai.domain.TheCode
+import org.opalj.ai.domain.l1.ReferenceValues
 import org.opalj.br.Code
 import org.opalj.br.instructions.Instruction
 import org.opalj.collection.mutable.IntArrayStack
@@ -68,10 +68,10 @@ trait ConsoleTracer extends AITracer { tracer =>
                 case rv: IsReferenceValue if rv.allValues.size > 1 =>
                     val values = rv.allValues
                     val t =
-                        if (rv.isInstanceOf[domain.l1.ReferenceValues#TheReferenceValue])
-                            s";refId=${rv.asInstanceOf[org.opalj.ai.domain.l1.ReferenceValues#TheReferenceValue].refId}"
-                        else
-                            ""
+                        rv match {
+                            case value1: ReferenceValues#TheReferenceValue => s";refId=${value1.refId}"
+                            case _                                         => ""
+                        }
                     values.map(toStringWithOID(_)).mkString("OneOf[" + values.size + "](", ",", ")") +
                         rv.upperTypeBound.map(_.toJava).mkString(";lutb=", " with ", ";") +
                         s"isPrecise=${rv.isPrecise};isNull=${rv.isNull}$t " +
@@ -115,7 +115,7 @@ trait ConsoleTracer extends AITracer { tracer =>
 
         val ps = {
             val ps = domain.properties(pc)
-            if ((ps eq null) || ps == None)
+            if ((ps eq null) || ps.isEmpty)
                 ""
             else {
                 s"\tproperties: ${ps.get}\n"
@@ -173,7 +173,7 @@ trait ConsoleTracer extends AITracer { tracer =>
 
     override def deadLocalVariable(domain: Domain)(pc: Int, lvIndex: Int): Unit = {
         println(
-            pc.toString + line(domain, pc).toString + ":" +
+            pc.toString + line(domain, pc) + ":" +
                 Console.BLACK_B + Console.WHITE + s"local variable $lvIndex is dead"
         )
     }
@@ -382,7 +382,7 @@ trait ConsoleTracer extends AITracer { tracer =>
     ): Unit = {
         val loc = pc.map(pc => s"$pc:").getOrElse("<NO PC>")
         println(
-            s"$loc[Domain:${source.getSimpleName().split('$')(0)} - $typeID] $message"
+            s"$loc[Domain:${source.getSimpleName.split('$')(0)} - $typeID] $message"
         )
     }
 }