@Override
	protected String getDisplayString(EObject modelElement, String qualifiedName, String shortName) {
		//try resolve proxy but don't work
		if (modelElement.eIsProxy()) {
			modelElement = EcoreUtil.resolve(modelElement, modelElement.eResource());
		}
		String displayString = getLabelProvider().getText(modelElement);
		return displayString;
	}

module com.sysord.Gvbscript

import org.eclipse.emf.mwe.utils.*
import org.eclipse.xtext.generator.*
import org.eclipse.xtext.ui.generator.*

var grammarURI = "classpath:/com/sysord/Gvbscript.xtext"
var file.extensions = "gvbs"
var projectName = "com.sysord.gvbscript"
var runtimeProject = "../${projectName}"

Workflow {
    bean = StandaloneSetup {
		platformUri = "${runtimeProject}/.."
	}

	component = DirectoryCleaner {
		directory = "${runtimeProject}/src-gen"
	}

	component = DirectoryCleaner {
		directory = "${runtimeProject}.ui/src-gen"
	}

	component = Generator {
		pathRtProject = runtimeProject
		pathUiProject = "${runtimeProject}.ui"
		projectNameRt = projectName
		projectNameUi = "${projectName}.ui"
		language = {
			uri = grammarURI
			fileExtensions = file.extensions

			// Java API to access grammar elements (required by several other fragments)
			fragment = grammarAccess.GrammarAccessFragment {}

			// generates Java API for the generated EPackages 
			fragment = ecore.EcoreGeneratorFragment {
			// referencedGenModels = "uri to genmodel, uri to next genmodel"
			}

			// the serialization component
			fragment = parseTreeConstructor.ParseTreeConstructorFragment {}

			// a custom ResourceFactory for use with EMF 
			fragment = resourceFactory.ResourceFactoryFragment {
				fileExtensions = file.extensions
			}

			// The antlr parser generator fragment.
//			fragment = parser.antlr.XtextAntlrGeneratorFragment {
//			  	options = {
//			//		backtrack = true
//				}
//			}
			fragment = parser.antlr.ex.rt.AntlrGeneratorFragment {
				options = {
					ignoreCase = true
				}
			}

			// java-based API for validation 
			fragment = validation.JavaValidatorFragment {
				composedCheck = "org.eclipse.xtext.validation.ImportUriValidator"
				composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator"
				// registerForImportedPackages = true
			}

			// scoping and exporting API
			 fragment = scoping.ImportURIScopingFragment {
			 	ignoreCase = true
			 }
			 
			 fragment = exporting.SimpleNamesFragment {}

			// scoping and exporting API 
//			fragment = scoping.ImportNamespacesScopingFragment {}
//			fragment = exporting.QualifiedNamesFragment {}
//			fragment = builder.BuilderIntegrationFragment {}

			// formatter API 
			fragment = formatting.FormatterFragment {}

			// labeling API 
			fragment = labeling.LabelProviderFragment {}

			// outline API 
			fragment = outline.TransformerFragment {}
			fragment = outline.OutlineNodeAdapterFactoryFragment {}
			fragment = outline.QuickOutlineFragment {}

			// quickfix API 
			fragment = quickfix.QuickfixProviderFragment {}

			// content assist API  
			fragment = contentAssist.JavaBasedContentAssistFragment {}

			// generates a more lightweight Antlr parser and lexer tailored for content assist  
//			fragment = parser.antlr.XtextAntlrUiGeneratorFragment {
//			}
			fragment = org.eclipse.xtext.generator.parser.antlr.ex.ca.ContentAssistParserGeneratorFragment{
					options = {
					ignoreCase = true
				}				
			}

			// project wizard (optional) 
			// fragment = projectWizard.SimpleProjectWizardFragment {
			// 		generatorProjectName = "${projectName}.generator" 
			//		modelFileExtension = file.extensions
			// }
		}
	}

public class GvbscriptProposalProvider extends AbstractGvbscriptProposalProvider {

	@Inject
	IScopeProvider scopeProvider;

	@Override
	public void completeAssignment(Assignment assignment, ContentAssistContext contentAssistContext, ICompletionProposalAcceptor acceptor) {
		
		//when assignment is a crossreference 
		if(CrossReference.class.isAssignableFrom(assignment.getTerminal().getClass())){
			CrossReference crossReference = (CrossReference)assignment.getTerminal();
			ParserRule containingParserRule = GrammarUtil.containingParserRule(crossReference);
			if (!GrammarUtil.isDatatypeRule(containingParserRule)) {				
				//Look for complete method override
				boolean existsMethodOverride;
				try {
					String methodName = "complete" + Strings.toFirstUpper(containingParserRule.getName()) + "_" + Strings.toFirstUpper(assignment.getFeature());
					Method completeMethod = this.getClass().getMethod(methodName, EObject.class, Assignment.class, ContentAssistContext.class, ICompletionProposalAcceptor.class);
					existsMethodOverride = (completeMethod.getDeclaringClass().equals(this.getClass()));
				} catch (Exception e) {
					existsMethodOverride = false;
				}
				
				//No complete method override, Use generic complete method for crossReference
				if(!existsMethodOverride){
					completeUsingScopeProvider(crossReference, contentAssistContext, acceptor);					
				}
			}
			
		}

		//Use standard base method.
		super.completeAssignment(assignment, contentAssistContext, acceptor);
		
	}

//
// Custom complete methods override ...
//

	/**
	 * Create proposal with scope provider
	 * 
	 * @param crossReference
	 * @param contentAssistContext
	 * @param acceptor
	 */
	protected void completeUsingScopeProvider(CrossReference crossReference, ContentAssistContext contentAssistContext,
												ICompletionProposalAcceptor acceptor) {
		
		EReference target = GrammarUtil.getReference(crossReference);
		if(target == null){
			return;
		}
		
		//Request elements to the scope provider
		EObject currentModelElement = contentAssistContext.getCurrentModel();
		IScope scope = scopeProvider.getScope(currentModelElement, target);
		for (IEObjectDescription scopeElement : scope.getAllContents()) {

			//Get element and resolve proxy if needed
			EObject object = scopeElement.getEObjectOrProxy();
			if (object.eIsProxy()) {
				object = EcoreUtil.resolve(object, currentModelElement.eResource());
			}

			//Create new proposal
			String label = getLabelProvider().getText(object);
			if(label == null || label.equals("")){
				label = scopeElement.getName();
			}
			ICompletionProposal completionProposal = createCompletionProposal(scopeElement.getName(),
					getLabelProvider().getText(object), null, contentAssistContext);

			//Register proposal
			acceptor.accept(completionProposal);
		}
	}
}