if (inputReferences.isEmpty()) {
            return ImmutableList.of();
        }
        ImmutableList.Builder<ModelBinding> bindings = ImmutableList.builderWithExpectedSize(inputReferences.size());
        for (BindingPredicate inputReference : inputReferences) {
            bindings.add(binding(inputReference, descriptor, false, inputBindAction));
        }
        return bindings.build();
    }

                overflowed = true
                return false
            }
            val uniqueProblem = UniquePropertyProblem.of(problem)
            if (uniqueProblems.add(uniqueProblem) && causes.size < maxCauses) {
                problem.exception?.let {
                    causes.add(it)
                }
            }
            return true
        }
    }
}


internal

class WriteIdentities {

    private
    val instanceIds = IdentityHashMap<Any, Int>()

    fun getId(instance: Any) = instanceIds[instance]

    fun putInstance(instance: Any): Int {
        val id = instanceIds.size
        instanceIds[instance] = id
        return id
    }
}


class ReadIdentities {

    private
    val instanceIds = HashMap<Int, Any>()

    fun getInstance(id: Int) = instanceIds[id]

            if (stringList.isEmpty()) {
                return "";
            }
            if (stringList.size() == 1) {
                return stringList.get(0);
            }
            int bound = stringList.size() - 1;
            return String.join(", ", stringList.subList(0, bound)) + " or " + stringList.get(bound);
        });
    }

 * </p>
 */
public interface Collector<T> extends ValueSupplier {
    Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest);

    int size();

    void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor);

    /**
     * Returns a view of this collector that never returns a missing value.
     */

                x = 5
            }
            """.trimIndent(),
            defaultCodeResolver(elementFilter = AnalysisStatementFilterUtils.isCallNamed("n2").not())
        )

        assertEquals(1, result.assignments.size)
        assertEquals("4", result.assignments.single().rhs.originElement.sourceData.text())
    }

        Class<T> operationType,
        Consumer<TestBuildOperationRunner.Log.TypedRecord<D, R>> verifier
    ) {
        assert buildOperationRunner.log.records.size() == 1
        interaction {
            verifier.accept(buildOperationRunner.log.mostRecent(operationType))
        }
    }

    }

    private
    fun ResolutionResult.isSuccessful() {
        assertTrue { errors.isEmpty() }
        assertTrue { additions.size == 1 }
    }

    private
    fun ResolutionResult.isError(errorReason: KClass<out ErrorReason>) {
        assertTrue { errors.any { errorReason.isInstance(it.errorReason) } }
    }

    private

                    assertMutable();
                    iterator.remove();
                }
            };
        }

        @Override
        public int size() {
            return delegate().size();
        }

        @Override
        public boolean contains(Object o) {
            return delegate().contains(o);
        }

        @Override

                instanceOf<SubmittedModelRequest>(),
                instanceOf<ReceivedModelResponse>(),
                instanceOf<ResolvedDependencies>()
            )
        )
        assertThat(events.size, equalTo(4))
        assertNoEditorReport()
    }

    fun <T : ResolverEvent> assertLastEventIsInstanceOf(eventType: KClass<T>) {
        assertThat(
            events.last().event,