@Test
	def void testDerivedPropertyAccess() {
		val model = '''
			class  Car {
				price:Double;
			}
			class Person {	
				public car:Car = new Car();	
				public doStuff(){
					car.price;
			}	
			}
		'''.parse
		
		 model.assertNoErrors
}

grammar org.xtext.example.mydsl.MyDsl with org.eclipse.xtext.common.Terminals

generate myDsl "http://www.xtext.org/example/mydsl/MyDsl"

Model:
	classes+=Class*;
	
NamedElement returns NamedElement:
	Class | Field | Method ;

Class:
	'class' name=ID '{'
	members+=Member*
	'}';

Member:
	Field | Method;
//
Field:
	type=[Class|QualifiedName] name=ID ';';

QualifiedName:
	ID ('.' ID)*;
//
Method:
	type=[Class|QualifiedName] name=ID
	'(' ')'  
	body=MethodBody;
//
MethodBody:
	{MethodBody} '{' statements+=Statement* '}';
//
Statement returns Expression:
	Expression ';';
//
Expression returns Expression:
	PrimaryExpression
	
;
//
PrimaryExpression returns Expression:
	PropertyAccessExpression;

PropertyAccessExpression:
	{PropertyAccessExpression} featureReference=FeatureReference;

FeatureReference:
	{FeatureReference}
	(expression=NameExpression) | (expression=NameExpression '.' nameBinding=[Member])
	;
NameExpression:
	{NameExpression}
	nameBinding=[NamedElement|ID];

class MyDslScopeProvider extends AbstractDeclarativeScopeProvider {

	def IScope scope_Member(FeatureReference featureRefContext, EReference eReference) {
		var parentScope = IScope::NULLSCOPE
		val expr = (featureRefContext.expression as NameExpression)

		val field = expr.nameBinding as Field
		val type = field.type

		if (type instanceof Class) { 

			 
			val innerScope = type.selectMemberInRightOrder(featureRefContext)
			return Scopes::scopeFor(innerScope,parentScope)
		}

	}

	def selectMemberInRightOrder(Class type, FeatureReference ref) {

		 
		switch (type) {
			Class: type.members.filter(typeof(Field)) + type.members.filter(typeof(Method))
		}

	}

}

	@Override
	public void ensureLinked(EObject obj, IDiagnosticProducer producer) {
		super.ensureLinked(obj, producer);

		if (obj instanceof Parameter && checkNode(obj)) {
			Parameter par = (Parameter) obj;

			// set the uppervalue of an param to 1
			if (par.getUpper() == 0) {
				par.setUpper(1);

			}

		}
		if (obj instanceof Model && checkNode(obj)) {
			((Model) obj).setName("model");
		}

	}

	private boolean checkNode(EObject obj) {

		return NodeModelUtils.getNode(obj) != null;
	}

FeatureReference returns Expression:
	NameOrThisExpression ({FeatureReference.expression=current} '.' nameBinding=[Member])* ';';

FeatureReference returns Expression:
	NameOrThisExpression ({FeatureReference.expression=current} '.' nameBinding=[Member])* ';';

	def IScope scope_FeatureReference_nameBinding(FeatureReference ctx, EReference ref) {
		val target = ctx.expression
		val type = getType(target) as Class
		var parentScope = IScope::NULLSCOPE
		if (type == null || !(type instanceof Class)) {
			return parentScope
		}

		return Scopes::scopeFor(type.selectMemberInRightOrder(), parentScope)
	}