public MutableMethodDeclaration implementMethod(final MutableMemberDeclaration delegate, final ResolvedMethod resolvedMethod) {
MutableMethodDeclaration _xblockexpression = null;
{
delegate.markAsRead();
final MethodDeclaration declaration = resolvedMethod.getDeclaration();
MutableTypeDeclaration _declaringType = delegate.getDeclaringType();
String _simpleName = declaration.getSimpleName();
final Procedure1<MutableMethodDeclaration> _function = new Procedure1<MutableMethodDeclaration>() {
public void apply(final MutableMethodDeclaration impl) {
Element _primarySourceElement = Util.this.context.getPrimarySourceElement(delegate);
Util.this.context.setPrimarySourceElement(impl, _primarySourceElement);
final HashMap<TypeReference, TypeReference> typeParameterMappings = CollectionLiterals.<TypeReference, TypeReference>newHashMap();
Iterable<? extends ResolvedTypeParameter> _resolvedTypeParameters = resolvedMethod.getResolvedTypeParameters();
final Procedure1<ResolvedTypeParameter> _function = new Procedure1<ResolvedTypeParameter>() {
public void apply(final ResolvedTypeParameter param) {
TypeParameterDeclaration _declaration = param.getDeclaration();
String _simpleName = _declaration.getSimpleName();
Iterable<? extends TypeReference> _resolvedUpperBounds = param.getResolvedUpperBounds();
final MutableTypeParameterDeclaration copy = impl.addTypeParameter(_simpleName, ((TypeReference[])Conversions.unwrapArray(_resolvedUpperBounds, TypeReference.class)));
TypeParameterDeclaration _declaration_1 = param.getDeclaration();
TypeReference _newTypeReference = Util.this.context.newTypeReference(_declaration_1);
TypeReference _newTypeReference_1 = Util.this.context.newTypeReference(copy);
typeParameterMappings.put(_newTypeReference, _newTypeReference_1);
}
};
IterableExtensions.forEach(_resolvedTypeParameters, _function);
Iterable<? extends TypeReference> _resolvedExceptionTypes = resolvedMethod.getResolvedExceptionTypes();
final Function1<TypeReference, TypeReference> _function_1 = new Function1<TypeReference, TypeReference>() {
public TypeReference apply(final TypeReference it) {
return Util.this.replace(it, typeParameterMappings);
}
};
Iterable<TypeReference> _map = IterableExtensions.map(_resolvedExceptionTypes, _function_1);
impl.setExceptions(((TypeReference[])Conversions.unwrapArray(_map, TypeReference.class)));
boolean _isVarArgs = declaration.isVarArgs();
impl.setVarArgs(_isVarArgs);
TypeReference _resolvedReturnType = resolvedMethod.getResolvedReturnType();
TypeReference _replace = Util.this.replace(_resolvedReturnType, typeParameterMappings);
impl.setReturnType(_replace);
Iterable<? extends ResolvedParameter> _resolvedParameters = resolvedMethod.getResolvedParameters();
final Procedure1<ResolvedParameter> _function_2 = new Procedure1<ResolvedParameter>() {
public void apply(final ResolvedParameter p) {
ParameterDeclaration _declaration = p.getDeclaration();
String _simpleName = _declaration.getSimpleName();
TypeReference _resolvedType = p.getResolvedType();
TypeReference _replace = Util.this.replace(_resolvedType, typeParameterMappings);
impl.addParameter(_simpleName, _replace);
}
};
IterableExtensions.forEach(_resolvedParameters, _function_2);
StringConcatenationClient _client = new StringConcatenationClient() {
@Override
protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
String _returnIfNeeded = Util.this.returnIfNeeded(resolvedMethod);
_builder.append(_returnIfNeeded, "");
CharSequence _delegateAccess = Util.this.delegateAccess(delegate, declaration);
_builder.append(_delegateAccess, "");
_builder.append(".");
String _simpleName = declaration.getSimpleName();
_builder.append(_simpleName, "");
_builder.append("(");
Iterable<? extends ParameterDeclaration> _parameters = declaration.getParameters();
final Function1<ParameterDeclaration, String> _function = new Function1<ParameterDeclaration, String>() {
public String apply(final ParameterDeclaration it) {
return it.getSimpleName();
}
};