public override void Validate(Environment env)
{
using var _ = env.Scopes.Use();
Expr.Validate(env);
Expr.AssertType(new BooleanType());
Block.Validate(env);
}
public static void Validate(IContainer container, ExprNode node)
{
try
{
node.Validate(SupportExprValidationContextFactory.MakeEmpty(container));
}
catch (ExprValidationException ex)
{
throw new EPRuntimeException(ex);
}
}
private void TopValidate(ExprNode exprNode, ExprEvaluatorContext exprEvaluatorContext)
{
try
{
var validationContext = new ExprValidationContext(null, null, null, null, null, null, exprEvaluatorContext, null, null, null, null, null, null, false, false, false, false, null, false);
exprNode.Validate(validationContext);
}
catch (ExprValidationException e)
{
throw new IllegalStateException("Failed to make representative node for outer join criteria");
}
}
private void TopValidate(
ExprNode exprNode,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices compileTimeServices)
{
try {
ExprValidationContext validationContext =
new ExprValidationContextBuilder(null, statementRawInfo, compileTimeServices).Build();
exprNode.Validate(validationContext);
}
catch (ExprValidationException) {
throw new IllegalStateException("Failed to make representative node for outer join criteria");
}
}
public override void Validate(Environment env)
{
Expr.Validate(env);
DerivedType = Expr.Type;
if (TypeAnnotation != null)
{
DerivedType = TypeAnnotation.EvalType(env);
Expr.AssertType(DerivedType);
}
env.Scopes.Values.Bind(Name, new VariableBinding()
{
Name = Name,
Type = DerivedType,
IsConst = IsConst,
});
}
private void TopValidate(ExprNode exprNode, ExprEvaluatorContext exprEvaluatorContext)
{
try {
var container = exprEvaluatorContext != null
? FallbackContainer.GetInstance(exprEvaluatorContext.Container)
: FallbackContainer.GetInstance();
var validationContext = new ExprValidationContext(
container,
null, null, null,
null, null, null,
null, exprEvaluatorContext, null,
null, -1, null,
null, null,
false, false, false, false, null, false);
exprNode.Validate(validationContext);
}
catch (ExprValidationException)
{
throw new IllegalStateException("Failed to make representative node for outer join criteria");
}
}
public static void Validate(ExprNode node)
{
node.Validate(ExprValidationContextFactory.MakeEmpty());
}
private static ExprNode GetValidatedSubtreeInternal(
ExprNode exprNode,
ExprValidationContext validationContext,
bool isTopLevel)
{
ExprNode result = exprNode;
if (exprNode is ExprLambdaGoesNode) {
return exprNode;
}
for (int i = 0; i < exprNode.ChildNodes.Length; i++) {
ExprNode childNode = exprNode.ChildNodes[i];
if (childNode is ExprDeclaredOrLambdaNode node) {
if (node.IsValidated) {
continue;
}
}
ExprNode childNodeValidated = GetValidatedSubtreeInternal(childNode, validationContext, false);
exprNode.SetChildNode(i, childNodeValidated);
}
try {
ExprNode optionalReplacement = exprNode.Validate(validationContext);
if (optionalReplacement != null) {
return GetValidatedSubtreeInternal(optionalReplacement, validationContext, isTopLevel);
}
}
catch (ExprValidationException e) {
if (exprNode is ExprIdentNode identNode) {
try {
result = ResolveStaticMethodOrField(identNode, e, validationContext);
}
catch (ExprValidationException) {
var resolutionStream = ResolveAsStreamName(identNode, validationContext);
if (resolutionStream.First == false) {
throw;
}
result = resolutionStream.Second;
}
}
else {
throw;
}
}
// For top-level expressions check if we perform audit
if (isTopLevel) {
if (validationContext.IsExpressionAudit) {
return (ExprNode) ExprNodeProxy.NewInstance(result);
}
}
else {
if (validationContext.IsExpressionNestedAudit &&
!(result is ExprIdentNode) &&
!(ExprNodeUtilityQuery.IsConstant(result))) {
return (ExprNode) ExprNodeProxy.NewInstance(result);
}
}
return result;
}
public override void Validate(Environment env)
{
Expr.Validate(env);
ReturnType = Expr.Type;
}
public static void Validate(ExprNode node)
{
node.Validate(SupportExprValidationContextFactory.MakeEmpty(
SupportContainer.Instance));
}
