Function: 'function' name=ID '(' (parameters+=Parameter (',' parameters+=Parameter)*)? ')' 'endfunction';
Parameter: type=ParameterType reference?='&'? name=ID;
ParameterType: BasicType | 'any';
BasicType: 'integer'| 'float' | 'string';

function=[Function] '(' arguments+=Expression? (',' arguments+=Expression)* ')'

SomeRule returns Expression:
 ...
 | constant = Constant
 | function=[Function] '(' arguments+=Expression? (',' arguments+=Expression)* ')'
 (that is mentioned above)
 | ...
;
Constant: IntegerConstant | FloatConstant | StringConstant | CharacterConstant;
IntegerConstant: value=INTEGER | value=HEXA;
FloatConstant: value=FLOAT;
StringConstant: value=STRING;
CharacterConstant: value=CHARACTER;

Model:
	functions+=Function*
	calls+=Call*;
	
Function:
	"func" name=ID '(' (types+=DeclaredParameter (',' types+=DeclaredParameter)*)? ')' ':' returnType=Type
;
	
DeclaredParameter:
	name=ID ":" type=Type
;
Expression:
	Literal | Call
;

Literal:
	IntegerLiteral | StringLiteral
;

IntegerLiteral:
	value=INT
;

StringLiteral:
	value=STRING
;


enum Type: String | Integer;

Call:
	 func=[Function] '(' (params+=Expression (',' params+=Expression)*)? ')'
;	

class MyDslResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy {

	private final static Logger LOG = Logger.getLogger(MyDslResourceDescriptionStrategy);

	override createEObjectDescriptions(EObject eObject, IAcceptor<IEObjectDescription> acceptor) {
		if (eObject instanceof Function) {
			if (getQualifiedNameProvider() === null)
				return false;
			try {
				val QualifiedName qualifiedName = getQualifiedNameProvider().getFullyQualifiedName(eObject);
				if (qualifiedName !== null) {
					val userData = newHashMap
					if (eObject.returnType !== null) {
						userData.put("RETURN_TYPE", eObject.returnType.literal)
					}
					userData.put("PARAM_TYPES", eObject.types.map[type.literal].join(","))
					acceptor.accept(EObjectDescription.create(qualifiedName, eObject, userData));
				}
			} catch (Exception exc) {
				LOG.error(exc.getMessage(), exc);
			}
			return true;
		}
		return super.createEObjectDescriptions(eObject, acceptor)
	}

}

class MyDslImportedNamespaceAwareLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider {

	override protected internalGetAllDescriptions(Resource resource) {
		var Iterable<EObject> allContents = new Iterable<EObject>() {
			override Iterator<EObject> iterator() {
				return EcoreUtil.getAllContents(resource, false)
			}
		}
		var Iterable<IEObjectDescription> allDescriptions = scopedElementsFor(allContents, qualifiedNameProvider)
		return new MultimapBasedSelectable(allDescriptions)

	}

	def static <T extends EObject> Iterable<IEObjectDescription> scopedElementsFor(Iterable<? extends T> elements,
		Function<T, QualifiedName> nameComputation) {
		var Iterable<IEObjectDescription> transformed = Iterables.transform(elements, [ T from |
			val QualifiedName qualifiedName = nameComputation.apply(from)

			if (qualifiedName !== null) {
				if (from instanceof org.xtext.example.mydsl1.myDsl.Function) {
					val userData = newHashMap
					if (from.returnType !== null) {
						userData.put("RETURN_TYPE", from.returnType.literal)
					}
					userData.put("PARAM_TYPES", from.types.map[type.literal].join(","))
					return new EObjectDescription(qualifiedName, from, userData)
				}
				return new EObjectDescription(qualifiedName, from, null)
			}
		])
		return Iterables.filter(transformed, Predicates.notNull())
	}

}

class MyDslScopeProvider extends AbstractMyDslScopeProvider {
	
	override getScope(EObject context, EReference reference) {
		if (reference === MyDslPackage.Literals.CALL__FUNC) {
			if (context instanceof Call) {
				val actualSignature =
					context.params.map[
						p |
						if (p instanceof StringLiteral) {
							return Type.STRING.literal
						}
						if (p instanceof IntegerLiteral) {
							return Type.INTEGER.literal
						}
						if (p instanceof Call) {
							return p.func.returnType.literal
						}
					].join(",")
				return new FilteringScope(delegateGetScope(context, reference)) [
					val sig = getUserData("PARAM_TYPES")
					if (sig !== null) {
						return actualSignature == sig
					}
					return true
				]
			}
		}
		super.getScope(context, reference)
	}

}

class MyDslRuntimeModule extends AbstractMyDslRuntimeModule {
    
    def Class<? extends IDefaultResourceDescriptionStrategy> bindIDefaultResourceDescriptionStrategy() {
        MyDslResourceDescriptionStrategy
    }

 override configureIScopeProviderDelegate(Binder binder) {
        binder.bind(IScopeProvider).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(
            MyDslImportedNamespaceAwareLocalScopeProvider);

    }
}