/** * @since 2.0 */ public static boolean isEObjectRule(EObject grammarElement) { return grammarElement instanceof ParserRule && ((ParserRule) grammarElement).getType().getClassifier() instanceof EClass; }
public boolean apply(TypeRef input) { return !(input.eContainer() instanceof CrossReference) && input.getClassifier() instanceof EClass; } }), new Function<TypeRef, EPackage>() {
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(); }
final TypeRef typeRef = object.getType(); if (typeRef != null) { if (typeRef.getClassifier() != null) { boolean result = GrammarUtil.isDatatypeRule(object); if (result) EDataType dataType = GrammarUtil.findEString(GrammarUtil.getGrammar(object)); if (dataType != null) typeRef.setClassifier(dataType); else { typeRef.setClassifier(EcorePackage.Literals.ESTRING);
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; }
TypeRef getTypeRef(EClassifier classifier) { TypeRef result = XtextFactory.eINSTANCE.createTypeRef(); result.setClassifier(classifier); EPackage pack = classifier.getEPackage(); for(AbstractMetamodelDeclaration decl: GrammarUtil.allMetamodelDeclarations(grammar)) { if (pack.equals(decl.getEPackage())) { result.setMetamodel(decl); return result; } } return result; }
/** * Returns the invocation of an element or rule accessor, including the .getType() call. * Example1: getFooRule().getType() * Example2: getBarRule().getFooAction().getType() */ public String gaTypeAccessor(final TypeRef ele) { String _switchResult = null; EObject _eContainer = ele.eContainer(); final EObject cnt = _eContainer; boolean _matched = false; if (cnt instanceof AbstractElement) { _matched=true; String _gaRuleElementAccessor = this.gaRuleElementAccessor(((AbstractElement)cnt)); _switchResult = (_gaRuleElementAccessor + ".getType()"); } if (!_matched) { if (cnt instanceof AbstractRule) { _matched=true; String _gaRuleAccessor = this.gaRuleAccessor(((AbstractRule)cnt)); _switchResult = (_gaRuleAccessor + ".getType()"); } } if (!_matched) { String _name = ele.eContainer().eClass().getName(); String _plus = ("<error: unknown type " + _name); _switchResult = (_plus + ">"); } return _switchResult; }
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; }
private boolean isTypeRef(EObject object, EStructuralFeature feature) { return (feature == XtextPackage.eINSTANCE.getTypeRef_Classifier() && ((TypeRef) object).getMetamodel() instanceof GeneratedMetamodel); }
private EClassifierInfo createEClassifierInfo(TypeRef typeRef, String name) throws TransformationException { if (eClassifierInfos.getInfo(typeRef) != null) throw new IllegalArgumentException("Cannot create EClass for same type twice " + typeRef.getClassifier().getName()); 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); classifier.setName(classifierName); generatedEPackage.getEClassifiers().add(classifier); typeRef.setClassifier(classifier); return result; typeRef.setClassifier(classifier); SourceAdapter.adapt(classifier, typeRef); return eClassifierInfos.getInfo(classifier);
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 static boolean isEObjectRuleCall(EObject grammarElement) { if (grammarElement instanceof RuleCall) { AbstractRule calledRule = ((RuleCall) grammarElement).getRule(); return calledRule != null && calledRule instanceof ParserRule && calledRule.getType().getClassifier() instanceof EClass; } return false; }
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; }
@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); }
protected boolean isConsumingElement() { return element instanceof Assignment || (element instanceof RuleCall && ((RuleCall) element).getRule().getType().getClassifier() instanceof EClass) || element instanceof Action; }
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; }
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)); }
/** * @since 2.0 */ protected EClass getConstructedType(AbstractElement ele) { if (ele instanceof Action) return (EClass) ((Action) ele).getType().getClassifier(); if (GrammarUtil.containingAssignment(ele) != null) return (EClass) GrammarUtil.containingRule(ele).getType().getClassifier(); return null; }
@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; } } }