/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IUnaryNotExpression node, object data)
{
ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant;
Debug.Assert(node.ConstantSourceList.Count == 1);
IExpression RightConstantSource = node.ConstantSourceList[0];
Debug.Assert(RightConstantSource == node.RightExpression);
Debug.Assert(RightConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant RightExpressionConstant = RightConstantSource.ExpressionConstant.Item;
if (RightExpressionConstant != NeutralLanguageConstant.NotConstant)
{
IBooleanLanguageConstant RightConstant = RightExpressionConstant as IBooleanLanguageConstant;
Debug.Assert(RightConstant != null);
bool? RightConstantValue = RightConstant.Value;
if (RightConstantValue.HasValue)
ExpressionConstant = new BooleanLanguageConstant(!RightConstantValue.Value);
else
ExpressionConstant = new BooleanLanguageConstant();
}
node.ExpressionConstant.Item = ExpressionConstant;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IEqualityExpression node, object data)
{
ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant;
Debug.Assert(node.ConstantSourceList.Count == 2);
IExpression LeftConstantSource = node.ConstantSourceList[0];
Debug.Assert(LeftConstantSource == node.LeftExpression);
IExpression RightConstantSource = node.ConstantSourceList[1];
Debug.Assert(RightConstantSource == node.RightExpression);
Debug.Assert(LeftConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant LeftExpressionConstant = LeftConstantSource.ExpressionConstant.Item;
Debug.Assert(RightConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant RightExpressionConstant = RightConstantSource.ExpressionConstant.Item;
if (LeftExpressionConstant != NeutralLanguageConstant.NotConstant && RightExpressionConstant != NeutralLanguageConstant.NotConstant)
{
if (LeftExpressionConstant.IsCompatibleWith(RightExpressionConstant) && LeftExpressionConstant.IsValueKnown && RightExpressionConstant.IsValueKnown)
{
switch (node.Comparison)
{
case BaseNode.ComparisonType.Equal:
ExpressionConstant = new BooleanLanguageConstant(LeftExpressionConstant.IsConstantEqual(RightExpressionConstant));
break;
case BaseNode.ComparisonType.Different:
ExpressionConstant = new BooleanLanguageConstant(!LeftExpressionConstant.IsConstantEqual(RightExpressionConstant));
break;
}
IBooleanLanguageConstant BooleanLanguageConstant = ExpressionConstant as IBooleanLanguageConstant;
Debug.Assert(BooleanLanguageConstant != null);
Debug.Assert(BooleanLanguageConstant.IsValueKnown);
}
else
{
ExpressionConstant = new BooleanLanguageConstant();
}
}
node.ExpressionConstant.Item = ExpressionConstant;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IBinaryOperatorExpression node, object data)
{
ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant;
Debug.Assert(node.ConstantSourceList.Count == 2);
IExpression LeftConstantSource = node.ConstantSourceList[0];
Debug.Assert(LeftConstantSource == node.LeftExpression);
IExpression RightConstantSource = node.ConstantSourceList[1];
Debug.Assert(RightConstantSource == node.RightExpression);
Debug.Assert(LeftConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant LeftExpressionConstant = LeftConstantSource.ExpressionConstant.Item;
Debug.Assert(RightConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant RightExpressionConstant = RightConstantSource.ExpressionConstant.Item;
if (LeftExpressionConstant != NeutralLanguageConstant.NotConstant && RightExpressionConstant != NeutralLanguageConstant.NotConstant)
{
Debug.Assert(node.ResolvedResult.IsAssigned);
IResultType ResolvedResult = node.ResolvedResult.Item;
if (ResolvedResult.Count == 1)
{
IExpressionType ConstantType = ResolvedResult.At(0);
bool IsBooleanTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType);
bool IsNumberTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType);
if (IsBooleanTypeAvailable && ConstantType.ValueType == BooleanType)
{
ExpressionConstant = new BooleanLanguageConstant();
}
else if (IsNumberTypeAvailable && ConstantType.ValueType == NumberType)
{
ExpressionConstant = new NumberLanguageConstant();
}
}
}
node.ExpressionConstant.Item = ExpressionConstant;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IUnaryOperatorExpression node, object data)
{
ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant;
Debug.Assert(node.ConstantSourceList.Count == 1);
IExpression RightConstantSource = node.ConstantSourceList[0];
Debug.Assert(RightConstantSource == node.RightExpression);
Debug.Assert(RightConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant RightExpressionConstant = RightConstantSource.ExpressionConstant.Item;
if (RightExpressionConstant != NeutralLanguageConstant.NotConstant)
{
Debug.Assert(node.SelectedOverloadType.IsAssigned);
IQueryOverloadType SelectedOverloadType = node.SelectedOverloadType.Item;
if (SelectedOverloadType.ResultTable.Count == 1)
{
IParameter OverloadResult = SelectedOverloadType.ResultTable[0];
Debug.Assert(OverloadResult.ResolvedParameter.ResolvedEffectiveType.IsAssigned);
ICompiledType ResultType = OverloadResult.ResolvedParameter.ResolvedEffectiveType.Item;
if (Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType) && ResultType == BooleanType)
{
ExpressionConstant = new BooleanLanguageConstant();
}
else if (Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType) && ResultType == NumberType)
{
ExpressionConstant = new NumberLanguageConstant();
}
else if (Expression.IsLanguageTypeAvailable(LanguageClasses.Character.Guid, node, out ITypeName CharacterTypeName, out ICompiledType CharacterType) && ResultType == CharacterType)
{
ExpressionConstant = new CharacterLanguageConstant();
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IBinaryConditionalExpression node, object data)
{
ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant;
Debug.Assert(node.ConstantSourceList.Count == 2);
IExpression LeftConstantSource = node.ConstantSourceList[0];
Debug.Assert(LeftConstantSource == node.LeftExpression);
IExpression RightConstantSource = node.ConstantSourceList[1];
Debug.Assert(RightConstantSource == node.RightExpression);
Debug.Assert(LeftConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant LeftExpressionConstant = LeftConstantSource.ExpressionConstant.Item;
Debug.Assert(RightConstantSource.ExpressionConstant.IsAssigned);
ILanguageConstant RightExpressionConstant = RightConstantSource.ExpressionConstant.Item;
if (LeftExpressionConstant != NeutralLanguageConstant.NotConstant && RightExpressionConstant != NeutralLanguageConstant.NotConstant)
{
IBooleanLanguageConstant LeftConstant = LeftExpressionConstant as IBooleanLanguageConstant;
Debug.Assert(LeftConstant != null);
IBooleanLanguageConstant RightConstant = RightExpressionConstant as IBooleanLanguageConstant;
Debug.Assert(RightConstant != null);
bool?LeftConstantValue = LeftConstant.Value;
bool?RightConstantValue = RightConstant.Value;
if (LeftConstantValue.HasValue && RightConstantValue.HasValue)
{
switch (node.Conditional)
{
case BaseNode.ConditionalTypes.And:
ExpressionConstant = new BooleanLanguageConstant(LeftConstantValue.Value && RightConstantValue.Value);
break;
case BaseNode.ConditionalTypes.Or:
ExpressionConstant = new BooleanLanguageConstant(LeftConstantValue.Value || RightConstantValue.Value);
break;
case BaseNode.ConditionalTypes.Xor:
ExpressionConstant = new BooleanLanguageConstant(LeftConstantValue.Value ^ RightConstantValue.Value);
break;
case BaseNode.ConditionalTypes.Implies:
ExpressionConstant = new BooleanLanguageConstant(!LeftConstantValue.Value || RightConstantValue.Value);
break;
}
Debug.Assert(ExpressionConstant is IBooleanLanguageConstant);
}
else
{
ExpressionConstant = new BooleanLanguageConstant();
}
}
node.ExpressionConstant.Item = ExpressionConstant;
}
