protected String _localVar(final EnumLiteralDeclaration it) {
   EnumRule _containingEnumRule = GrammarUtil.containingEnumRule(it);
   AbstractElement _alternatives = _containingEnumRule.getAlternatives();
   List<AbstractElement> _contentsAsList = this.contentsAsList(_alternatives);
   int _indexOf = _contentsAsList.indexOf(it);
   return ("enumLiteral_" + Integer.valueOf(_indexOf));
 }
  public class Enum1Elements extends AbstractEnumRuleElementFinder {
    private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "Enum1");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final EnumLiteralDeclaration cLit1EnumLiteralDeclaration_0 =
        (EnumLiteralDeclaration) cAlternatives.eContents().get(0);
    private final Keyword cLit1Lit1Keyword_0_0 =
        (Keyword) cLit1EnumLiteralDeclaration_0.eContents().get(0);
    private final EnumLiteralDeclaration cLit2EnumLiteralDeclaration_1 =
        (EnumLiteralDeclaration) cAlternatives.eContents().get(1);
    private final Keyword cLit2Lit2Keyword_1_0 =
        (Keyword) cLit2EnumLiteralDeclaration_1.eContents().get(0);
    private final EnumLiteralDeclaration cLit3EnumLiteralDeclaration_2 =
        (EnumLiteralDeclaration) cAlternatives.eContents().get(2);
    private final Keyword cLit3Lit3Keyword_2_0 =
        (Keyword) cLit3EnumLiteralDeclaration_2.eContents().get(0);

    // enum Enum1:
    //	lit1 | lit2 | lit3;
    public EnumRule getRule() {
      return rule;
    }

    // lit1 | lit2 | lit3
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // lit1
    public EnumLiteralDeclaration getLit1EnumLiteralDeclaration_0() {
      return cLit1EnumLiteralDeclaration_0;
    }

    // "lit1"
    public Keyword getLit1Lit1Keyword_0_0() {
      return cLit1Lit1Keyword_0_0;
    }

    // lit2
    public EnumLiteralDeclaration getLit2EnumLiteralDeclaration_1() {
      return cLit2EnumLiteralDeclaration_1;
    }

    // "lit2"
    public Keyword getLit2Lit2Keyword_1_0() {
      return cLit2Lit2Keyword_1_0;
    }

    // lit3
    public EnumLiteralDeclaration getLit3EnumLiteralDeclaration_2() {
      return cLit3EnumLiteralDeclaration_2;
    }

    // "lit3"
    public Keyword getLit3Lit3Keyword_2_0() {
      return cLit3Lit3Keyword_2_0;
    }
  }
  public class GeneratedEnumElements extends AbstractEnumRuleElementFinder {
    private final EnumRule rule =
        (EnumRule)
            GrammarUtil.findRuleForName(
                getGrammar(),
                "org.eclipse.xtext.ui.tests.enumrules.EnumRulesUiTestLanguage.GeneratedEnum");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final EnumLiteralDeclaration cSameNameEnumLiteralDeclaration_0 =
        (EnumLiteralDeclaration) cAlternatives.eContents().get(0);
    private final Keyword cSameNameSameNameKeyword_0_0 =
        (Keyword) cSameNameEnumLiteralDeclaration_0.eContents().get(0);
    private final EnumLiteralDeclaration cDifferentNameEnumLiteralDeclaration_1 =
        (EnumLiteralDeclaration) cAlternatives.eContents().get(1);
    private final Keyword cDifferentNameDifferentLiteralKeyword_1_0 =
        (Keyword) cDifferentNameEnumLiteralDeclaration_1.eContents().get(0);

    // enum GeneratedEnum:
    //	SameName | DifferentName="DifferentLiteral";
    public EnumRule getRule() {
      return rule;
    }

    // SameName | DifferentName="DifferentLiteral"
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // SameName
    public EnumLiteralDeclaration getSameNameEnumLiteralDeclaration_0() {
      return cSameNameEnumLiteralDeclaration_0;
    }

    // "SameName"
    public Keyword getSameNameSameNameKeyword_0_0() {
      return cSameNameSameNameKeyword_0_0;
    }

    // DifferentName="DifferentLiteral"
    public EnumLiteralDeclaration getDifferentNameEnumLiteralDeclaration_1() {
      return cDifferentNameEnumLiteralDeclaration_1;
    }

    // "DifferentLiteral"
    public Keyword getDifferentNameDifferentLiteralKeyword_1_0() {
      return cDifferentNameDifferentLiteralKeyword_1_0;
    }
  }
Example #4
0
 private ArrayList<AbstractRule> copyRuleStubs(
     final RuleNames names,
     final Map<RuleWithParameterValues, AbstractRule> origToCopy,
     final List<AbstractRule> rulesToCopy,
     final boolean discardTypeRef) {
   final ArrayList<AbstractRule> result = CollectionLiterals.<AbstractRule>newArrayList();
   for (final AbstractRule rule : rulesToCopy) {
     {
       String ruleName = names.getAntlrRuleName(rule);
       boolean _matched = false;
       if (rule instanceof ParserRule) {
         _matched = true;
         List<Parameter> params = ((ParserRule) rule).getParameters();
         boolean _isEmpty = params.isEmpty();
         if (_isEmpty) {
           ParserRule copy = this.<ParserRule>copy(((ParserRule) rule));
           copy.setName(ruleName);
           boolean _isFragment = ((ParserRule) rule).isFragment();
           copy.setFragment(_isFragment);
           boolean _isWildcard = ((ParserRule) rule).isWildcard();
           copy.setWildcard(_isWildcard);
           if ((!discardTypeRef)) {
             TypeRef _type = ((ParserRule) rule).getType();
             TypeRef _copyTypeRef = this.copyTypeRef(_type);
             copy.setType(_copyTypeRef);
           }
           this.attachTo(copy, rule, origToCopy);
           result.add(copy);
         } else {
           ImmutableSet<Parameter> _copyOf = ImmutableSet.<Parameter>copyOf(params);
           Set<Set<Parameter>> _powerSet = Sets.<Parameter>powerSet(_copyOf);
           final Procedure2<Set<Parameter>, Integer> _function =
               (Set<Parameter> parameterConfig, Integer i) -> {
                 RuleWithParameterValues parameterValues =
                     new RuleWithParameterValues(rule, parameterConfig);
                 ParserRule copy_1 = this.<ParserRule>copy(((ParserRule) rule));
                 String _antlrRuleName = names.getAntlrRuleName(rule, (i).intValue());
                 copy_1.setName(_antlrRuleName);
                 boolean _isFragment_1 = ((ParserRule) rule).isFragment();
                 copy_1.setFragment(_isFragment_1);
                 boolean _isWildcard_1 = ((ParserRule) rule).isWildcard();
                 copy_1.setWildcard(_isWildcard_1);
                 if ((!discardTypeRef)) {
                   TypeRef _type_1 = ((ParserRule) rule).getType();
                   TypeRef _copyTypeRef_1 = this.copyTypeRef(_type_1);
                   copy_1.setType(_copyTypeRef_1);
                 }
                 origToCopy.put(parameterValues, copy_1);
                 parameterValues.attachToEmfObject(copy_1);
                 result.add(copy_1);
               };
           IterableExtensions.<Set<Parameter>>forEach(_powerSet, _function);
         }
       }
       if (!_matched) {
         if (rule instanceof TerminalRule) {
           _matched = true;
           TerminalRule orig = ((TerminalRule) rule);
           TerminalRule copy = this.<TerminalRule>copy(orig);
           copy.setName(ruleName);
           boolean _isFragment = orig.isFragment();
           copy.setFragment(_isFragment);
           this.attachTo(copy, orig, origToCopy);
           result.add(copy);
         }
       }
       if (!_matched) {
         if (rule instanceof EnumRule) {
           _matched = true;
           EnumRule copy = this.<EnumRule>copy(((EnumRule) rule));
           copy.setName(ruleName);
           this.attachTo(copy, rule, origToCopy);
           result.add(copy);
         }
       }
     }
   }
   return result;
 }
 protected String _ruleName(final EnumRule it) {
   String _name = it.getName();
   return ("rule" + _name);
 }
Example #6
0
 @Override
 public Boolean caseEnumRule(EnumRule object) {
   return doSwitch(object.getAlternatives());
 }