protected void _computeTypes(XInstanceOfExpression object, ITypeComputationState state) { ITypeComputationState expressionState = state.withExpectation(state.getReferenceOwner().newReferenceToObject()); expressionState.computeTypes(object.getExpression()); JvmTypeReference type = object.getType(); if (type != null && type.getType() instanceof JvmTypeParameter) { LightweightTypeReference lightweightReference = state.getReferenceOwner().toLightweightTypeReference(type); LightweightTypeReference rawTypeRef = lightweightReference.getRawTypeReference(); state.addDiagnostic(new EObjectDiagnosticImpl( Severity.ERROR, IssueCodes.INVALID_USE_OF_TYPE_PARAMETER, "Cannot perform instanceof check against type parameter "+lightweightReference.getHumanReadableName()+". Use its erasure "+rawTypeRef.getHumanReadableName()+" instead since further generic type information will be erased at runtime.", object.getType(), null, -1, new String[] { })); } LightweightTypeReference bool = getRawTypeForName(Boolean.TYPE, state); state.acceptActualType(bool); }
@Test public void testSerialize_01() throws Exception { Resource resource = newResource("'foo' as String"); XCastedExpression casted = (XCastedExpression) resource.getContents().get(0); XbaseFactory factory = XbaseFactory.eINSTANCE; XClosure closure = factory.createXClosure(); XStringLiteral stringLiteral = factory.createXStringLiteral(); stringLiteral.setValue("value"); XBlockExpression blockExpression = factory.createXBlockExpression(); blockExpression.getExpressions().add(stringLiteral); closure.setExpression(blockExpression); closure.setExplicitSyntax(true); XInstanceOfExpression instanceOfExpression = factory.createXInstanceOfExpression(); instanceOfExpression.setExpression(closure); instanceOfExpression.setType(EcoreUtil.copy(casted.getType())); resource.getContents().clear(); resource.getContents().add(instanceOfExpression); ISerializer serializer = get(ISerializer.class); String string = serializer.serialize(instanceOfExpression); assertEquals("[|\"value\"] instanceof String", string); XInstanceOfExpression parsedExpression = parseHelper.parse(string); assertTrue(EcoreUtil.equals(instanceOfExpression, parsedExpression)); }
@Test public void testSerialize_02() throws Exception { Resource resource = newResource("'foo' as String"); XCastedExpression casted = (XCastedExpression) resource.getContents().get(0); XbaseFactory factory = XbaseFactory.eINSTANCE; XIfExpression ifExpression = factory.createXIfExpression(); ifExpression.setIf(factory.createXBooleanLiteral()); XStringLiteral stringLiteral = factory.createXStringLiteral(); stringLiteral.setValue("value"); ifExpression.setThen(stringLiteral); XInstanceOfExpression instanceOfExpression = factory.createXInstanceOfExpression(); instanceOfExpression.setExpression(ifExpression); instanceOfExpression.setType(EcoreUtil.copy(casted.getType())); resource.getContents().clear(); resource.getContents().add(instanceOfExpression); ISerializer serializer = get(ISerializer.class); String string = serializer.serialize(instanceOfExpression); // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=464846 assertEquals("( if(false) \"value\" ) instanceof String", string); XInstanceOfExpression parsedExpression = parseHelper.parse(string); assertTrue(EcoreUtil.equals(instanceOfExpression, parsedExpression)); }
@Check public void checkInstanceOf(XInstanceOfExpression instanceOfExpression) { LightweightTypeReference leftType = getActualType(instanceOfExpression.getExpression()); final LightweightTypeReference rightType = toLightweightTypeReference(instanceOfExpression.getType(), true); if (leftType == null || rightType == null || rightType.getType() == null || rightType.getType().eIsProxy()) { return; } if (containsTypeArgs(rightType)) { error("Cannot perform instanceof check against parameterized type " + getNameOfTypes(rightType), null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, INVALID_INSTANCEOF); return; } if (leftType.isAny() || leftType.isUnknown()) { return; // null / unknown is ok } if (rightType.isPrimitive()) { error("Cannot perform instanceof check against primitive type " + this.getNameOfTypes(rightType), null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, INVALID_INSTANCEOF); return; } if (leftType.isPrimitive() || rightType.isArray() && !(leftType.isArray() || leftType.isType(Object.class) || leftType.isType(Cloneable.class) || leftType.isType(Serializable.class)) || isFinal(rightType) && !memberOfTypeHierarchy(rightType, leftType) || isFinal(leftType) && !memberOfTypeHierarchy(leftType, rightType)) { error("Incompatible conditional operand types " + this.getNameOfTypes(leftType)+" and "+this.getNameOfTypes(rightType), null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, INVALID_INSTANCEOF); return; } if (!isIgnored(OBSOLETE_INSTANCEOF) && rightType.isAssignableFrom(leftType, new TypeConformanceComputationArgument(false, false, true, true, false, false))) { addIssueToState(OBSOLETE_INSTANCEOF, "The expression of type " + getNameOfTypes(leftType) + " is already of type " + canonicalName(rightType), null); } }
/** * If the condition is a {@link XInstanceOfExpression type check}, the checked expression * will be automatically casted in the returned state. */ protected ITypeComputationState reassignCheckedType(XExpression condition, /* @Nullable */ XExpression guardedExpression, ITypeComputationState state) { if (condition instanceof XInstanceOfExpression) { XInstanceOfExpression instanceOfExpression = (XInstanceOfExpression) condition; JvmTypeReference castedType = instanceOfExpression.getType(); if (castedType != null) { state = state.withTypeCheckpoint(guardedExpression); JvmIdentifiableElement refinable = getRefinableCandidate(instanceOfExpression.getExpression(), state); if (refinable != null) { state.reassignType(refinable, state.getReferenceOwner().toLightweightTypeReference(castedType)); } } } return state; }
@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); } }
protected void _toJavaExpression(XInstanceOfExpression expr, ITreeAppendable b) { b.append("("); internalToJavaExpression(expr.getExpression(), b); b.append(" instanceof "); serialize(expr.getType(), expr, b); b.append(")"); }
protected Object _doEvaluate(XInstanceOfExpression instanceOf, IEvaluationContext context, CancelIndicator indicator) { Object instance = internalEvaluate(instanceOf.getExpression(), context, indicator); if (instance == null) return Boolean.FALSE; Class<?> expectedType = null; String className = instanceOf.getType().getType().getQualifiedName(); try { expectedType = classFinder.forName(className); } catch (ClassNotFoundException cnfe) { throw new EvaluationException(new NoClassDefFoundError(className)); } return expectedType.isInstance(instance); }
protected void _format(final XInstanceOfExpression expr, @Extension final IFormattableDocument doc) { final Procedure1<IHiddenRegionFormatter> _function = (IHiddenRegionFormatter it) -> { it.oneSpace(); }; doc.surround(this.textRegionExtensions.regionFor(expr).keyword("instanceof"), _function); doc.<XExpression>format(expr.getExpression()); doc.<JvmTypeReference>format(expr.getType()); }
/** * Constraint: * (expression=XRelationalExpression_XInstanceOfExpression_1_0_0_0_0 type=JvmTypeReference) */ protected void sequence_XRelationalExpression(EObject context, XInstanceOfExpression semanticObject) { if(errorAcceptor != null) { if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__TYPE) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__TYPE)); if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__EXPRESSION) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__EXPRESSION)); } INodesForEObjectProvider nodes = createNodeProvider(semanticObject); SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes); feeder.accept(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), semanticObject.getExpression()); feeder.accept(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0(), semanticObject.getType()); feeder.finish(); }
@Deprecated protected void sequence_XRelationalExpression(EObject context, XInstanceOfExpression semanticObject) { sequence_XRelationalExpression(createContext(context, semanticObject), semanticObject); }
@Check public void checkInstanceOfOrder(XIfExpression expression) { if (isIgnored(IssueCodes.UNREACHABLE_IF_BLOCK)) { return; } if (expression.eContainer() instanceof XIfExpression) { XIfExpression container = (XIfExpression) expression.eContainer(); if (container.getElse() == expression) { return; } } List<XExpression> ifParts = collectIfParts(expression, new ArrayList<XExpression>()); ITypeReferenceOwner owner = new StandardTypeReferenceOwner(getServices(), expression); Multimap<JvmIdentifiableElement, LightweightTypeReference> previousTypeReferences = HashMultimap.create(); for (XExpression ifPart : ifParts) { if (!(ifPart instanceof XInstanceOfExpression)) { continue; } XInstanceOfExpression instanceOfExpression = (XInstanceOfExpression) ifPart; if (!(instanceOfExpression.getExpression() instanceof XAbstractFeatureCall)) { continue; } XAbstractFeatureCall featureCall = (XAbstractFeatureCall) instanceOfExpression.getExpression(); JvmIdentifiableElement feature = featureCall.getFeature(); if (!(feature instanceof XVariableDeclaration) && !(feature instanceof JvmField) && !(feature instanceof JvmFormalParameter)) { continue; } JvmTypeReference type = instanceOfExpression.getType(); LightweightTypeReference actualType = owner.toLightweightTypeReference(type); if (actualType == null) { continue; } if (isHandled(actualType, previousTypeReferences.get(feature))) { addIssue("Unreachable code: The if condition can never match. It is already handled by a previous condition.", type, IssueCodes.UNREACHABLE_IF_BLOCK); continue; } previousTypeReferences.put(feature, actualType); } }
@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); } }
@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); } }
/** * @param isReferenced unused in this context but necessary for dispatch signature */ protected void _toJavaStatement(XInstanceOfExpression expr, ITreeAppendable b, boolean isReferenced) { internalToJavaStatement(expr.getExpression(), b, true); }
@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 void _findImplicitReturns(final XInstanceOfExpression expression, final ImplicitReturnFinder.Acceptor acceptor) { acceptor.accept(expression); }
public void findImplicitReturns(final XExpression expression, final ImplicitReturnFinder.Acceptor acceptor) { if (expression instanceof XAbstractFeatureCall) { _findImplicitReturns((XAbstractFeatureCall)expression, acceptor); return; } else if (expression instanceof XBlockExpression) { _findImplicitReturns((XBlockExpression)expression, acceptor); return; } else if (expression instanceof XBooleanLiteral) { _findImplicitReturns((XBooleanLiteral)expression, acceptor); return; } else if (expression instanceof XCastedExpression) { _findImplicitReturns((XCastedExpression)expression, acceptor); return; } else if (expression instanceof XClosure) { _findImplicitReturns((XClosure)expression, acceptor); return; } else if (expression instanceof XCollectionLiteral) { _findImplicitReturns((XCollectionLiteral)expression, acceptor); return; } else if (expression instanceof XConstructorCall) { _findImplicitReturns((XConstructorCall)expression, acceptor); return; } else if (expression instanceof XIfExpression) { _findImplicitReturns((XIfExpression)expression, acceptor); return; } else if (expression instanceof XInstanceOfExpression) { _findImplicitReturns((XInstanceOfExpression)expression, acceptor); return; } else if (expression instanceof XNullLiteral) { _findImplicitReturns((XNullLiteral)expression, acceptor); return; } else if (expression instanceof XNumberLiteral) { _findImplicitReturns((XNumberLiteral)expression, acceptor); return; } else if (expression instanceof XStringLiteral) { _findImplicitReturns((XStringLiteral)expression, acceptor); return; } else if (expression instanceof XSwitchExpression) { _findImplicitReturns((XSwitchExpression)expression, acceptor); return; } else if (expression instanceof XSynchronizedExpression) { _findImplicitReturns((XSynchronizedExpression)expression, acceptor); return; } else if (expression instanceof XTryCatchFinallyExpression) { _findImplicitReturns((XTryCatchFinallyExpression)expression, acceptor); return; } else if (expression instanceof XTypeLiteral) { _findImplicitReturns((XTypeLiteral)expression, acceptor); return; } else if (expression != null) { _findImplicitReturns(expression, acceptor); return; } else if (expression == null) { _findImplicitReturns((Void)null, acceptor); return; } else { throw new IllegalArgumentException("Unhandled parameter types: " + Arrays.<Object>asList(expression, acceptor).toString()); } }
@Test public void testInstanceOf() throws Exception { XInstanceOfExpression expression = (XInstanceOfExpression) expression("true instanceof Boolean"); doTestInstanceOf(expression); }
protected void doTestInstanceOf(XInstanceOfExpression expression) { assertEquals("java.lang.Boolean",expression.getType().getIdentifier()); assertTrue(expression.getExpression() instanceof XBooleanLiteral); }
/** * Contexts: * XExpression returns XInstanceOfExpression * XAssignment returns XInstanceOfExpression * XAssignment.XBinaryOperation_1_1_0_0_0 returns XInstanceOfExpression * XOrExpression returns XInstanceOfExpression * XOrExpression.XBinaryOperation_1_0_0_0 returns XInstanceOfExpression * XAndExpression returns XInstanceOfExpression * XAndExpression.XBinaryOperation_1_0_0_0 returns XInstanceOfExpression * XEqualityExpression returns XInstanceOfExpression * XEqualityExpression.XBinaryOperation_1_0_0_0 returns XInstanceOfExpression * XRelationalExpression returns XInstanceOfExpression * XRelationalExpression.XInstanceOfExpression_1_0_0_0_0 returns XInstanceOfExpression * XRelationalExpression.XBinaryOperation_1_1_0_0_0 returns XInstanceOfExpression * XOtherOperatorExpression returns XInstanceOfExpression * XOtherOperatorExpression.XBinaryOperation_1_0_0_0 returns XInstanceOfExpression * XAdditiveExpression returns XInstanceOfExpression * XAdditiveExpression.XBinaryOperation_1_0_0_0 returns XInstanceOfExpression * XMultiplicativeExpression returns XInstanceOfExpression * XMultiplicativeExpression.XBinaryOperation_1_0_0_0 returns XInstanceOfExpression * XUnaryOperation returns XInstanceOfExpression * XCastedExpression returns XInstanceOfExpression * XCastedExpression.XCastedExpression_1_0_0_0 returns XInstanceOfExpression * XPostfixOperation returns XInstanceOfExpression * XPostfixOperation.XPostfixOperation_1_0_0 returns XInstanceOfExpression * XMemberFeatureCall returns XInstanceOfExpression * XMemberFeatureCall.XAssignment_1_0_0_0_0 returns XInstanceOfExpression * XMemberFeatureCall.XMemberFeatureCall_1_1_0_0_0 returns XInstanceOfExpression * XPrimaryExpression returns XInstanceOfExpression * XParenthesizedExpression returns XInstanceOfExpression * XExpressionOrVarDeclaration returns XInstanceOfExpression * * Constraint: * (expression=XRelationalExpression_XInstanceOfExpression_1_0_0_0_0 type=JvmTypeReference) */ protected void sequence_XRelationalExpression(ISerializationContext context, XInstanceOfExpression semanticObject) { if (errorAcceptor != null) { if (transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__EXPRESSION) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__EXPRESSION)); if (transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__TYPE) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XINSTANCE_OF_EXPRESSION__TYPE)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); feeder.accept(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), semanticObject.getExpression()); feeder.accept(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0(), semanticObject.getType()); feeder.finish(); }