Java 类org.eclipse.xtext.xbase.XListLiteral 实例源码

protected void computeType(XListLiteral literal, JvmGenericType listType, ITypeExpectation expectation,
        ITypeComputationState state) {
    LightweightTypeReference elementTypeExpectation = null;
    final LightweightTypeReference expectedType = expectation.getExpectedType();
    if(expectedType != null) {
        if(expectedType.isArray()) {
            computeArrayLiteralType(literal, expectedType, expectation, state);
            return; 
        } 
        elementTypeExpectation = getElementOrComponentType(expectedType, state);
    }
    List<LightweightTypeReference> listTypeCandidates = computeCollectionTypeCandidates(literal, listType, elementTypeExpectation, state);
    LightweightTypeReference commonListType = getCommonSuperType(listTypeCandidates, state);
    if (commonListType != null) {
        LightweightTypeReference commonElementType = getElementOrComponentType(commonListType, state);
        ITypeReferenceOwner owner = state.getReferenceOwner();
        commonElementType = normalizeElementType(commonElementType, expectedType, owner);
        if (expectedType != null) {
            commonListType = createCollectionTypeReference(listType, commonElementType, expectedType, owner);
        }
        expectation.acceptActualType(commonListType, ConformanceFlags.UNCHECKED);
        refineElementTypeExpectation(literal, commonElementType, state);
    } else {
        setUnboundCollectionType(literal, listType, expectation, elementTypeExpectation, state);
    }
}

protected void computeArrayLiteralType(XListLiteral literal, LightweightTypeReference expectedArrayType, ITypeExpectation expectation,
        ITypeComputationState state) {
    LightweightTypeReference elementTypeExpectation = getElementOrComponentType(expectedArrayType, state);
    int allFlags = 0;
    for(XExpression element: literal.getElements()) {
        ITypeComputationResult elementTypeResult = computeTypes(element, elementTypeExpectation, state);
        deferredBindTypeArgument(elementTypeExpectation, elementTypeResult.getActualExpressionType(), state);
        allFlags |= elementTypeResult.getCheckedConformanceFlags();
    }
    if ((allFlags & ConformanceFlags.INCOMPATIBLE) != 0) {
        allFlags &= (~ConformanceFlags.SUCCESS);
        allFlags |= ConformanceFlags.SEALED | ConformanceFlags.CHECKED | ConformanceFlags.PROPAGATED_TYPE;
        expectation.acceptActualType(expectedArrayType, allFlags);
    } else if ((allFlags & ConformanceFlags.SUCCESS) != 0) {
        allFlags |= ConformanceFlags.SEALED | ConformanceFlags.CHECKED;
        expectation.acceptActualType(expectedArrayType, allFlags);
    } else {
        expectation.acceptActualType(expectedArrayType, ConformanceFlags.CHECKED_SUCCESS | ConformanceFlags.SEALED);
    }
}

protected Object _doEvaluate(XListLiteral literal, IEvaluationContext context, CancelIndicator indicator) {
    IResolvedTypes resolveTypes = typeResolver.resolveTypes(literal);
    LightweightTypeReference type = resolveTypes.getActualType(literal);
    List<Object> list = newArrayList();
    for(XExpression element: literal.getElements()) {
        if (indicator.isCanceled())
            throw new InterpreterCanceledException();
        list.add(internalEvaluate(element, context, indicator));
    }
    if(type != null && type.isArray()) {
        try {
            LightweightTypeReference componentType = type.getComponentType();
            return Conversions.unwrapArray(list, getJavaType(componentType.getType()));
        } catch (ClassNotFoundException e) {
        }
    }
    return Collections.unmodifiableList(list);
}

protected boolean isValidAnnotationValue(final XExpression expression) {
  if (expression instanceof XListLiteral) {
    return _isValidAnnotationValue((XListLiteral)expression);
  } else if (expression instanceof XAbstractFeatureCall) {
    return _isValidAnnotationValue((XAbstractFeatureCall)expression);
  } else if (expression instanceof XAnnotation) {
    return _isValidAnnotationValue((XAnnotation)expression);
  } else if (expression != null) {
    return _isValidAnnotationValue(expression);
  } else if (expression == null) {
    return _isValidAnnotationValue((Void)null);
  } else {
    throw new IllegalArgumentException("Unhandled parameter types: " +
      Arrays.<Object>asList(expression).toString());
  }
}

@Override
protected void appendImmutableCollectionExpression(final XCollectionLiteral literal, final ITreeAppendable b, final String collectionsMethod, final Class<?> guavaHelper, final String guavaHelperMethod) {
  // This is a work-around for a bug in the xbase compiler, which always constructs empty list literals #[] as List<Object>,
  // which then cannot be assigned (without cast) to any typed list. Note that this is not a problem in check; it also occurs
  // in plain xtend.
  if (literal.getElements().isEmpty()) {
    JvmType collectionsClass = findKnownTopLevelType(Collections.class, literal);
    if (collectionsClass != null) {
      if (literal instanceof XListLiteral) {
        b.append(collectionsClass).append(".emptyList()");
        return;
      } else if (literal instanceof XSetLiteral) {
        b.append(collectionsClass).append(".emptySet()");
        return;
      }
    }
  }
  super.appendImmutableCollectionExpression(literal, b, collectionsMethod, guavaHelper, guavaHelperMethod);
}

/**
 * Validates that all XNumberLiterals in this expression, which occurs on the right-hand side of a formal parameter
 * declaration/definition, have indeed integral values.
 * 
 * @param value
 *          to check
 * @param issueCode
 *          to issue if the validation fails
 */
protected void checkRightHandSideHasOnlyIntegralNumbers(final XExpression value, final String issueCode) {
  if (value != null) {
    List<XExpression> exprs = (value instanceof XListLiteral) ? ((XListLiteral) value).getElements() : Collections.singletonList(value);
    for (XExpression expr : exprs) {
      XExpression e = expr;
      while (e instanceof XUnaryOperation) {
        e = ((XUnaryOperation) e).getOperand();
      }
      if (e instanceof XNumberLiteral) {
        try {
          Integer.decode(((XNumberLiteral) e).getValue());
        } catch (NumberFormatException ex) {
          error("Only integral values as numbers are allowed in check parameters", expr, null, issueCode); // TODO: NLS
        }
      }
    }
  }
}

/**
 * Evaluate an expression (value of a ConfiguredParameter).
 *
 * @param newValue
 *          the new value
 * @return the string
 */
private String evaluateParameterValue(final XExpression newValue) {
  if (newValue instanceof XListLiteral) {
    return evaluateList((XListLiteral) newValue);
  } else {
    Object evaluationResult = interpreter.evaluate(newValue).getResult();
    if (evaluationResult instanceof Boolean) {
      return ((Boolean) evaluationResult).toString();
    } else if (evaluationResult instanceof Integer) {
      return ((Integer) evaluationResult).toString();
    } else if (evaluationResult instanceof String) {
      // Note: control characters are no problem; java.util.Properties is smart enough to encode/decode those.
      return (String) evaluationResult;
    }
  }
  return null;
}

/**
 * Evaluates a list.
 *
 * @param list
 *          to evaluate
 * @return the evaluated list.
 */
private String evaluateList(final XListLiteral list) {
  Iterable<Object> evaluated = Iterables.transform(list.getElements(), new Function<XExpression, Object>() {
    @Override
    public Object apply(final XExpression expr) {
      return interpreter.evaluate(expr).getResult();
    }
  });
  Object first = Iterables.getFirst(evaluated, null);
  if (first != null) {
    if (first instanceof Boolean) {
      return CheckPreferencesHelper.marshalBooleans(Iterables.filter(evaluated, Boolean.class));
    } else if (first instanceof Integer) {
      return CheckPreferencesHelper.marshalIntegers(Iterables.filter(evaluated, Integer.class));
    } else if (first instanceof String) {
      return CheckPreferencesHelper.marshalStrings(Iterables.filter(evaluated, String.class));
    }
  }
  return null;
}

/**
 * Entry point from the {@link XbaseTypeComputer}.
 */
public void computeType(XListLiteral literal, ITypeComputationState state) {
    JvmGenericType listType = findDeclaredType(List.class, state);
    if (listType == null) {
        handleCollectionTypeNotAvailable(literal, state, List.class);
        return;
    }
    for(ITypeExpectation expectation: state.getExpectations()) {
        computeType(literal, listType, expectation, state);
    }
}

protected boolean canUseArrayInitializer(XListLiteral literal, ITreeAppendable appendable) {
    if (literal.eContainingFeature() == XbasePackage.Literals.XVARIABLE_DECLARATION__RIGHT
        || literal.eContainingFeature() == XAnnotationsPackage.Literals.XANNOTATION_ELEMENT_VALUE_PAIR__VALUE
        || literal.eContainingFeature() == XAnnotationsPackage.Literals.XANNOTATION__VALUE
        ) {
        return canUseArrayInitializerImpl(literal, appendable);
    }
    return false;
}

protected boolean canUseArrayInitializerImpl(XListLiteral literal, ITreeAppendable appendable) {
    for(XExpression element: literal.getElements()) {
        if (isVariableDeclarationRequired(element, appendable, true))
            return false;
    }
    return true;
}

@Override
protected void internalToConvertedExpression(XExpression obj, ITreeAppendable appendable) {
    if (obj instanceof XBlockExpression) {
        _toJavaExpression((XBlockExpression) obj, appendable);
    } else if (obj instanceof XCastedExpression) {
        _toJavaExpression((XCastedExpression) obj, appendable);
    } else if (obj instanceof XClosure) {
        _toJavaExpression((XClosure) obj, appendable);
    } else if (obj instanceof XAnnotation) {
        _toJavaExpression((XAnnotation) obj, appendable);
    } else if (obj instanceof XConstructorCall) {
        _toJavaExpression((XConstructorCall) obj, appendable);
    } else if (obj instanceof XIfExpression) {
        _toJavaExpression((XIfExpression) obj, appendable);
    } else if (obj instanceof XInstanceOfExpression) {
        _toJavaExpression((XInstanceOfExpression) obj, appendable);
    } else if (obj instanceof XSwitchExpression) {
        _toJavaExpression((XSwitchExpression) obj, appendable);
    } else if (obj instanceof XTryCatchFinallyExpression) {
        _toJavaExpression((XTryCatchFinallyExpression) obj, appendable);
    } else if (obj instanceof XListLiteral) {
        _toJavaExpression((XListLiteral) obj, appendable);
    } else if (obj instanceof XSetLiteral) {
        _toJavaExpression((XSetLiteral) obj, appendable);
    } else if (obj instanceof XSynchronizedExpression) {
        _toJavaExpression((XSynchronizedExpression) obj, appendable);
    } else if (obj instanceof XReturnExpression) {
        _toJavaExpression((XReturnExpression) obj, appendable);
    } else if (obj instanceof XThrowExpression) {
        _toJavaExpression((XThrowExpression) obj, appendable);
    } else {
        super.internalToConvertedExpression(obj, appendable);
    }
}

@Deprecated
protected void sequence_XListLiteral(EObject context, XListLiteral semanticObject) {
    sequence_XListLiteral(createContext(context, semanticObject), semanticObject);
}

@Deprecated
protected void sequence_XAnnotationElementValueOrCommaList_XListLiteral(EObject context, XListLiteral semanticObject) {
    sequence_XAnnotationElementValueOrCommaList_XListLiteral(createContext(context, semanticObject), semanticObject);
}

@Deprecated
protected void sequence_XAnnotationElementValue_XListLiteral(EObject context, XListLiteral semanticObject) {
    sequence_XAnnotationElementValue_XListLiteral(createContext(context, semanticObject), semanticObject);
}

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
    if (expression instanceof XAssignment) {
        _computeTypes((XAssignment)expression, state);
    } else if (expression instanceof XAbstractFeatureCall) {
        _computeTypes((XAbstractFeatureCall)expression, state);
    } else if (expression instanceof XDoWhileExpression) {
        _computeTypes((XDoWhileExpression)expression, state);
    } else if (expression instanceof XWhileExpression) {
        _computeTypes((XWhileExpression)expression, state);
    } else if (expression instanceof XBlockExpression) {
        _computeTypes((XBlockExpression)expression, state);
    } else if (expression instanceof XBooleanLiteral) {
        _computeTypes((XBooleanLiteral)expression, state);
    } else if (expression instanceof XCastedExpression) {
        _computeTypes((XCastedExpression)expression, state);
    } else if (expression instanceof XClosure) {
        _computeTypes((XClosure)expression, state);
    } else if (expression instanceof XConstructorCall) {
        _computeTypes((XConstructorCall)expression, state);
    } else if (expression instanceof XForLoopExpression) {
        _computeTypes((XForLoopExpression)expression, state);
    } else if (expression instanceof XBasicForLoopExpression) {
        _computeTypes((XBasicForLoopExpression)expression, state);
    } else if (expression instanceof XIfExpression) {
        _computeTypes((XIfExpression)expression, state);
    } else if (expression instanceof XInstanceOfExpression) {
        _computeTypes((XInstanceOfExpression)expression, state);
    } else if (expression instanceof XNumberLiteral) {
        _computeTypes((XNumberLiteral)expression, state);
    } else if (expression instanceof XNullLiteral) {
        _computeTypes((XNullLiteral)expression, state);
    } else if (expression instanceof XReturnExpression) {
        _computeTypes((XReturnExpression)expression, state);
    } else if (expression instanceof XStringLiteral) {
        _computeTypes((XStringLiteral)expression, state);
    } else if (expression instanceof XSwitchExpression) {
        _computeTypes((XSwitchExpression)expression, state);
    } else if (expression instanceof XThrowExpression) {
        _computeTypes((XThrowExpression)expression, state);
    } else if (expression instanceof XTryCatchFinallyExpression) {
        _computeTypes((XTryCatchFinallyExpression)expression, state);
    } else if (expression instanceof XTypeLiteral) {
        _computeTypes((XTypeLiteral)expression, state);
    } else if (expression instanceof XVariableDeclaration) {
        _computeTypes((XVariableDeclaration)expression, state);
    } else if (expression instanceof XListLiteral) {
        _computeTypes((XListLiteral)expression, state);
    } else if (expression instanceof XSetLiteral) {
        _computeTypes((XSetLiteral)expression, state);
    } else if (expression instanceof XSynchronizedExpression) {
        _computeTypes((XSynchronizedExpression)expression, state);
    } else {
        throw new UnsupportedOperationException("Missing type computation for expression type: " + expression.eClass().getName() + " / " + state);
    }
}

protected void _computeTypes(XListLiteral literal, ITypeComputationState state) {
    collectionLiterals.computeType(literal, state);
}

/**
 * @param isReferenced unused in this context but necessary for dispatch signature 
 */
protected void _toJavaStatement(XListLiteral literal, ITreeAppendable b, boolean isReferenced) {
    for(XExpression element: literal.getElements()) 
        internalToJavaStatement(element, b, true);
}

protected void _toJavaExpression(XListLiteral literal, ITreeAppendable b) {
    LightweightTypeReference literalType = batchTypeResolver.resolveTypes(literal).getActualType(literal);
    if (literalType == null) {
        b.append("error - couldn't compute type for literal : "+literal);
        return;
    } 
    if (literalType.isArray()) {
        LightweightTypeReference expectedType = batchTypeResolver.resolveTypes(literal).getExpectedType(literal);
        boolean skipTypeName = false;
        if (expectedType != null && expectedType.isArray()) {
            if (canUseArrayInitializer(literal, b)) {
                skipTypeName = true;
            }
        }
        if (!skipTypeName) {
            if (literalType instanceof CompoundTypeReference) {
                for (LightweightTypeReference c : literalType.getMultiTypeComponents()) {
                    if (c.isArray()) {
                        b.append("new ")
                        .append(c.getType()) // append raw type since we cannot create generic arrays
                        .append(" ");
                        break;
                    }
                }
            } else {
                b.append("new ")
                    .append(literalType.getType()) // append raw type since we cannot create generic arrays
                    .append(" ");
            }
        }
        if (literal.getElements().isEmpty()) {
            b.append("{}");
        } else {
            b.append("{ ");
            boolean isFirst = true;
            for(XExpression element: literal.getElements())  {
                if(!isFirst)
                    b.append(", ");
                isFirst = false;
                internalToJavaExpression(element, b);
            }
            b.append(" }");
        }
        return;
    } else {
        appendImmutableCollectionExpression(literal, b, "unmodifiableList", CollectionLiterals.class, "newArrayList");
    }
}

@Override
protected void doInternalToJavaStatement(XExpression obj, ITreeAppendable appendable, boolean isReferenced) {
    if (obj instanceof XBlockExpression) {
        _toJavaStatement((XBlockExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XCastedExpression) {
        _toJavaStatement((XCastedExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XClosure) {
        _toJavaStatement((XClosure) obj, appendable, isReferenced);
    } else if (obj instanceof XConstructorCall) {
        _toJavaStatement((XConstructorCall) obj, appendable, isReferenced);
    } else if (obj instanceof XDoWhileExpression) {
        _toJavaStatement((XDoWhileExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XForLoopExpression) {
        _toJavaStatement((XForLoopExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XBasicForLoopExpression) {
        _toJavaStatement((XBasicForLoopExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XIfExpression) {
        _toJavaStatement((XIfExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XInstanceOfExpression) {
        _toJavaStatement((XInstanceOfExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XReturnExpression) {
        _toJavaStatement((XReturnExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XSwitchExpression) {
        _toJavaStatement((XSwitchExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XThrowExpression) {
        _toJavaStatement((XThrowExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XTryCatchFinallyExpression) {
        _toJavaStatement((XTryCatchFinallyExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XVariableDeclaration) {
        _toJavaStatement((XVariableDeclaration) obj, appendable, isReferenced);
    } else if (obj instanceof XWhileExpression) {
        _toJavaStatement((XWhileExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XListLiteral) {
        _toJavaStatement((XListLiteral) obj, appendable, isReferenced);
    } else if (obj instanceof XSetLiteral) {
        _toJavaStatement((XSetLiteral) obj, appendable, isReferenced);
    } else if (obj instanceof XSynchronizedExpression) {
        _toJavaStatement((XSynchronizedExpression) obj, appendable, isReferenced);
    } else {
        super.doInternalToJavaStatement(obj, appendable, isReferenced);
    }
}

@Override
protected boolean isVariableDeclarationRequired(XExpression expr, ITreeAppendable b, boolean recursive) {
    if (expr instanceof XAnnotation) {
        return false;
    }
    if (expr instanceof XListLiteral) {
        return false;
    }
    if (expr instanceof XSetLiteral) {
        return false;
    }
    if (expr instanceof XCastedExpression) {
        return false;
    }
    if (expr instanceof XInstanceOfExpression) {
        return false;
    }
    if (expr instanceof XMemberFeatureCall && isVariableDeclarationRequired((XMemberFeatureCall) expr, b))
        return true;
    EObject container = expr.eContainer();
    if ((container instanceof XVariableDeclaration)
        || (container instanceof XReturnExpression) 
        || (container instanceof XThrowExpression)) {
        return false;
    }
    if (container instanceof XIfExpression) {
        XIfExpression ifExpression = (XIfExpression) container;
        if (ifExpression.getThen() == expr || ifExpression.getElse() == expr) {
            return false;
        }
    }
    if (container instanceof XCasePart) {
        XCasePart casePart = (XCasePart) container;
        if (casePart.getThen() == expr) {
            return false;
        }
    }
    if (container instanceof XSwitchExpression) {
        XSwitchExpression switchExpression = (XSwitchExpression) container;
        if (switchExpression.getDefault() == expr) {
            return false;
        }
    }
    if (container instanceof XBlockExpression) {
        List<XExpression> siblings = ((XBlockExpression) container).getExpressions();
        if (siblings.get(siblings.size() - 1) == expr) {
            return isVariableDeclarationRequired(getFeatureCall(expr), expr, b);
        }
    }
    if (container instanceof XClosure) {
        if (((XClosure) container).getExpression() == expr) {
            return false;
        }
    }
    if (expr instanceof XAssignment) {
        XAssignment a = (XAssignment) expr;
        for (XExpression arg : getActualArguments(a)) {
            if (isVariableDeclarationRequired(arg, b, recursive)) {
                return true;
            }
        }
    }
    return super.isVariableDeclarationRequired(expr, b, recursive);
}

/**
 * don't call this directly. Always call evaluate() internalEvaluate()
 */
protected Object doEvaluate(XExpression expression, IEvaluationContext context, CancelIndicator indicator) {
    if (expression instanceof XAssignment) {
      return _doEvaluate((XAssignment)expression, context, indicator);
    } else if (expression instanceof XDoWhileExpression) {
      return _doEvaluate((XDoWhileExpression)expression, context, indicator);
    } else if (expression instanceof XMemberFeatureCall) {
      return _doEvaluate((XMemberFeatureCall)expression, context, indicator);
    } else if (expression instanceof XWhileExpression) {
      return _doEvaluate((XWhileExpression)expression, context, indicator);
    } else if (expression instanceof XFeatureCall) {
        return _doEvaluate((XFeatureCall)expression, context, indicator);
    } else if (expression instanceof XAbstractFeatureCall) {
        return _doEvaluate((XAbstractFeatureCall)expression, context, indicator);
    } else if (expression instanceof XBlockExpression) {
      return _doEvaluate((XBlockExpression)expression, context, indicator);
    } else if (expression instanceof XSynchronizedExpression) {
      return _doEvaluate((XSynchronizedExpression)expression, context, indicator);
    } else if (expression instanceof XBooleanLiteral) {
      return _doEvaluate((XBooleanLiteral)expression, context, indicator);
    } else if (expression instanceof XCastedExpression) {
      return _doEvaluate((XCastedExpression)expression, context, indicator);
    } else if (expression instanceof XClosure) {
      return _doEvaluate((XClosure)expression, context, indicator);
    } else if (expression instanceof XConstructorCall) {
      return _doEvaluate((XConstructorCall)expression, context, indicator);
    } else if (expression instanceof XForLoopExpression) {
      return _doEvaluate((XForLoopExpression)expression, context, indicator);
    } else if (expression instanceof XBasicForLoopExpression) {
      return _doEvaluate((XBasicForLoopExpression)expression, context, indicator);
    } else if (expression instanceof XIfExpression) {
      return _doEvaluate((XIfExpression)expression, context, indicator);
    } else if (expression instanceof XInstanceOfExpression) {
      return _doEvaluate((XInstanceOfExpression)expression, context, indicator);
    } else if (expression instanceof XNullLiteral) {
      return _doEvaluate((XNullLiteral)expression, context, indicator);
    } else if (expression instanceof XNumberLiteral) {
      return _doEvaluate((XNumberLiteral)expression, context, indicator);
    } else if (expression instanceof XReturnExpression) {
      return _doEvaluate((XReturnExpression)expression, context, indicator);
    } else if (expression instanceof XStringLiteral) {
      return _doEvaluate((XStringLiteral)expression, context, indicator);
    } else if (expression instanceof XSwitchExpression) {
      return _doEvaluate((XSwitchExpression)expression, context, indicator);
    } else if (expression instanceof XThrowExpression) {
      return _doEvaluate((XThrowExpression)expression, context, indicator);
    } else if (expression instanceof XTryCatchFinallyExpression) {
      return _doEvaluate((XTryCatchFinallyExpression)expression, context, indicator);
    } else if (expression instanceof XTypeLiteral) {
      return _doEvaluate((XTypeLiteral)expression, context, indicator);
    } else if (expression instanceof XVariableDeclaration) {
          return _doEvaluate((XVariableDeclaration)expression, context, indicator);
    } else if (expression instanceof XListLiteral) {
          return _doEvaluate((XListLiteral)expression, context, indicator);
    } else if (expression instanceof XSetLiteral) {
          return _doEvaluate((XSetLiteral)expression, context, indicator);
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(expression, context, indicator).toString());
    }
}

protected boolean _isValidAnnotationValue(final XListLiteral expression) {
  return (expression.getElements().isEmpty() || IterableExtensions.<XExpression>forall(expression.getElements(), ((Function1<XExpression, Boolean>) (XExpression it) -> {
    return Boolean.valueOf(this.isValidAnnotationValue(it));
  })));
}

/**
 * Contexts:
 *     XExpression returns XListLiteral
 *     XAssignment returns XListLiteral
 *     XAssignment.XBinaryOperation_1_1_0_0_0 returns XListLiteral
 *     XOrExpression returns XListLiteral
 *     XOrExpression.XBinaryOperation_1_0_0_0 returns XListLiteral
 *     XAndExpression returns XListLiteral
 *     XAndExpression.XBinaryOperation_1_0_0_0 returns XListLiteral
 *     XEqualityExpression returns XListLiteral
 *     XEqualityExpression.XBinaryOperation_1_0_0_0 returns XListLiteral
 *     XRelationalExpression returns XListLiteral
 *     XRelationalExpression.XInstanceOfExpression_1_0_0_0_0 returns XListLiteral
 *     XRelationalExpression.XBinaryOperation_1_1_0_0_0 returns XListLiteral
 *     XOtherOperatorExpression returns XListLiteral
 *     XOtherOperatorExpression.XBinaryOperation_1_0_0_0 returns XListLiteral
 *     XAdditiveExpression returns XListLiteral
 *     XAdditiveExpression.XBinaryOperation_1_0_0_0 returns XListLiteral
 *     XMultiplicativeExpression returns XListLiteral
 *     XMultiplicativeExpression.XBinaryOperation_1_0_0_0 returns XListLiteral
 *     XUnaryOperation returns XListLiteral
 *     XCastedExpression returns XListLiteral
 *     XCastedExpression.XCastedExpression_1_0_0_0 returns XListLiteral
 *     XPostfixOperation returns XListLiteral
 *     XPostfixOperation.XPostfixOperation_1_0_0 returns XListLiteral
 *     XMemberFeatureCall returns XListLiteral
 *     XMemberFeatureCall.XAssignment_1_0_0_0_0 returns XListLiteral
 *     XMemberFeatureCall.XMemberFeatureCall_1_1_0_0_0 returns XListLiteral
 *     XPrimaryExpression returns XListLiteral
 *     XLiteral returns XListLiteral
 *     XCollectionLiteral returns XListLiteral
 *     XListLiteral returns XListLiteral
 *     XParenthesizedExpression returns XListLiteral
 *     XExpressionOrVarDeclaration returns XListLiteral
 *
 * Constraint:
 *     (elements+=XExpression elements+=XExpression*)?
 */
protected void sequence_XListLiteral(ISerializationContext context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Contexts:
 *     XAnnotationElementValueOrCommaList returns XListLiteral
 *
 * Constraint:
 *     (
 *         (elements+=XAnnotationOrExpression elements+=XAnnotationOrExpression*) | 
 *         (elements+=XAnnotationElementValueOrCommaList_XListLiteral_1_1_0 elements+=XAnnotationOrExpression+) | 
 *         (elements+=XExpression elements+=XExpression*)
 *     )?
 */
protected void sequence_XAnnotationElementValueOrCommaList_XListLiteral(ISerializationContext context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Contexts:
 *     XAnnotationElementValue returns XListLiteral
 *
 * Constraint:
 *     ((elements+=XAnnotationOrExpression elements+=XAnnotationOrExpression*) | (elements+=XExpression elements+=XExpression*))?
 */
protected void sequence_XAnnotationElementValue_XListLiteral(ISerializationContext context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     (
 *         ((elements+=XAnnotationOrExpression elements+=XAnnotationOrExpression*)?) | 
 *         (elements+=XAnnotationElementValueOrCommaList_XListLiteral_1_1_0 elements+=XAnnotationOrExpression+) | 
 *         ((elements+=XExpression elements+=XExpression*)?)
 *     )
 */
protected void sequence_XAnnotationElementValueOrCommaList_XListLiteral(EObject context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     (((elements+=XAnnotationOrExpression elements+=XAnnotationOrExpression*)?) | ((elements+=XExpression elements+=XExpression*)?))
 */
protected void sequence_XAnnotationElementValue_XListLiteral(EObject context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     ((elements+=XConstantUnaryOperation elements+=XConstantUnaryOperation*)?)
 */
protected void sequence_XConstantListLiteral(EObject context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     ((elements+=XExpression elements+=XExpression*)?)
 */
protected void sequence_XListLiteral(EObject context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     ((elements+=XConstantUnaryOperation elements+=XConstantUnaryOperation*)?)
 */
protected void sequence_XConstantListLiteral(EObject context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     ((elements+=XExpression elements+=XExpression*)?)
 */
protected void sequence_XListLiteral(EObject context, XListLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}