GRAMMAR:
Model:
    entities+=Entity*
    usages+=Usage*
;

//No Feature interface. Attribute and reference are defined as EAttr and ERefs directly on Entity ...
 
Entity:
    "entity" name=ID "{"
	"attr" name=ID ":" type=DataType
	"ref" name=ID ":" type=[Entity]
    "}"
;

enum DataType:
    string | int
;

//No Feature, Attribute or Ref available
/*Feature:
    Attribute | Reference
;
 
Attribute:
    "attr" name=ID ":" type=DataType
;
 
Reference:
    "ref" name=ID ":" type=[Entity]
;*/

 
Usage:
    "use" ref=DotExpression
;
 
DotExpression returns Ref:
    EntityRef ({DotExpression.ref=current}  "." tail=[How to reference att and ref from entity??])*
;
 
EntityRef returns Ref:
    {EntityRef} entity=[Entity]
; 

SCOPE PROVIDER:

class MyDslScopeProvider extends AbstractDeclarativeScopeProvider {
	def IScope scope_DotExpression_tail(DotExpression exp, EReference ref) {
        val head = exp.ref;
        switch (head) {
            //EntityRef : Scopes::scopeFor(head.entity.features)
            EntityRef : Scopes::scopeFor(head.entity.eCrossReferences)
            DotExpression : {
                val tail = head.tail
                switch (tail) {
                    EAttribute : IScope::NULLSCOPE
                    EReference : Scopes::scopeFor(tail.eCrossReferences)
                    //Reference : Scopes::scopeFor(tail.type.features)
                    default: IScope::NULLSCOPE
                }
            }
             
            default: IScope::NULLSCOPE
        }
    }
}

entity A { 
	attr hello : string
}

use A.hello

Entity:
    "entity" name=ID "{"
    	"attribute" type=INT
    	"reference" ref=[Entity|ID]
    "}"
; 

use A.a1

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

grammar org.xtext.example.mydot.MyDot with org.eclipse.xtext.common.Terminals

generate myDot "http://www.xtext.org/example/mydot/MyDot"
import "http://www.eclipse.org/emf/2002/Ecore" as ecore

Model:
    entities+=Entity*
    usages+=Usage*
;
 
Entity:
    "entity" name=ID "{"
    	"attribute" type=INT
    	("reference" ref=[Entity|ID])?
    "}"
;
 
Usage:
    "use" ref=DotExpression
;
 
DotExpression returns Ref:
    EntityRef ({DotExpression.ref=current}  "." tail=[ecore::EStructuralFeature])*
;
 
EntityRef returns Ref:
    {EntityRef} entity=[Entity]
; 

entity test1 { 
	attribute 9
}

entity test2 { 
	attribute 8 
	reference test1
}

use test1.attribute
use test2.reference	 
	 

DotExpression returns Ref:
    EntityRef ({DotExpression.ref=current}  "." tail=[ecore::EStructuralFeature])*
;

Robot robo 

Link mylink1
Link myLink2 
	isReuseOf mylink1 
	Inertia instance_inert 
		ixx 6 
		ixy 88 
		ixz 00 
		iyy 1 
		iyz 22 
		izz 55 

Joint myJoint 
	ChildOf ccc 
	ParentOf pppp 
	Type Fixed

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

generate myDsl "http://www.xtext.org/example/mydot1/MyDsl"
import "http://www.eclipse.org/emf/2002/Ecore" as ecore

Robot returns Robot:
	'Robot' name=ID
	(link+=Link | joint+=Joint)* 
	 usage+=Usage*
;

ReUseAble:
	Link | Joint | LinkDecorator
;

Usage returns Usage:
    "use" ref=DotExpression
;

DotExpression returns Ref:
    EntityRef ({DotExpression.ref=current}  "." tail=[ecore::EStructuralFeature])*       
    
;

EntityRef returns Ref:
    {EntityRef} entity=[ReUseAble]
;

Link:
	'Link' name=ID
	('isReuseOf' isReuseOf=[Link])?
	inert+=Inertia*	
	//decorator=LinkDecorator
;

LinkDecorator:
	{LinkDecorator} 
		inert+=Inertia*		
;

LinkRef:
	'add_to' ref=[Link|ID] 
	    decorator=[LinkDecorator|ID]
;

Joint:
	'Joint' name=ID
  	('isReuseOf' isReuseOf=[Joint])?
	'ChildOf' ChildOf=[Link|ID]
	'ParentOf' ParentOf=[Link|ID]
	'Type' Type=JointType
;

enum JointType returns JointType:
		fixed = 'Fixed' |revolute = 'Revolute' |  prismatic = 'Prismatic' | continuous = 'Continuous';
		
JointRef returns JointRef:
	 fix = '->' | rev = 'r->' | pris = 'p->' | cont = 'c->'  
;		

Inertia returns Inertia:
	'Inertia' (name=ID)?
	'ixx' ixx=INT 'ixy' ixy=INT 'ixz' ixz=INT 'iyy' iyy=INT 'iyz' iyz=INT 'izz' izz=INT
;

class MyDslScopeProvider extends AbstractMyDslScopeProvider {
	
     override IScope getScope(EObject exp, EReference ref) {
     	if (exp instanceof DotExpression) {
        val head = exp.ref;
        switch (head) {
            EntityRef : Scopes::scopeFor(head.entity.eClass.getEStructuralFeatures())
            DotExpression : {
                val tail = head.tail
                switch (tail.getEType()) {
                //switch (tail) {	
                    EAttribute : IScope::NULLSCOPE
                    EReference : Scopes::scopeFor(tail.eClass.getEStructuralFeatures())
                    default: IScope::NULLSCOPE
                }
            }
             
            default: IScope::NULLSCOPE
        }
    } else super.getScope(exp, ref)
    
    
    }
}