AssertExpression returns xbase::XExpression :
	{SarlAssertExpression}
	'assert' (->condition=XExpression) (->',' message=STRING)?
;

class SarlCompiler extends XtendCompiler {
	public void doInternalToJavaStatement(XExpression obj, ITreeAppendable appendable, boolean isReferenced) {
		if (obj instanceof SarlAssertExpression) {
			_toJavaStatement((SarlAssertExpression) obj, appendable, isReferenced);
		} else {
			super.doInternalToJavaStatement(obj, appendable, isReferenced);
		}
	}

	public void internalToConvertedExpression(XExpression obj, ITreeAppendable appendable) {
		if (obj instanceof SarlAssertExpression) {
			_toJavaExpression((SarlAssertExpression) obj, appendable);
		} else {
			super.internalToConvertedExpression(obj, appendable);
		}
	}

	protected void _toJavaStatement(SarlAssertExpression assertExpression, ITreeAppendable appendable, boolean isReferenced) {
		if (assertExpression.getCondition() != null) {
			final XExpression condition = assertExpression.getCondition();
			appendable.newLine().append("assert ");
			final Boolean booleanConstant = this.sarlExpressionHelper.toBooleanPrimitiveWrapperConstant(condition);
			if (booleanConstant != null) {
				appendable.append(booleanConstant.toString());
			} else {
				final LightweightTypeReference actualType = getLightweightType(condition);
				if (actualType != null &&
						(actualType.isAssignableFrom(boolean.class) || (actualType.isAssignableFrom(Boolean.class)))) {
					appendable.append("(");
					appendable.append(Function0.class);
					appendable.append("<Boolean>) () -> {");
					appendable.increaseIndentation();
					internalToJavaStatement(condition, appendable, true);
					appendable.newLine();
					appendable.append("return (");
					internalToConvertedExpression(condition, appendable, actualType);
					appendable.append(");");
					appendable.decreaseIndentation().newLine();
					appendable.append("}).apply().booleanValue()");
				} else {
					appendable.append("true /* illegal expression type */");
				}
			}
			if (!Strings.isEmpty(assertExpression.getMessage())) {
				appendable.append(" : \"");
				appendable.append(Strings.convertToJavaString(assertExpression.getMessage()));
				appendable.append("\"");
			}
			appendable.append(";");
		}
	}

	protected void _toJavaExpression(SarlAssertExpression assertExpression, ITreeAppendable appendable) {
		appendable.append("/* error - couldn't compile nested assert */");
	}

	protected boolean internalCanCompileToJavaExpression(XExpression expression, ITreeAppendable appendable) {
		if (expression instanceof SarlAssertExpression) {
			return true;
		}
		return super.internalCanCompileToJavaExpression(expression, appendable);
	}

	protected boolean isVariableDeclarationRequired(XExpression expression, ITreeAppendable appendable, boolean recursive) {
		final EObject container = expression.eContainer();
		if (container instanceof SarlAssertExpression) {
			return false;
		}
		return super.isVariableDeclarationRequired(expression, appendable, recursive);
	}
}

public void computeTypes(XExpression expression, ITypeComputationState state) {
	if (expression instanceof SarlAssertExpression) {
		_computeTypes((SarlAssertExpression) expression, state);
	} else {
		super.computeTypes(expression, state);
	}
}
protected void _computeTypes(SarlAssertExpression object, ITypeComputationState state) {
	final LightweightTypeReference primitiveVoid = getPrimitiveVoid(state);
	state.acceptActualType(primitiveVoid);
}

agent A1 {
    def fct1(x : int) : int {
        assert x > 0
        return x + 1
    }
    def fct2(x : int) : int {
        if (x > 0) {}
        return x + 1
    }
}