Fix.

Author: csyonghe

source/slang/slang-check-constraint.cpp

@@ -573,10 +573,13 @@ DeclRef<Decl> SemanticsVisitor::trySolveConstraintSystem(
             }
             auto& types = solvedArgs[typeParam->parameterIndex].types;
             // Fail if any of the resolved type element is empty.
-            for (auto t : types)
+            for (auto& t : types)
             {
                 if (!t)
                     return DeclRef<Decl>();
+                // If the resolved type is an integer literal type, we should use its proper type.
+                if (auto litType = as<IntLiteralType>(t))
+                    t = litType->getProperType();
             }
             if (!isPack)
             {

source/slang/slang-check-conversion.cpp

@@ -1439,6 +1439,7 @@ bool SemanticsVisitor::_coerce(
                 outCost,
                 fromExpr ? fromExpr->loc : SourceLoc());
         }
+        fromType = fromIntLitType->getProperType();
     }
 
     // A enum type can be converted into its underlying tag type.

source/slang/slang-check-expr.cpp

@@ -2941,6 +2941,7 @@ Expr* SemanticsExprVisitor::convertToLogicOperatorExpr(InvokeExpr* expr)
             bool shortCircuitSupport = true;
             for (auto& arg : expr->arguments)
             {
+                arg = maybeCoerceExprToProperIntType(arg);
                 if (!as<BasicExpressionType>(arg->type.type))
                 {
                     shortCircuitSupport = false;
@@ -3020,13 +3021,15 @@ Expr* SemanticsExprVisitor::visitInvokeExpr(InvokeExpr* expr)
     {
         arg = CheckExpr(arg);
     }
-    if (auto result = tryFoldLiteralNegateExpr(expr))
-        return result;
+
     // if the expression is '&&' or '||', we will convert it
     // to use short-circuit evaluation.
     if (auto newExpr = convertToLogicOperatorExpr(expr))
         return newExpr;
 
+    if (auto result = tryFoldLiteralNegateExpr(expr))
+        return result;
+
     expr->functionExpr = CheckTerm(expr->functionExpr);
 
     if (auto baseType = as<DeclRefType>(expr->functionExpr->type))
@@ -4955,6 +4958,20 @@ Expr* SemanticsVisitor::checkGeneralMemberLookupExpr(MemberExpr* expr, Type* bas
     return createLookupResultExpr(expr->name, lookupResult, expr->baseExpression, expr->loc, expr);
 }
 
+bool isValidVectorSwizzleName(Name* name)
+{
+    if (!name)
+        return false;
+    if (name->text.getLength() > 4 || name->text.getLength() == 0)
+        return false;
+    for (auto ch : name->text)
+    {
+        if (ch < 'w' || ch > 'z')
+            return false;
+    }
+    return true;
+}
+
 Expr* SemanticsExprVisitor::visitMemberExpr(MemberExpr* expr)
 {
     bool needDeref = false;
@@ -4996,15 +5013,21 @@ Expr* SemanticsExprVisitor::visitMemberExpr(MemberExpr* expr)
     }
     if (auto baseVecType = as<VectorExpressionType>(baseType))
     {
-        return CheckSwizzleExpr(
-            expr,
-            baseVecType->getElementType(),
-            baseVecType->getElementCount());
+        if (isValidVectorSwizzleName(expr->name))
+        {
+            return CheckSwizzleExpr(
+                expr,
+                baseVecType->getElementType(),
+                baseVecType->getElementCount());
+        }
     }
-    else if (auto baseScalarType = as<BasicExpressionType>(baseType))
+    if (auto baseScalarType = as<BasicExpressionType>(baseType))
     {
-        // Treat scalar like a 1-element vector when swizzling
-        return CheckSwizzleExpr(expr, baseScalarType, 1);
+        if (isValidVectorSwizzleName(expr->name))
+        {
+            // Treat scalar like a 1-element vector when swizzling
+            return CheckSwizzleExpr(expr, baseScalarType, 1);
+        }
     }
     else if (as<NamespaceType>(baseType))
     {