public static boolean isParserRuleCall(EObject grammarElement) { if (grammarElement instanceof RuleCall) { AbstractRule calledRule = ((RuleCall) grammarElement).getRule(); return calledRule != null && calledRule instanceof ParserRule; } return false; }
@Override public Boolean caseRuleCall(RuleCall object) { if (object.getRule() instanceof EnumRule) { } else if (object.getRule() instanceof TerminalRule || GrammarUtil.isDatatypeRule((ParserRule) object.getRule())) { if (object.eContainer() instanceof Assignment) { completeNestedAssignment((Assignment) object.eContainer(), context, acceptor); } } return Boolean.TRUE; }
/** * @since 2.14 */ protected int computeParamStackOffset(List<AbstractElement> currentState, List<Integer> paramStack) { int paramIndex = paramStack.size() - 1; if (!paramStack.isEmpty()) { for(AbstractElement abstractElement: currentState) { if (abstractElement instanceof RuleCall) { RuleCall call = (RuleCall) abstractElement; if (!call.getArguments().isEmpty()) { paramIndex--; } } } } return paramIndex; }
@Override public String caseRuleCall(RuleCall object) { doSwitch(object.getRule()); result.append(Strings.emptyIfNull(object.getCardinality())); return ""; }
/** * @since 2.14 */ protected String[][] getRequiredRuleNames(Param param, AbstractElement elementToParse) { if (elementToParse instanceof RuleCall) { RuleCall call = (RuleCall) elementToParse; if (call.getRule() instanceof ParserRule) { String antlrRuleName = ruleNames.getAntlrRuleName(call.getRule()); if (!call.getArguments().isEmpty()) { Set<Parameter> context = param.getAssignedParametes(); Set<Parameter> arguments = getAssignedArguments(call, context); int config = getParameterConfig(arguments); antlrRuleName = ruleNames.getAntlrRuleName(call.getRule(), config); } return new String[][] { { antlrRuleName } }; } } return EMPTY_ARRAY; }
protected void updateOverriddenRules(Grammar grammar, Map<String, AbstractRule> rulePerName) { if (grammar.isDefinesHiddenTokens()) { updateHiddenTokens(grammar.getHiddenTokens(), rulePerName); } for (AbstractRule rule : grammar.getRules()) { if (rule instanceof ParserRule && ((ParserRule) rule).isDefinesHiddenTokens()) { updateHiddenTokens(((ParserRule) rule).getHiddenTokens(), rulePerName); } } final List<RuleCall> allRuleCalls = EcoreUtil2.getAllContentsOfType(grammar, RuleCall.class); for (RuleCall call : allRuleCalls) { if (call.getRule() != null) { AbstractRule rule = rulePerName.get(call.getRule().getName()); if (rule != null) call.setRule(rule); } } }
@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); } }
final List<NamedArgument> arguments = ruleCall.getArguments(); AbstractRule abstractRule = ruleCall.getRule(); boolean needsCurrent = passCurrentIntoFragment && GrammarUtil.isEObjectFragmentRule(abstractRule) && !GrammarUtil.isDatatypeRule((ParserRule) getOriginalElement(abstractRule)); if (arguments.isEmpty()) {
if (parserRule != null) { RuleCall ruleCall = XtextFactory.eINSTANCE.createRuleCall(); ruleCall.setRule(parserRule); calculator.doSwitch(ruleCall);
public static boolean isEnumRuleCall(EObject grammarElement) { if (grammarElement instanceof RuleCall) { AbstractRule calledRule = ((RuleCall) grammarElement).getRule(); return calledRule != null && calledRule instanceof EnumRule; } return false; }
@Override public Boolean caseRuleCall(RuleCall object) { if (!visitedRuleCalls.add(object)) return isOptional(object); acceptor.accept(object); Set<Parameter> oldConfig = currentConfig; try { if (!object.getArguments().isEmpty()) { currentConfig = ParameterConfigHelper.getAssignedArguments(object, getParameterValues(object)); } else { currentConfig = Collections.emptySet(); } Boolean result = doSwitch(object.getRule()) || isOptional(object); visitedRuleCalls.remove(object); return result; } finally { currentConfig = oldConfig; } }
@Override protected void _createProposals(final RuleCall ruleCall, final ContentAssistContext context, final IIdeContentProposalAcceptor acceptor) { AbstractRule _rule = ruleCall.getRule(); boolean _matched = false; ParserRule _xExpressionRule = this._xbaseGrammarAccess.getXExpressionRule(); if (Objects.equal(_rule, _xExpressionRule)) { _matched=true; if (((ruleCall.eContainer() instanceof Group) && Objects.equal(GrammarUtil.containingRule(ruleCall).getName(), "XParenthesizedExpression"))) { this.createLocalVariableAndImplicitProposals(context.getCurrentModel(), IExpressionScope.Anchor.WITHIN, context, acceptor); } } if (!_matched) { super._createProposals(ruleCall, context, acceptor); } }
if (parserRule != null) { RuleCall ruleCall = XtextFactory.eINSTANCE.createRuleCall(); ruleCall.setRule(parserRule); calculator.doSwitch(ruleCall);
/** * @since 2.14 */ protected int setParamConfigAndUpdateOffset(FollowElementCalculator calculator, List<Integer> paramStack, int paramIndex, AbstractElement abstractElement) { if (paramIndex >= 0) { calculator.setParameterConfig(paramStack.get(paramIndex)); } else { calculator.setParameterConfig(0); } if (abstractElement instanceof RuleCall) { RuleCall call = (RuleCall) abstractElement; if (!call.getArguments().isEmpty()) { paramIndex++; } } return paramIndex; }
protected static AbstractRule getRule(EObject grammarElement) { if (grammarElement instanceof TerminalRule) { return (AbstractRule) grammarElement; } if (grammarElement instanceof RuleCall) { return ((RuleCall) grammarElement).getRule(); } return null; }
final AbstractRule calledRule = ruleCall.getRule(); Group group = (Group) calledRule.getAlternatives(); AbstractElement first = group.getElements().get(0); AbstractElement result = getPredicatedElement(first); if (ruleCall.getArguments().isEmpty()) { return result;
protected boolean shouldUseParent(ICompositeNode result, int offset, ILeafNode leaf) { if (leaf.getTotalEndOffset() == offset) { return true; } if (result.getGrammarElement() instanceof RuleCall) { RuleCall rc = (RuleCall) result.getGrammarElement(); if (!rc.getArguments().isEmpty()) { return true; } Assignment assignment = GrammarUtil.containingAssignment(rc); if (assignment != null && (GrammarUtil.isMultipleCardinality(assignment) || (assignment.eContainer() instanceof AbstractElement && GrammarUtil .isMultipleCardinality((AbstractElement) assignment.eContainer())))) { return true; } } return false; }
/** * @since 2.0 */ public static boolean isTerminalRuleCall(EObject grammarElement) { if (grammarElement instanceof RuleCall) { AbstractRule calledRule = ((RuleCall) grammarElement).getRule(); return calledRule != null && calledRule instanceof TerminalRule; } return false; }