private BinaryEqualExpression Eq(Expression lhs, Expression rhs, ParserRuleContext context) { if (rhs == null || lhs == null) { return(null); } if (lhs.Type != rhs.Type) { this.AddSyntaxError("Types mismatch. Are you missing a cast?", context); return(null); } if (!ArithmeticTypeHelper.IsArithmetic(lhs.Type.ClrType)) { var eqType = typeof(IEquatable <>).MakeGenericType(lhs.Type.ClrType); if (lhs.Type.ClrType.GetInterfaces().Contains(eqType)) { this.AddSyntaxError($"There is no defined equality operator for the type {lhs.Type.ClrType.Name}.", context); return(null); } var meth = lhs.Type.ClrType.GetMethod("Equals", new[] { lhs.Type.ClrType }); return(new BinaryEqualExpression(lhs, rhs, meth, context)); } return(new BinaryEqualExpression(lhs, rhs, context)); }
private T BinaryCompare <T>(Expression lhs, Expression rhs, ParserRuleContext context) where T : BinaryExpression { if (lhs == null || rhs == null) { return(null); } if (lhs.Type != rhs.Type) { this.AddSyntaxError("Types mismatch. Are you missing a cast?", context); return(null); } var t = lhs.Type.ClrType; if (!ArithmeticTypeHelper.IsArithmetic(t)) { var comparableInterface = typeof(IComparable <>).MakeGenericType(t); if (!t.GetInterfaces().Contains(comparableInterface)) { this.AddSyntaxError($"The type {t.Name} is not comparable.", context); return(null); } else { return((T)Activator.CreateInstance(typeof(T), lhs, rhs, t.GetMethod("CompareTo", new Type[] { t }), context)); } } return((T)Activator.CreateInstance(typeof(T), lhs, rhs, context)); }
private T Binary <T>(Expression lhs, Expression rhs, string opName, ParserRuleContext context) where T : BinaryExpression { if (lhs == null || rhs == null) { return(null); } if (lhs.Type != rhs.Type) { this.AddSyntaxError("Types mismatch. Are you missing a cast?", context); return(null); } if (ArithmeticTypeHelper.IsArithmetic(lhs.Type.ClrType)) { return((T)Activator.CreateInstance(typeof(T), lhs, rhs, context)); } else { var op = this.FindOperator(lhs.Type.ClrType, "Add", context); if (op == null) { return(null); } return((T)Activator.CreateInstance(typeof(T), lhs, rhs, op, context)); } }
private bool IsComparable(Type t, ParserRuleContext context) { if (!ArithmeticTypeHelper.IsArithmetic(t)) { var comparableInterface = typeof(IComparable <>).MakeGenericType(t); if (!t.GetInterfaces().Contains(comparableInterface)) { this.AddSyntaxError($"The type {t.Name} is not comparable.", context); return(false); } } return(true); }