private Object _equalValue(final XTypeLiteral myValue, final XTypeLiteral otherTypeLiteral) { return Boolean.valueOf((Objects.equal(myValue.getType(), otherTypeLiteral.getType()) && Objects.equal(myValue.getArrayDimensions(), otherTypeLiteral.getArrayDimensions()))); }
/** Append the inline code for the given XTypeLiteral. * * @param expression the expression of the operation. * @param parentExpression is the expression that contains this one, or {@code null} if the current expression is * the root expression. * @param feature the feature that contains the expression. * @param output the output. * @return {@code true} if a text was appended. */ @SuppressWarnings("static-method") protected Boolean _generate(XTypeLiteral expression, XExpression parentExpression, XtendExecutable feature, InlineAnnotationTreeAppendable output) { output.appendTypeConstant(expression.getType()); return Boolean.TRUE; }
/** Generate the given object. * * @param literal the type literal. * @param it the target for the generated content. * @param context the context. * @return the literal. */ @SuppressWarnings("static-method") protected XExpression _generate(XTypeLiteral literal, IAppendable it, IExtraLanguageGeneratorContext context) { appendReturnIfExpectedReturnedExpression(it, context); it.append(literal.getType()); return literal; }
private Object _equalValue(final JvmType myValue, final XTypeLiteral otherTypeLiteral) { return Boolean.valueOf((Objects.equal(myValue, otherTypeLiteral.getType()) && otherTypeLiteral.getArrayDimensions().isEmpty())); }
protected void _visit(final XTypeLiteral semanticElement, final INode originNode, final ImportsAcceptor acceptor) { final List<INode> elementNode = NodeModelUtils.findNodesForFeature(semanticElement, XbasePackage.Literals.XTYPE_LITERAL__TYPE); this.visit(semanticElement.getType(), IterableExtensions.<INode>head(elementNode), acceptor); }
private Object _equalValue(final XTypeLiteral myValue, final JvmType otherType) { return Boolean.valueOf((Objects.equal(myValue.getType(), otherType) && myValue.getArrayDimensions().isEmpty())); }
@Check public void checkDeprecated(XTypeLiteral expression) { if (!isIgnored(DEPRECATED_MEMBER_REFERENCE)) { JvmType jvmType = expression.getType(); checkDeprecated( jvmType, expression, XbasePackage.Literals.XTYPE_LITERAL__TYPE); } }
protected Object _internalEvaluate(final XTypeLiteral it, final Context ctx) { return this.toTypeReference(it.getType(), it.getArrayDimensions().size()); }
return ((XTypeLiteral) evalue).getType().getIdentifier();
@Check public void checkTypeLiteral(XTypeLiteral typeLiteral) { if (!typeLiteral.getArrayDimensions().isEmpty() && typeLiteral.getType().getIdentifier().equals("void")) { error("'void"+Joiner.on("").join(typeLiteral.getArrayDimensions()) +"' is not a valid type", null, INVALID_TYPE); } }
if (expr instanceof XTypeLiteral) { final XTypeLiteral typeLiteral = (XTypeLiteral) expr; final JvmType type = typeLiteral.getType(); if (type != null && !type.eIsProxy()) { final LightweightTypeReference reference = toLightweightTypeReference(type, capacity);
public void _toJavaExpression(XTypeLiteral expr, ITreeAppendable b) { b.append(expr.getType()).append(Joiner.on("").join(expr.getArrayDimensions())).append(".class"); }
/** * @param context unused in this context but required for dispatching * @param indicator unused in this context but required for dispatching */ protected Object _doEvaluate(XTypeLiteral literal, IEvaluationContext context, CancelIndicator indicator) { if (literal.getType() == null || literal.getType().eIsProxy()) { List<INode> nodesForFeature = NodeModelUtils.findNodesForFeature(literal, XbasePackage.Literals.XTYPE_LITERAL__TYPE); // TODO cleanup if (nodesForFeature.isEmpty()) throw new EvaluationException(new ClassNotFoundException()); throw new EvaluationException(new ClassNotFoundException(nodesForFeature.get(0).getText())); } JvmType type = literal.getType(); Object result = translateJvmTypeToResult(type, literal.getArrayDimensions().size()); return result; }
protected void _computeTypes(XTypeLiteral object, ITypeComputationState state) { JvmType type = object.getType(); if (type == null) { return; } checkTypeParameterNotAllowedAsLiteral(object, type, state); ITypeReferenceOwner owner = state.getReferenceOwner(); LightweightTypeReference clazz = owner.newParameterizedTypeReference(type); for (int i = 0; i < object.getArrayDimensions().size(); i++) { clazz = owner.newArrayTypeReference(clazz); } if (object.getArrayDimensions().isEmpty()) { if (clazz.isPrimitiveVoid()) { clazz = state.getReferenceOwner().newReferenceTo(Void.class); } else { clazz = clazz.getWrapperTypeIfPrimitive(); } } LightweightTypeReference result = owner.newReferenceTo(Class.class); if (result instanceof ParameterizedTypeReference) { ParameterizedTypeReference parameterizedTypeReference = (ParameterizedTypeReference) result; parameterizedTypeReference.addTypeArgument(clazz); } state.acceptActualType(result); }