Java AbstractRule類代碼示例

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@Override
public void initializeFor(AbstractRule rule) {
	// TODO: GH-61.
	// Remove this function to see test errors in GHOLD-92-LINKING_DIAGNOSTIC_import_missing_B.n4js.xt
	/*
	 * Comment by Sebastian: This is a super nasty side effect of some Xpect internals: Xpect uses own injectors
	 * thus reflectively creates a new injector for the language. Effectively two injectors for N4JS exist at that
	 * time. Both have their own 'singleton'-bindings, their own in-memory gramar representation etc. This is highly
	 * problematic since all sorts of assumptions do no longer hold in such a setup. That is, especially the grammar
	 * elements are supposed to be singletons and to be comparable by identity. Now we have each grammar element
	 * twice in memory. Further there appears to be a blurry boundary between which object is obtain from which of
	 * both injectors, so in the end, we face a parser instance that was produced by the real injector being used by
	 * objects that were produced by the second injector. To be honest, I wonder wow this can even work. This is a
	 * super critical misbehavior of Xpect from my point of view.
	 */
	if (super.getEntryRule() == null) {
		super.initializeFor(rule);
	}
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
private static void rewriteKeywords(AbstractRule rule, N4JSKeywords keywords,
		ImmutableMap.Builder<AbstractElement, Integer> builder) {
	for (EObject obj : EcoreUtil2.eAllContents(rule.getAlternatives())) {
		if (obj instanceof Keyword) {
			Keyword keyword = (Keyword) obj;
			Integer type = keywords.getTokenType(keyword);
			if (type != null) {
				if (keyword.eContainer() instanceof EnumLiteralDeclaration) {
					builder.put((AbstractElement) keyword.eContainer(), type);
				} else {
					builder.put(keyword, type);
				}
			}
		}
	}
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
private static void rewriteTypeReferences(N4JSGrammarAccess ga,
		ImmutableMap.Builder<AbstractElement, Integer> builder) {
	for (ParserRule rule : GrammarUtil.allParserRules(ga.getGrammar())) {
		for (EObject obj : EcoreUtil2.eAllContents(rule.getAlternatives())) {
			if (obj instanceof Assignment) {
				Assignment assignment = (Assignment) obj;
				AbstractElement terminal = assignment.getTerminal();
				if (terminal instanceof RuleCall) {
					AbstractRule calledRule = ((RuleCall) terminal).getRule();
					EClassifier classifier = calledRule.getType().getClassifier();
					if (classifier instanceof EClass
							&& TypeRefsPackage.Literals.TYPE_REF.isSuperTypeOf((EClass) classifier)) {
						builder.put(assignment, TYPE_REF_TOKEN);
					}
				}
			}
		}
	}
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
private static void rewriteIdentifiers(N4JSGrammarAccess ga,
		ImmutableMap.Builder<AbstractElement, Integer> builder) {
	ImmutableSet<AbstractRule> identifierRules = ImmutableSet.of(
			ga.getBindingIdentifierRule(),
			ga.getIdentifierNameRule(),
			ga.getIDENTIFIERRule());
	for (ParserRule rule : GrammarUtil.allParserRules(ga.getGrammar())) {
		for (EObject obj : EcoreUtil2.eAllContents(rule.getAlternatives())) {
			if (obj instanceof Assignment) {
				Assignment assignment = (Assignment) obj;
				AbstractElement terminal = assignment.getTerminal();
				int type = InternalN4JSParser.RULE_IDENTIFIER;
				if (terminal instanceof CrossReference) {
					terminal = ((CrossReference) terminal).getTerminal();
					type = IDENTIFIER_REF_TOKEN;
				}
				if (terminal instanceof RuleCall) {
					AbstractRule calledRule = ((RuleCall) terminal).getRule();
					if (identifierRules.contains(calledRule)) {
						builder.put(assignment, type);
					}
				}
			}
		}
	}
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
private static void rewriteNumberLiterals(N4JSGrammarAccess ga,
		ImmutableMap.Builder<AbstractElement, Integer> builder) {
	for (ParserRule rule : GrammarUtil.allParserRules(ga.getGrammar())) {
		for (EObject obj : EcoreUtil2.eAllContents(rule.getAlternatives())) {
			if (obj instanceof Assignment) {
				Assignment assignment = (Assignment) obj;
				AbstractElement terminal = assignment.getTerminal();
				if (terminal instanceof RuleCall) {
					AbstractRule calledRule = ((RuleCall) terminal).getRule();
					EClassifier classifier = calledRule.getType().getClassifier();
					if (classifier == EcorePackage.Literals.EBIG_DECIMAL) {
						builder.put(assignment, NUMBER_LITERAL_TOKEN);
					}
				}
			}
		}
	}
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@SuppressWarnings("unchecked")
@Override
protected void registerRules(Grammar grammar) {
	if (ALL_RULES_FIELD != null) {
		try {
			Map<String, AbstractRule> localAllRules = (Map<String, AbstractRule>) ALL_RULES_FIELD.get(this);
			if (allRules == null) {
				super.registerRules(grammar);
				allRules = localAllRules;
			} else {
				localAllRules.putAll(allRules);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	} else {
		super.registerRules(grammar);
	}
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@Test
public void testUnassignedRule_04() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar org.foo with org.eclipse.xtext.common.Terminals");
  _builder.newLine();
  _builder.append("generate metamodel \'foo.sample\'");
  _builder.newLine();
  _builder.append("First : Second (name=ID)? id=INT;");
  _builder.newLine();
  _builder.append("Second: id=INT (name=ID)?;");
  _builder.newLine();
  String grammarAsString = _builder.toString();
  final Grammar grammar = this.getGrammar(grammarAsString);
  AbstractRule _findRuleForName = GrammarUtil.findRuleForName(grammar, "First");
  final ParserRule rule = ((ParserRule) _findRuleForName);
  this.validateRule(rule);
  Assert.assertEquals(this.warnings.toString(), 4, this.warnings.size());
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
/**
 * @since 2.9
 */
@SuppressWarnings("unchecked")
public static <T extends EObject> T getOriginalElement(T obj) {
	if (obj instanceof AbstractRule) {
		AbstractRule result = RuleWithParameterValues.tryGetOriginalRule((AbstractRule) obj);
		if (result != null)
			return (T) result;
		return obj;
	}
	if (obj instanceof Grammar) {
		OriginalGrammar originalGrammar = OriginalGrammar.findInEmfObject(obj);
		return (T) originalGrammar.getOriginal();
	}
	if (obj instanceof AbstractElement) {
		OriginalElement original = OriginalElement.findInEmfObject(obj);
		return (T) original.getOriginal();
	}
	throw new IllegalArgumentException(String.valueOf(obj));
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@Test
public void testUnorderedGroup_03() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar org.foo with org.eclipse.xtext.common.Terminals");
  _builder.newLine();
  _builder.append("generate metamodel \'foo.sample\'");
  _builder.newLine();
  _builder.append("Model : (a = ID & b = STRING)+;");
  _builder.newLine();
  String grammarAsString = _builder.toString();
  final Grammar grammar = this.getGrammar(grammarAsString);
  AbstractRule _findRuleForName = GrammarUtil.findRuleForName(grammar, "Model");
  final ParserRule rule = ((ParserRule) _findRuleForName);
  this.validateRule(rule);
  Assert.assertEquals(this.warnings.toString(), 2, this.warnings.size());
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
/**
 * 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;
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@Test
public void testMultiInheritance_01() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar test with org.eclipse.xtext.enumrules.EnumRulesTestLanguage");
  _builder.newLine();
  _builder.append("import \'http://www.eclipse.org/xtext/common/JavaVMTypes\' as types");
  _builder.newLine();
  _builder.append("generate myDsl \"http://example.xtext.org/MyDsl\" as mydsl");
  _builder.newLine();
  _builder.append("Array returns mydsl::Array: componentType=ComponentType componentType=DeclaredType;");
  _builder.newLine();
  _builder.append("DeclaredType returns types::JvmDeclaredType: members+=DeclaredType;");
  _builder.newLine();
  _builder.append("ComponentType returns types::JvmComponentType: \'ignore\';");
  _builder.newLine();
  final String grammarAsString = _builder.toString();
  final XtextResource resource = this.getResourceFromString(grammarAsString);
  EObject _head = IterableExtensions.<EObject>head(resource.getContents());
  final Grammar grammar = ((Grammar) _head);
  EClassifier _classifier = IterableExtensions.<AbstractRule>head(grammar.getRules()).getType().getClassifier();
  EClass array = ((EClass) _classifier);
  Assert.assertEquals("JvmComponentType", this.<EStructuralFeature>feature(array, "componentType").getEType().getName());
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@Test
public void testMultiInheritance_02() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar test with org.eclipse.xtext.enumrules.EnumRulesTestLanguage");
  _builder.newLine();
  _builder.append("import \'http://www.eclipse.org/xtext/common/JavaVMTypes\' as types");
  _builder.newLine();
  _builder.append("generate myDsl \"http://example.xtext.org/MyDsl\" as mydsl");
  _builder.newLine();
  _builder.append("Array returns mydsl::Array: componentType=DeclaredType componentType=ComponentType;");
  _builder.newLine();
  _builder.append("DeclaredType returns types::JvmDeclaredType: members+=DeclaredType;");
  _builder.newLine();
  _builder.append("ComponentType returns types::JvmComponentType: \'ignore\';");
  _builder.newLine();
  final String grammarAsString = _builder.toString();
  final XtextResource resource = this.getResourceFromString(grammarAsString);
  EObject _head = IterableExtensions.<EObject>head(resource.getContents());
  final Grammar grammar = ((Grammar) _head);
  EClassifier _classifier = IterableExtensions.<AbstractRule>head(grammar.getRules()).getType().getClassifier();
  EClass array = ((EClass) _classifier);
  Assert.assertEquals("JvmComponentType", this.<EStructuralFeature>feature(array, "componentType").getEType().getName());
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@Test
public void testFragment_05() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar org.foo with org.eclipse.xtext.common.Terminals");
  _builder.newLine();
  _builder.append("generate metamodel \'foo.sample\'");
  _builder.newLine();
  _builder.append("First : Named*;");
  _builder.newLine();
  _builder.append("fragment Named: name=ID;");
  _builder.newLine();
  String grammarAsString = _builder.toString();
  final Grammar grammar = this.getGrammar(grammarAsString);
  AbstractRule _findRuleForName = GrammarUtil.findRuleForName(grammar, "First");
  final ParserRule rule = ((ParserRule) _findRuleForName);
  this.validateRule(rule);
  Assert.assertEquals(this.warnings.toString(), 1, this.warnings.size());
  AbstractRule _findRuleForName_1 = GrammarUtil.findRuleForName(grammar, "Named");
  final ParserRule fragment = ((ParserRule) _findRuleForName_1);
  this.validateRule(fragment);
  Assert.assertEquals(this.warnings.toString(), 0, this.warnings.size());
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
@Test
public void testUnassignedRule_02() throws Exception {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("grammar org.foo with org.eclipse.xtext.common.Terminals");
  _builder.newLine();
  _builder.append("generate metamodel \'foo.sample\'");
  _builder.newLine();
  _builder.append("First : Second name=ID;");
  _builder.newLine();
  _builder.append("Second: name=ID;");
  _builder.newLine();
  String grammarAsString = _builder.toString();
  final Grammar grammar = this.getGrammar(grammarAsString);
  AbstractRule _findRuleForName = GrammarUtil.findRuleForName(grammar, "First");
  final ParserRule rule = ((ParserRule) _findRuleForName);
  this.validateRule(rule);
  Assert.assertEquals(this.warnings.toString(), 2, this.warnings.size());
}
 

import org.eclipse.xtext.AbstractRule; //導入依賴的package包/類
/** {@inheritDoc} */
@Override
public List<INode> getDocumentationNodes(final EObject object) {
  ICompositeNode node = NodeModelUtils.getNode(object);
  if (node == null) {
    return ImmutableList.of();
  }

  // get all single line comments before a non hidden leaf node
  List<INode> result = Lists.newArrayList();
  for (ILeafNode leaf : node.getLeafNodes()) {
    if (!leaf.isHidden()) {
      break;
    }
    EObject grammarElement = leaf.getGrammarElement();
    if (grammarElement instanceof AbstractRule && ruleName.equals(((AbstractRule) grammarElement).getName())) {
      String comment = leaf.getText();
      if (getCommentPattern().matcher(comment).matches() && !comment.matches(ignore)) {
        result.add(leaf);
      }
    }
  }

  return result;
}