CollSpec:
    importSection=XImportSection?
    module = Module;


Module:
    'module' name=QualifiedName
    collaboration = Collaboration;


Collaboration:
    'collaboration' name=ValidID '{'
    (
            (roles+=CoordinatorRole) &
            (roles+=NonCoordinatorRole+)
    )
    '}'
;

CoordinatorRole:
    'coordinator' 'role' Role
;

NonCoordinatorRole:
    'role' Role
;

fragment Role:
    name=ValidID '{'
    features+=Feature*
    '}'
;

...

Feature:
    Property | Operation;

Property:
    name=ValidID ':' type=JvmTypeReference;

Operation:
    (isPlayerQualifierSet?='playable') 'op' name=ValidID
    '('(params+=FullJvmFormalParameter
    (',' params+=FullJvmFormalParameter)*)?')'
    ':' type=JvmTypeReference
    body=XBlockExpression?;

collaboration Test {
    coordinator role A {
    }
    role B {
        test:String
        playable op bar() :String {
            player.doSomething(String test)
        }
    }
}

public String bar() {
    player.performBRoleDoSomething() // something like getPlayer().doSomething() would be preferred actually.
    return null;
}

def dispatch void infer(NonCoordinatorRole role, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase, CollSpec collSpec){
        acceptor.accept(role.toClass('''«collSpec.module.fullyQualifiedName».«role.name»Role''')) [
            documentation = role.documentation
            if(!isPreIndexingPhase) {
                superTypes += AbstractRole.typeRef
                var playerRef = typesFactory.createJvmField()
                playerRef.type = typeRef('''«collSpec.module.fullyQualifiedName».I«role.name»RolePlayer''')
                playerRef.simpleName = 'player'
                playerRef.visibility = JvmVisibility.PRIVATE
                playerRef.type
                members += playerRef
            }
            for(feature : role.features) {
                switch feature {

                    Property : {
                        members += feature.toField(feature.name, feature.type)
                        members += feature.toGetter(feature.name, feature.type)
                        members += feature.toSetter(feature.name, feature.type)
                    }

                    Operation : {
                        members += feature.toMethod(feature.name, feature.type) [
                            documentation = feature.documentation
                            for(p : feature.params) {
                                parameters += p.toParameter(p.name, p.parameterType)
                            }
                            body = feature.body
                        ]
                    }
                }
            }
        ]
    }

    def void inferPlayerInterface(Role role, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase, CollSpec collSpec) {
        acceptor.accept(role.toClass('''«collSpec.module.fullyQualifiedName».I«role.name»RolePlayer''')) [
            setInterface = true
            for (feature : role.features) {
                if (feature instanceof Operation) {
                    if (feature.isPlayerQualifierSet) {
                        members += feature.toMethod('''perform«role.name»Role«feature.name.toFirstUpper»''', feature.type) [
                            documentation = feature.documentation
                            for(p : feature.params) {
                                parameters += p.toParameter(p.name, p.parameterType)
                            }

//                            body = feature.body
                        ]
                    }
                }
            }
        ]
    }

PlayerFeatureCall returns xBase::XExpression:
    {PlayerFeatureCall}
    'player'
    ((".")
    feature=[types::JvmIdentifiableElement|IdOrSuper] (
            =>explicitOperationCall?='('
            (
                    memberCallArguments+=XExpression (',' memberCallArguments+=XExpression)*
            )?
            ')')?
    );

def dispatch void infer(CollSpec collSpec, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
        infer(collSpec.module.collaboration,acceptor,isPreIndexingPhase,collSpec)
        collSpec.module.collaboration.roles.forEach [
            infer(it,acceptor,isPreIndexingPhase,collSpec)
        ]
        collSpec.module.collaboration.roles.forEach [
            inferPlayerInterface(it,acceptor,isPreIndexingPhase,collSpec)
        ]
    }

def void inferPlayerInterface(Role role, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase, CollSpec collSpec) {
        acceptor.accept(role.toClass('''«collSpec.module.fullyQualifiedName».I«role.name»RolePlayer''')) [
            setInterface = true
            for(feature : role.features) {
                if(feature instanceof Operation) {
                    if(feature.isPlayerQualifierSet) {
                        members += feature.toMethod('''perform«role.name»Role«feature.name.toFirstUpper»''', feature.type) [
                            setDefault = false
                            documentation = feature.documentation
                            for(p : feature.params) {
                                parameters += p.toParameter(p.name, p.parameterType)
                            }
                        ]
                    }
                    var playerReferences = feature?.body?.findPlayerReferences
                    for(featureCall : playerReferences) {
                        println(featureCall)
                        var op = typesFactory.createJvmOperation
                        members += featureCall.toMethod('''perform«role.name»Role«feature.name.toFirstUpper»«featureCall.feature.simpleName.toFirstUpper»''',if(featureCall.explicitReturnType) featureCall.returnType else Void.typeRef) [
                            setDefault = false
                            setAbstract = true
                        ]
                    }
                }
            }
        ]
    }

PlayerFeatureCall returns xBase::XExpression:
    (=>'player' '.' {PlayerFeatureCall}
    //('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')?
    feature=[types::JvmIdentifiableElement|IdOrSuper] (
            =>explicitOperationCall?='('
            (
                    //memberCallArguments+=XShortClosure
                    //|
                    memberCallArguments+=XExpression (',' memberCallArguments+=XExpression)*
            )?
            ')')?
    (=>explicitReturnType?='returns' returnType=JvmTypeReference)?
    //memberCallArguments+=XClosure?
    );

XPrimaryExpression returns xBase::XExpression:
    XConstructorCall |
    XBlockExpression |
    XSwitchExpression |
    XSynchronizedExpression |
    XFeatureCall |
    XLiteral |
    XIfExpression |
    XForLoopExpression |
    XBasicForLoopExpression |
    XWhileExpression |
    XDoWhileExpression |
    XThrowExpression |
    XReturnExpression |
    XTryCatchFinallyExpression |
    XParenthesizedExpression |
    PlayerFeatureCall
;

private def dispatch List<PlayerFeatureCall> findPlayerReferences(XExpression expr) {
        return newArrayList
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(Void expr) {
        return newArrayList
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XBlockExpression expr) {
        var result = newArrayList
        for(el : expr.expressions) {
            result.addAll(el.findPlayerReferences)
        }
        result
    }
    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XClosure expr) {
        var result = newArrayList
        result.addAll(expr.expression.findPlayerReferences)
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XIfExpression expr) {
        var result = newArrayList
        result.addAll(expr.getIf.findPlayerReferences)
        result.addAll(expr.getThen.findPlayerReferences)
        result.addAll(expr.getElse.findPlayerReferences)
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XForLoopExpression expr) {
        var result = newArrayList
        result.addAll(expr.forExpression.findPlayerReferences)
        result.addAll(expr.eachExpression.findPlayerReferences)
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XBasicForLoopExpression expr) {
        var result = newArrayList
        result.addAll(expr.eachExpression.findPlayerReferences)
        result.addAll(expr.expression.findPlayerReferences)
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XSwitchExpression expr) {
        var result = newArrayList
        result.addAll(expr.getSwitch.findPlayerReferences)
        result.addAll(expr.getDefault.findPlayerReferences)
        for(el : expr.cases) {
            result.addAll(el.findPlayerReferences)
        }
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XCasePart expr) {
        var result = newArrayList
        result.addAll(expr.getCase.findPlayerReferences)
        result.addAll(expr.getThen.findPlayerReferences)
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XAbstractWhileExpression expr) {
        var result = newArrayList
        result.addAll(expr.getPredicate.findPlayerReferences)
        result.addAll(expr.getBody.findPlayerReferences)
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XMemberFeatureCall expr) {
        var result = newArrayList
        result.addAll(expr.memberCallTarget.findPlayerReferences)
        result.addAll(expr.implicitFirstArgument.findPlayerReferences)
        result.addAll(expr.implicitReceiver.findPlayerReferences)
        result.addAll(expr.actualReceiver.findPlayerReferences)
        for(el : expr.memberCallArguments) {
            result.addAll(el.findPlayerReferences)
        }
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(PlayerFeatureCall expr) {
        var result = newArrayList
        result.add(expr)
        for(el : expr.memberCallArguments) {
            result.addAll(el.findPlayerReferences)
        }
        result
    }

    private def dispatch List<PlayerFeatureCall> findPlayerReferences(XAbstractFeatureCall expr) {
        var result = newArrayList
        result.addAll(expr.implicitFirstArgument.findPlayerReferences)
        result.addAll(expr.implicitReceiver.findPlayerReferences)
        result.addAll(expr.actualReceiver.findPlayerReferences)
        for(el : expr.actualArguments) {
            result.addAll(el.findPlayerReferences)
        }
        result
    }

Model:
	elements+=Element*
;

Element:
	"element" name=ID "{"
		operation=Operation
	"}"
;

Operation:
	"op" name=ID "("")" body=XBlockExpression
;

/*
 * generated by Xtext 2.11.0.RC2
 */
package org.xtext.example.mydsl.jvmmodel

import com.google.inject.Inject
import org.eclipse.xtext.Action
import org.eclipse.xtext.nodemodel.ICompositeNode
import org.eclipse.xtext.nodemodel.util.NodeModelUtils
import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer
import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder
import org.xtext.example.mydsl.myDsl.Element
import org.xtext.example.mydsl.services.MyDslGrammarAccess
import org.eclipse.xtext.RuleCall

/**
 * <p>Infers a JVM model from the source model.</p> 
 * 
 * <p>The JVM model should contain all elements that would appear in the Java code 
 * which is generated from the source model. Other models link against the JVM model rather than the source model.</p>     
 */
class MyDslJvmModelInferrer extends AbstractModelInferrer {

	@Inject extension JvmTypesBuilder

	@Inject extension MyDslGrammarAccess

	def dispatch void infer(Element element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
		acceptor.accept(element.toInterface("demo.I" + element.name + "Player", [])) [
			if (element.operation !== null) {
				val node = NodeModelUtils.findActualNodeFor(element.operation.body)
				// search the nodemodel. this is just an example. make sure you catch all cases
				if (node !== null) {
					for (e : node.asTreeIterable) {
						val ge = e.grammarElement
						if (ge instanceof Action) {
							if (ge === XMemberFeatureCallAccess.XMemberFeatureCallMemberCallTargetAction_1_1_0_0_0) {
								if (e instanceof ICompositeNode) {
									for (ex : e.children) {
										val gex = ex.grammarElement
										if (gex instanceof RuleCall) {
											if (gex.rule === XMemberFeatureCallRule) {
												val text = ex.text.trim
												if ("player".equals(text)) {
													var next = ex.nextSibling
													while (next !== null) {
														if (next.grammarElement ==
															XMemberFeatureCallAccess.
																featureJvmIdentifiableElementCrossReference_1_1_2_0) {
																	val ftext = next.text.trim
																	members +=
																		element.toMethod(ftext, Void.TYPE.typeRef)[]
																	next = null
																} else {
																	next = next.nextSibling
																}
															}
														}
													}
												}
											}
										}
									}
								}

							}
						}
					}
				]
				acceptor.accept(element.toClass("demo." + element.name)) [
					members += element.toField("player", ("demo.I" + element.name + "Player").typeRef)[]
					if (element.operation !== null) {
						members += element.operation.toMethod(element.operation.name, Void.TYPE.typeRef) [
							body = element.operation.body
						]
					}
				]
			}
		}
		

class MyDslJvmModelInferrer extends AbstractModelInferrer {

	@Inject extension JvmTypesBuilder

	@Inject extension MyDslGrammarAccess

	def dispatch void infer(Element element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
		acceptor.accept(element.toInterface("demo.I" + element.name + "Player", [])) [
			if (element.operation !== null) {
				for (XMemberFeatureCall c : EcoreUtil2.getAllContentsOfType(element.operation.body,
					XMemberFeatureCall)) {
					val node = NodeModelUtils.findNodesForFeature(c,
							XbasePackage.Literals.XMEMBER_FEATURE_CALL__MEMBER_CALL_TARGET).head
					if (node !== null) {
						val text = node.text.trim
						if ("player" == text) {
							val node2 = NodeModelUtils.findNodesForFeature(c,
							XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE).head
							if (node2 !== null) {
								val text2 = node2.text.trim
								members+= element.toMethod(text2, Void.TYPE.typeRef)[]
							}
						
						}
					}
				}
			}
		]
		acceptor.accept(element.toClass("demo." + element.name)) [
			members += element.toField("player", ("demo.I" + element.name + "Player").typeRef)[]
			if (element.operation !== null) {
				members += element.operation.toMethod(element.operation.name, Void.TYPE.typeRef) [
					body = element.operation.body
				]
			}
		]
	}
}