docs: protected void appendSyntheticDefaultValuedParameterMethods(
  			XtendTypeDeclaration source,
  			JvmDeclaredType target,
  			GenerationContext context) {
  
  		// Generate the different operations.
  		final Iterator<Runnable> differedGeneration = context.getPreFinalizationElements().iterator();
  		while (differedGeneration.hasNext()) {
  			final Runnable runnable = differedGeneration.next();
  			differedGeneration.remove();
  			runnable.run();
  		}
  
  		// Generated the missed functions that are the result of the generation of operations
  		// with default values.
  		int actIndex = context.getActionIndex();
  
  		for (final Entry<ActionPrototype, JvmOperation> missedOperation : context.getInheritedOperationsToImplement()
  				.entrySet()) {
  
  			final String originalSignature = this.annotationUtils.findStringValue(
  					missedOperation.getValue(), DefaultValueUse.class);
  			if (!Strings.isNullOrEmpty(originalSignature)) {
  
  				// Find the definition of the operation from the inheritance context.
  				final JvmOperation redefinedOperation = context.getInheritedOverridableOperations().get(
  						this.sarlSignatureProvider.createActionPrototype(
  								missedOperation.getKey().getActionName(),
  								this.sarlSignatureProvider.createParameterTypesFromString(originalSignature)));
  				if (redefinedOperation != null) {
  					final ActionParameterTypes parameterTypes = this.sarlSignatureProvider.createParameterTypesFromJvmModel(
  							redefinedOperation.isVarArgs(), redefinedOperation.getParameters());
  					final QualifiedActionName qualifiedActionName = this.sarlSignatureProvider.createQualifiedActionName(
  							missedOperation.getValue().getDeclaringType(),
  							redefinedOperation.getSimpleName());
  
  					// Retreive the inferred prototype (including the prototypes with optional arguments)
  					InferredPrototype redefinedPrototype = this.sarlSignatureProvider.getPrototypes(
  							qualifiedActionName, parameterTypes);
  					if (redefinedPrototype == null) {
  						// The original operation was not parsed by the SARL compiler in the current run-time context.
  						redefinedPrototype = this.sarlSignatureProvider.createPrototypeFromJvmModel(
  								qualifiedActionName, redefinedOperation.isVarArgs(),
  								redefinedOperation.getParameters());
  					}
  
  					// Retreive the specification of the formal parameters that will be used for
  					// determining the calling arguments.
  					final List<InferredStandardParameter> argumentSpec = redefinedPrototype.getInferredParameterTypes().get(
  							missedOperation.getKey().getParametersTypes());
  
  					// Create the missed java operation.
  					final JvmOperation op = this.typeBuilder.toMethod(
  							source,
  							missedOperation.getValue().getSimpleName(),
  							missedOperation.getValue().getReturnType(),
  							null);
  					op.setVarArgs(missedOperation.getValue().isVarArgs());
  					op.setFinal(true);
  
  					final List<String> arguments = new ArrayList<>();
  
  					// Create the formal parameters.
  					for (final InferredStandardParameter parameter : argumentSpec) {
  						if (parameter instanceof InferredValuedParameter) {
  							final InferredValuedParameter inferredParameter = (InferredValuedParameter) parameter;
  							arguments.add(this.sarlSignatureProvider.toJavaArgument(
  									target.getIdentifier(), inferredParameter.getCallingArgument()));
  						} else {
  							arguments.add(parameter.getName());
  							final JvmFormalParameter jvmParam = this.typesFactory.createJvmFormalParameter();
  							jvmParam.setName(parameter.getName());
  							jvmParam.setParameterType(this.typeBuilder.cloneWithProxies(parameter.getType()));
  							this.associator.associate(parameter.getParameter(), jvmParam);
  							op.getParameters().add(jvmParam);
  						}
  					}
  
  					// Create the body
  					setBody(op,
  							it -> {
  							it.append(redefinedOperation.getSimpleName());
  							it.append("("); //$NON-NLS-1$
  							it.append(IterableExtensions.join(arguments, ", ")); //$NON-NLS-1$
  							it.append(");"); //$NON-NLS-1$
  						});
  
  					// Add the annotations.
  					addAnnotationSafe(op, DefaultValueUse.class, originalSignature);
  					appendGeneratedAnnotation(op, context);
  
  					// Add the operation in the container.
  					target.getMembers().add(op);
  					++actIndex;
  				}
  			}
  		}
  		context.setActionIndex(actIndex);
  	}