fix: integer overflow in Complexity analysis

cmake/SouffleTests.cmake

@@ -388,3 +388,9 @@ function(SOUFFLE_POSITIVE_MULTI_TEST)
                          FACTS_DIR_NAME ${FACTS_DIR_NAME})
     endforeach()
 endfunction()
+
+function(SOUFFLE_POSITIVE_FUNCTOR_TEST TEST_NAME)
+        souffle_run_test_helper(TEST_NAME ${TEST_NAME} FUNCTORS ${ARGN})
+        souffle_run_test_helper(TEST_NAME ${TEST_NAME} COMPILED FUNCTORS ${ARGN})
+        souffle_run_test_helper(TEST_NAME ${TEST_NAME} COMPILED_SPLITTED FUNCTORS ${ARGN})
+endfunction()

src/ram/analysis/Complexity.cpp

@@ -29,6 +29,8 @@
 
 namespace souffle::ram::analysis {
 
+static const int MAX_COMPLEXITY = std::numeric_limits<int>::max();
+
 int ComplexityAnalysis::getComplexity(const Node* node) const {
     // visitor
     class ValueComplexityVisitor : public Visitor<int> {
@@ -39,7 +41,12 @@ int ComplexityAnalysis::getComplexity(const Node* node) const {
 
         // conjunction
         int visit_(type_identity<Conjunction>, const Conjunction& conj) override {
-            return dispatch(conj.getLHS()) + dispatch(conj.getRHS());
+            const int cl = dispatch(conj.getLHS());
+            const int cr = dispatch(conj.getRHS());
+            if (cl == MAX_COMPLEXITY || cr == MAX_COMPLEXITY) {
+                return MAX_COMPLEXITY;
+            }
+            return cl + cr;
         }
 
         // negation
@@ -58,11 +65,16 @@ int ComplexityAnalysis::getComplexity(const Node* node) const {
         }
 
         int visit_(type_identity<Constraint>, const Constraint& c) override {
-            return dispatch(c.getLHS()) + dispatch(c.getRHS());
+            const int cl = dispatch(c.getLHS());
+            const int cr = dispatch(c.getRHS());
+            if (cl == MAX_COMPLEXITY || cr == MAX_COMPLEXITY) {
+                return MAX_COMPLEXITY;
+            }
+            return cl + cr;
         }
 
         int visit_(type_identity<UserDefinedOperator>, const UserDefinedOperator&) override {
-            return std::numeric_limits<int>::max();
+            return MAX_COMPLEXITY;
         }
 
         // emptiness check
@@ -74,7 +86,13 @@ int ComplexityAnalysis::getComplexity(const Node* node) const {
         int visit_(type_identity<AbstractOperator>, const AbstractOperator& op) override {
             int exprComplexity = 0;
             for (auto* expr : op.getArguments()) {
-                exprComplexity += dispatch(*expr);
+                const int complexity = dispatch(*expr);
+                if (complexity == MAX_COMPLEXITY) {
+                    exprComplexity = MAX_COMPLEXITY;
+                    break;
+                } else {
+                    exprComplexity += dispatch(*expr);
+                }
             }
             return exprComplexity;
         }

tests/evaluation/CMakeLists.txt

@@ -168,3 +168,6 @@ positive_test(unsigned_operations)
 positive_test(unused_constraints)
 positive_test(x9)
 positive_test(issue2160)
+
+add_subdirectory(issue2508)
+souffle_positive_functor_test(issue2508 CATEGORY evaluation)

tests/evaluation/issue2508/B.csv

@@ -0,0 +1 @@
+()

tests/evaluation/issue2508/C.csv

@@ -0,0 +1 @@
+()

tests/evaluation/issue2508/CMakeLists.txt

@@ -0,0 +1,28 @@
+# Souffle - A Datalog Compiler
+# Copyright (c) 2022 The Souffle Developers. All rights reserved
+# Licensed under the Universal Permissive License v 1.0 as shown at:
+# - https://opensource.org/licenses/UPL
+# - <souffle root>/licenses/SOUFFLE-UPL.txt
+
+add_library(issue2508 SHARED functors.cpp)
+target_include_directories(issue2508 PRIVATE "${CMAKE_SOURCE_DIR}/src/include")
+
+target_compile_features(issue2508
+                        PUBLIC cxx_std_17)
+
+set_target_properties(issue2508 PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(issue2508 PROPERTIES OUTPUT_NAME "functors")
+set_target_properties(issue2508 PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+if (WIN32)
+  # Prefix all shared libraries with 'lib'.
+  set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
+
+  # Prefix all static libraries with 'lib'.
+  set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
+endif ()
+
+if (SOUFFLE_DOMAIN_64BIT)
+    target_compile_definitions(issue2508
+                               PUBLIC RAM_DOMAIN_SIZE=64)
+endif()

tests/evaluation/issue2508/functors.cpp

@@ -0,0 +1,16 @@
+#include "souffle/RecordTable.h"
+#include "souffle/SymbolTable.h"
+
+extern "C" {
+
+souffle::RamDomain id(
+        souffle::SymbolTable* symbolTable, souffle::RecordTable* recordTable, souffle::RamDomain x) {
+    return x;
+}
+
+souffle::RamDomain decode(
+        souffle::SymbolTable* symbolTable, souffle::RecordTable* recordTable, souffle::RamDomain x) {
+    symbolTable->decode(x);
+    return x;
+}
+}

tests/evaluation/issue2508/issue2508.dl

@@ -0,0 +1,22 @@
+.functor id(symbol): symbol stateful
+.functor decode(symbol): symbol stateful
+
+.type T = C1 {A0 : symbol} | C2 {A0: number}
+
+.decl A(A2: T)
+.decl B()
+.output B()
+.decl C()
+.output C()
+
+A($C2(10000000)).
+A($C1("X")).
+A($C1("Y")).
+
+B() :-
+  A($C1(X)),
+  (@decode(X) = @id("Y")).
+
+C() :-
+  A($C2(_)).
+

tests/interface/CMakeLists.txt

@@ -13,13 +13,6 @@ add_subdirectory(lattice1)
 add_subdirectory(lattice2)
 add_subdirectory(lattice3)
 
-# swig test which will run python, java or both
-function(SOUFFLE_POSITIVE_FUNCTOR_TEST TEST_NAME)
-        souffle_run_test_helper(TEST_NAME ${TEST_NAME} FUNCTORS ${ARGN})
-        souffle_run_test_helper(TEST_NAME ${TEST_NAME} COMPILED FUNCTORS ${ARGN})
-        souffle_run_test_helper(TEST_NAME ${TEST_NAME} COMPILED_SPLITTED FUNCTORS ${ARGN})
-endfunction()
-
 function(SOUFFLE_RUN_CPP_TEST)
     cmake_parse_arguments(
         PARAM

tests/semantic/CMakeLists.txt

@@ -27,11 +27,6 @@ function(negative_test NAME)
     souffle_negative_test(${NAME} semantic)
 endfunction()
 
-function(SOUFFLE_POSITIVE_FUNCTOR_TEST TEST_NAME)
-        souffle_run_test_helper(TEST_NAME ${TEST_NAME} FUNCTORS ${ARGN})
-        souffle_run_test_helper(TEST_NAME ${TEST_NAME} COMPILED FUNCTORS ${ARGN})
-endfunction()
-
 negative_test(adt_invalid_arity)
 negative_test(adt_invalid_branch)
 negative_test(agg_checks)