Add the final assignment of the property to the partial value object's source code.
510988
public void addPartialFieldAssignment(
      SourceBuilder code, Excerpt finalField, String builder) {
    addFinalFieldAssignment(code, finalField, builder);
  }
384380
def assign_value(self, comp_def, value, src_ref):
        
        super().assign_value(comp_def, value, src_ref)
        if "rclr" in comp_def.properties:
            del comp_def.properties["rclr"]
        if "rset" in comp_def.properties:
            del comp_def.properties["rset"]
968523
def assign_value(self, comp_def, value, src_ref):
        
        super().assign_value(comp_def, value, src_ref)
        comp_def.properties['incrthreshold'] = value
402714
def add_final_state(self, f):

        
        if f not in self.Q:
            LOG.error("The specified value is invalid, f must be a member of Q")
            raise InputError("The specified value is invalid, f must be a member of Q")

        self.F.add(f)
1350380
public static void assignBidirectionalAssociations(Object object, Map source, PersistentEntity persistentEntity) {
        if (source == null) {
            return;
        }

        for (Object key : source.keySet()) {
            String propertyName = key.toString();
            if (propertyName.indexOf('.') > -1) {
                propertyName = propertyName.substring(0, propertyName.indexOf('.'));
            }
            PersistentProperty prop = persistentEntity.getPropertyByName(propertyName);

            if (prop != null && prop instanceof OneToOne && ((OneToOne) prop).isBidirectional()) {
                Object val = source.get(key);
                PersistentProperty otherSide = ((OneToOne) prop).getInverseSide();
                if (val != null && otherSide != null) {
                    MetaClass mc = GroovySystem.getMetaClassRegistry().getMetaClass(val.getClass());
                    try {
                        mc.setProperty(val, otherSide.getName(), object);
                    }
                    catch (Exception e) {
                        // ignore
                    }
                }
            }

        }
    }
495885
public void assign(RPCParameters source) {
        clear();

        for (RPCParameter param : source.params) {
            params.add(new RPCParameter(param));
        }
    }
793824
def _add(self, codeobj):
        """"""
        assert isinstance(codeobj, (CodeNamespace, CodeClass,
                                    CodeFunction, CodeVariable))
        self.children.append(codeobj)
259658
private void addPropertyStateExtractMethod() {
        MethodInfo mi = mClassFile.addMethod(Modifiers.PRIVATE, PROPERTY_STATE_EXTRACT_METHOD_NAME,
                                             TypeDesc.INT, new TypeDesc[] {TypeDesc.STRING});

        addPropertySwitch(new CodeBuilder(mi), SWITCH_FOR_STATE);
    }
667635
public void addToStringCondition(SourceBuilder code) {
    checkState(initialState() == Initially.OPTIONAL);
    code.add("%s != null", property.getField());
  }
495541
@SuppressWarnings("WeakerAccess")
    void addOrReplaceProperty(final String name, final Object value) {
        final String currentValue = SecurityActions.setPropertyPrivileged(name, value.toString());
        if (currentValue != null) {
            propertiesToReset.put(name, currentValue);
        } else {
            propertiesToClear.add(name);
        }
    }
265165
private void addPropertyData(
      Property.Builder propertyBuilder,
      TypeElement valueType,
      ExecutableElement method,
      Optional<JacksonSupport> jacksonSupport) {
    TypeMirror propertyType = getReturnType(valueType, method, types);
    propertyBuilder
        .setAllCapsName(camelCaseToAllCaps(propertyBuilder.getName()))
        .setType(propertyType)
        .setFullyCheckedCast(CAST_IS_FULLY_CHECKED.visit(propertyType));
    if (jacksonSupport.isPresent()) {
      jacksonSupport.get().addJacksonAnnotations(propertyBuilder, method);
    }
    if (propertyType.getKind().isPrimitive()) {
      PrimitiveType unboxedType = types.getPrimitiveType(propertyType.getKind());
      TypeMirror boxedType = types.erasure(types.boxedClass(unboxedType).asType());
      propertyBuilder.setBoxedType(boxedType);
    }
  }
911191
public void assign(Iterable<?> source) {
        clear();
        int i = 0;
        
        for (Object value : source) {
            values.put(Integer.toString(++i), value);
        }
    }
966875
public void setGlobalVariable(String name, Element value, boolean finalFlag) {

		assert (name != null);

		// Either modify an existing value (with appropriate checks) or add a
		// new one.
		if (globalVariables.containsKey(name)) {

			GlobalVariable gvar = globalVariables.get(name);
			gvar.setValue(value);
			gvar.setFinalFlag(finalFlag);

		} else if (value != null) {
			GlobalVariable gvar = new GlobalVariable(finalFlag, value);
			globalVariables.put(name, gvar);
		}
	}
951925
public void put(final K key, V value) {
        ManagedReference<V> ref = new ManagedReference<V>(bundle, value) {
            @Override
            public void finalizeReference() {
                super.finalizeReference();
                internalMap.remove(key, get());
            }
        };
        internalMap.put(key, ref);
    }
63964
function(dest_container, source_container, property_name) {

		var name,
			dest = dest_container[property_name],
			source = source_container[property_name];

		for (name in source) {

			if (!(name in dest)) {

				dest[name] = source[name];

			}

		}

	}
424802
function baseAssignValue(object, key, value) {
        if (key == "__proto__" && defineProperty) {
            defineProperty(object, key, {
                configurable: true,
                enumerable: true,
                value: value,
                writable: true
            });
        } else {
            object[key] = value;
        }
    }
137335
function addPartial(filename, done) {
      // Create a copy of the file and delete it from the database.
      const file = clone(files[filename])
      delete files[filename]

      // Compile the partial.
      const info = path.parse(filename)
      const transform = info.ext ? info.ext.substring(1) : null
      const transformer = getTransformer(transform)
      if (transformer) {
        // Construct the options.
        const options = extend({}, metalsmith.metadata(), file, {
          filename: path.join(metalsmith.source(), filename)
        })

        // Compile the partial.
        transformer.compileAsync(file.contents.toString(), options).then(template => {
          /**
           * Define the partial as a function.
           */
          metalsmith.metadata().partials[info.name] = locals => {
            const opt = extend({}, options, locals)
            return template.fn.apply(file, [opt])
          }
          metalsmith.metadata().partials[info.name].file = file
          done()
        }, done)
      } else {
        // Do not error out when the Transformer is not found.
        done()
      }
    }