}

    @Override
    public T get() {
        return fileAccess.readFile((Supplier<T>) this::deserialize);
    }

    @Override
    public void set(final T newValue) {
        fileAccess.writeFile(() -> serialize(newValue));
    }

    @Override
    public T update(final UpdateAction<T> updateAction) {
        class Updater implements Runnable {
            private final UpdateAction<T> updateAction;

    private ValueCollector newConventionValue(Iterable<?> paths) {
        return newValue(getBaseValue(false), paths);
    }

    private ValueCollector newConventionValue(Object[] paths) {
        return newValue(getBaseValue(false), paths);
    }

    private ValueCollector newExplicitValue(Iterable<?> paths) {
        return newValue(getBaseValue(true), paths);
    }

	// ok, albeit maybe confusing for a debugger.
	ls := f.fe.SplitSlot(name, sfx, offset, t)
	f.CanonicalLocalSplits[lssk] = &ls
	return &ls
}

// newValue allocates a new Value with the given fields and places it at the end of b.Values.
func (f *Func) newValue(op Op, t *types.Type, b *Block, pos src.XPos) *Value {
	var v *Value
	if f.freeValues != nil {
		v = f.freeValues
		f.freeValues = v.argstorage[0]

    doTestSet(e3());
  }

  private void doTestSet(E newValue) {
    int index = aValidIndex();
    E initialValue = getList().get(index);
    assertEquals(
        "set(i, x) should return the old element at position i.",
        initialValue,
        getList().set(index, newValue));
    assertEquals("After set(i, x), get(i) should return x", newValue, getList().get(index));

        public CompilationState get() {
            return compilationStateIndexedCache.getIfPresent(taskPath);
        }

        @Override
        public void set(CompilationState newValue) {
            compilationStateIndexedCache.put(taskPath, newValue);
        }

        @Override
        public CompilationState update(UpdateAction<CompilationState> updateAction) {
            throw new UnsupportedOperationException();
        }

        }

        newValue = computingValueReference.compute(key, function);
        if (newValue != null) {
          if (valueReference != null && newValue == valueReference.get()) {
            computingValueReference.set(newValue);
            e.setValueReference(valueReference);
            recordWrite(e, 0, now); // no change in weight
            return newValue;
          }
          try {

        if (!escape) {
            return value;
        }

        String newValue = value;
        for (final String element : Constants.RESERVED) {
            final String replacement = element.replaceAll("(.)", "\\\\$1");
            newValue = newValue.replace(element, replacement);
        }
        return newValue;
    }

    public String build() {

    doTestSet(e3());
  }

  private void doTestSet(E newValue) {
    int index = aValidIndex();
    E initialValue = getList().get(index);
    assertEquals(
        "set(i, x) should return the old element at position i.",
        initialValue,
        getList().set(index, newValue));
    assertEquals("After set(i, x), get(i) should return x", newValue, getList().get(index));

      }

      while (true) {
        int oldValue = existingCounter.get();
        if (oldValue != 0) {
          try {
            int newValue = IntMath.checkedAdd(oldValue, occurrences);
            if (existingCounter.compareAndSet(oldValue, newValue)) {
              // newValue can't == 0, so no need to check & remove
              return oldValue;
            }
          } catch (ArithmeticException overflow) {

	return p.underlyingTypeProvider.FindStructFieldType(structType, fieldName)
}

// NewValue creates a new type value from a qualified name and map of fields.
func (p *TypeProvider) NewValue(structType string, fields map[string]ref.Val) ref.Val {
	t, ok := p.typeResolver.Resolve(structType)
	if ok {
		return t.Val(fields)
	}
	return p.underlyingTypeProvider.NewValue(structType, fields)
}