grammar ee.xtext.test.Test with org.eclipse.xtext.common.Terminals

generate test "www.xtext.ee/test/Test"

File:
	(expressions+=BlockExpression)+
;

Expression:
	VariableDeclarations | FeatureCall | BlockExpression
;

BlockExpression returns Expression:
	{BlockExpression}
	'{'
		(expressions+=Expression)+
	'}'
;

VariableDeclarations returns Expression:
	{VariableDeclarations}
	'var' declarations+=VariableDeclaration (',' declarations+=VariableDeclaration)*;

VariableDeclaration:
	{VariableDeclaration}
	name=ID;
	
FeatureCall returns Expression:
	{FeatureCall}
	feature=[VariableDeclaration];

{
	b						//should not work
	
	var a					//declare a1 (gives an error on a)
	
	
	{
		a			//refer to a1
		
		var b, c		//declare b1 and c1 (gives an error on c)
		
		c			//refer to c1
		
		{
			var c	//declare c2  (gives an error on c)
			
			a		//refer to a1
			b		//refer to b1
			c		//refer to c2
		}
		
		var a			//declare a2 (gives an error on a)
		
		a			//refer to a2
		c			//refer to c1
	}
	
	c					//should not work
}

public class TestScopeProvider extends AbstractDeclarativeScopeProvider {
	public IScope scope_FeatureCall_feature(BlockExpression context, EReference reference)
	{
		IScope parentScope = getParentScopes(context);
		
		// problem, no current location available
		List<VariableDeclaration> elements = getVariableDeclarations(null, context);
		
		return Scopes.scopeFor(elements, parentScope);
	}
	
	public IScope scope_FeatureCall_feature(FeatureCall context, EReference reference)
	{
		BlockExpression block = (BlockExpression) context.eContainer();
		
		IScope parentScope = getParentScopes(block);
		
		List<VariableDeclaration> elements = getVariableDeclarations(context, block);
		
		return Scopes.scopeFor(elements, parentScope);
	}

	private IScope getParentScopes(BlockExpression block) {
		
		EObject container = block.eContainer();
		
		if (container instanceof BlockExpression)
		{
			BlockExpression parentBlock = (BlockExpression) container;
			IScope parentScope = getParentScopes(parentBlock);
			
			List<VariableDeclaration> elements = getVariableDeclarations(block, parentBlock);
			
			return Scopes.scopeFor(elements, parentScope);
		} else
		{
			return IScope.NULLSCOPE;
		}
	}
	
	private List<VariableDeclaration> getVariableDeclarations(EObject context, BlockExpression block) {
		
		EList<Expression> expressions = block.getExpressions();
		int index = context == null ? expressions.size() : expressions.indexOf(context);
		List<VariableDeclaration> elements = Lists.newArrayList();
		
		for (int i = 0; i < index; i++)
		{
			Expression expression = expressions.get(i);
			
			if (expression instanceof VariableDeclarations)
			{
				elements.addAll(((VariableDeclarations) expression).getDeclarations());
			}
		}
		return elements;
	}
}

public class TestScopeProvider extends AbstractDeclarativeScopeProvider {

	public IScope getBlockExpressionScope(int index, BlockExpression context)
	{
		IScope parentScope = getParentScopes(context);
		
		List<VariableDeclaration> elements = getVariableDeclarations(index, context.getExpressions());
		
		return Scopes.scopeFor(elements, parentScope);
	}
	
	public IScope scope_FeatureCall_feature(FeatureCall context, EReference reference)
	{
		BlockExpression block = (BlockExpression) context.eContainer();
		
		IScope parentScope = getParentScopes(block);
		
		EList<Expression> expressions = block.getExpressions();
		int index = expressions.indexOf(context);
		
		List<VariableDeclaration> elements = getVariableDeclarations(index, expressions);
		
		return Scopes.scopeFor(elements, parentScope);
	}

	private IScope getParentScopes(BlockExpression block) {
		
		EObject container = block.eContainer();
		
		if (container instanceof BlockExpression)
		{
			BlockExpression parentBlock = (BlockExpression) container;
			IScope parentScope = getParentScopes(parentBlock);
			
			EList<Expression> expressions = parentBlock.getExpressions();
			int index = expressions.indexOf(block);

			List<VariableDeclaration> elements = getVariableDeclarations(index, expressions);
			
			return Scopes.scopeFor(elements, parentScope);
		} else
		{
			return IScope.NULLSCOPE;
		}
	}
	
	private List<VariableDeclaration> getVariableDeclarations(int currentIndex, EList<Expression> expressions) {
		
		List<VariableDeclaration> elements = Lists.newArrayList();
		
		for (int i = 0; i < currentIndex; i++)
		{
			Expression expression = expressions.get(i);
			
			if (expression instanceof VariableDeclarations)
			{
				elements.addAll(((VariableDeclarations) expression).getDeclarations());
			}
		}
		return elements;
	}
}

public class TestProposalProvider extends AbstractTestProposalProvider {

	@Inject
	private ReferenceProposalCreator crossReferenceProposalCreator;
	
	@Inject
	private TestScopeProvider scopeProvider;
	
	public void completeFeatureCall_Feature(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
		CrossReference crossReference = (CrossReference) assignment.getTerminal();
		ParserRule containingParserRule = GrammarUtil.containingParserRule(crossReference);
		
		if (!GrammarUtil.isDatatypeRule(containingParserRule)) {
			
			String ruleName = null;
			if (crossReference.getTerminal() instanceof RuleCall) {
				ruleName = ((RuleCall) crossReference.getTerminal()).getRule().getName();
			}
			
			EReference reference = GrammarUtil.getReference(crossReference);
			
			EObject previousModel = context.getPreviousModel();
			
			int index = -1;
			
			if (!previousModel.equals(model))
			{
				//find the direct child of the model
				while (!previousModel.eContainer().equals(model))
				{
					previousModel = previousModel.eContainer();
				}
				
				index = model.eContents().indexOf(previousModel);
			}
			
			IScope scope = scopeProvider.getBlockExpressionScope(index + 1, (BlockExpression) model);
			
			crossReferenceProposalCreator.lookupCrossReference(scope, model, reference, acceptor, Predicates.<IEObjectDescription> alwaysTrue(), getProposalFactory(ruleName, context));
		}
	}
}

public class TestJavaValidator extends AbstractTestJavaValidator {


	@Check
	public void checkUniqueVariableName(VariableDeclaration variableDeclaration)
	{
		Map<Object, Object> context = getContext();

		if (context != null) {
			if (context.containsKey(variableDeclaration))
				return; // variableDeclaration was already validated
			context.put(variableDeclaration, this);
		}
		
		//find block
		EObject block = variableDeclaration.eContainer();
		while (!(block instanceof BlockExpression))
		{
			block = block.eContainer();
		}

		//check if any other variable has the same name
		String name = variableDeclaration.getName();
		for (EObject object : block.eContents())
		{
			if (object instanceof VariableDeclarations)
			{
				VariableDeclarations declarations = (VariableDeclarations) object;
				
				for (VariableDeclaration foundVariableDeclaration : declarations.getDeclarations())
				{
					if (!foundVariableDeclaration.equals(variableDeclaration) && foundVariableDeclaration.getName().equals(name))
					{
						error("Duplicate variable name '"+name+"'", variableDeclaration, TestPackage.Literals.VARIABLE_DECLARATION__NAME, -1);
					}
				}
			}
		}
		
	}
}