Model:
	classes+=Class*
;
Class:
	'class' name=ID '{'
		variables += Variable*
		statements += Statement*
	'}';	
Variable:
	name=ID ':' type=Type ';'
;
Type:
	PrimitiveType | ClassType
;
PrimitiveType:
	type=PrimitiveTypes
;
ClassType:
	refClass = [Class]
;
enum PrimitiveTypes:
	BOOL | INT | REAL 
;
Statement:
	lValue=LValue '=' rValue=RValue ';'
;
LValue:
	VariableRef
;
RValue:
	VariableRef | ConstantLiteral
;
VariableRef:
	variable=[Variable] ({VariableRef.qualifier=current} '.' variable=[Variable])*	
;
ConstantLiteral:
	value=INT
;

override getScope(EObject context, EReference reference) {
	if (reference == MyDslPackage.eINSTANCE.variableRef_Variable) {
		if (context instanceof VariableRef) {
			val type = context.qualifier?.variable?.type
			if (type instanceof ClassType) {
				return Scopes.scopeFor(type.refClass.variables)
			}
		}
	}
	return super.getScope(context, reference)
}

class A {
	x: INT;
        y: INT;
}
class B {
	vc: C;
}
class D {
	vb: B;
		
	vb.vc.va.x = 2;
}

class C {
	va: A;
}

override getScope(EObject context, EReference reference) {
	if (reference == MyDslPackage.eINSTANCE.variableRef_Variable) {
		if (context instanceof VariableRef) {
			val type = context.qualifier?.variable?.type
			if (type instanceof ClassType) {
				var class = type.refClass
				if (class.eResource == null) {
					val uriFragment = EcoreUtil.getURI(class).fragment
					class = context.eResource.getEObject(uriFragment) as org.xtext.example.mydsl.myDsl.Class
				}
				return Scopes.scopeFor(class.variables)
			}
		}
	}
	return super.getScope(context, reference)
}

package org.xtext.example.mydsl.scoping

import org.eclipse.xtext.resource.impl.DefaultResourceDescriptionStrategy
import com.google.inject.Singleton
import com.google.inject.Inject
import org.eclipse.xtext.naming.IQualifiedNameProvider
import org.xtext.example.mydsl.myDsl.Entity
import org.eclipse.xtext.resource.EObjectDescription
import org.eclipse.emf.ecore.EObject
import org.eclipse.xtext.util.IAcceptor
import org.eclipse.xtext.resource.IEObjectDescription
import static extension org.eclipse.xtext.EcoreUtil2.*
import org.xtext.example.mydsl.myDsl.Model

@Singleton
class myDslResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy{

	@Inject extension IQualifiedNameProvider 
	override createEObjectDescriptions(EObject eObj, IAcceptor<IEObjectDescription> acceptor){
		if(eObj instanceof Model){
			(eObj as Model).getAllContentsOfType(typeof(Entity)).forEach[it|
				acceptor.accept(EObjectDescription::create((it as Entity).fullyQualifiedName, (it as Entity)))
			]
			true
		} 	else false
	}

}

 
	def IScope scope_EntityRef_entity(EntityRef entity, EReference ref) {
		val model = entity.getContainerOfType(typeof(Model)) as Model
		val outerScope=delegateGetScope(model, ref)
		val currentScope=Scopes::scopeFor(model.getAllContentsOfType(typeof(Entity)), outerScope)
		return currentScope
		
	}
	def IScope scope_Reference_type(Reference context, EReference ref) {
		val model = context.getContainerOfType(typeof(Model)) as Model		
		val outerScope=delegateGetScope(context.getContainerOfType(typeof(Model)), ref)
		val currentScope=Scopes::scopeFor(context.getAllContentsOfType(typeof(Entity)), outerScope)
		return currentScope
	}

org.xtext.example.mydsl.AbstractMyDslRuntimeModule {
    public Class<? extends IDefaultResourceDescriptionStrategy> bindIDefaultResourceDescriptionStrategy() {
        return myDslResourceDescriptionStrategy.class;
      }
}

entity A {
    attr a1 : int
    attr a2 : string
    ref b : B
    ref c : C
}
  
   
entity C {
    attr c1 : string
    attr c2 : int
}

entity B { 
    attr b1 : string
    attr b2 : string
    ref a : A
    ref c : C
} 

use A.b.b2
use A.b.c.c1 
use A.a1
use A.b.a.a1   

class MyDslResourceDescriptionManager extends DefaultResourceDescriptionManager implements IResourceDescription.Manager.AllChangeAware {
	
	override isAffectedByAny(Collection<Delta> deltas, IResourceDescription candidate,
		IResourceDescriptions context) throws IllegalArgumentException {
		for (delta : deltas) {
			val Set<QualifiedName> names = Sets.newHashSet()
			addExportedNames(names, delta.getOld())
			addExportedNames(names, delta.getNew())
			val result = !Collections.disjoint(names, getImportedNames(candidate))
			println(candidate)
			println(result)
			if (result) {
				return true
			}
		}
		return false

	}

}

    @Override
	public boolean isAffected(Collection<Delta> deltas, IResourceDescription candidate, IResourceDescriptions context) {
        Set<URI> outgoingReferences = descriptionUtils.collectOutgoingReferences(candidate);
        if (!outgoingReferences.isEmpty()) {
	        for (IResourceDescription.Delta delta : deltas)
	            if (hasChanges(delta, candidate) && outgoingReferences.contains(delta.getUri()))
	                return true;
        }
        // this is a tradeoff - we could either check whether a given delta uri is contained
        // in a reachable container and check for intersecting names afterwards, or we can do
        // the other way round
        // unfortunately there is no way to decide reliably which algorithm scales better
        // note that this method is called for each description so we have something like a 
        // number of deltas x number of resources which is not really nice
        List<IContainer> containers = null;
        Collection<QualifiedName> importedNames = getImportedNames(candidate);
        for (IResourceDescription.Delta delta : deltas) {
			if (hasChanges(delta, candidate)) {
				// not a java resource - delta's resource should be contained in a visible container
				// as long as we did not delete the resource
				URI uri = delta.getUri();
				if ((uri.isPlatform() || uri.isArchive()) && delta.getNew() != null) { 
					if (containers == null)
						containers = containerManager.getVisibleContainers(candidate, context);
					boolean descriptionIsContained = false;
					for(int i = 0; i < containers.size() && !descriptionIsContained; i++) {
						descriptionIsContained = containers.get(i).hasResourceDescription(uri);
					}
					if (!descriptionIsContained)
						return false;
				}
				if (isAffected(importedNames, delta.getNew()) || isAffected(importedNames, delta.getOld())) {
					return true;
				}
			}
        }
        return false;
    }