1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/* ****************************************************************************
*
* Copyright (c) Microsoft Corporation.
*
* This source code is subject to terms and conditions of the Microsoft Public License. A
* copy of the license can be found in the License.html file at the root of this distribution. If
* you cannot locate the Microsoft Public License, please send an email to
* dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
* by the terms of the Microsoft Public License.
*
* You must not remove this notice, or any other, from this software.
*
*
* ***************************************************************************/
using System.Diagnostics;
using System.Linq.Expressions;
using Microsoft.Scripting.Utils;
namespace Microsoft.Scripting.Generation {
public static class ConstantCheck {
/// <summary>
/// Tests to see if the expression is a constant with the given value.
/// </summary>
/// <param name="expression">The expression to examine</param>
/// <param name="value">The constant value to check for.</param>
/// <returns>true/false</returns>
public static bool Check(Expression expression, object value) {
ContractUtils.RequiresNotNull(expression, "expression");
return IsConstant(expression, value);
}
/// <summary>
/// Tests to see if the expression is a constant with the given value.
/// </summary>
/// <param name="e">The expression to examine</param>
/// <param name="value">The constant value to check for.</param>
/// <returns>true/false</returns>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
internal static bool IsConstant(Expression e, object value) {
switch (e.NodeType) {
case ExpressionType.AndAlso:
return CheckAndAlso((BinaryExpression)e, value);
case ExpressionType.OrElse:
return CheckOrElse((BinaryExpression)e, value);
case ExpressionType.Constant:
return CheckConstant((ConstantExpression)e, value);
case ExpressionType.TypeIs:
return Check((TypeBinaryExpression)e, value);
default:
return false;
}
}
//CONFORMING
internal static bool IsNull(Expression e) {
return IsConstant(e, null);
}
private static bool CheckAndAlso(BinaryExpression node, object value) {
Debug.Assert(node.NodeType == ExpressionType.AndAlso);
if (node.Method != null) {
return false;
}
//TODO: we can propagate through conversion, but it may not worth it.
if (node.Conversion != null) {
return false;
}
if (value is bool) {
if ((bool)value) {
return IsConstant(node.Left, true) && IsConstant(node.Right, true);
} else {
// if left isn't a constant it has to be evaluated
return IsConstant(node.Left, false);
}
}
return false;
}
private static bool CheckOrElse(BinaryExpression node, object value) {
Debug.Assert(node.NodeType == ExpressionType.OrElse);
if (node.Method != null) {
return false;
}
if (value is bool) {
if ((bool)value) {
return IsConstant(node.Left, true);
} else {
return IsConstant(node.Left, false) && IsConstant(node.Right, false);
}
}
return false;
}
private static bool CheckConstant(ConstantExpression node, object value) {
if (value == null) {
return node.Value == null;
} else {
return value.Equals(node.Value);
}
}
private static bool Check(TypeBinaryExpression node, object value) {
// allow constant TypeIs expressions to be optimized away
if (value is bool && ((bool)value) == true) {
return node.TypeOperand.IsAssignableFrom(node.Expression.Type);
}
return false;
}
}
}
|
