@Override
                public DaemonRegistryContent update(DaemonRegistryContent oldValue) {
                    if (oldValue == null) {
                        return oldValue;
                    }
                    oldValue.removeInfo(((InetEndpoint)address).getPort());
                    return oldValue;
                }
            });
        } finally {
            lock.unlock();
        }

        Object oldValue;
        synchronized (delegate) {
            oldValue = delegate.putIfAbsent(key, value);
        }
        reportAccess(key, oldValue);
        if (oldValue == null) {
            // Properties disallow null values, so it is safe to assume that the map was changed.
            reportChange(key, value);
        }
        return oldValue;

    }

    @Override

            @Override
            public void run() {
                T oldValue = deserialize();
                result = updateAction.update(oldValue);
                if (!(oldValue == null && result == null) && (oldValue == null || result == null || !oldValue.equals(result))) {
                    serialize(result);
                } else {
                    result = oldValue;
                }
            }
        }

      Entry<K, V> e = RegularImmutableMap.makeImmutable(requireNonNull(entryArray[i]));
      entryArray[i] = e;
      V oldValue = forwardDelegate.putIfAbsent(e.getKey(), e.getValue());
      if (oldValue != null) {
        throw conflictException("key", e.getKey() + "=" + oldValue, entryArray[i]);
      }
      K oldKey = backwardDelegate.putIfAbsent(e.getValue(), e.getKey());
      if (oldKey != null) {

        }

        fun systemPropertyLoaded(key: Any, value: Any?, oldValue: Any?) {
            val loadedOldValue = when (val loadedSystemProperty = mutatedSystemProperties[key]) {
                is SystemPropertyLoad -> loadedSystemProperty.oldValue
                else -> oldValue
            }

            mutatedSystemProperties[key] = SystemPropertyLoad(key, value, loadedOldValue)

    }

    public LoadingValueReference(@CheckForNull ValueReference<K, V> oldValue) {
      this.oldValue = (oldValue == null) ? LocalCache.unset() : oldValue;
    }

    @Override
    public boolean isLoading() {
      return true;
    }

    @Override
    public boolean isActive() {
      return oldValue.isActive();
    }

    @Override
    public int getWeight() {

internal
class VintageEnvironmentChangeTracker : EnvironmentChangeTracker {

    override fun systemPropertyChanged(key: Any, value: Any?, consumer: String?) {}

    override fun systemPropertyLoaded(key: Any, value: Any?, oldValue: Any?) {}

    override fun systemPropertyOverridden(key: Any) {}

    public LoadingValueReference(ValueReference<K, V> oldValue) {
      this.oldValue = oldValue;
    }

    @Override
    public boolean isLoading() {
      return true;
    }

    @Override
    public boolean isActive() {
      return oldValue.isActive();
    }

    @Override
    public int getWeight() {
      return oldValue.getWeight();
    }

    @CanIgnoreReturnValue

  public V remove(@CheckForNull Object key) {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.remove(key);
    }
    Object oldValue = removeHelper(key);
    return (oldValue == NOT_FOUND) ? null : (V) oldValue;
  }

  private @Nullable Object removeHelper(@CheckForNull Object key) {
    if (needsAllocArrays()) {
      return NOT_FOUND;
    }
    int mask = hashTableMask();

        when:
        run "someTask"

        then:
        skipped(":someTask")
    }

    def "task is out of date when property type changes #oldValue -> #newValue"() {
        buildFile << """
task someTask {
    inputs.property("a", $oldValue).optional(true)
    outputs.file "out"
    doLast ${Actions.name}.doNothing() // attach an action that is not defined by the build script
}
"""
        given: