private DynamicInvoke ( |
||
e | ||
return | object |
static bool CheckArgument(ExpressionParser parser, MethodCallExpression methE, bool left, out string hint) { int ix1 = left ? 0 : 1; int ix2 = left ? 1 : 0; if (typeof (Delegate).IsAssignableFrom(methE.Arguments[ix1].Type)) { object leftR; try { leftR = parser.DynamicInvoke(Expression.Invoke(methE.Arguments[ix1])); } catch (InvalidOperationException) // delegate needs arguments { hint = null; return false; } if (Equals(leftR, parser.DynamicInvoke(methE.Arguments[ix2]))) { hint = string.Format(", but would have been True if you had invoked '{0}'", NodeFormatter.PrettyPrint(parser.Parse(methE.Arguments[ix1]))); return true; } } hint = null; return false; }
public bool TryGetHint(ExpressionParser parser, Expression expression, out string hint) { var methE = expression as MethodCallExpression; if (methE != null) { if (methE.Method == ObjectEqualsMethodInfo) { var left = parser.DynamicInvoke(methE.Arguments[0]); var right = parser.DynamicInvoke(methE.Arguments[1]); if (left is Delegate || right is Delegate) { if (CheckArgument(parser, methE, true, out hint)) { return true; } if (CheckArgument(parser, methE, false, out hint)) { return true; } hint = ", this is a suspicious comparison"; return true; } } } hint = null; return false; }
public bool TryGetHint(ExpressionParser parser, Expression expression, out string hint) { object left = null; object right = null; Type declaringType = null; var methE = expression as MethodCallExpression; if (methE != null) { if (methE.Method == ObjectEqualsMethodInfo) { left = parser.DynamicInvoke(methE.Object); right = parser.DynamicInvoke(methE.Arguments[0]); // methE.Method.DeclaringType doesn't work here, it will // always return the base class method declaringType = GetDerivedMethodInfo(methE.Object.Type, methE.Method).DeclaringType; } } var binE = expression as BinaryExpression; if (binE != null && binE.NodeType == ExpressionType.Equal) { left = parser.DynamicInvoke(binE.Left); right = parser.DynamicInvoke(binE.Right); if (binE.Method != null) { declaringType = binE.Method.DeclaringType; } else { declaringType = typeof (object); // this should never happen - the hints are only called when the assert fails } } if (left != null && left == right) { hint = ", type " + ExpressionParser.NameOfType(declaringType) + " has a broken equality implementation (both sides are the same object)"; return true; } hint = null; return false; }
public bool TryGetHint(ExpressionParser parser, Expression expression, out string hint) { var methE = expression as MethodCallExpression; if (methE != null) { if (StringEqualsMethodInfo.Any(x => x == methE.Method)) { var obj = parser.DynamicInvoke(methE.Object); var arg = parser.DynamicInvoke(methE.Arguments.First()); var comparison = (StringComparison) (methE.Arguments.Select(parser.DynamicInvoke) .FirstOrDefault(x => x is StringComparison) ?? StringComparison.CurrentCulture); hint = HintUtils.GetStringDifferHint((string) obj, (string) arg, GetComparerFromComparison(comparison)); return hint != null; } } hint = null; return false; }
public bool TryGetHint(ExpressionParser parser, Expression expression, out string hint) { var methE = expression as MethodCallExpression; if (methE != null) { if (methE.Method == ObjectInstanceEqualsMethodInfo) { var obj = parser.DynamicInvoke(methE.Object) as IEnumerable; var arg = parser.DynamicInvoke(methE.Arguments.First()) as IEnumerable; if (obj != null && arg != null) { if (obj.Cast<object>().SequenceEqual(arg.Cast<object>())) { hint = ", but would have been True with .SequenceEqual()"; return true; } } } } hint = null; return false; }
x.GetParameters().Count() == 2); // TODO: equality comparer support public bool TryGetHint(ExpressionParser parser, Expression expression, out string hint) { var methE = expression as MethodCallExpression; if (methE != null) { var typeParams = methE.Method.GetGenericArguments(); if (typeParams.Count() == 1) { var instantiatedMethodInfo = SequenceEqualMethodInfo.MakeGenericMethod(typeParams); if (methE.Method == instantiatedMethodInfo) { var left = parser.DynamicInvoke(methE.Arguments[0]); var right = parser.DynamicInvoke(methE.Arguments[1]); var enumLeft = ((IEnumerable) left).GetEnumerator(); var enumRight = ((IEnumerable) right).GetEnumerator(); { int i = 0; while (enumLeft.MoveNext() && enumRight.MoveNext()) { if (!Equals(enumLeft.Current, enumRight.Current)) { hint = string.Format(", enumerables differ at index {0}, {1} != {2}", i, ObjectFormatter.FormatObject(enumLeft.Current), ObjectFormatter.FormatObject(enumRight.Current)); return true; } ++i; } } } } } hint = null; return false; }
public bool TryGetHint(ExpressionParser parser, Expression expression, out string hint) { if (expression is BinaryExpression && expression.NodeType == ExpressionType.Equal) { var be = (BinaryExpression) expression; object left; object right; try { left = parser.DynamicInvoke(be.Left); right = parser.DynamicInvoke(be.Right); } catch (TargetInvocationException exception) { hint = ObjectFormatter.FormatTargetInvocationException(exception); return true; } return TryGetHint(parser, left, right, out hint); } hint = null; return false; }
string Parse(ExpressionParser parser, Type enumType, Expression expression) { return enumType.Name + "." + Enum.GetName(enumType, parser.DynamicInvoke(expression)); }