Adrian Kuegel <******@****.***> 1648469008 -0700

SideEffects GetSideEffectsFromEffectInstance(
    const MemoryEffects::EffectInstance& effect_instance, Operation* op) {
  mlir::SideEffects::Effect* effect = effect_instance.getEffect();
  SideEffects side_effects;
  if (isa<MemoryEffects::Allocate>(effect)) {
    side_effects.SetAlloc();
  } else if (isa<MemoryEffects::Free>(effect)) {
    side_effects.SetFree();

        given:
        def sideEffect1 = Mock(ValueSupplier.SideEffect)
        def sideEffect2 = Mock(ValueSupplier.SideEffect)
        def sideEffect3 = Mock(ValueSupplier.SideEffect)
        def sideEffect4 = Mock(ValueSupplier.SideEffect)
        def sideEffect5 = Mock(ValueSupplier.SideEffect)
        def propertyFactory = new DefaultPropertyFactory(Stub(PropertyHost))

        nouts = node.args[6].value
        # TODO(mdan): Look at the actual types out of if_body.
        side_effects = {
            qual_names.QN(n.value): {TFRTypes.TENSOR}
            for n in node.args[5].elts[:nouts]
        }
        return {type(None)}, side_effects

      if name == QN(QN('ag__'), attr='for_stmt'):
        assert isinstance(node.args[2], ast.Name)

        given:
        def sideEffect1 = Mock(ValueSupplier.SideEffect)
        def sideEffect2 = Mock(ValueSupplier.SideEffect)
        def counter = new AtomicInteger(23)
        def parent = Providers.changing { counter.getAndIncrement() }.withSideEffect(sideEffect1)
        def provider = Providers.internal(parent.flatMap { Providers.of(it * 2).withSideEffect(sideEffect2) })

        when:

    def "runs chained side effects when calling '#method' on provider with value"() {
        given:
        def sideEffect1 = Mock(ValueSupplier.SideEffect)
        def sideEffect2 = Mock(ValueSupplier.SideEffect)
        def parent = providerWithValue(someValue())
        def provider = parent.withSideEffect(sideEffect1).withSideEffect(sideEffect2)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)

        def sideEffect1 = Mock(ValueSupplier.SideEffect)
        def sideEffect2 = Mock(ValueSupplier.SideEffect)
        def expectedUnpackedValue = ["some value", "simple value", "other value"]

        when:
        property.add(Providers.of("some value").withSideEffect(sideEffect1))
        property.add(Providers.of("simple value"))

        private CompositeSideEffect(Iterable<SideEffect<? super T>> sideEffects) {
            this.sideEffects = ImmutableList.copyOf(sideEffects);
        }

        @Override
        public void execute(T t) {
            for (SideEffect<? super T> sideEffect : sideEffects) {
                sideEffect.execute(t);
            }
        }

        @Override
        public String toString() {

        def sideEffect1 = Mock(ValueSupplier.SideEffect)
        def sideEffect2 = Mock(ValueSupplier.SideEffect)

        when:
        property.put("some key", Providers.of("some value").withSideEffect(sideEffect1))
        property.putAll(Providers.of(["other key": "other value"]).withSideEffect(sideEffect2))
        def keySetProvider = property.keySet()
        then:

    }

    fun collectSideEffects(): List<BlockAddress> = entries.toList()

    fun write(sideEffect: BuildTreeModelSideEffect) {
        val blockAddress = valuesStore.write(sideEffect)
        entries += blockAddress
    }

    fun restoreFromCacheEntry(sideEffects: List<BlockAddress>): List<BuildTreeModelSideEffect> {
        return sideEffects.map {
            valuesStore.read(it)
        }
    }

    private