/// <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; }