本文整理了Java中org.eclipse.xtext.xbase.XFeatureCall类的一些代码示例，展示了XFeatureCall类的具体用法。这些代码示例主要来源于Github/Stackoverflow/Maven等平台，是从一些精选项目中提取出来的代码，具有较强的参考意义，能在一定程度帮忙到你。XFeatureCall类的具体详情如下：
包路径：org.eclipse.xtext.xbase.XFeatureCall
类名称：XFeatureCall

XFeatureCall介绍

[英]A representation of the model object 'XFeature Call'.
[中]模型对象“XFeature Call”的表示形式。

代码示例

代码示例来源：origin: org.eclipse.incquery/org.eclipse.incquery.patternlanguage.emf

@Override
 public String apply(final XFeatureCall it) {
  return it.getConcreteSyntaxFeatureName();
 }
};

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected boolean isReferenceToSelf(XFeatureCall featureCall, JvmType type) {
  return !featureCall.isTypeLiteral() && !featureCall.isPackageFragment()
      && type.equals(featureCall.getFeature())
      && IFeatureNames.SELF.getFirstSegment().equals(featureCall.getConcreteSyntaxFeatureName());
}

代码示例来源：origin: org.eclipse.xtend/org.eclipse.xtend.core

private boolean isEnumExpectationInAnnotationValue(final XFeatureCall it, final JvmType expectedRawType) {
 if (((expectedRawType instanceof JvmEnumerationType) || ((expectedRawType instanceof JvmArrayType) && (((JvmArrayType) expectedRawType).getComponentType() instanceof JvmEnumerationType)))) {
  EObject container = it.eContainer();
  if ((container instanceof XAnnotationElementValuePair)) {
   return true;
  }
  if ((container instanceof XAnnotation)) {
   return true;
  }
  if ((container instanceof XListLiteral)) {
   container = ((XListLiteral)container).eContainer();
   if ((container instanceof XAnnotationElementValuePair)) {
    return true;
   }
   if ((container instanceof XAnnotation)) {
    return true;
   }
  }
 }
 return false;
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected void _visit(final XFeatureCall semanticObj, final INode originNode, final ImportsAcceptor acceptor) {
 if (((semanticObj.getFeature() instanceof JvmType) && semanticObj.isTypeLiteral())) {
  JvmIdentifiableElement _feature = semanticObj.getFeature();
  this.visit(((JvmType) _feature), originNode, acceptor);
 } else {
  this.collectStaticImportsFrom(semanticObj, acceptor);
 }
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

@Check
public void checkExplicitOperationCall(XFeatureCall featureCall) {
  if (featureCall.getFeature() instanceof JvmOperation 
      && !featureCall.isExplicitOperationCallOrBuilderSyntax()
      && featureCall.getFeature().getSimpleName().equals(featureCall.getConcreteSyntaxFeatureName())) {
    addIssue("Method call without parentheses", featureCall, XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, OPERATION_WITHOUT_PARENTHESES);
  }
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected boolean isSimpleFeatureCall(XExpression switch1) {
  if (switch1 instanceof XFeatureCall)  {
    XFeatureCall featureCall = (XFeatureCall) switch1;
    return !(featureCall.getFeature() instanceof JvmOperation);
  }
  return false;
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected boolean hasConstructorCallWithThis(JvmConstructor constr) {
  XExpression associatedExpression = logicalContainerProvider.getAssociatedExpression(constr);
  if (associatedExpression == null) {
    return false;
  }
  TreeIterator<EObject> contents = associatedExpression.eAllContents();
  while (contents.hasNext()) {
    EObject next = contents.next();
    if (next instanceof XFeatureCall) {
      XFeatureCall featureCall = (XFeatureCall) next;
      if (featureCall.getFeature() instanceof JvmConstructor && featureCall.getConcreteSyntaxFeatureName().equals(IFeatureNames.THIS.toString())) {
        return true;
      }
    }
  }
  return false;
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected IFeatureScopeSession addExtensionsToMemberSession(ResolvedTypes resolvedTypes,
    IFeatureScopeSession featureScopeSession, JvmDeclaredType type) {
  IEObjectDescription thisDescription = featureScopeSession.getLocalElement(IFeatureNames.THIS);
  if (thisDescription == null) {
    throw new IllegalStateException("Cannot find feature 'THIS'");
  }
  JvmIdentifiableElement thisFeature = (JvmIdentifiableElement) thisDescription.getEObjectOrProxy();
  IFeatureScopeSession childSession = addExtensionFieldsToMemberSession(
      resolvedTypes, featureScopeSession, type, thisFeature, Sets.<String>newHashSetWithExpectedSize(8), Sets.<JvmType>newHashSetWithExpectedSize(4));
  XFeatureCall thisAccess = getXbaseFactory().createXFeatureCall();
  thisAccess.setFeature(thisFeature);
  LightweightTypeReference thisType = resolvedTypes.getActualType(thisFeature);
  childSession = childSession.addToExtensionScope(Collections.<XExpression, LightweightTypeReference>singletonMap(thisAccess, thisType));
  return childSession;
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

List<JvmTypeReference> typeArguments = featureCall.getTypeArguments();
if (!typeArguments.isEmpty()) {
  acceptor.accept(featureCallElements.getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0(), typeArguments.get(0), 0);
acceptor.accept(featureCallElements.getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1(), featureCall.getFeature());
if (featureCall.isExplicitOperationCallOrBuilderSyntax()) {
  if (featureCall.isExplicitOperationCall())
    acceptor.accept(featureCallElements.getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
  List<XExpression> arguments = featureCall.getFeatureCallArguments();
  if (!arguments.isEmpty()) {
    if (featureCall.isExplicitOperationCall() && isXShortClosureAndBuilderSyntax(arguments, XbasePackage.Literals.XFEATURE_CALL__FEATURE_CALL_ARGUMENTS, nodes)) {
      acceptor.accept(featureCallElements.getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0(), arguments.get(0), 0);
      acceptor.accept(featureCallElements.getFeatureCallArgumentsXClosureParserRuleCall_4_0(), arguments.get(1), 1);
    } else if (featureCall.isExplicitOperationCall() && isXShortClosure(featureCall, XbasePackage.Literals.XFEATURE_CALL__FEATURE_CALL_ARGUMENTS, nodes)) {
      acceptor.accept(featureCallElements.getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0(), arguments.get(0), 0);
    } else {
      int diff = 0;
      if (isBuilderSyntax(featureCall, XbasePackage.Literals.XFEATURE_CALL__FEATURE_CALL_ARGUMENTS, featureCall.isExplicitOperationCall(), nodes)) {
        diff = 1;
      if (featureCall.isExplicitOperationCall()) {
        if (arguments.size() - diff > 0)
          acceptor.accept(featureCallElements.getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0(), arguments.get(0), 0);

代码示例来源：origin: org.eclipse.xtend/org.eclipse.xtend.core

protected Object _internalEvaluate(final XFeatureCall it, final Context ctx) {
 Object _eGet = it.eGet(XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, this.isResolveProxies(it));
 final EObject feature = ((EObject) _eGet);
 boolean _eIsProxy = feature.eIsProxy();
 final String featureName = it.getConcreteSyntaxFeatureName();
 JvmType _switchResult_1 = null;
 JvmTypeReference _expectedType = ctx.getExpectedType();

代码示例来源：origin: io.sarl/io.sarl.eclipse

call.setFeature(getJvmConstructor(constructor, context));
call.setExplicitOperationCall(true);
final List<XExpression> arguments = call.getFeatureCallArguments();
for (final IFormalParameterBuilder currentParam : sarlParams) {
  final XFeatureCall argumentSource = XbaseFactory.eINSTANCE.createXFeatureCall();

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

@Check
public void checkConstructorArgumentsAreValid(XFeatureCall featureCall) {
  JvmIdentifiableElement feature = featureCall.getFeature();
  if (feature != null && !feature.eIsProxy() && feature instanceof JvmConstructor) {
    JvmType containerType = EcoreUtil2.getContainerOfType(logicalContainerProvider.getNearestLogicalContainer(featureCall), JvmType.class);
    for(XExpression argument: featureCall.getFeatureCallArguments()) {
      checkIsValidConstructorArgument(argument, containerType);
    }
  }
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected void _format(final XFeatureCall expr, final FormattableDocument format) {
 this.formatFeatureCallTypeParameters(expr, format);
 boolean _isExplicitOperationCall = expr.isExplicitOperationCall();
 if (_isExplicitOperationCall) {
  final ILeafNode open = this._nodeModelAccess.nodeForKeyword(expr, "(");
  final Procedure1<FormattingDataInit> _function = (FormattingDataInit it) -> {
   it.noSpace();
  };
  Function1<? super FormattableDocument, ? extends Iterable<FormattingData>> _prepend = this._formattingDataFactory.prepend(open, _function);
  format.operator_add(_prepend);
  boolean _isMultiParamInOwnLine = this.isMultiParamInOwnLine(expr, format);
  if (_isMultiParamInOwnLine) {
   this.formatFeatureCallParamsMultiline(open, expr.getFeatureCallArguments(), format);
  } else {
   this.formatFeatureCallParamsWrapIfNeeded(open, expr.getFeatureCallArguments(), format);
  }
 } else {
  EList<XExpression> _featureCallArguments = expr.getFeatureCallArguments();
  for (final XExpression arg : _featureCallArguments) {
   this.format(arg, format);
  }
 }
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

/**
 * Returns the node that best describes the error, e.g. if there is an expression
 * <code>com::foo::DoesNotExist::method()</code> the error will be rooted at <code>com</code>, but
 * the real problem is <code>com::foo::DoesNotExist</code>.
 */
private INode getErrorNode(XExpression expression, INode node) {
  if (expression instanceof XFeatureCall) {
    XFeatureCall featureCall = (XFeatureCall) expression;
    if (!canBeTypeLiteral(featureCall)) {
      return node;
    }
    if (featureCall.eContainingFeature() == XbasePackage.Literals.XMEMBER_FEATURE_CALL__MEMBER_CALL_TARGET) {
      XMemberFeatureCall container = (XMemberFeatureCall) featureCall.eContainer();
      if (canBeTypeLiteral(container)) {
        boolean explicitStatic = container.isExplicitStatic();
        XMemberFeatureCall outerMost = getLongestTypeLiteralCandidate(container, explicitStatic);
        if (outerMost != null)
          return NodeModelUtils.getNode(outerMost);
      }
    }
  }
  return node;
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

public List<XExpression> getSyntacticArguments(XAbstractFeatureCall expression) {
  if (expression instanceof XFeatureCall) {
    return ((XFeatureCall) expression).getFeatureCallArguments();
  }
  if (expression instanceof XMemberFeatureCall) {
    return ((XMemberFeatureCall) expression).getMemberCallArguments();
  }
  if (expression instanceof XAssignment) {
    return Collections.singletonList(((XAssignment) expression).getValue());
  }
  if (expression instanceof XBinaryOperation) {
    return Collections.singletonList(((XBinaryOperation) expression).getRightOperand());
  }
  // explicit condition to make sure we thought about it
  if (expression instanceof XUnaryOperation) {
    return Collections.emptyList();
  }
  if (expression instanceof XPostfixOperation) {
    return Collections.emptyList();
  }
  return Collections.emptyList();
}

代码示例来源：origin: org.eclipse.xtend/org.eclipse.xtend.core

protected boolean isDelegateConstructorCall(XExpression expression) {
  if(expression instanceof XFeatureCall) {
    JvmIdentifiableElement feature = ((XFeatureCall)expression).getFeature();
    return (feature != null && !feature.eIsProxy() && feature instanceof JvmConstructor);
  }
  return false;
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

@Override
public void addExtensionsToCurrentScope(List<? extends JvmIdentifiableElement> extensionProviders) {
  if (extensionProviders.isEmpty())
    return;
  if (extensionProviders.size() == 1) {
    addExtensionToCurrentScope(extensionProviders.get(0));
    return;
  }
  Map<XExpression, LightweightTypeReference> prototypeToType = Maps2.newLinkedHashMapWithExpectedSize(extensionProviders.size());
  for(JvmIdentifiableElement extensionProvider: extensionProviders) {
    LightweightTypeReference knownType = getResolvedTypes().getActualType(extensionProvider);
    if (knownType != null && !knownType.isAny() && !knownType.isUnknown()) {
      XFeatureCall prototype = getResolver().getXbaseFactory().createXFeatureCall();
      prototype.setFeature(extensionProvider);
      prototypeToType.put(prototype, knownType);
    }
  }
  if (!prototypeToType.isEmpty())
    featureScopeSession = featureScopeSession.addToExtensionScope(prototypeToType);
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected Object _doEvaluate(XFeatureCall featureCall, IEvaluationContext context, CancelIndicator indicator) {
  if (featureCall.isTypeLiteral()) {
    JvmType type = (JvmType) featureCall.getFeature();
    Object result = translateJvmTypeToResult(type, 0);
    return result;
  } else {
    return _doEvaluate((XAbstractFeatureCall) featureCall, context, indicator);
  }
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected void _format(final XFeatureCall expr, @Extension final IFormattableDocument format) {
 this.formatFeatureCallTypeParameters(expr, format);
 boolean _isExplicitOperationCall = expr.isExplicitOperationCall();
 if (_isExplicitOperationCall) {
  final Procedure1<IHiddenRegionFormatter> _function = (IHiddenRegionFormatter it) -> {
   it.noSpace();
  };
  final ISemanticRegion open = format.prepend(this.textRegionExtensions.regionFor(expr).keyword(this.grammar.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()), _function);
  final ISemanticRegion close = this.textRegionExtensions.regionFor(expr).keyword(this.grammar.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
  this.formatFeatureCallParams(expr.getFeatureCallArguments(), open, close, format);
 } else {
  EList<XExpression> _featureCallArguments = expr.getFeatureCallArguments();
  for (final XExpression arg : _featureCallArguments) {
   this.format(arg, format);
  }
 }
}

代码示例来源：origin: org.eclipse.xtext/org.eclipse.xtext.xbase

protected boolean _isMultiParamInOwnLine(final XFeatureCall fc, final FormattableDocument doc) {
 final ILeafNode closingBracket = this._nodeModelAccess.nodeForKeyword(fc, ")");
 HiddenLeafs _hiddenLeafsBefore = null;
 if (closingBracket!=null) {
  _hiddenLeafsBefore=this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket);
 }
 boolean _tripleNotEquals = (_hiddenLeafsBefore != null);
 if (_tripleNotEquals) {
  int _newLines = this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket).getNewLines();
  return (_newLines > 0);
 }
 final Iterable<XExpression> params = this.explicitParams(fc.getFeatureCallArguments());
 return ((IterableExtensions.size(params) > 1) && this.isEachExpressionInOwnLine(params));
}