address comments

Author: VinayGuthal

buildSrc/src/main/java/com/google/firebase/gradle/plugins/semver/ApiDiffer.kt

@@ -55,44 +55,44 @@ abstract class ApiDiffer : DefaultTask() {
     }
     val afterJar = readApi(currentJar.get())
     val beforeJar = readApi(previousJar.get())
-    val apiDeltas = mutableListOf<Delta>()
     val classKeys = afterJar.keys union beforeJar.keys
-      val apiDeltas =
+    val apiDeltas =
       classKeys
         .map { className -> Pair(beforeJar.get(className), afterJar.get(className)) }
         .flatMap { (before, after) ->
           DeltaType.values().flatMap { it.getViolations(before, after) }
         }
-    var deltaViolations: List<Delta> = mutableListOf()
-    if (curVersionDelta == VersionDelta.MINOR) {
-      deltaViolations = apiDeltas.filter { it.versionDelta == VersionDelta.MAJOR }
-    } else if (curVersionDelta == VersionDelta.PATCH) {
-      deltaViolations = apiDeltas
-    }
-    if (apiDeltas.size != 0) {
-      println(
-        "Here is a list of all the minor/major version bump changes which are made since the last release"
-      )
-      apiDeltas.forEach { println("[${it.versionDelta}] ${it.description}") }
+    val deltaViolations: List<Delta> =
+      if (curVersionDelta == VersionDelta.MINOR)
+        apiDeltas.filter { it.versionDelta == VersionDelta.MAJOR }
+      else if (curVersionDelta == VersionDelta.PATCH) apiDeltas else mutableListOf()
+    if (!apiDeltas.isEmpty()) {
+      val printString =
+        apiDeltas.joinToString(
+          prefix =
+            "Here is a list of all the minor/major version bump changes which are made since the last release.\n",
+          separator = "\n"
+        ) {
+          "[${it.versionDelta}] ${it.description}"
+        }
+      println(printString)
     }
-    if (deltaViolations.size != 0) {
-      var outputString =
-        "Here is a list of all the violations which needs to be fixed before we could release.\n"
-      deltaViolations.forEach { outputString += "[${it.versionDelta}] ${it.description}\n" }
+    if (!deltaViolations.isEmpty()) {
+      val outputString =
+        deltaViolations.joinToString(
+          prefix =
+            "Here is a list of all the violations which needs to be fixed before we could release.\n",
+          separator = "\n"
+        ) {
+          "[${it.versionDelta}] ${it.description}"
+        }
       throw GradleException(outputString)
     }
   }
 
   private fun readApi(jarPath: String): Map<String, ClassInfo> {
     val classes: Map<String, ClassNode> = readClassNodes(Paths.get(jarPath))
-    var classInfoDict = mutableMapOf<String, ClassInfo>()
-    for (classNodeInfo in classes) {
-      classInfoDict[classNodeInfo.key] = ClassInfo(classNodeInfo.value, classes)
-    }
-    for (classNodeInfo in classes) {
-      classInfoDict[classNodeInfo.key] = ClassInfo(classNodeInfo.value, classes)
-    }
-    return classInfoDict
+    return classes.entries.associate { (key, value) -> key to ClassInfo(value, classes) }
   }
 
   /** Returns true if the class is local or anonymous. */

buildSrc/src/main/java/com/google/firebase/gradle/plugins/semver/ClassInfo.kt

@@ -33,32 +33,23 @@ class ClassInfo(val _node: ClassNode, val _classNodes: Map<String, ClassNode>) {
     this.methods = getAllMethods(_node, _classNodes)
   }
 
-  fun getAllFields(node: ClassNode): Map<String, FieldNode> {
-    var fields: MutableMap<String, FieldNode> = mutableMapOf()
-    for (field in node.fields) {
-      val descriptor = AccessDescriptor(field.access)
-      if (descriptor.isSynthetic() || UtilityClass.isObfuscatedSymbol(field.name)) continue
-      fields.put("${field.name}-${field.desc}", field)
-    }
-    return fields
-  }
+  fun getAllFields(node: ClassNode): Map<String, FieldNode> =
+    node.fields
+      .filterNot {
+        AccessDescriptor(it.access).isSynthetic() || UtilityClass.isObfuscatedSymbol(it.name)
+      }
+      .associate { field -> "${field.name}-${field.desc}" to field }
 
-  fun getAllMethods(node: ClassNode, classNodes: Map<String, ClassNode>): Map<String, MethodNode> {
-    return getAllStaticMethods(node) + getAllNonStaticMethods(node, classNodes)
-  }
+  fun getAllMethods(node: ClassNode, classNodes: Map<String, ClassNode>): Map<String, MethodNode> =
+    getAllStaticMethods(node) + getAllNonStaticMethods(node, classNodes)
 
-  fun getAllStaticMethods(node: ClassNode): Map<String, MethodNode> {
-    var staticMethods: MutableMap<String, MethodNode> = mutableMapOf()
-    for (method in node.methods) {
-      val descriptor = AccessDescriptor(method.access)
-      if (!descriptor.isStatic() || descriptor.isSynthetic()) continue
-      if (UtilityClass.isObfuscatedSymbol(method.name) || method.name.equals("<clint>")) {
-        continue
+  fun getAllStaticMethods(node: ClassNode): Map<String, MethodNode> =
+    node.methods
+      .filterNot {
+        !AccessDescriptor(it.access).isStatic() || AccessDescriptor(it.access).isSynthetic()
       }
-      staticMethods.put("${method.name}-${method.desc}", method)
-    }
-    return staticMethods
-  }
+      .filterNot { UtilityClass.isObfuscatedSymbol(it.name) || it.name.equals("<clint>") }
+      .associate { method -> "${method.name}-${method.desc}" to method }
 
   fun getAllNonStaticMethods(
     node: ClassNode?,
@@ -70,17 +61,16 @@ class ClassInfo(val _node: ClassNode, val _classNodes: Map<String, ClassNode>) {
     if (methodsCache.containsKey(node.name)) {
       return methodsCache.get(node.name)!!
     }
-    var result = mutableMapOf<String, MethodNode>()
-    for (method in node.methods) {
-      var descriptor = AccessDescriptor(method.access)
-      if (descriptor.isSynthetic() || descriptor.isBridge() || descriptor.isStatic()) {
-        continue
-      }
-      if (UtilityClass.isObfuscatedSymbol(method.name)) {
-        continue
-      }
-      result.put("${method.name}-${method.desc}", method)
-    }
+    var result =
+      node.methods
+        .filterNot {
+          (AccessDescriptor(it.access).isSynthetic() ||
+            AccessDescriptor(it.access).isBridge() ||
+            AccessDescriptor(it.access).isStatic())
+        }
+        .filterNot { UtilityClass.isObfuscatedSymbol(it.name) }
+        .associate { method -> "${method.name}-${method.desc}" to method }
+
     if (node.superName != null) {
       result =
         (result + getAllNonStaticMethods(classNodes.get(node.superName), classNodes))