@Override
public String[] getExportedPackagesRt(Grammar grammar) {
	List<GeneratedMetamodel> typeSelect = org.eclipse.xtext.EcoreUtil2.typeSelect(
			grammar.getMetamodelDeclarations(), GeneratedMetamodel.class);
	Set<String> exportedPackages = new LinkedHashSet<String>();
	if (modelPluginID == null) {
		for (GeneratedMetamodel generatedMetamodel : typeSelect) {
			final String modelPackage = Strings.skipLastToken(
					getGeneratedEPackageName(grammar, generatedMetamodel.getEPackage()), ".");
			exportedPackages.add(modelPackage);
			exportedPackages.add(modelPackage + ".impl");
			exportedPackages.add(modelPackage + ".util");
		}
	}
	return exportedPackages.toArray(new String[exportedPackages.size()]);
}
 

@Override
protected synchronized ResourceLoader getResourceLoader(GeneratedMetamodel metamodel) {
	if (resourceLoader != null)
		return resourceLoader;

	URI uri = metamodel.eResource().getURI();
	if (ClasspathUriUtil.isClasspathUri(uri)) {
		ResourceSet resourceSet = metamodel.eResource().getResourceSet();
		uri = resourceSet.getURIConverter().normalize(uri);
	}
	IFile grammarFile = getWorkspace().getRoot().getFile(new Path(uri.toPlatformString(true)));
	IJavaProject javaProject = JavaCore.create(grammarFile.getProject());
	try {
		if (javaProject.exists()) {
			ClassLoader classLoader = createClassLoader(javaProject);
			resourceLoader = new ResourceLoaderImpl(classLoader);
			return resourceLoader;
		}
	} catch (CoreException e) {
		logger.error("Error creating execution context for java project '" + grammarFile.getProject().getName()
				+ "'", e);
	}
	return super.getResourceLoader(metamodel);
}
 

/**
 * Not a full featured solution for the computation of available structural features, but it is sufficient for some
 * interesting 85%.
 */
@Override
public void completeAssignment_Feature(EObject model, Assignment assignment, ContentAssistContext context,
		ICompletionProposalAcceptor acceptor) {
	AbstractRule rule = EcoreUtil2.getContainerOfType(model, AbstractRule.class);
	TypeRef typeRef = rule.getType();
	if (typeRef != null && typeRef.getClassifier() instanceof EClass) {
		Iterable<EStructuralFeature> features = ((EClass) typeRef.getClassifier()).getEAllStructuralFeatures();
		Function<IEObjectDescription, ICompletionProposal> factory = getProposalFactory(grammarAccess.getValidIDRule().getName(), context);
		Iterable<String> processedFeatures = completeStructuralFeatures(context, factory, acceptor, features);
		if(rule.getType().getMetamodel() instanceof GeneratedMetamodel) {
			if(notNull(rule.getName()).toLowerCase().startsWith("import")) {
				completeSpecialAttributeAssignment("importedNamespace", 2, processedFeatures, factory, context, acceptor); 
				completeSpecialAttributeAssignment("importURI", 1, processedFeatures, factory, context, acceptor); 
			} else {
				completeSpecialAttributeAssignment("name", 3, processedFeatures, factory, context, acceptor); 
			}
		}
	}
	super.completeAssignment_Feature(model, assignment, context, acceptor);
}
 

@Override
public void process(GeneratedMetamodel metamodel) {
	Resource xtendFile = loadXtendFile(metamodel);
	if (xtendFile != null) {
		logger.warn("You are using an old xtend(1)-based IXtext2EcorePostProcessor. This features is deprecated and will be dropped in a future release of Xtext.");
		ExecutionContext ctx = getExecutionContext(metamodel);
		ctx = ctx.cloneWithResource(xtendFile);
		ResourceLoader currentThreadResourceLoader = null;
		try {
			currentThreadResourceLoader = getCurrentThreadResourceLoader();
			setCurrentThreadResourceLoader(getResourceLoader(metamodel));
			final Object[] params = new Object[] { metamodel };
			Extension extension = ctx.getExtension("process", params);
			if (extension != null) {
				extension.evaluate(params, ctx);
			}
		}
		catch (EvaluationException e) {
			logger.error("Error encountered processing metamodel " + metamodel.getName() + " with "
					+ xtendFile.getFullyQualifiedName(), e);
		}
		finally {
			setCurrentThreadResourceLoader(currentThreadResourceLoader);
		}
	}
}
 

public List<EPackage> getGeneratedPackages() {
	final List<EPackage> result = new ArrayList<EPackage>();
	final ResourceSet resourceSet = grammar.eResource().getResourceSet();
	if (resourceSet == null)
		throw new NullPointerException("resourceSet may not be null");
	Iterables.addAll(result, Iterables.filter(Iterables.transform(
			Iterables.filter(grammar.getMetamodelDeclarations(), GeneratedMetamodel.class),
			new Function<AbstractMetamodelDeclaration, EPackage>() {
				@Override
				public EPackage apply(AbstractMetamodelDeclaration param) {
					EPackage pack = (EPackage) param.eGet(XtextPackage.Literals.ABSTRACT_METAMODEL_DECLARATION__EPACKAGE, false);
					if (pack != null && !pack.eIsProxy()) {
						return pack;
					}
					return null;
				}
			}), Predicates.notNull()));
	return getPackagesSortedByName(result);
}
 

private TypeRef getOrComputeReturnType(AbstractRule rule) {
	TypeRef result = rule.getType();
	if (result == null) {
		EClassifier classifier = getClassifierFor(rule);
		if (classifier == null) {
			if (rule.getName() == null)
				return null;
			result = getTypeRef(rule.getName());
		} else
			result = getTypeRef(classifier);
		if (result.getMetamodel() == null) {
			AbstractMetamodelDeclaration bestMatch = null;
			for (AbstractMetamodelDeclaration decl : grammar.getMetamodelDeclarations()) {
				if (decl instanceof GeneratedMetamodel && Strings.isEmpty(decl.getAlias())) {
					bestMatch = decl;
					break;
				}
			}
			if (result.getMetamodel() == null)
				result.setMetamodel(bestMatch);
		}
		rule.setType(result);
	}
	return result;
}
 

void discardGeneratedPackages(EObject root) {
	if (root instanceof Grammar) {
		// unload generated metamodels as they will be recreated during linking 
		for (AbstractMetamodelDeclaration metamodelDeclaration : ((Grammar) root).getMetamodelDeclarations()) {
			if (metamodelDeclaration instanceof GeneratedMetamodel) {
				EPackage ePackage = (EPackage) metamodelDeclaration.eGet(XtextPackage.Literals.ABSTRACT_METAMODEL_DECLARATION__EPACKAGE, false);
				if (ePackage != null && !ePackage.eIsProxy()) {
					Resource resource = ePackage.eResource();
					if (resource != null && resource.getResourceSet() != null) {
						if (unloader != null) {
							for (EObject content : resource.getContents()) {
								unloader.unloadRoot(content);
							}
						}
						resource.getResourceSet().getResources().remove(resource);
					}
				}
			}
		}
	}
}
 

private void doPropagateValidationResult(Diagnostic diagnostic,
		GeneratedMetamodel metamodel, ValidationMessageAcceptor acceptor) {
	boolean foundEObject = false;
	Object firstData = null;
	for(Object data: diagnostic.getData()) {
		if (firstData == null) {
			firstData = diagnostic.getData().get(0);
		}
		if (data instanceof EObject) {
			if (createMessageForSource(diagnostic, (EObject) data, acceptor)) {
				foundEObject = true;
			} 
			if (data instanceof EStructuralFeature && ((EStructuralFeature) data).getEContainingClass() != firstData) {
				EClass containingClass = ((EStructuralFeature) data).getEContainingClass();
				createMessageForSource(diagnostic, containingClass, acceptor);
			}
		}
	}
	if (!foundEObject) {
		doCreateMessage(
				diagnostic, 
				metamodel, 
				XtextPackage.Literals.ABSTRACT_METAMODEL_DECLARATION__EPACKAGE, 
				acceptor);
	}
}
 

@Check
public void checkReferencedMetamodel(ReferencedMetamodel metamodel) throws ValueConverterException {
	if (metamodel.getEPackage() == null)
		return;
	String nsURI = metamodel.getEPackage().getNsURI();
	List<GeneratedMetamodel> allGeneratedMetamodels = getInheritedGeneratedMetamodels(metamodel);
	String text = getUsedUri(metamodel);
	for (GeneratedMetamodel generatedMetamodel : allGeneratedMetamodels) {
		EPackage generatedPackage = generatedMetamodel.getEPackage();
		if (generatedPackage != null && nsURI.equals((generatedPackage.getNsURI()))) {
			if (!text.equals(nsURI)) {
				addIssue("Metamodels that have been generated by a super grammar must be referenced by nsURI: " + nsURI,
						metamodel,
						XtextPackage.Literals.ABSTRACT_METAMODEL_DECLARATION__EPACKAGE,
						INVALID_PACKAGE_REFERENCE_INHERITED,
						nsURI);
				return;
			}
			return;
		}
	}
	checkExternalPackage(metamodel, text);
}
 

@Check
public void checkGeneratedEnumIsValid(EnumLiteralDeclaration decl) {
	EnumRule rule = GrammarUtil.containingEnumRule(decl);
	if (!(rule.getType().getMetamodel() instanceof GeneratedMetamodel))
		return;
	if (!(rule.getType().getClassifier() instanceof EEnum))
		return;
	EEnum eEnum = (EEnum) rule.getType().getClassifier();
	List<EnumLiteralDeclaration> declarations = EcoreUtil2.getAllContentsOfType(rule, EnumLiteralDeclaration.class);
	if (declarations.size() == eEnum.getELiterals().size())
		return;
	for (EnumLiteralDeclaration otherDecl : declarations) {
		if (decl == otherDecl) {
			return;
		}
		if (otherDecl.getEnumLiteral() == decl.getEnumLiteral()) {
			if (!decl.getEnumLiteral().getLiteral().equals(decl.getLiteral().getValue()))
				addIssue("Enum literal '" + decl.getEnumLiteral().getName()
						+ "' has already been defined with literal '" + decl.getEnumLiteral().getLiteral() + "'.",
						decl,
						XtextPackage.Literals.ENUM_LITERAL_DECLARATION__ENUM_LITERAL,
						DUPLICATE_ENUM_LITERAL);
			return;
		}
	}
}
 

private List<EObject> createPackage(GeneratedMetamodel generatedMetamodel, ILeafNode text) {
	final String nsURI = getMetamodelNsURI(text);
	final URI uri = URI.createURI(nsURI);
	if (uri == null || isReferencedByUsedGrammar(generatedMetamodel, nsURI))
		return Collections.emptyList();
	EPackage pack = ((GeneratedMetamodelImpl)generatedMetamodel).basicGetEPackage();
	if (pack != null && !pack.eIsProxy())
		return singletonList((EObject)pack);
	final EPackage generatedEPackage = EcoreFactory.eINSTANCE.createEPackage();
	generatedEPackage.setName(generatedMetamodel.getName());
	generatedEPackage.setNsPrefix(generatedMetamodel.getName());
	generatedEPackage.setNsURI(nsURI);
	final Resource generatedPackageResource = new EcoreResourceFactoryImpl().createResource(uri);
	XtextResourceSet resourceSet = (XtextResourceSet) generatedMetamodel.eResource().getResourceSet();
	if (!resourceSet.getURIResourceMap().containsKey(generatedPackageResource.getURI())) {
		generatedMetamodel.eResource().getResourceSet().getResources().add(generatedPackageResource);
	} else {
		generatedPackageResource.setURI(URI.createURI(nsURI+"_"+generatedMetamodel.hashCode()));
		generatedMetamodel.eResource().getResourceSet().getResources().add(generatedPackageResource);
	}
	generatedPackageResource.getContents().add(generatedEPackage);
	return Collections.<EObject>singletonList(generatedEPackage);
}
 

@Test public void testCycleInTypeHierarchy() throws Exception {
	String grammarAsText = "grammar test with org.eclipse.xtext.common.Terminals" +
			" generate test 'http://test'";
	grammarAsText += " RuleA: RuleB;";
	grammarAsText += " RuleB: RuleC;";
	grammarAsText += " RuleC: RuleA;";
	grammarAsText += " RuleD: RuleA;";

	Grammar grammar = (Grammar) getModel(grammarAsText);
	AbstractMetamodelDeclaration metamodelDeclaration = grammar.getMetamodelDeclarations().get(0);
	
	XtextValidator validator = get(XtextValidator.class);
	ValidatingMessageAcceptor messageAcceptor = new ValidatingMessageAcceptor(grammar.getRules().get(0).getType(), true, false);
	messageAcceptor.expectedContext(
			grammar.getRules().get(1).getType(),
			grammar.getRules().get(2).getType()
	);
	validator.setMessageAcceptor(messageAcceptor);
	validator.checkGeneratedPackage((GeneratedMetamodel) metamodelDeclaration, Diagnostician.INSTANCE, Collections.EMPTY_MAP);
	messageAcceptor.validate();
}
 

@Test public void testNameClash_01() throws Exception {
	String grammarAsText =
			"grammar test with org.eclipse.xtext.common.Terminals\n" +
			"generate test 'http://test'\n" +
			"PRINTF: vars=PRINTF_Vars;\n" +
			"PRINTF_Vars: arg1=ID;";
	
	Grammar grammar = (Grammar) getModel(grammarAsText);
	AbstractMetamodelDeclaration metamodelDeclaration = grammar.getMetamodelDeclarations().get(0);
	
	XtextValidator validator = get(XtextValidator.class);
	ValidatingMessageAcceptor messageAcceptor = new ValidatingMessageAcceptor(null, true, false);
	messageAcceptor.expectedContext(
			grammar.getRules().get(0).getAlternatives(),
			grammar.getRules().get(1).getType()
	);
	validator.setMessageAcceptor(messageAcceptor);
	validator.checkGeneratedPackageForNameClashes((GeneratedMetamodel) metamodelDeclaration);
	messageAcceptor.validate();
}
 

@Test public void testNameClash_02() throws Exception {
	String grammarAsText =
			"grammar test with org.eclipse.xtext.common.Terminals\n" +
			"generate test 'http://test'\n" +
			"Class returns Class: {Class_} name=ID;\n";
	
	Grammar grammar = (Grammar) getModel(grammarAsText);
	AbstractMetamodelDeclaration metamodelDeclaration = grammar.getMetamodelDeclarations().get(0);
	
	XtextValidator validator = get(XtextValidator.class);
	ValidatingMessageAcceptor messageAcceptor = new ValidatingMessageAcceptor(null, true, false);
	CompoundElement element = (CompoundElement) grammar.getRules().get(0).getAlternatives();
	messageAcceptor.expectedContext(
			grammar.getRules().get(0).getType(),
			((Action) element.getElements().get(0)).getType()
	);
	validator.setMessageAcceptor(messageAcceptor);
	validator.checkGeneratedPackage((GeneratedMetamodel) metamodelDeclaration, Diagnostician.INSTANCE, Collections.EMPTY_MAP);
	messageAcceptor.validate();
}
 

@Test public void testNameClash_03() throws Exception {
	String grammarAsText =
			"grammar test with org.eclipse.xtext.common.Terminals\n" +
			"generate test 'http://test'\n" +
			"Foo: myVars=ID my_vars=ID;\n";
	
	Grammar grammar = (Grammar) getModel(grammarAsText);
	AbstractMetamodelDeclaration metamodelDeclaration = grammar.getMetamodelDeclarations().get(0);
	
	XtextValidator validator = get(XtextValidator.class);
	ValidatingMessageAcceptor messageAcceptor = new ValidatingMessageAcceptor(null, true, false);
	CompoundElement element = (CompoundElement) grammar.getRules().get(0).getAlternatives();
	messageAcceptor.expectedContext(
			grammar.getRules().get(0).getType(),
			element.getElements().get(0),
			element.getElements().get(1)
	);
	validator.setMessageAcceptor(messageAcceptor);
	validator.checkGeneratedPackage((GeneratedMetamodel) metamodelDeclaration, Diagnostician.INSTANCE, Collections.EMPTY_MAP);
	messageAcceptor.validate();
}
 

@Deprecated
@Test
public void testPostProcessorHook() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar test with org.eclipse.xtext.common.Terminals import \'http://www.eclipse.org/emf/2002/Ecore\' as ecore  generate test \'http://test\' MyRule: myFeature=INT;");
  final String xtextGrammar = _builder.toString();
  EObject _model = this.getModel(xtextGrammar);
  final Grammar grammar = ((Grammar) _model);
  final Xtext2EcoreTransformer transformer = new Xtext2EcoreTransformer(grammar);
  AbstractMetamodelDeclaration _get = grammar.getMetamodelDeclarations().get(1);
  GeneratedMetamodel testMetamodel = ((GeneratedMetamodel) _get);
  final Xtext2EcoreTransformerTest.MockedXtext2EcorePostProcessor postProcessor = new Xtext2EcoreTransformerTest.MockedXtext2EcorePostProcessor(testMetamodel);
  transformer.setPostProcessor(postProcessor);
  transformer.transform();
  Assert.assertEquals("process mthde called once", 1, postProcessor.proccessMethCalled());
}
 

@Override
protected List<Object> getParameters(Grammar grammar) {
	List<String> packageQNames = new ArrayList<String>();
	List<GeneratedMetamodel> list = EcoreUtil2.typeSelect(grammar.getMetamodelDeclarations(),
			GeneratedMetamodel.class);
	for (GeneratedMetamodel generatedMetamodel : list) {
		packageQNames.add(getGeneratedEPackageName(grammar, getNaming(), generatedMetamodel.getEPackage()));
	}
	List<Object> parameters = Lists.newArrayList((Object) packageQNames);
	parameters.add(this.composedChecks);
	parameters.add(getValidatorSuperClassName(grammar));
	return parameters;
}
 

@Override
protected void checkConfigurationInternal(Issues issues) {
	naming.setProjectNameRt(getProjectNameRt());
	naming.setProjectNameIde(getProjectNameIde());
	naming.setIdeBasePackage(!isIde() && isUi() ? getProjectNameUi() : getProjectNameIde());
	naming.setProjectNameUi(getProjectNameUi());
	naming.setUiBasePackage(getProjectNameUi());
	naming.setActivatorName(getActivator());
	naming.setPathTestProject(getPathTestProject());
	naming.setFileHeader(getFileHeader());
	naming.setClassAnnotations(getClassAnnotationsAsString());
	naming.setAnnotationImports(getAnnotationImportsAsString());
	naming.setHasUI(isUi());
	naming.setHasIde(isIde());
	Map<String, Grammar> uris = new HashMap<String, Grammar>();
	for (LanguageConfig config : languageConfigs) {
		config.registerNaming(naming);
		config.checkConfiguration(issues);
		Grammar grammar = config.getGrammar();
		List<GeneratedMetamodel> select = EcoreUtil2.typeSelect(grammar.getMetamodelDeclarations(),
				GeneratedMetamodel.class);
		for (GeneratedMetamodel generatedMetamodel : select) {
			String nsURI = generatedMetamodel.getEPackage().getNsURI();
			if (uris.containsKey(nsURI)) {
				issues.addError("Duplicate generated grammar with nsURI '" + nsURI + "' in "
						+ uris.get(nsURI).getName() + " and " + grammar.getName());
			} else {
				uris.put(nsURI, grammar);
			}
		}
	}
	if (getProjectNameRt() == null)
		issues.addError("The property 'projectNameRt' is mandatory");
	if (isUiMergedIntoRt() && getPathIdeProject() != null && ! isIdeMergedIntoRt()) {
		issues.addError("Cannot have a dedicated ide project when ui project is merged into runtime project");
	}
}
 

protected Collection<EPackage> getRegistryPackagesToValidate() {
  Collection<EPackage> _xblockexpression = null;
  {
    final Collection<EPackage> packages = GrammarUtil.allEPackagesToValidate(this.grammar);
    final Function1<GeneratedMetamodel, EPackage> _function = (GeneratedMetamodel it) -> {
      return it.getEPackage();
    };
    packages.removeAll(
      IterableExtensions.<EPackage>toList(IterableExtensions.<GeneratedMetamodel, EPackage>map(Iterables.<GeneratedMetamodel>filter(GrammarUtil.allMetamodelDeclarations(this.grammar), GeneratedMetamodel.class), _function)));
    _xblockexpression = packages;
  }
  return _xblockexpression;
}
 

@Override
public void completeGeneratedMetamodel_Alias(EObject model, Assignment assignment, ContentAssistContext context,
		ICompletionProposalAcceptor acceptor) {
	if (model instanceof GeneratedMetamodel) {
		EPackage ePackage = ((GeneratedMetamodel) model).getEPackage();
		String name = ((GeneratedMetamodel) model).getName();
		createAliasProposal(context, acceptor, ePackage, name);
	}
	super.completeGeneratedMetamodel_Alias(model, assignment, context, acceptor);
}
 

protected boolean acceptHyperLink(XtextResource resource, EObject objectAtOffset) {
	if (objectAtOffset instanceof EClass) {
		EClass eClass = (EClass) objectAtOffset;
		Grammar grammar = GrammarUtil.getGrammar(resource.getEObject("/"));
		List<AbstractMetamodelDeclaration> allMetamodelDeclarations = GrammarUtil.allMetamodelDeclarations(grammar);
		for (GeneratedMetamodel generatedMetamodel : Iterables.filter(allMetamodelDeclarations,
				GeneratedMetamodel.class)) {
			if (eClass.getEPackage().equals(generatedMetamodel.getEPackage())) {
				return false;
			}
		}
	}
	return true;
}
 

protected void renameReturnType(URI targetElementURI, String newName, ResourceSet resourceSet) {
	AbstractRule rule = (AbstractRule) resourceSet.getEObject(targetElementURI, false);
	TypeRef parserRuleType = rule.getType();
	if (rule.getName().equals(parserRuleType.getClassifier().getName())
			&& parserRuleType.getMetamodel() instanceof GeneratedMetamodel) {
		parserRuleType.getClassifier().setName(newName);
	}
}
 

/**
 * Expects an Xtend file named <code>MyDsl</code>PostProcessor.ext with an extension with signature
 * process(xtext::GeneratedMetamodel) in the same folder as the grammar file.
 * 
 * @param metamodel
 *            the metamodel to augment
 * @return the xtendFile to execute
 */
protected Resource loadXtendFile(GeneratedMetamodel metamodel) {
	if (xtendFile == null) {
		final String extension = getExtensionName(metamodel);
		try {
			URI uri = getXtendFileLocation(metamodel);
			if (uri != null) {
				URIConverter uriConverter = metamodel.eResource().getResourceSet().getURIConverter();
				if (uriConverter.exists(uri, null)) {
					InputStream in = uriConverter.createInputStream(uri);
					try {
						XtendResourceParser parser = new XtendResourceParser();
						xtendFile = parser.parse(new InputStreamReader(in), extension + '.'
								+ XtendFile.FILE_EXTENSION);
						fireXtendFileLoaded();
					} finally {
						if (in != null)
							in.close();
					}
				}
			}
		} catch (ClasspathUriResolutionException ignored) {
			// no xtend file found
		} catch (Exception e) {
			logger.error("Could not parse " + extension, e);
		}
	}
	return xtendFile;
}
 

protected URI getXtendFileLocation(GeneratedMetamodel metamodel) {
	URI uri = metamodel.eResource().getURI();
	// check if uri can be used for resolve
	if (!uri.isHierarchical() || uri.isRelative())
		return null;
	uri = URI.createURI(Strings.lastToken(getExtensionName(metamodel), "::")).appendFileExtension(
			XtendFile.FILE_EXTENSION).resolve(uri);
	return uri;
}
 

private Set<String> getGeneratedEPackageURIs() {
	List<GeneratedMetamodel> list = EcoreUtil2.typeSelect(grammar.getMetamodelDeclarations(), GeneratedMetamodel.class);
	return Sets.newLinkedHashSet(Iterables.transform(list, new Function<GeneratedMetamodel, String>() {
		@Override
		public String apply(GeneratedMetamodel from) {
			return from.getEPackage()!=null?from.getEPackage().getNsURI() : null;
		}
	}));
}
 

private void addGeneratedEPackage(GeneratedMetamodel generatedMetamodel) throws TransformationException {
	// we do not allow the same alias twice for generated metamodels
	String alias = Strings.emptyIfNull(generatedMetamodel.getAlias());
	if (generatedEPackages.containsKey(alias))
		throw new TransformationException(TransformationErrorCode.AliasForMetamodelAlreadyExists, "alias '" + alias
				+ "' already exists", generatedMetamodel);

	if (generatedMetamodel.getEPackage() == null)
		throw new TransformationException(TransformationErrorCode.UnknownMetaModelAlias, "Cannot create EPackage without NsURI.", generatedMetamodel);

	// instantiate EPackages for generated metamodel
	EPackage generatedEPackage = generatedMetamodel.getEPackage();
	generatedEPackages.put(alias, generatedEPackage);
	collectClassInfosOf(generatedEPackage, generatedMetamodel);
}
 

@SuppressWarnings("deprecation")
private void postProcessGeneratedPackages() {
	if (postProcessor != null) {
		final Iterable<GeneratedMetamodel> generatedMetamodels = Iterables.filter(grammar
				.getMetamodelDeclarations(), GeneratedMetamodel.class);
		for (GeneratedMetamodel metamodel : generatedMetamodels) {
			postProcessor.process(metamodel);
		}
	}
}
 

@Check
public void checkGeneratedMetamodel(GeneratedMetamodel metamodel) {
	if (metamodel.getName() != null && metamodel.getName().length() != 0)
		if (Character.isUpperCase(metamodel.getName().charAt(0)))
			addIssue("Metamodel names should start with a lower case letter.",
					metamodel,
					XtextPackage.Literals.GENERATED_METAMODEL__NAME,
					INVALID_METAMODEL_NAME,
					metamodel.getName());
}
 

@Check
public void checkGeneratedPackage(GeneratedMetamodel metamodel) {
	Map<Object, Object> context = getContext();
	if (context != null) {
		Diagnostician diagnostician = (Diagnostician) context.get(EValidator.class);
		if (diagnostician != null)
			checkGeneratedPackage(metamodel, diagnostician, context);
	}
}
 

@Check
public void checkGeneratedPackageForNameClashes(GeneratedMetamodel metamodel) {
	EPackage pack = metamodel.getEPackage();
	Multimap<String, ENamedElement> constantNameToElement = HashMultimap.create();
	Multimap<String, ENamedElement> accessorNameToElement = HashMultimap.create();
	if (pack != null) {
		for(EClassifier classifier: pack.getEClassifiers()) {
			String accessorName = classifier.getName();
			if ("Class".equals(accessorName) || "Name".equals(accessorName))
				accessorName += "_";
			accessorNameToElement.put("get" + accessorName, classifier);
			String classifierConstantName = CodeGenUtil2.format(classifier.getName(), '_', null, true, true).toUpperCase();
			constantNameToElement.put(classifierConstantName, classifier);
			if (classifier instanceof EClass) {
				for(EStructuralFeature feature: ((EClass) classifier).getEAllStructuralFeatures()) {
					String featureConstantPart = CodeGenUtil2.format(feature.getName(), '_', null, false, false).toUpperCase();
					String featureConstantName = classifierConstantName + "__" + featureConstantPart;
					constantNameToElement.put(featureConstantName, feature);
					String featureAccessorName = "get" + classifier.getName() + "_" + Strings.toFirstUpper(feature.getName());
					accessorNameToElement.put(featureAccessorName, feature);
				}
			}
		}
	}
	createMessageForNameClashes(constantNameToElement);
	createMessageForNameClashes(accessorNameToElement);
}