Minor. Extract common pattern in DeserializedMemberScope

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt

@@ -68,14 +68,25 @@ abstract class DeserializedMemberScope protected constructor(
             getNameIndex: (M) -> Int
     ) = groupBy { c.nameResolver.getName(getNameIndex(it)) }
 
-    private fun computeFunctions(name: Name): Collection<SimpleFunctionDescriptor> {
+    private fun computeFunctions(name: Name) =
-        val protos = functionProtos[name].orEmpty()
+            computeDescriptors(
+                    name,
+                    functionProtos,
+                    { c.memberDeserializer.loadFunction(it) },
+                    { computeNonDeclaredFunctions(name, it)}
+            )
 
-        val descriptors = protos.mapTo(linkedSetOf()) {
+    inline private fun <M : MessageLite, D : DeclarationDescriptor> computeDescriptors(
-            c.memberDeserializer.loadFunction(it)
+            name: Name,
-        }
+            protosByName: Map<Name, Collection<M>>,
+            factory: (M) -> D,
+            computeNonDeclared: (MutableCollection<D>) -> Unit
+    ): Collection<D> {
+        val protos = protosByName[name].orEmpty()
 
-        computeNonDeclaredFunctions(name, descriptors)
+        val descriptors = protos.mapTo(linkedSetOf(), factory)
+
+        computeNonDeclared(descriptors)
         return descriptors.toReadOnlyList()
     }
 
@@ -84,28 +95,23 @@ abstract class DeserializedMemberScope protected constructor(
 
     override fun getContributedFunctions(name: Name, location: LookupLocation): Collection<SimpleFunctionDescriptor> = functions(name)
 
-    private fun computeProperties(name: Name): Collection<PropertyDescriptor> {
+    private fun computeProperties(name: Name) =
-        val protos = propertyProtos[name].orEmpty()
+            computeDescriptors(
-
+                    name,
-        val descriptors = protos.mapTo(linkedSetOf()) {
+                    propertyProtos,
-            c.memberDeserializer.loadProperty(it)
+                    { c.memberDeserializer.loadProperty(it) },
-        }
+                    { computeNonDeclaredProperties(name, it) }
-
+            )
-        computeNonDeclaredProperties(name, descriptors)
-        return descriptors.toReadOnlyList()
-    }
 
     protected open fun computeNonDeclaredProperties(name: Name, descriptors: MutableCollection<PropertyDescriptor>) {
     }
 
-    private fun computeTypeAliases(name: Name): Collection<TypeAliasDescriptor> {
+    private fun computeTypeAliases(name: Name) =
-        val protos = typeAliasProtos[name] ?: return emptyList()
+            computeDescriptors(
-        val descriptors = protos.mapTo(linkedSetOf()) {
+                    name,
-            c.memberDeserializer.loadTypeAlias(it)
+                    typeAliasProtos,
-        }
+                    { c.memberDeserializer.loadTypeAlias(it) },
-
+                    { })
-        return descriptors.toReadOnlyList()
-    }
 
     override fun getContributedVariables(name: Name, location: LookupLocation): Collection<PropertyDescriptor> = properties(name)