ResourceDescriptionsProvider.getResourceDescriptions(eObject).getExportedObjects()

Operation:
name=ID '('...params..')' ;

OpCall:
reference = [Operation]

class B{}
class A {
a:String; 			
myOp(age: B, name:String){
this.a;
}}

B,
 A, 
 A.a, 
 A.myOp(age[0..1],String[0..1]):void, 
 A.myOp(age[0..1],String[0..1]):void.age, 
 A.myOp(age[0..1],String[0..1]):void.name

OpCall:
reference = [Operation] ('(' (expression+=Expression ("," expression+=Expression)*)? ')' )?

myOp(new B(), "asdf")

	class Tester {
		f (x: Integer){
}
  		f (x: Boolean){
}

		public useF(){ 
			 f(true);
		}    
	}

Model:
	elements+=Element*;
	
Element:
	Operation | Call
;

enum DataType:
	string | int | boolean
;

Operation:
	"def" name=ID "(" ( parameter+=Parameter ("," parameter+=Parameter )*)? ")"
;

Parameter:
	type=DataType name=ID
;

Call:
	"call" operation=[Operation] "(" (parameter+=Expression (","parameter+=Expression)*)? ")"
;

Expression:
	StringLiteral | IntLiteral | BooleanLiteral
;

StringLiteral:
	value=STRING
;

IntLiteral:
	value=INT
;

BooleanLiteral:
	{BooleanLiteral} (value?='true' | 'false')
;

class MyDslImportedNamespaceAwareLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider {
	
	override ISelectable internalGetAllDescriptions(Resource resource) {
		val Iterable<EObject> allContents = new Iterable<EObject>(){
			override Iterator<EObject> iterator() {
				return EcoreUtil.getAllContents(resource, false);
			}
		}; 
		val Iterable<IEObjectDescription> allDescriptions = scopedElementsFor(allContents, qualifiedNameProvider);
		return new MultimapBasedSelectable(allDescriptions);
	}
	
	def <T extends EObject> Iterable<IEObjectDescription> scopedElementsFor(Iterable<? extends T> elements,
			Function<T, QualifiedName> nameComputation) {
		val Iterable<IEObjectDescription> transformed = Iterables.transform(elements,
				new Function<T, IEObjectDescription>() {
					override IEObjectDescription apply(T from) {
						val QualifiedName qualifiedName = nameComputation.apply(from);
						var Map<String,String> data = null
						if (from instanceof Operation) {
							data = <String,String>newHashMap("signature" -> from.parameter.map[type.literal].join(","))
						}
						if (qualifiedName != null)
							return new EObjectDescription(qualifiedName, from, data);
						return null;
					}
				});
		return Iterables.filter(transformed, Predicates.notNull());
	}
	
}

class MyDslResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy {
	
	private final static Logger LOG = Logger.getLogger(MyDslResourceDescriptionStrategy)
	
	override createEObjectDescriptions(EObject eObject, IAcceptor<IEObjectDescription> acceptor) {
		if (eObject instanceof Operation) {
			createOperationDescriptions(eObject,acceptor)
		}
		super.createEObjectDescriptions(eObject, acceptor)
	}
	
	def boolean createOperationDescriptions(Operation eObject, IAcceptor<IEObjectDescription> acceptor) {
		if (getQualifiedNameProvider() == null)
			return false;
		try {
			val QualifiedName qualifiedName = getQualifiedNameProvider().getFullyQualifiedName(eObject);
			if (qualifiedName != null) {
				val data = newHashMap
				data.put("signature", eObject.parameter.map[type.literal].join(","))
				acceptor.accept(EObjectDescription.create(qualifiedName, eObject,data));
			}
		} catch (Exception exc) {
			LOG.error(exc.getMessage(), exc);
		}
		return true;
	}
	
}

class MyDslScopeProvider extends AbstractDeclarativeScopeProvider {

	def IScope scope_Call_operation(Call ctx, EReference ref) {
		new FilteringScope(delegateGetScope(ctx,ref)) [
			val signature = ctx.parameter.map[p|
				val x = switch(p) {
					StringLiteral: DataType.STRING
					BooleanLiteral: DataType.BOOLEAN
					IntLiteral: DataType.INT
				}
				x.literal
			].join(",")
			getUserData("signature") == signature
		]
	}

}

public class MyDslRuntimeModule extends org.xtext.example.mydsl2.AbstractMyDslRuntimeModule {

	public Class<? extends IDefaultResourceDescriptionStrategy> bindIDefaultResourceDescriptionStrategy() {
		return MyDslResourceDescriptionStrategy.class;
	}
	
	public void configureIScopeProviderDelegate(Binder binder) {
		binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(MyDslImportedNamespaceAwareLocalScopeProvider.class);
	}
	
}

new Iterable<EObject>(){
			override Iterator<EObject> iterator() {
				return EcoreUtil.getAllContents(resource, false); 
			}
		}; 

class MyDslLinkingService extends DefaultLinkingService {

	@Inject
	@LinkingScopeProviderBinding
	private IScopeProvider scopeProvider;

	@Inject
	private Provider<ImportedNamesAdapter> importedNamesAdapterProvider;

	@Inject
	private LinkingHelper linkingHelper;

	@Inject
	private IQualifiedNameConverter qualifiedNameConverter;

	override getLinkedObjects(EObject context, EReference ref, INode node) throws IllegalNodeException {
		val o = NodeModelUtils.findActualSemanticObjectFor(node)
		println(o)
		if (o instanceof Call) {
			val signature = o.parameter.map [ p |
				val x = switch (p) {
					StringLiteral: DataType.STRING
					BooleanLiteral: DataType.BOOLEAN
					IntLiteral: DataType.INT
				}
				x.literal
			].join(",")

			val EClass requiredType = ref.getEReferenceType();
			if (requiredType == null)
				return Collections.<EObject>emptyList();

			val String crossRefString = getCrossRefNodeAsString(node);
			if (crossRefString != null && !crossRefString.equals("")) {
				val IScope scope = getScope(context, ref);
				val QualifiedName qualifiedLinkName = qualifiedNameConverter.toQualifiedName(crossRefString);
				val eObjectDescriptions = scope.getElements(qualifiedLinkName);
				for (eObjectDescription : eObjectDescriptions) {
					if (eObjectDescription != null && eObjectDescription.getUserData("signature") == signature)
						return Collections.singletonList(eObjectDescription.getEObjectOrProxy());
				}
				
			}
			return Collections.emptyList();
		}

		super.getLinkedObjects(context, ref, node)

	}

}

	class Tester {
		f (x: Integer){
}
  		f (x: Boolean){
}

		public useF(){ 
			 this.f(true);
		}    
	}

def <T extends EObject> Iterable<IEObjectDescription> scopedElementsForWithSignature(Iterable<? extends T> elements,
		Function<T, QualifiedName> nameComputationFunction) {

		val Iterable<IEObjectDescription> formatedOperations = Iterables.transform(elements,
			new Function<T, IEObjectDescription>() {

				override IEObjectDescription apply(T from) {
					val QualifiedName qualifiedName = nameComputationFunction.apply(from);

					//this is the arbitrary user data of an EOject in an EObjectDescription
					var Map<String, String> data = null
					if (from instanceof Operation) {
						val sig = QualifiedNameFormatter.createOperationSignature(from)
						data = <String, String>newHashMap("signature" -> sig)
					}
					if (qualifiedName != null)
						return new EObjectDescription(qualifiedName, from, data);
					return null;
				}
			});
		return Iterables.filter(formatedOperations, Predicates.notNull());
	}

val eObjectDescrs = createEObjectDesrcList(elements, QualifiedName.wrapper(SimpleAttributeResolver.NAME_RESOLVER));
val finalScope =  new SimpleScope(parentScope, innerScopeElementsIObjectDescr);