C#编译器二元运算符类型解析机制及自定义实现困惑

我正在开发一款基于C# Expression Trees的类型化脚本语言，目前在二元运算符的类型转换处理上遇到瓶颈，希望复刻C#编译器的转换规则：

var value = "someString" + 10; // 结果为字符串
var value = 5 + "someString"; // 结果也为字符串，我对此存疑
var x = 10f + 10; // 结果为float类型
var y = 10 + 10f; // 结果也为float类型，我对此存疑

我想了解C#编译器如何判断在第一行中调用整数的ToString()方法，以及在与float相加时双向转换整数为float？这些转换规则是硬编码的吗？

我当前编译器处理二元运算符的逻辑如下：

Expression Visit(Type tryToConvertTo, ASTNode node) {
    // 细节无关紧要。若tryToConvertTo不为null
    // 若结果表达式类型不符则转换为该类型
}

// 高度简化后的核心逻辑
Expression VisitBinaryOperator(Operator operator) {
    Expression lhs = Visit(null, operator.lhs);
    Expression rhs = Visit(lhs, operator.rhs); // 存在错误，仅在部分场景生效
    switch(operator.opType) {
        case OperatorType.Add: {
            return Expression.Add(lhs, rhs);
        }
        // 省略其他运算符/错误处理等逻辑
    }
}

我知晓始终以左侧类型为准的逻辑有误，但除了硬编码基本类型规则外，不知该如何正确处理上述示例场景，恳请指点方向！

先澄清你存疑的C#行为 #

你提到的两个"存疑"场景都是C#的标准行为：

• 只要+运算符的任意一方是string类型，C#就会触发字符串拼接逻辑：将另一方转换为字符串后拼接，不管左右顺序。
• 当数值类型（如int和float）相加时，C#会遵循数值类型提升规则：将精度更低的类型（int）隐式转换为精度更高的类型（float），最终结果为高精度类型，同样与左右顺序无关。

C#编译器的转换规则逻辑 #

这些规则并非完全硬编码，而是基于C#语言规范定义的运算符重载决议和隐式转换优先级：

1. 字符串拼接的处理：
   C#为string类型重载了+运算符，支持string + object和object + string两种形式。编译器会优先匹配这两个重载，将非字符串的操作数通过ToString()（或处理null为"null"）转换为字符串后执行拼接。
2. 数值类型的隐式转换：
   对于数值类型的+运算，编译器会根据类型的精度和范围，自动将低精度类型转换为高精度类型（比如int→float、float→double等），这是语言规范中定义的隐式转换规则，而非简单的硬编码。

基于Expression Trees的改进方案 #

你当前的逻辑仅以左侧类型为准，无法处理双向转换和字符串拼接场景，可按以下方向改进：

1. 针对+运算符的分场景处理 #

在VisitBinaryOperator中处理Add时，先判断操作数类型：

case OperatorType.Add: {
    Type lhsType = lhs.Type;
    Type rhsType = rhs.Type;

    // 场景1：任意一方是string，触发字符串拼接
    if (lhsType == typeof(string) || rhsType == typeof(string)) {
        // 将非字符串的操作数转换为object（匹配string+object的重载）
        Expression lhsStr = lhsType == typeof(string) ? lhs : Expression.Convert(lhs, typeof(object));
        Expression rhsStr = rhsType == typeof(string) ? rhs : Expression.Convert(rhs, typeof(object));
        // 调用string的+运算符重载
        return Expression.Add(lhsStr, rhsStr, typeof(string).GetMethod("op_Addition", new[] { typeof(string), typeof(object) }));
    }

    // 场景2：数值类型，处理隐式类型提升
    Type targetType = GetPromotedNumericType(lhsType, rhsType);
    if (targetType != null) {
        // 将左右操作数转换为目标类型
        Expression convertedLhs = Expression.Convert(lhs, targetType);
        Expression convertedRhs = Expression.Convert(rhs, targetType);
        return Expression.Add(convertedLhs, convertedRhs);
    }

    // 其他场景：默认处理自定义类型的重载等
    return Expression.Add(lhs, rhs);
}

2. 实现数值类型提升的判断方法 #

基于C#语言规范的数值类型优先级，实现目标类型判断（这是规范驱动的编码，而非无意义硬编码）：

private Type GetPromotedNumericType(Type a, Type b) {
    // 按C#隐式数值转换优先级排序：byte→short→int→long→float→double→decimal
    var numericOrder = new List<Type> {
        typeof(byte), typeof(short), typeof(int), typeof(long),
        typeof(float), typeof(double), typeof(decimal)
    };

    if (!numericOrder.Contains(a) || !numericOrder.Contains(b)) {
        return null; // 非数值类型
    }

    int indexA = numericOrder.IndexOf(a);
    int indexB = numericOrder.IndexOf(b);
    return numericOrder[Math.Max(indexA, indexB)];
}

3. 优化类型转换逻辑 #

修改Visit方法，支持根据目标类型双向转换，而非固定以左侧为准：

Expression Visit(Type targetType, ASTNode node) {
    Expression expr = // 解析node得到原始表达式
    if (targetType != null && expr.Type != targetType) {
        // 判断是否允许隐式转换
        if (IsImplicitConversionAllowed(expr.Type, targetType)) {
            return Expression.Convert(expr, targetType);
        }
        // 无合法转换时抛出编译错误
        throw new CompileException($"无法将{expr.Type}转换为{targetType}");
    }
    return expr;
}

// 辅助方法：判断是否允许隐式转换
private bool IsImplicitConversionAllowed(Type from, Type to) {
    if (from == typeof(string) && to == typeof(object)) return true;
    return Type.GetTypeCode(from) switch {
        TypeCode.Byte => to == typeof(short) || to == typeof(int) || to == typeof(long) || to == typeof(float) || to == typeof(double) || to == typeof(decimal),
        TypeCode.Int32 => to == typeof(long) || to == typeof(float) || to == typeof(double) || to == typeof(decimal),
        // 补充其他数值类型的隐式转换规则
        _ => to.IsAssignableFrom(from)
    };
}

关键总结 #

• 无需完全硬编码所有规则，但需要基于C#语言规范实现运算符重载决议和隐式转换优先级逻辑；
• 针对字符串拼接这类特殊重载，需单独处理；
• 数值类型提升可通过规范定义的类型优先级来实现，而非零散的硬编码。

内容的提问来源于stack exchange，提问作者weichsem