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)
}

      }

      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) {

    }

    public void propertyMissing(String property, Object newValue) {
        doSetProperty(property, newValue);
    }

    @SuppressWarnings("deprecation")
    private void doSetProperty(String property, Object newValue) {
        PropertyHelper.getPropertyHelper(getProject()).setUserProperty(null, property, newValue);
    }

    public Object propertyMissing(String name) {

        return parent.remove(toCamelCase(key), value);
    }

    @Override
    public boolean replace(final K key, final V oldValue, final V newValue) {
        if (parent.replace(key, oldValue, newValue)) {
            return true;
        }
        return parent.replace(key, oldValue, newValue);
    }

    @Override
    public V replace(final K key, final V value) {
        // use original key

                doLast {
                    verify.prop.put('key', 'newValue')
                    verify.expected = ['key': 'newValue']
                }
            }

            task replacingPutWithProvider {
                doLast {
                    verify.prop.put('key', provider { 'newValue' })
                    verify.expected = ['key': 'newValue']
                }
            }

        }
    }

    @Override
    public void setProperty(String name, @Nullable Object newValue) {
        if (name.equals("properties")) {
            throw new ReadOnlyPropertyException("name", ExtraPropertiesExtension.class);
        }
        set(name, newValue);
    }

    @Override
    public Map<String, Object> getProperties() {
        return new HashMap<>(storage);
    }

  @CheckForNull
  public V replace(K key, V value) {
    return delegate().replace(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean replace(K key, V oldValue, V newValue) {
    return delegate().replace(key, oldValue, newValue);
  }

            return InvokerHelper.getProperty(clientModule, property);
        }

        @Override
        public void setProperty(String property, Object newValue) {
            InvokerHelper.setProperty(clientModule, property, newValue);
        }
    }

    public void replace(Transformer<? extends @org.jetbrains.annotations.Nullable Provider<? extends T>, ? super Provider<T>> transformation) {
        Provider<? extends T> newValue = transformation.transform(shallowCopy());
        if (newValue != null) {
            set(newValue);
        } else {
            set((T) null);
        }
    }

    override fun getProperty(propertyName: String?): Any? {
        return delegate.getProperty(propertyName)
    }

    override fun setProperty(propertyName: String?, newValue: Any?) {
        return delegate.setProperty(propertyName, newValue)
    }

    override fun getMetaClass(): MetaClass {
        return delegate.metaClass
    }

    override fun setMetaClass(metaClass: MetaClass?) {