private boolean isTypeRef(EObject object, EStructuralFeature feature) { return (feature == XtextPackage.eINSTANCE.getTypeRef_Classifier() && ((TypeRef) object).getMetamodel() instanceof GeneratedMetamodel); }
protected String getTypeRefName(TypeRef typeRef) { String simpleName = GrammarUtil.getTypeRefName(typeRef); if (typeRef.getMetamodel() != null && !Strings.isEmpty(typeRef.getMetamodel().getAlias())) return typeRef.getMetamodel().getAlias() + "::" + simpleName; return simpleName; } }
public boolean addInfo(TypeRef typeRef, EClassifierInfo metatypeInfo) { if (typeRef.getMetamodel() == null || typeRef.getClassifier() == null) throw new NullPointerException(); return addInfo(typeRef.getMetamodel(), typeRef.getClassifier().getName(), metatypeInfo); }
@Override public EClassifier caseTypeRef(TypeRef object) { if (object.getClassifier() == null) { if (object.getMetamodel() == null || object.getMetamodel().getEPackage() == null) return null; String name = GrammarUtil.getTypeRefName(object); if (Strings.isEmpty(name)) return null; EClassifierInfo info = classifierInfos.getInfo(object.getMetamodel(), name); if (info != null) object.setClassifier(info.getEClassifier()); } return object.getClassifier(); }
TypeRef getTypeRef(String qualifiedName) { TypeRef result = XtextFactory.eINSTANCE.createTypeRef(); String[] split = qualifiedName.split("::"); String name = qualifiedName; if (split.length > 1) { result.setMetamodel(findMetamodel(grammar, split[0], split[1])); name = split[1]; } else { result.setMetamodel(findDefaultMetamodel(grammar, qualifiedName)); } if (result.getMetamodel() instanceof ReferencedMetamodel && result.getMetamodel().getEPackage() != null) { result.setClassifier(result.getMetamodel().getEPackage().getEClassifier(name)); } return result; }
@Override protected void beforeEnsureIsLinked(EObject obj, EReference ref, IDiagnosticProducer producer) { if (XtextPackage.eINSTANCE.getTypeRef_Classifier() == ref) { final TypeRef typeRef = (TypeRef) obj; if (typeRef.getMetamodel() == null) setDefaultValue(obj, XtextPackage.eINSTANCE.getTypeRef_Metamodel(), producer); } else super.beforeEnsureIsLinked(obj, ref, producer); }
private EClassifierInfo findOrCreateEClassifierInfo(AbstractRule rule) throws TransformationException { final TypeRef typeRef = getOrComputeReturnType(rule); if (typeRef == null) throw new TransformationException(TransformationErrorCode.NoSuchTypeAvailable, "Cannot create type for unnamed rule.", rule); if (typeRef.getMetamodel() != null && typeRef.getMetamodel().getEPackage() == null) throw new TransformationException(TransformationErrorCode.UnknownMetaModelAlias, "Cannot create type without declared package.", typeRef); return findOrCreateEClassifierInfo(typeRef, rule.getName(), grammar.getRules().contains(rule)); }
public EClassifierInfo getInfo(TypeRef typeRef) { if (typeRef.getClassifier() == null) return null; EClassifierInfo result = getInfo(typeRef.getMetamodel(), typeRef.getClassifier().getName()); if (result == null) { Grammar declaringGrammar = GrammarUtil.getGrammar(typeRef); if (grammar.equals(declaringGrammar)) return result; for(EClassifierInfos parent: parents) { result = parent.getInfo(typeRef); if (result != null) return result; } } return 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; }
@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())) warning("Enum literal '" + decl.getEnumLiteral().getName() + "' has already been defined with literal '" + decl.getEnumLiteral().getLiteral() + "'.", XtextPackage.Literals.ENUM_LITERAL_DECLARATION__ENUM_LITERAL); return; } } }
private EClassifierInfo findOrCreateEClassifierInfo(TypeRef typeRef, String name, boolean createIfMissing) throws TransformationException { if (typeRef.getClassifier() != null && typeRef.getMetamodel() == null) throw new TransformationException(TransformationErrorCode.UnknownMetaModelAlias, "Cannot find metamodel for type '" + typeRef.getClassifier().getName() + "'", typeRef); EClassifierInfo info = eClassifierInfos.getInfo(typeRef); if (info == null) { // we assumend EString for terminal rules and datatype rules, so // we have to do a look up in super grammar EDataType dataType = GrammarUtil.findEString(GrammarUtil.getGrammar(typeRef)); if (dataType != null && typeRef.getClassifier() == dataType) { info = eClassifierInfos.getInfoOrNull(typeRef); if (info != null) return info; } if (createIfMissing) info = createEClassifierInfo(typeRef, name); } return info; }
String text = node.getText(); EEnumLiteral literal = null; if (rule.getType().getMetamodel() instanceof ReferencedMetamodel) { literal = returnType.getEEnumLiteral(text); } else {
throw new TransformationException(TransformationErrorCode.NoSuchTypeAvailable, "Cannot reference unnamed type.", typeRef); AbstractMetamodelDeclaration metaModel = typeRef.getMetamodel(); if (metaModel == null) throw new TransformationException(TransformationErrorCode.UnknownMetaModelAlias, "Cannot create type for " + classifierName if (generatedEPackage == null) { throw new TransformationException(TransformationErrorCode.CannotCreateTypeInSealedMetamodel, "Cannot create type '" + classifierName + "' in alias " + typeRef.getMetamodel().getAlias(), typeRef);
if (feature == XtextPackage.eINSTANCE.getTypeRef_Metamodel()) { final TypeRef typeRef = (TypeRef) owner; final AbstractMetamodelDeclaration m = typeRef.getMetamodel(); if (m == null || Strings.isEmpty(m.getAlias())) return true;
if (feature == XtextPackage.eINSTANCE.getTypeRef_Metamodel()) { final TypeRef typeRef = (TypeRef) owner; final AbstractMetamodelDeclaration m = typeRef.getMetamodel(); if (m == null || Strings.isEmpty(m.getAlias())) return YES;
public IScope getScope(EObject context, EReference reference) { if (reference == XtextPackage.eINSTANCE.getTypeRef_Classifier()) { if (context instanceof TypeRef) { final TypeRef typeRef = (TypeRef) context; final AbstractMetamodelDeclaration metaModel = typeRef.getMetamodel(); if (metaModel != null) { EPackage pack = metaModel.getEPackage(); if (pack != null) return createClassifierScope(pack.getEClassifiers()); } else { return createReferencedPackagesScope(GrammarUtil.getGrammar(context)); } } else { return createReferencedPackagesScope(GrammarUtil.getGrammar(context)); } return IScope.NULLSCOPE; } if (reference == XtextPackage.eINSTANCE.getEnumLiteralDeclaration_EnumLiteral()) { final EnumRule rule = GrammarUtil.containingEnumRule(context); if (rule.getType() != null && rule.getType().getClassifier() != null && rule.getType().getClassifier() instanceof EEnum) { return createEnumLiteralsScope((EEnum) rule.getType().getClassifier()); } return IScope.NULLSCOPE; } return createScope(context.eResource(), reference.getEReferenceType()); }