org.eclipse.xtext.Keyword Java Examples

/**
 * Syntax: '('*
 */
@Override
protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject,
		ISynNavigable transition, List<INode> nodes) {

	Keyword kw = grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0();

	if (nodes == null) {
		if (semanticObject instanceof XIfExpression || semanticObject instanceof XTryCatchFinallyExpression) {
			EObject cnt = semanticObject.eContainer();
			if (cnt instanceof XExpression && !(cnt instanceof XBlockExpression)
					&& !(cnt instanceof XForLoopExpression))
				acceptUnassignedKeyword(kw, kw.getValue(), null);
		}
		if (semanticObject instanceof XConstructorCall) {
			XConstructorCall call = (XConstructorCall) semanticObject;
			if (!call.isExplicitConstructorCall() && call.getArguments().isEmpty()) {
				acceptUnassignedKeyword(kw, kw.getValue(), null);
			}
		}
	}
	acceptNodes(transition, nodes);
}
 

@Override
public boolean filterKeyword(final Keyword keyword, final ContentAssistContext context) {
  final String value = keyword.getValue();
  if (((value.length() > 1) && Character.isLetter(value.charAt(0)))) {
    if ((Objects.equal(value, "as") || Objects.equal(value, "instanceof"))) {
      final EObject previousModel = context.getPreviousModel();
      if ((previousModel instanceof XExpression)) {
        if (((context.getPrefix().length() == 0) && (NodeModelUtils.getNode(previousModel).getEndOffset() > context.getOffset()))) {
          return false;
        }
        final LightweightTypeReference type = this.typeResolver.resolveTypes(previousModel).getActualType(((XExpression)previousModel));
        if (((type == null) || type.isPrimitiveVoid())) {
          return false;
        }
      }
    }
    return true;
  }
  return false;
}
 

public void collectTokens(final EObject it, final List<String> known) {
  if (it instanceof Keyword) {
    _collectTokens((Keyword)it, known);
    return;
  } else if (it instanceof AbstractRule) {
    _collectTokens((AbstractRule)it, known);
    return;
  } else if (it != null) {
    _collectTokens(it, known);
    return;
  } else {
    throw new IllegalArgumentException("Unhandled parameter types: " +
      Arrays.<Object>asList(it, known).toString());
  }
}
 

private static boolean detectBugSituation(IHiddenRegion hiddenRegion) {
	if (hiddenRegion != null) {
		final ISemanticRegion semanticRegion = hiddenRegion.getNextSemanticRegion();
		if (semanticRegion != null) {
			final EObject element = semanticRegion.getGrammarElement();
			if (element instanceof Keyword
					&& Strings.equal(((Keyword) element).getValue(), "}")) { //$NON-NLS-1$
				return true;
			}
		}
	}
	return false;
}
 

public void completeClassicFacet_Key(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
	if (assignment.getTerminal() instanceof RuleCall) {
		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
	}
	if (assignment.getTerminal() instanceof Keyword) {
		// subclasses may override
	}
}
 

@Override
public void completeKeyword(Keyword keyword, ContentAssistContext contentAssistContext,
		ICompletionProposalAcceptor acceptor) {
	if (isKeywordWorthyToPropose(keyword, contentAssistContext)) {
		super.completeKeyword(keyword, contentAssistContext, acceptor);
	}
}
 

@Override
protected void emit_ModelThing_ThingKeyword_0_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
    ILeafNode node = nodes != null && nodes.size() == 1 && nodes.get(0) instanceof ILeafNode ? (ILeafNode) nodes
            .get(0) : null;
    Keyword keyword = grammarAccess.getModelThingAccess().getThingKeyword_0();
    acceptUnassignedKeyword(keyword, keyword.getValue(), node);
}
 

@Check
public void checkKeywordNotEmpty(final Keyword keyword) {
	if (keyword.getValue().length()==0 && !(keyword.eContainer() instanceof EnumLiteralDeclaration)) {
		addIssue("A keyword cannot be empty.", 
				keyword, 
				null,
				EMPTY_KEYWORD);
	}
}
 

public void accept(Keyword keyword, Object value, int indexInFeature, int indexInNonTransient) {
	Assignment ass = getAssignment(keyword);
	EStructuralFeature feature = getFeature(ass.getFeature());
	assertIndex(feature, indexInFeature);
	assertIndex(feature, indexInNonTransient);
	assertValue(feature, value);
	ILeafNode node = getLeafNode(feature, indexInFeature, indexInNonTransient, value);
	String token = getToken(keyword, value, node);
	acceptKeyword(ass, keyword, value, token, indexInFeature, node);
}
 

@Override
public String caseKeyword(final Keyword object) {
  return '"' + object.getValue() + '"';
}
 

@Override
public int consumeKeyword(Keyword keyword, String feature, boolean isMany, boolean isBoolean, ICharacterClass notFollowedBy, boolean optional) {
	keywordConsumer.configure(keyword, notFollowedBy);
	return consumeTerminal(keywordConsumer, feature, isMany, isBoolean, keyword, ISequenceMatcher.Factory.nullMatcher(), optional);
}
 

/**
 * General formatting configuration. Delegates formatting configuration to individual grammar elements.
 *
 * @param configuration
 *          formating configuration
 * @param access
 *          grammarAccess
 */
private void configure(final FormattingConfig configuration, final CheckGrammarAccess access) {

  super.configure(configuration, access.getXbaseWithAnnotationsGrammarAccess());

  // Common curly brackets handling (for check grammar only)
  List<Pair<Keyword, Keyword>> curlyPairs = access.findKeywordPairs("{", "}"); //$NON-NLS-1$ //$NON-NLS-2$
  for (Pair<Keyword, Keyword> pair : curlyPairs) {
    if (EcoreUtil2.getContainerOfType(pair.getFirst(), GrammarImpl.class).getName().equals(CheckConstants.GRAMMAR)) {
      configuration.setLinewrap().after(pair.getFirst());
      configuration.setIndentation(pair.getFirst(), pair.getSecond());
      configuration.setLinewrap().before(pair.getSecond());
    }
  }

  // AutoLineWrap
  configuration.setAutoLinewrap(LINE_WRAP_LENGTH);

  // Comments
  configuration.setLinewrap(0, 1, 2).before(access.getSL_COMMENTRule());
  configuration.setLinewrap(1, 1, 2).before(access.getML_COMMENTRule());
  configuration.setLinewrap(1, 1, 1).after(access.getML_COMMENTRule());

  // Rules
  configuration.setLinewrap(1, 1, 2).before(access.getXImportDeclarationRule());
  configuration.setLinewrap(1, 2, 2).before(access.getCategoryRule());
  configuration.setLinewrap(1, 2, 2).before(access.getImplementationRule());
  configuration.setLinewrap(1, 2, 2).before(access.getCheckRule());
  configuration.setLinewrap(1, 1, 2).before(access.getXGuardExpressionRule());
  configuration.setLinewrap(1, 1, 2).before(access.getXIssueExpressionRule());
  configuration.setLinewrap(1, 1, 2).before(access.getXIfExpressionRule());
  configuration.setLinewrap(1, 1, 2).before(access.getXVariableDeclarationRule());

  // Rule elements
  configureFeatureCall(configuration, access.getXMemberFeatureCallAccess());
  configureCheckCatalog(configuration, access.getCheckCatalogAccess());
  configureSeverityRange(configuration, access.getSeverityRangeAccess());
  configureCheck(configuration, access.getCheckAccess());
  configureXIssueExpression(configuration, access.getXIssueExpressionAccess());
  configureCheckContext(configuration, access.getContextAccess());
}
 

protected boolean isKeywordWorthyToPropose(Keyword keyword) {
	return keyword.getValue().length() > 1 && Character.isLetter(keyword.getValue().charAt(0));
}
 

@Override
public void acceptAssignedKeyword(Keyword keyword, String token, Object value, int index, ILeafNode node) {
	emitHiddenTokens(getHiddenNodesBetween(lastNode, node));
	lastNode = node;
	delegate.acceptAssignedKeyword(keyword, token, value, index, node);
}
 

/**
 * Contexts:
 *     PredicatedKeyword returns Keyword
 *
 * Constraint:
 *     ((predicated?='=>' | firstSetPredicated?='->') value=STRING)
 */
protected void sequence_PredicatedKeyword(ISerializationContext context, Keyword semanticObject) {
	genericSequencer.createSequence(context, semanticObject);
}
 

public Keyword getDetailDetailKeyword_2_0() { return cDetailDetailKeyword_2_0; } 

public Keyword getNumberSignDigitFourKeyword_1_3_0() { return cNumberSignDigitFourKeyword_1_3_0; } 

public Keyword getSuperKeyword_0() { return cSuperKeyword_0; } 

public Keyword getModesKeyword_1_0() { return cModesKeyword_1_0; } 

public Keyword getNumberSignDigitOneDigitFourKeyword_0() { return cNumberSignDigitOneDigitFourKeyword_0; } 

public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } 

public Keyword getFifthAKeyword_4_0() { return cFifthAKeyword_4_0; } 

public Keyword getNumberSignDigitOneDigitTwoKeyword_1_11_0() { return cNumberSignDigitOneDigitTwoKeyword_1_11_0; } 

public Keyword getKeywordKeyword_1_11_1_1_1() { return cKeywordKeyword_1_11_1_1_1; } 

public Keyword getOperatorQuestionMarkEqualsSignKeyword_1_0_2() { return cOperatorQuestionMarkEqualsSignKeyword_1_0_2; } 

public Keyword getColonKeyword_1_0_0() { return cColonKeyword_1_0_0; } 

public Keyword getStringBKeyword_3_1_0() { return cStringBKeyword_3_1_0; } 

public Keyword getDigitTwoKeyword_1_0() { return cDigitTwoKeyword_1_0; } 

public Keyword getPlusSignKeyword_1_1() { return cPlusSignKeyword_1_1; } 

public Keyword getCommaKeyword_2_0() { return cCommaKeyword_2_0; }