protected boolean allowTransient(EObject obj, EStructuralFeature feature, Collection<ISyntaxConstraint> constraint) { if (feature.getEType() instanceof EEnum) return true; Object value = obj.eGet(feature); List<RuleCall> ruleCalls = GrammarUtil.containedRuleCalls(constraint.iterator().next().getGrammarElement()); if (ruleCalls.isEmpty()) return false; return valueSerializer.isValid(obj, ruleCalls.get(0), value, null); }
public boolean isCalled(final AbstractRule rule, final Grammar grammar) { boolean _xblockexpression = false; { final List<AbstractRule> allRules = GrammarUtil.allRules(grammar); _xblockexpression = ((allRules.indexOf(rule) == 0) || IterableExtensions.<RuleCall>exists(Iterables.<RuleCall>concat(ListExtensions.<AbstractRule, List<RuleCall>>map(allRules, ((Function1<AbstractRule, List<RuleCall>>) (AbstractRule it) -> { return GrammarUtil.containedRuleCalls(it); }))), ((Function1<RuleCall, Boolean>) (RuleCall ruleCall) -> { AbstractRule _rule = ruleCall.getRule(); return Boolean.valueOf(Objects.equal(_rule, rule)); }))); } return _xblockexpression; }
protected void collectReachableRules(ParserRule pr, Set<ParserRule> rules, Set<ParserRule> visited) { if (!visited.add(pr)) return; for (RuleCall rc : GrammarUtil.containedRuleCalls(pr)) if (isParserRule(rc.getRule())) { if (GrammarUtil.containingAssignment(rc) != null) rules.add((ParserRule) rc.getRule()); collectReachableRules((ParserRule) rc.getRule(), rules, visited); } }
protected boolean internalFindPathToImportSection(LinkedList<EObject> pathToImportSection, Set<ParserRule> seenRules, EObject ruleOrRuleCall) { ParserRule rule = null; EClassifier returnType = null; if(ruleOrRuleCall instanceof ParserRule) rule = (ParserRule) ruleOrRuleCall; else rule = (ParserRule) ((RuleCall) ruleOrRuleCall).getRule(); if(seenRules.contains(rule)) return false; seenRules.add(rule); pathToImportSection.addLast(ruleOrRuleCall); returnType = rule.getType().getClassifier(); if(returnType instanceof EClass && XtypePackage.Literals.XIMPORT_SECTION.isSuperTypeOf((EClass) returnType)) { return true; } for(RuleCall containedRuleCall: GrammarUtil.containedRuleCalls(rule)) { if(containedRuleCall.getRule() instanceof ParserRule) if(internalFindPathToImportSection(pathToImportSection, seenRules, containedRuleCall)) { return true; } } pathToImportSection.removeLast(); return false; }
private List<AbstractRule> unassignedCalledTokenRules() { final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf(GrammarUtil.isEObjectRule(it)); }; final Iterable<AbstractRule> rules = IterableExtensions.<AbstractRule>filter(GrammarUtil.allRules(this.getGrammar()), _function); final Function1<AbstractRule, Iterable<RuleCall>> _function_1 = (AbstractRule it) -> { final Function1<RuleCall, Boolean> _function_2 = (RuleCall it_1) -> { return Boolean.valueOf(this.isUnassignedRuleCall(it_1)); }; return IterableExtensions.<RuleCall>filter(GrammarUtil.containedRuleCalls(it), _function_2); }; final Iterable<RuleCall> calls = Iterables.<RuleCall>concat(IterableExtensions.<AbstractRule, Iterable<RuleCall>>map(rules, _function_1)); final Function1<RuleCall, AbstractRule> _function_2 = (RuleCall it) -> { return it.getRule(); }; final Function1<AbstractRule, String> _function_3 = (AbstractRule it) -> { return it.getName(); }; return IterableExtensions.<AbstractRule, String>sortBy(IterableExtensions.<AbstractRule>toSet(IterableExtensions.<RuleCall, AbstractRule>map(calls, _function_2)), _function_3); }
} else { ErrorAcceptor err = new ErrorAcceptor(); for (RuleCall ruleCall : GrammarUtil.containedRuleCalls(token.getGrammarElement())) { if (ruleCall.getRule() instanceof EnumRule) { if (enumSerializer.isValid(token.getEObject(), ruleCall, value, err))