[J2KT] Replace custom zip with Streams.zip in passes.

Replace the custom `zip` implementation in `AbstractJ2ktNormalizationPass` with `Streams.zip` as per TODO.

PiperOrigin-RevId: 926682016

Author: rluble

transpiler/java/com/google/j2cl/transpiler/passes/AbstractJ2ktNormalizationPass.java

@@ -15,11 +15,11 @@
  */
 package com.google.j2cl.transpiler.passes;
 
-import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Streams;
 import com.google.errorprone.annotations.FormatMethod;
 import com.google.j2cl.common.SourcePosition;
 import com.google.j2cl.transpiler.ast.ArrayTypeDescriptor;
@@ -32,8 +32,6 @@
 import com.google.j2cl.transpiler.ast.TypeDescriptors;
 import com.google.j2cl.transpiler.ast.TypeVariable;
 import com.google.j2cl.transpiler.ast.UnionTypeDescriptor;
-import java.util.List;
-import java.util.function.BiFunction;
 
 /**
  * Abstract base class for Kotlin passes, providing shared functionality:
@@ -90,16 +88,13 @@ private static TypeDescriptor projectCaptures(
                   seen));
 
       case DeclaredTypeDescriptor descriptor ->
-          descriptor.isRaw()
-              ? descriptor
-              : descriptor.withTypeArguments(
-                  zip(
-                      typeDescriptor.isRaw()
-                          ? ImmutableList.of()
-                          : descriptor.getTypeDeclaration().getTypeParameterDescriptors(),
-                      descriptor.getTypeArgumentDescriptors(),
+          descriptor.withTypeArguments(
+              Streams.zip(
+                      descriptor.getTypeDeclaration().getTypeParameterDescriptors().stream(),
+                      descriptor.getTypeArgumentDescriptors().stream(),
                       (typeParameter, typeArgument) ->
-                          projectArgumentCaptures(typeArgument, typeParameter, seen)));
+                          projectArgumentCaptures(typeArgument, typeParameter, seen))
+                  .collect(toImmutableList()));
 
       case TypeVariable typeVariable when !typeVariable.isWildcardOrCapture() -> typeVariable;
       case TypeVariable typeVariable when seen.contains(typeVariable) -> typeVariable;
@@ -185,12 +180,11 @@ static TypeVariable getArrayComponentTypeParameterDescriptor() {
   /** Returns type argument descriptors with nullability which satisfy their declarations. */
   static ImmutableList<TypeDescriptor> getTypeArgumentDescriptorsWithValidNullability(
       DeclaredTypeDescriptor declaredTypeDescriptor) {
-    return declaredTypeDescriptor.isRaw()
-        ? ImmutableList.of()
-        : zip(
-            declaredTypeDescriptor.getTypeArgumentDescriptors(),
-            declaredTypeDescriptor.getTypeDeclaration().getTypeParameterDescriptors(),
-            AbstractJ2ktNormalizationPass::getTypeArgumentDescriptorWithValidNullability);
+    return Streams.zip(
+            declaredTypeDescriptor.getTypeArgumentDescriptors().stream(),
+            declaredTypeDescriptor.getTypeDeclaration().getTypeParameterDescriptors().stream(),
+            AbstractJ2ktNormalizationPass::getTypeArgumentDescriptorWithValidNullability)
+        .collect(toImmutableList());
   }
 
   /** Returns type argument descriptor with nullability which satisfies its declaration. */
@@ -216,19 +210,4 @@ static TypeDescriptor removeRedundantNullabilityAnnotation(TypeDescriptor typeDe
     }
     return typeDescriptor;
   }
-
-  // TODO(b/406815802): Replace all usages with `Streams.zip`
-  static <A, B, R> ImmutableList<R> zip(
-      List<A> listA, List<B> listB, BiFunction<? super A, ? super B, ? extends R> function) {
-    checkArgument(
-        listA.size() == listB.size(),
-        "Lists are of different sizes (%s, %s)",
-        listA.size(),
-        listB.size());
-    ImmutableList.Builder<R> builder = ImmutableList.builder();
-    for (int i = 0; i < listA.size(); i++) {
-      builder.add(function.apply(listA.get(i), listB.get(i)));
-    }
-    return builder.build();
-  }
 }

transpiler/java/com/google/j2cl/transpiler/passes/AddDisambiguatingOverloadResolutionCastsJ2kt.java

@@ -15,6 +15,7 @@
  */
 package com.google.j2cl.transpiler.passes;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
 import static java.util.function.Predicate.isEqual;
 
 import com.google.common.collect.Streams;
@@ -70,10 +71,12 @@ public Node rewriteInvocation(Invocation invocation) {
             // parameter's type.
             return invocation.toBuilder()
                 .setArguments(
-                    zip(
-                        invocation.getTarget().getParameterTypeDescriptors(),
-                        invocation.getArguments(),
-                        AddDisambiguatingOverloadResolutionCastsJ2kt::castArgumentToParameterType))
+                    Streams.zip(
+                            invocation.getTarget().getParameterTypeDescriptors().stream(),
+                            invocation.getArguments().stream(),
+                            AddDisambiguatingOverloadResolutionCastsJ2kt
+                                ::castArgumentToParameterType)
+                        .collect(toImmutableList()))
                 .build();
           }
         });

transpiler/java/com/google/j2cl/transpiler/passes/PropagateNullability.java

@@ -298,10 +298,11 @@ public Node rewriteInvocation(Invocation invocation) {
             // Propagate nullability from parameters into arguments, this covers the cases where the
             // expression is a lambda and its parameters are inferred from the surrounding context.
             ImmutableList<Expression> rewrittenArguments =
-                zip(
-                    invocation.getArguments(),
-                    rewrittenMethodDescriptor.getParameterTypeDescriptors(),
-                    PropagateNullability::propagateNullabilityToExpression);
+                Streams.zip(
+                        invocation.getArguments().stream(),
+                        rewrittenMethodDescriptor.getParameterTypeDescriptors().stream(),
+                        PropagateNullability::propagateNullabilityToExpression)
+                    .collect(toImmutableList());
 
             if (rewrittenMethodDescriptor.equals(methodDescriptor)
                 && rewrittenArguments.equals(invocation.getArguments())) {
@@ -323,12 +324,15 @@ public Node rewriteFunctionExpression(FunctionExpression functionExpression) {
             ImmutableList<TypeDescriptor> typeArgumentDescriptors =
                 toNonRawTypeDescriptor(functionalInterface).getTypeArgumentDescriptors();
             ImmutableList<TypeDescriptor> inferredTypeArgumentDescriptors =
-                zip(
-                    typeParameterDescriptors,
-                    typeArgumentDescriptors,
-                    (typeParameterDescriptor, typeArgumentDescriptor) ->
-                        propagateTypeArgumentNullabilityFromReturnExpressions(
-                            typeParameterDescriptor, typeArgumentDescriptor, functionExpression));
+                Streams.zip(
+                        typeParameterDescriptors.stream(),
+                        typeArgumentDescriptors.stream(),
+                        (typeParameterDescriptor, typeArgumentDescriptor) ->
+                            propagateTypeArgumentNullabilityFromReturnExpressions(
+                                typeParameterDescriptor,
+                                typeArgumentDescriptor,
+                                functionExpression))
+                    .collect(toImmutableList());
             DeclaredTypeDescriptor inferredFunctionalInterface =
                 functionalInterface.withTypeArguments(inferredTypeArgumentDescriptors);
             Streams.forEachPair(

transpiler/java/com/google/j2cl/transpiler/passes/PropagateNullabilityInOverrides.java

@@ -15,6 +15,8 @@
  */
 package com.google.j2cl.transpiler.passes;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
 import com.google.common.collect.Streams;
 import com.google.j2cl.transpiler.ast.AbstractRewriter;
 import com.google.j2cl.transpiler.ast.CompilationUnit;
@@ -74,11 +76,12 @@ private static MethodDescriptor propagateNullability(MethodDescriptor from, Meth
                 specialize(parametrization, from.getReturnTypeDescriptor()),
                 to.getReturnTypeDescriptor()))
         .setParameterDescriptors(
-            zip(
-                from.getParameterTypeDescriptors(),
-                to.getParameterDescriptors(),
-                (fromTd, toPd) ->
-                    propagateParameterNullability(specialize(parametrization, fromTd), toPd)))
+            Streams.zip(
+                    from.getParameterTypeDescriptors().stream(),
+                    to.getParameterDescriptors().stream(),
+                    (fromTd, toPd) ->
+                        propagateParameterNullability(specialize(parametrization, fromTd), toPd))
+                .collect(toImmutableList()))
         .build();
   }