grammar com.functions.xtext.Functions with org.eclipse.xtext.common.Terminals
generate intTerm "http://www.functions.com/xtext/Functions"

Module:
	(statements+=Statement)*;

Statement:
	Definition | Evaluation;
	
Definition:
	'def' returnType=Type name=ID ('(' types+=Type args+=DeclaredParameter (',' types+=Type args+=DeclaredParameter)* ')')? ';';

DeclaredParameter:
	name=VarName;
	
Type:
	IntegerType | StringType;

IntegerType:
	{IntegerType} type="Integer";

StringType:
	{StringType} type="String";
	
Evaluation:
	expression=Expression ';';

Expression returns Type:
	FunctionCall | Constant | IntegerAtom | StringAtom;
	
IntegerAtom returns IntegerType:
	{IntegerAtom } INT ;

StringAtom returns StringType:
	value=A_STRING;

FunctionCall returns Type:
	{FunctionCall} source=DefinitionRef '(' ( args+=Expression (',' args+=Expression)* )? ')';

DefinitionRef returns Type:
	{DefinitionRef} refName=[Definition];
	
Constant:
	'const' type=Type constName=CONSTNAME;

terminal A_STRING:
	'"' ('a'..'z')+ '"';

VarName:
	{VarName} value=A_VARNAME;
	
terminal A_VARNAME:
	('a'..'z')('a'..'z')+;

terminal CONSTNAME:
	'$'('A'..'Z')('a'..'z')+;

def Integer IntFunc1 (Integer parama, Integer paramb);
def Integer IntFunc2 (Integer param);
def String StringFunc (Integer param);

IntFunc1(2, 3); // okay
IntFunc1(5, IntFunc2(3)); // okay
IntFunc1(1, 2, 3); // not okay, but no error marker
IntFunc1(StringFunc(3)); // not okay, but no error marker

    @Override
    public IScope getScope(EObject context, EReference reference) {
        if (context instanceof FunctionCall && "refName".equals(reference.getName())) {
            IScope scope = super.getScope(context, reference);
            Predicate<IEObjectDescription> filter = new Predicate<IEObjectDescription>() {
                public boolean apply(IEObjectDescription input) {
                    if (input instanceof EObjectDescription) {
                        EObject eobj = ((EObjectDescription)input).getEObjectOrProxy();
                        if (eobj instanceof Definition) {
                            Type returnType = ((Definition)eobj).getReturnType();
                            
                            // check, if returnType matches the corresponding parameter
                            // how to access the right parameter?							
                            //if (returnType matches parameter) {
                            //    return true;
                            //}
                        }
                    }
                    return false;
                }
            };
            return new FilteringScope(scope, filter);
        }
        return super.getScope(context, reference);
    }


    IScope scope_DefinitionRef_refName(EObject context, EReference ref) {
        return new FilteringScope(delegateGetScope(context, ref), new Predicate<IEObjectDescription>() {

            //@Override
            public boolean apply(IEObjectDescription input) {
		// how to access the right parameter?
                return true;
            }
        });
    }