@Inject private org.eclipse.xtext.common.types.TypesFactory typesFactory
    @Inject private org.eclipse.xtext.common.types.util.TypeReferences references

    val tp = typesFactory.createJvmTypeParameter()
    tp.name = "T"

        members += operation.toMethod(operation.name, references.createTypeRef(tp)) [
            typeParameters += tp
            parameters += params.head.toParameter(p.name, references.createTypeRef(tp))
            // ...
        ]

        members += operation.toMethod(f.name, references.createTypeRef(tp)) [
            typeParameters += tp
            parameters += params.head.toParameter(p.name, references.createTypeRef(tp))
            // ...
        ]
       members += operation.toMethod(f.name+"X", references.createTypeRef(tp)) [
            typeParameters += tp
            parameters += params.head.toParameter(p.name, references.createTypeRef(tp))
            // ...
        ]

	val genericTypes = method.createJvmTypeParameter()
	members += method.toMethod(method.declaration.methodName, method.type().cloneWithProxies) [
				
		genericTypes.forEach[tp|
			typeParameters += tp.cloneWithProxies
		]...
	]

	val genericTypesX = method.createJvmTypeParameter()
	members += method.toMethod(method.declaration.methodName+"X", method.type().cloneWithProxies) [
		genericTypesX.forEach[tp|
			typeParameters += tp.cloneWithProxies	
		]...
	]

	val genericTypes = method.createJvmTypeParameter()
	members += method.toMethod(method.declaration.methodName, method.type().cloneWithProxies) [
				
		genericTypes.forEach[tp|
			typeParameters += tp.cloneWithProxies
		]...
	]

	val genericTypesX = method.createJvmTypeParameter()
	members += method.toMethod(method.declaration.methodName+"X", method.type().cloneWithProxies) [
		genericTypesX.forEach[tp|
			typeParameters += tp.cloneWithProxies	
		]...
	]

val genericTypesX = method.createJvmTypeParameter()

    val tp = typesFactory.createJvmTypeParameter()
    tp.name = "T"

	val tp = typesFactory.createJvmTypeParameter()
	tp.name = "T"
	members += method.toMethod(method.declaration.methodName, method.type().cloneWithProxies) [
				
		typeParameters += tp.cloneWithProxies
		...
	]

	val tpX = typesFactory.createJvmTypeParameter()
	tpX.name = "T"
	members += method.toMethod(method.declaration.methodName+"X", method.type().cloneWithProxies) [
		typeParameters += tpX.cloneWithProxies
		...
	]

typeParameters += tp // .cloneWithProxies

  members += operation.toMethod(operation.name, references.createTypeRef(typeParameterT)) [ ...

	def dispatch void infer(Class element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
		acceptor.accept(element.toClass("my.class."+element.name))[
			element.methods.forEach[method|
				val tp = typesFactory.createJvmTypeParameter()
				tp.name = method.generic
				members += method.toMethod(method.name, references.createTypeRef(tp))[
					typeParameters += tp
				]
				val tpX = typesFactory.createJvmTypeParameter()
				tpX.name = method.generic
				members += method.toMethod(method.name+"X", references.createTypeRef(tpX))[
					typeParameters += tpX
				]
			]
		]
	}

Method:
	'<' generic=ValidID '>' ...

Method:
	'<'generic=JvmTypeParameter'>' ...

element.methods.forEach[method|
	members += method.toMethod(method.name, method.type)[
		typeParameters += method.generic
	]
	members += method.toMethod(method.name+"X", method.type)[
		typeParameters += method.generic
	]
]

grammar lutte.typedmethodParameter.LUTTE1 with org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations

generate lUTTE1 "http://www.typedmethodParameter.lutte/LUTTE1"

Model:
	'BusinessClass' name = ValidID
	operations += Operation*
;
	
Operation:
	typedParameters += TypedParameter* 'op' operationType = JvmTypeReference name = ValidID '(' parameters+=JvmFormalParameter(','parameters+=JvmFormalParameter)*')'
	body = XBlockExpression 
;

TypedParameter:
	'<'typedParameter = JvmTypeParameter'>'
;

/*
 * generated by Xtext 2.12.0
 */
package lutte.typedmethodParameter.jvmmodel

import com.google.inject.Inject
import lutte.typedmethodParameter.lUTTE1.Model
import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer
import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder

class LUTTE1JvmModelInferrer extends AbstractModelInferrer {

	@Inject extension JvmTypesBuilder

	def dispatch void infer(Model element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
		acceptor.accept(element.toClass("test."+element.name))[
			element.operations.forEach[op|
				members += op.toMethod(op.name, op.operationType.cloneWithProxies)[
					op.typedParameters.forEach[parameter|
						typeParameters += parameter.typedParameter
					]
					op.parameters.forEach[parameter|
						parameters += parameter.cloneWithProxies
					]
					body = op.body
				]
				members += op.toMethod(op.name+"2", op.operationType.cloneWithProxies)[
					op.typedParameters.forEach[parameter|
						typeParameters += parameter.typedParameter
					]
					op.parameters.forEach[parameter|
						parameters += parameter.cloneWithProxies
					]
				]

			]
		]
	}
}

/*
 * generated by Xtext 2.12.0
 */
package lutte.typedmethodParameter.tests

import com.google.inject.Inject
import com.google.inject.Provider
import java.util.ArrayList
import lutte.typedmethodParameter.lUTTE1.Model
import org.eclipse.xtext.generator.InMemoryFileSystemAccess
import org.eclipse.xtext.resource.XtextResourceSet
import org.eclipse.xtext.testing.InjectWith
import org.eclipse.xtext.testing.XtextRunner
import org.eclipse.xtext.testing.util.ParseHelper
import org.eclipse.xtext.xbase.compiler.JvmModelGenerator
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
import org.eclipse.emf.common.util.URI

@RunWith(XtextRunner)
@InjectWith(LUTTE1InjectorProvider)
class LUTTE1ParsingTest {
	@Inject
	ParseHelper<Model> parseHelper
	@Inject private Provider<XtextResourceSet> resourceSetProvider;
	@Inject private JvmModelGenerator generator;
	
	@Test
	def void loadModel() {
		val resourceSet = resourceSetProvider.get
		resourceSet.classpathURIContext = this
		val result = parseHelper.parse('''
			BusinessClass Test
			<T> op T test(T t)
			{
				t
			}
		''', URI.createURI("test/Test.lutte1"), resourceSet)
		Assert.assertNotNull(result)
		Assert.assertTrue(result.eResource.errors.isEmpty)
		
        val fsa = new InMemoryFileSystemAccess()
        val resources = new ArrayList(resourceSet.resources)
		resources.forEach[resource|
	        generator.doGenerate(resource, fsa)
		]
        
        fsa.allFiles.entrySet.forEach[entry|
        	println(entry.key)
        ]
        val file = fsa.textFiles.get("DEFAULT_OUTPUTtest/Test.java").toString;
		Assert.assertEquals('''package test;

@SuppressWarnings("all")
public class Test {
  public <T> T test(final T t) {
    return t;
  }
  
  public <T> test2(final T t);
}
'''.toString.remove('\r'), file)
	}

	def String remove (String from, String value)
	{
		return from.replaceAll("("+value+")", "");
	}
}

org.junit.ComparisonFailure: expected:<... t;
  }
  
  public [<T> test2(final T] t);
}
> but was:<... t;
  }
  
  public [? test2(final ?] t);
}
>
	at org.junit.Assert.assertEquals(Assert.java:115)
	at org.junit.Assert.assertEquals(Assert.java:144)
	at lutte.typedmethodParameter.tests.LUTTE1ParsingTest.loadModel(LUTTE1ParsingTest.java:98)
...