protected String _getConcreteSyntaxRuleName(final CrossReference crossReference) { String _xifexpression = null; AbstractElement _terminal = crossReference.getTerminal(); if ((_terminal instanceof RuleCall)) { _xifexpression = this.getConcreteSyntaxRuleName(crossReference.getTerminal()); } return _xifexpression; }
@Override public EClassifier caseCrossReference(CrossReference object) { return doSwitch(object.getType()); }
@Override protected void setDefaultValueImpl(EObject obj, EReference ref, IDiagnosticProducer producer) { if (XtextPackage.eINSTANCE.getTypeRef_Metamodel() == ref) { final TypeRef typeRef = (TypeRef) obj; final String typeRefName = GrammarUtil.getTypeRefName(typeRef); final List<EObject> metamodels = XtextMetamodelReferenceHelper.findBestMetamodelForType(typeRef, "", typeRefName, scopeProvider.getScope(typeRef, ref)); if (metamodels.isEmpty() || metamodels.size() > 1) producer.addDiagnostic(new DiagnosticMessage("Cannot find meta model for type '" + typeRefName + "'", Severity.ERROR, null)); else typeRef.setMetamodel((AbstractMetamodelDeclaration) metamodels.get(0)); } else if (XtextPackage.eINSTANCE.getCrossReference_Terminal() == ref) { AbstractRule rule = GrammarUtil.findRuleForName(GrammarUtil.getGrammar(obj), "ID"); if (rule == null) producer.addDiagnostic(new DiagnosticMessage("Cannot resolve implicit reference to rule 'ID'", Severity.ERROR, null)); else { RuleCall call = XtextFactory.eINSTANCE.createRuleCall(); call.setRule(rule); ((CrossReference) obj).setTerminal(call); } } else { super.setDefaultValueImpl(obj, ref, producer); } }
public void completeNestedCrossReference(CrossReference crossReference, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { Assignment assignment = (Assignment) crossReference.eContainer(); EReference reference = GrammarUtil.getReference(crossReference); if (reference != null) { String proposalText = "${" + assignment.getFeature() + ":CrossReference("+ reference.getEContainingClass().getName() + "." + reference.getName() +")}"; StyledString displayText = new StyledString("${", StyledString.DECORATIONS_STYLER) .append(assignment.getFeature()) .append(":CrossReference(", StyledString.DECORATIONS_STYLER) .append(reference.getEContainingClass().getName() + "." + reference.getName(), StyledString.COUNTER_STYLER) .append(")}", StyledString.DECORATIONS_STYLER) .append(" - Create a new template variable", StyledString.QUALIFIER_STYLER); ICompletionProposal proposal = createCompletionProposal(proposalText, displayText, null, context); if (proposal instanceof ConfigurableCompletionProposal) { ConfigurableCompletionProposal configurable = (ConfigurableCompletionProposal) proposal; configurable.setSelectionStart(configurable.getReplacementOffset() + 2); configurable.setSelectionLength(assignment.getFeature().length()); configurable.setAutoInsertable(false); configurable.setSimpleLinkedMode(context.getViewer(), '\t'); configurable.setPriority(configurable.getPriority() * 2); } acceptor.accept(proposal); } }
protected String addCrossRef(String result, AbstractElement ele) { if (!showAssignment) return result; CrossReference cr = GrammarUtil.containingCrossReference(ele); if (cr == null) return result; String name = cr.getType() != null && cr.getType().getClassifier() != null ? cr.getType().getClassifier() .getName() : "null"; return "[" + name + "|" + result + "]"; }
@Override public Void caseCrossReference(CrossReference object) { if (object.getTerminal() != null) return doSwitch(object.getTerminal()); return null; }
public EClass getCrossReferenceType() { if (element == null) return null; CrossReference cr = GrammarUtil.containingCrossReference(element); if (cr == null) return null; return (EClass) cr.getType().getClassifier(); }
@Check public void checkCrossReferenceTerminal(CrossReference reference) { if (reference.getTerminal() != null) { if (reference.getTerminal() instanceof RuleCall) { RuleCall call = (RuleCall) reference.getTerminal(); checkCrossReferenceTerminal(call); } } }
@Check public void checkCrossReferenceType(CrossReference reference) { checkTypeIsEClass(reference.getType()); }
protected boolean hasIdRule(final CrossReference crossRef) { AbstractElement _terminal = crossRef.getTerminal(); if ((_terminal instanceof RuleCall)) { AbstractElement _terminal_1 = crossRef.getTerminal(); final String ruleName = ((RuleCall) _terminal_1).getRule().getName(); return ((Objects.equal(ruleName, "IdOrSuper") || Objects.equal(ruleName, "ValidID")) || Objects.equal(ruleName, "FeatureCallID")); } return false; }
protected boolean isContentValidationNeeded(Collection<AbstractElement> ass) { if (ass == null || ass.size() < 2) return false; Iterator<AbstractElement> it = ass.iterator(); AbstractElement first = it.next(); CrossReference firstRef = GrammarUtil.containingCrossReference(first); while (it.hasNext()) { AbstractElement next = it.next(); if (next instanceof Action) return true; if (!EcoreUtil.equals(first, next)) return true; if (firstRef != null) { CrossReference nextRef = GrammarUtil.containingCrossReference(next); if (nextRef != null && nextRef.getType().getClassifier() != firstRef.getType().getClassifier()) return true; } } return false; } }
@Override public Boolean caseCrossReference(CrossReference object) { if (object == stopElement) return true; return doSwitch(object.getTerminal()); }
public List<CrossReference> findCrossReferences(EClassifier... targetEClassifiers) { Set<EClassifier> classifiers = new HashSet<EClassifier>(Arrays.asList(targetEClassifiers)); Collection<EClass> classes = Lists.newArrayList(Iterables.filter(classifiers, EClass.class)); ArrayList<CrossReference> r = new ArrayList<CrossReference>(); for (AbstractRule ar : getRules()) { TreeIterator<EObject> i = ar.eAllContents(); while (i.hasNext()) { EObject o = i.next(); if (o instanceof CrossReference) { CrossReference c = (CrossReference) o; if (classifiers.contains(c.getType().getClassifier())) r.add(c); else if (c.getType().getClassifier() instanceof EClass) for (EClass cls : classes) if (EcoreUtil2.isAssignableFrom(cls,(EClass) c.getType().getClassifier())) { r.add(c); break; } i.prune(); } } } return r; }
@Override public Boolean caseCrossReference(CrossReference object) { return doSwitch(object.getTerminal()); }
@Override public String caseCrossReference(CrossReference object) { String cr = "[" + object.getType().getClassifier().getName() + "]"; return addAssignemnt(cr, object) + card(object); }
protected String _assignmentEbnf(final CrossReference it, final Assignment assignment, final AntlrOptions options, final boolean supportActions) { return this.crossrefEbnf(it.getTerminal(), it, supportActions); }
/** * @param grammarElement * may be any crossreferencable element, i.e. a keyword or a rulecall */ public String getRuleNameFrom(EObject grammarElement) { if (!(grammarElement instanceof Keyword || grammarElement instanceof RuleCall || grammarElement instanceof CrossReference)) throw new IllegalArgumentException("grammarElement is of type: '" + grammarElement.eClass().getName() + "'"); AbstractRule rule = null; EObject elementToUse = grammarElement; if (grammarElement instanceof CrossReference) elementToUse = ((CrossReference) grammarElement).getTerminal(); if (elementToUse instanceof RuleCall) rule = ((RuleCall) elementToUse).getRule(); return rule != null ? rule.getName() : null; }
protected IInstanceDescription tryConsumeVal() { if((value = current.getConsumable("contextRef",true)) == null) return null; IInstanceDescription obj = current.cloneAndConsume("contextRef"); if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl IInstanceDescription param = getDescr((EObject)value); if(param.isInstanceOf(grammarAccess.getCompoundDialogueAccess().getContextRefExternalReferenceCrossReference_0_4_0().getType().getClassifier())) { type = AssignmentType.CR; element = grammarAccess.getCompoundDialogueAccess().getContextRefExternalReferenceCrossReference_0_4_0(); return obj; } } return null; }
public Iterable<AbstractElement> getSequentialChildren(AbstractElement ele) { switch (ele.eClass().getClassifierID()) { case XtextPackage.GROUP: return ((Group) ele).getElements(); case XtextPackage.ASSIGNMENT: return Collections.singleton(((Assignment) ele).getTerminal()); case XtextPackage.CROSS_REFERENCE: return Collections.singleton(((CrossReference) ele).getTerminal()); default: return null; } }