Check if the string is same when optimizing numeric strings

Author: adazem009

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -434,8 +434,15 @@ Compiler::StaticType LLVMBuildUtils::optimizeRegisterType(const LLVMRegister *re
     Compiler::StaticType ret = reg->type();
 
     // Optimize string constants that represent numbers
-    if (reg->isConst() && reg->type() == Compiler::StaticType::String && reg->constValue().isValidNumber())
-        ret = Compiler::StaticType::Number;
+    if (reg->isConst() && reg->type() == Compiler::StaticType::String) {
+        const Value &value = reg->constValue();
+        Value numberValue(value.toDouble());
+
+        // Apply this optimization only if the number matches the string
+        // TODO: Exclude unsafe constants
+        if (value.isValidNumber() && numberValue.toString() == value.toString())
+            ret = Compiler::StaticType::Number;
+    }
 
     return ret;
 }

test/llvm/code_analyzer/list_type_analysis.cpp

@@ -152,6 +152,36 @@ TEST(LLVMCodeAnalyzer_ListTypeAnalysis, StringOptimization_AfterClear)
     ASSERT_EQ(appendList2->targetType, Compiler::StaticType::Number);
 }
 
+TEST(LLVMCodeAnalyzer_ListTypeAnalysis, StringOptimization_AfterClear_DifferentString)
+{
+    LLVMCodeAnalyzer analyzer;
+    LLVMInstructionList list;
+    List targetList("", "");
+
+    auto clearList = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::ClearList, false);
+    clearList->targetList = &targetList;
+    list.addInstruction(clearList);
+
+    auto appendList1 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::AppendToList, false);
+    LLVMConstantRegister value1(Compiler::StaticType::String, "1.0");
+    appendList1->targetList = &targetList;
+    appendList1->args.push_back({ Compiler::StaticType::Unknown, &value1 });
+    list.addInstruction(appendList1);
+
+    auto appendList2 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::AppendToList, false);
+    LLVMConstantRegister value2(Compiler::StaticType::Bool, true);
+    appendList2->targetList = &targetList;
+    appendList2->args.push_back({ Compiler::StaticType::Unknown, &value2 });
+    list.addInstruction(appendList2);
+
+    analyzer.analyzeScript(list);
+
+    ASSERT_EQ(appendList1->targetType, Compiler::StaticType::Void);
+
+    // String "1.0" does NOT get optimized to Number because it would convert to "1"
+    ASSERT_EQ(appendList2->targetType, Compiler::StaticType::String);
+}
+
 TEST(LLVMCodeAnalyzer_ListTypeAnalysis, ClearListOperation)
 {
     LLVMCodeAnalyzer analyzer;

test/llvm/code_analyzer/variable_type_analysis.cpp

@@ -107,6 +107,31 @@ TEST(LLVMCodeAnalyzer_VariableTypeAnalysis, StringOptimization)
     ASSERT_EQ(setVar2->targetType, Compiler::StaticType::Number);
 }
 
+TEST(LLVMCodeAnalyzer_VariableTypeAnalysis, StringOptimization_DifferentString)
+{
+    LLVMCodeAnalyzer analyzer;
+    LLVMInstructionList list;
+    Variable var("", "");
+
+    auto setVar1 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    LLVMConstantRegister value1(Compiler::StaticType::String, "1.0");
+    setVar1->targetVariable = &var;
+    setVar1->args.push_back({ Compiler::StaticType::Unknown, &value1 });
+    list.addInstruction(setVar1);
+
+    auto setVar2 = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::WriteVariable, false);
+    LLVMConstantRegister value2(Compiler::StaticType::Bool, true);
+    setVar2->targetVariable = &var;
+    setVar2->args.push_back({ Compiler::StaticType::Unknown, &value2 });
+    list.addInstruction(setVar2);
+
+    analyzer.analyzeScript(list);
+
+    ASSERT_EQ(setVar1->targetType, Compiler::StaticType::Unknown);
+    // String "1.0" does NOT get optimized to Number because it would convert to "1"
+    ASSERT_EQ(setVar2->targetType, Compiler::StaticType::String);
+}
+
 TEST(LLVMCodeAnalyzer_VariableTypeAnalysis, LoopSingleWrite)
 {
     LLVMCodeAnalyzer analyzer;