SomeAction   Optional_InstanceOfObjectInAnotherClass    "MyValue1" "MyValue2"   ;
AnotherAction  123  987 ;

Action returns xbase::XExpression:
	{Action} type=JvmTypeReference args=Arguments ";";

Arguments:
	{Arguments} targets+=(UIElement)* (":" data+=Datum+)?;

UIElement : //;returns xbase::XExpression:
	{UIElement} block=XExpression;

Datum returns xbase::XExpression:
	 XLiteral | PropRef;

ConjunctionExpression returns xbase::XExpression:
	{ConjunctionExpression} pos=("after" | "before");

PropRef:
	ns=NS ":" prop=QualifiedName;

Action returns xbase::XExpression:
	{Action} type=JvmTypeReference args=Arguments ";";

Arguments:
	{Arguments} targets+=(UIElement)* (":" data+=Datum+)?;

UIElement :
	{UIElement} value=XExpression;

Datum returns xbase::XExpression:
	{Datum} value=(XLiteral | PropRef);

PropRef:
	ns=NS ":" prop=QualifiedName;

override protected doInternalToJavaStatement(XExpression expr, ITreeAppendable tree, boolean isReferenced) {
		switch expr {
			.....
			Action: {
				..........
				for (target : action.args.targets) {
					target.value.internalToConvertedExpression(tree);
				}
				for (datum : action.args.data) {
					datum.internalToConvertedExpression(tree);
				}
				......
			}
			default: {
				super.doInternalToJavaStatement(expr, tree
....

override protected internalToConvertedExpression(XExpression expr, ITreeAppendable tree) {
		switch expr {
			UIElement: {
				internalToConvertedExpression(expr.value, tree)
			}
			Datum: {
				internalToConvertedExpression(expr.value, tree)  // This will not work because expr.value does not always yield an expression. It can be XLiteral or PropRef !
			}
			PropRef: {.....}
			default: {
				super.internalToConvertedExpression(expr, tree)
			}
....

compile(Datum d){
if (d.value instance of PropRef) ...
else if (d instance of XLiteral) .... 
}

suite MyTest using (testFile.xml ){
Click MyOtherPage.text ;  
     prepare {
		Fill MyPage2.element : "How to use this text" ;
		Fill MyPage.text :  and:my.impl "How to use this 123" ;
		Click MyOtherPage.element ;
		Fill MyPage.text MyPage.text :  and:my.impl "How to use this 123" ;
		Fill ; 
		Fill MyPage.text :  and:my.impl "How to use this 123 " ;
		Fill MyPage.getValues(9) : "wow";
		test anotherTest using (some.xml){
			Fill MyPage.text ;
			Fill MyPage.text : "How to use this 123" ;
		}
		test myTestCaseSample using (some.xml ) {
			 Fill MyPage2.element ;
		}
	}
}

@SuppressWarnings("all")
public class MyTest {
  private MyContextManager ctx;
  
  @BeforeClass
  public static void beforeSuite() {
    (new actions.Click(MyOtherPage.text)).exec();
    
  }
  
  @Before
  public void beforeTest() {
    (new actions.Fill(MyPage2.element,"How to use this text")).exec();
    (new actions.Fill(MyPage.text,ctx.get("and:my.impl"),"How to use this 123")).exec();
    (new actions.Click(MyOtherPage.element)).exec();
    (new actions.Fill(MyPage.text,MyPage.text,ctx.get("and:my.impl"),"How to use this 123")).exec();
    (new actions.Fill()).exec();
    (new actions.Fill(MyPage.text,ctx.get("and:my.impl"),"How to use this 123 ")).exec();
    (new actions.Fill(MyPage.getValues(9),"wow")).exec();
    
  }
  
  @Test
  public void anotherTest() {
    (new actions.Fill(MyPage.text)).exec();
    (new actions.Fill(MyPage.text,"How to use this 123")).exec();
    
  }
  
  @Test
  public void myTestCaseSample() {
    (new actions.Fill(MyPage2.element)).exec();
    
  }
  
  @After
  public void afterTest() {
    
  }
}

class MyDslTypeComputer extends XbaseTypeComputer {

	override computeTypes(XExpression expression, ITypeComputationState state) {
		if (expression instanceof Action) {
			_computeTypes(expression as Action, state);
		} else if (expression instanceof PropRef) {
			state.acceptActualType(state.getReferenceOwner().newReferenceTo(Object))
		} else {
			super.computeTypes(expression, state)
		}
	}

	protected def void _computeTypes(Action action, ITypeComputationState state) {
		for (t : action.args.targets) {
			println("TODO better logic here ?!?")

			val iaction = state.getReferenceOwner().getServices().getTypeReferences().findDeclaredType(
				"org.example.ILocator", state.referenceOwner.contextResourceSet)
			state.withExpectation(
				state.referenceOwner.newParameterizedTypeReference(iaction)
			).computeTypes(t)
		}
		
		for (t : action.args.data)  {
			state.withNonVoidExpectation.computeTypes(t)
		}
		state.acceptActualType(getTypeForName(Void.TYPE, state), ConformanceFlags.CHECKED_SUCCESS)

	}

}

class MyDslCompiler extends XbaseCompiler {

	override protected doInternalToJavaStatement(XExpression expr, ITreeAppendable tree, boolean isReferenced) {
		switch expr {
			InitBody: {
				tree.newLine
				for (action : expr.expressions)
					action.doInternalToJavaStatement(tree, isReferenced);
			}
			TestBody: {
				tree.newLine
				for (action : expr.expressions)
					action.doInternalToJavaStatement(tree, false);
			}
			PropRef: {
				if (isReferenced) {
					val propRef = expr
					tree.newLine().append("final ");
					serialize(getType(propRef), propRef, tree);
					tree.append(" ");
					val variableName = tree.declareSyntheticVariable(propRef, "_propRef");
					tree.append(variableName).append(" = ");
					propRef.compile(tree)
					tree.append(";");
				} else {
					throw new IllegalStateException
				}
			}
			Action: {
				val action = expr as Action;
				for (t : action.args.targets) {
					internalToJavaStatement(t, tree, true);
				}
				for (d : action.args.data) {
					tree.newLine
					val name = tree.declareVariable(d, "data")
					serialize(getType(d), d, tree);
					tree.append(" ")
					tree.append(name);
					tree.append(" = ")
					internalToConvertedExpression(d, tree)
					tree.append(";").newLine
				}
				tree.newLine
				tree.trace(action)
				tree.append("(new ");
				tree.append(action.type.qualifiedName + "(");
				var itr = action.args.targets.iterator
				while (itr.hasNext) {
					tree.append(itr.next.getVarName(tree))
					if (itr.hasNext)
						tree.append(",")
				}

				if (action.args.targets.size > 0 && action.args.data.size > 0) {
					tree.append(",")
				}
				val dataItr = action.args.data.iterator

				while (dataItr.hasNext) {
					tree.append(dataItr.next.getVarName(tree))
					if (dataItr.hasNext)
						tree.append(",")
				}
				tree.append(")).exec();").newLine
			}
			default: {
				super.doInternalToJavaStatement(expr, tree, isReferenced)
			}
		}
	}

	override protected internalToConvertedExpression(XExpression expr, ITreeAppendable tree) {
		switch expr {
			PropRef: {
				expr.compile(tree)
			}
			default: {
				super.internalToConvertedExpression(expr, tree)
			}
		}
	}

	def void compile(PropRef ref, ITreeAppendable tree) {
		tree.append("ctx.get(\"");
		tree.append(ref.ns);
		tree.append(":" + ref.prop + "\")");
	}

}