wip: int literal type coercion.

Author: csyonghe

source/compiler-core/slang-lexer.cpp

@@ -678,22 +678,22 @@ IntegerLiteralValue getIntegerLiteralValue(
     UnownedStringSlice* outSuffix,
     bool* outIsDecimalBase)
 {
-    IntegerLiteralValue value = 0;
+    uint64_t value = 0;
 
     const UnownedStringSlice content = token.getContent();
 
     char const* cursor = content.begin();
     char const* end = content.end();
 
-    int base = _readOptionalBase(&cursor);
+    uint32_t base = _readOptionalBase(&cursor);
 
     for (;;)
     {
-        int digit = _maybeReadDigit(&cursor, base);
+        int32_t digit = _maybeReadDigit(&cursor, base);
         if (digit < 0)
             break;
 
-        value = value * base + digit;
+        value = value * base + (uint32_t)digit;
     }
 
     if (outSuffix)
@@ -706,7 +706,7 @@ IntegerLiteralValue getIntegerLiteralValue(
         *outIsDecimalBase = (base == 10);
     }
 
-    return value;
+    return (IntegerLiteralValue)value;
 }
 
 FloatingPointLiteralValue getFloatingPointLiteralValue(

source/slang/hlsl.meta.slang.temp.h

@@ -301,6 +301,11 @@ Type* ASTBuilder::getSpecializedBuiltinType(ArrayView<Val*> genericArgs, const c
     return rsType;
 }
 
+IntLiteralType* ASTBuilder::getIntLiteralType(ConstantIntVal* val)
+{
+    return getOrCreate<IntLiteralType>(val);
+}
+
 PtrType* ASTBuilder::getPtrType(Type* valueType, AddressSpace addrSpace)
 {
     return dynamicCast<PtrType>(getPtrType(valueType, addrSpace, "PtrType"));

source/slang/slang-ast-builder.cpp

@@ -499,6 +499,9 @@ class ASTBuilder : public RefObject
     Type* getNoneType() { return m_sharedASTBuilder->getNoneType(); }
     Type* getEnumTypeType() { return m_sharedASTBuilder->getEnumTypeType(); }
     Type* getDiffInterfaceType() { return m_sharedASTBuilder->getDiffInterfaceType(); }
+
+    IntLiteralType* getIntLiteralType(ConstantIntVal* val);
+
     // Construct the type `Ptr<valueType>`, where `Ptr`
     // is looked up as a builtin type.
     PtrType* getPtrType(Type* valueType, AddressSpace addrSpace);

source/slang/slang-ast-builder.h

@@ -93,6 +93,7 @@ class IntegerLiteralExpr : public LiteralExpr
     SLANG_AST_CLASS(IntegerLiteralExpr)
 
     IntegerLiteralValue value;
+    bool isSigned = false;
 };
 
 class FloatingPointLiteralExpr : public LiteralExpr

source/slang/slang-ast-expr.h

@@ -78,6 +78,22 @@ Type* InitializerListType::_createCanonicalTypeOverride()
     return this;
 }
 
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! IntLiteralType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+Type* IntLiteralType::getProperType()
+{
+    return getValue()->getType();
+}
+
+void IntLiteralType::_toTextOverride(StringBuilder& out)
+{
+    out << toSlice("int-literal");
+}
+
+Type* IntLiteralType::_createCanonicalTypeOverride()
+{
+    return this;
+}
+
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ErrorType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 void ErrorType::_toTextOverride(StringBuilder& out)

source/slang/slang-ast-type.cpp

@@ -30,6 +30,20 @@ class InitializerListType : public Type
     Type* _createCanonicalTypeOverride();
 };
 
+// The type of a known int literal that can be coerced to different integer types.
+class IntLiteralType : public Type
+{
+    SLANG_AST_CLASS(IntLiteralType)
+
+    ConstantIntVal* getValue() { return as<ConstantIntVal>(getOperand(0)); }
+    Type* getProperType();
+    IntLiteralType(ConstantIntVal* value) { setOperands(value); }
+
+    // Overrides should be public so base classes can access
+    void _toTextOverride(StringBuilder& out);
+    Type* _createCanonicalTypeOverride();
+};
+
 // The type of an expression that was erroneous
 class ErrorType : public Type
 {

source/slang/slang-ast-type.h

@@ -59,7 +59,7 @@ namespace Slang
 Type* SemanticsVisitor::TryJoinVectorAndScalarType(
     ConstraintSystem* constraints,
     VectorExpressionType* vectorType,
-    BasicExpressionType* scalarType)
+    Type* scalarType)
 {
     // Join( vector<T,N>, S ) -> vetor<Join(T,S), N>
     //
@@ -232,13 +232,18 @@ Type* SemanticsVisitor::TryJoinTypes(ConstraintSystem* constraints, QualType lef
     if (left->equals(right))
         return left;
 
+    auto leftBasic = as<BasicExpressionType>(left);
+    auto leftLit = as<IntLiteralType>(left);
+    auto rightBasic = as<BasicExpressionType>(right);
+    auto rightLit = as<IntLiteralType>(right);
+
     // We can join two basic types by picking the "better" of the two
-    if (auto leftBasic = as<BasicExpressionType>(left))
+    if (leftBasic || leftLit)
     {
-        if (auto rightBasic = as<BasicExpressionType>(right))
+        if (rightBasic || rightLit)
         {
-            auto costConvertRightToLeft = getConversionCost(leftBasic, right);
-            auto costConvertLeftToRight = getConversionCost(rightBasic, left);
+            auto costConvertRightToLeft = getConversionCost(left, right);
+            auto costConvertLeftToRight = getConversionCost(right, left);
 
             // Return the one that had lower conversion cost.
             if (costConvertRightToLeft > costConvertLeftToRight)
@@ -252,7 +257,7 @@ Type* SemanticsVisitor::TryJoinTypes(ConstraintSystem* constraints, QualType lef
         // We can also join a vector and a scalar
         if (auto rightVector = as<VectorExpressionType>(right))
         {
-            return TryJoinVectorAndScalarType(constraints, rightVector, leftBasic);
+            return TryJoinVectorAndScalarType(constraints, rightVector, left);
         }
     }
 
@@ -278,12 +283,18 @@ Type* SemanticsVisitor::TryJoinTypes(ConstraintSystem* constraints, QualType lef
         }
 
         // We can also join a vector and a scalar
-        if (auto rightBasic = as<BasicExpressionType>(right))
+        if (rightBasic || rightLit)
         {
-            return TryJoinVectorAndScalarType(constraints, leftVector, rightBasic);
+            return TryJoinVectorAndScalarType(constraints, leftVector, right);
         }
+    
     }
 
+    if (leftLit)
+        left = leftLit->getProperType();
+    if (rightLit)
+        right = rightLit->getProperType();
+
     // HACK: trying to work trait types in here...
     if (auto leftDeclRefType = as<DeclRefType>(left))
     {

source/slang/slang-check-constraint.cpp

@@ -1089,6 +1089,109 @@ ConversionCost SemanticsVisitor::getImplicitConversionCostWithKnownArg(
     return candidateCost;
 }
 
+bool SemanticsVisitor::coerceIntLitToBaseType(
+    IntLiteralType* fromType,
+    BasicExpressionType* toType,
+    Expr** outToExpr,
+    ConversionCost* outCost,
+    SourceLoc loc)
+{
+    if (toType->getBaseType() == BaseType::Void)
+        return false;
+
+    ConstantIntVal* value = fromType->getValue();
+    ConversionCost cost = 0;
+    if (!isIntValueInRangeOfType(value->getValue(), toType))
+    {
+        switch (toType->getBaseType())
+        {
+        case BaseType::Half:
+            cost = kConversionCost_IntegerToHalfConversion;
+            break;
+        case BaseType::Float:
+        case BaseType::Double:
+            cost = kConversionCost_IntegerToFloatConversion;
+            break;
+        default:
+            cost = kConversionCost_IntegerTruncate;
+            break;
+        }
+    }
+    else
+    {
+        if (toType != fromType->getProperType())
+        {
+            switch (toType->getBaseType())
+            {
+            case BaseType::UInt:
+            case BaseType::UInt16:
+            case BaseType::UInt8:
+                cost = kConversionCost_InRangeIntLitSignedToUnsignedConversion;
+                break;
+            default:
+                cost = kConversionCost_InRangeIntLitConversion;
+                break;
+            }
+        }
+    }
+    if (outCost)
+        *outCost = cost;
+    if (outToExpr)
+    {
+        switch (toType->getBaseType())
+        {
+        case BaseType::Half:
+        case BaseType::Float:
+        case BaseType::Double:
+            {
+                auto floatLit = m_astBuilder->create<FloatingPointLiteralExpr>();
+                floatLit->loc = loc;
+                floatLit->type = QualType(toType);
+                floatLit->value = (FloatingPointLiteralValue)value->getValue();
+                *outToExpr = floatLit;
+            }
+            break;
+        default:
+            {
+                auto intLit = m_astBuilder->create<IntegerLiteralExpr>();
+                intLit->loc = loc;
+                intLit->type = QualType(toType);
+                intLit->value =
+                    _fixIntegerLiteral(toType->getBaseType(), value->getValue(), nullptr, nullptr);
+                *outToExpr = intLit;
+            }
+            break;
+        }
+    }
+    return true;
+}
+
+Expr* SemanticsVisitor::maybeCoerceExprToProperIntType(Expr* expr)
+{
+    auto intLitExpr = as<IntegerLiteralExpr>(expr);
+    if (!intLitExpr)
+    {
+        SLANG_ASSERT(!as<IntLiteralType>(expr->type.type));
+        return expr;
+    }
+    auto intLitType = as<IntLiteralType>(expr->type.type);
+    expr->type.type = intLitType->getProperType();
+    return expr;
+}
+
+BasicExpressionType* SemanticsVisitor::getProperTypeForIntLit(IntegerLiteralValue value, bool isSigned)
+{
+    if (value >= std::numeric_limits<int32_t>::min() &&
+        value <= std::numeric_limits<int32_t>::max())
+        return (BasicExpressionType*)m_astBuilder->getBuiltinType(BaseType::Int);
+    if (value >= std::numeric_limits<uint32_t>::min() &&
+        value <= std::numeric_limits<uint32_t>::max())
+        return (BasicExpressionType*)m_astBuilder->getBuiltinType(BaseType::UInt);
+    if (isSigned || value >= 0 && value <= std::numeric_limits<int64_t>::max())
+        return (BasicExpressionType*)m_astBuilder->getBuiltinType(BaseType::Int64);
+    return (BasicExpressionType*)m_astBuilder->getBuiltinType(BaseType::UInt64);
+}
+
 bool SemanticsVisitor::_coerce(
     CoercionSite site,
     Type* toType,
@@ -1315,6 +1418,25 @@ bool SemanticsVisitor::_coerce(
         return true;
     }
 
+    if (auto fromIntLitType = as<IntLiteralType>(fromType))
+    {
+        auto toBasicType = as<BasicExpressionType>(toType);
+        if (!toBasicType)
+        {
+            if (auto toLitType = as<IntLiteralType>(toType))
+                toBasicType = (BasicExpressionType*)toLitType->getProperType();
+        }
+        if (toBasicType)
+        {
+            return coerceIntLitToBaseType(
+                fromIntLitType,
+                toBasicType,
+                outToExpr,
+                outCost,
+                fromExpr ? fromExpr->loc : SourceLoc());
+        }
+    }
+
     // A enum type can be converted into its underlying tag type.
     if (auto enumDecl = isEnumType(fromType))
     {
@@ -1671,8 +1793,7 @@ bool SemanticsVisitor::_coerce(
             }
             else if (cost >= kConversionCost_Default)
             {
-                // For general types of implicit conversions, we issue a warning, unless `fromExpr`
-                // is a known constant and we know it won't cause a problem.
+                // For general types of implicit conversions, we issue a warning.
                 bool shouldEmitGeneralWarning = true;
                 if (isScalarIntegerType(toType) || isHalfType(toType))
                 {