Program:
	{Program}
	body = XBlockExpression
	types += Type
;

Variable returns XVariableDeclaration:
	{Variable} writeable?='variable' simpleName=ID ':' (typing=DataType);

Type:
	(Enumeration | Composition);

DataType:
	(SimpleDataType | ComplexDataType | ListType);

ListType:
	=> ('list' '<' type=DataType) '>';

ComplexDataType:
	{ComplexDataType} typeName=[Type];

Composition:
	{Composition} "type" name=ID ":" "structure" "{" (attributes+=Attribute)* "}";

Attribute:
	{Attribute}
	"attribute" name=ID ":" typing=DataType ";";

Enumeration:
	{Enumeration} "type" name=ID ":" "enumeration" "{" values+=EnumTypeValue ("," values+=EnumTypeValue)* "}";

EnumTypeValue:
	name=ID;

SimpleDataType:
	{SimpleDataType} typeName=('integer' | 'string' | 'rational' | 'boolean');

@Override 
XPrimaryExpression returns XExpression:
/* Default XPrimaryExpressions */ | 
	Variable;

{
	variable a : TestStruc
	a.a = 3
}
type TestStruc : structure {
	attribute a : integer;
}

	/* THE PROBLEM IS PROBABLY HERE BECAUSE THE TYPE DOESN'T GET CALCULATED CORRECTLY */
			var cdt = vr.typing as ComplexDataType
			if (cdt.typeName instanceof Enumeration) {
				state.assignType(vr, getRawTypeForName((cdt.typeName as Enumeration).class, state)) // is this the right way?
			} else if (cdt.typeName instanceof Composition) { /* Composition */
				var comp = cdt.typeName as Composition
				state.assignType(vr, getRawTypeForName((comp as Composition).class, state))
			// TODO Here is the mistake I guess 
			}

 getRawTypyeForName(comp.name, state)

getRawType(QualifiedName, JvmType, LightweightreferenceType)

def getTypeForName(String typename, ITypeComputationState state) {
		var type = findDeclaredType(typename, state)
		var owner = state.referenceOwner
		if (type === null) {
			return owner.newUnknownTypeReference(typename)
		}
		return owner.toLightweightTypeReference(type)
	}

	def findDeclaredType(String name, ITypeComputationState state) {
		if (name === null) {
			System.out.println("Name = null which is an error")
		}
		var declaredtype = findDeclaredType(name, state.referenceOwner.contextResourceSet)
		return declaredtype
	}

	def findDeclaredType(String name, Notifier context) {
		if (context === null) {
                      /* ERROR */
		}
		var resourceSet = EcoreUtil2.getResourceSet(context)
		if (resourceSet === null) {
			return null;
		}
		var typeProvider = typeProviderFactory.findOrCreateTypeProvider(resourceSet)
		try {
			val result = typeProvider.findTypeByName(name)
			return result
		} catch (RuntimeException e) {
			return null;
		}
	}