fix(ci): separate non-sanitized binary for valgrind and fix parse-error leaks

.github/workflows/ci.yml

@@ -74,13 +74,15 @@ jobs:
       - name: Build Brainrot
         run: |
           make
+          make brainrot-valgrind
 
       - name: Upload build artifacts
         uses: actions/upload-artifact@v7
         with:
           name: brainrot
           path: |
             brainrot
+            brainrot-valgrind
             libstdrot.so
 
   test:
@@ -98,7 +100,7 @@ jobs:
           path: .
 
       - name: Grant execute permissions to Brainrot
-        run: chmod +x brainrot
+        run: chmod +x brainrot brainrot-valgrind
 
       - name: Prepare shared library for tests
         run: |

.gitignore

@@ -1,5 +1,6 @@
 .vscode
 brainrot
+brainrot-valgrind
 lang.tab.c
 lang.tab.h
 lex.yy.c

CONTRIBUTING.md

@@ -39,15 +39,16 @@ make test
 
 ### Running Memory Leak Tests
 
-Make `run_valgrind_tests.sh` executable:
+Memory leak tests are run using Valgrind against the non-sanitized binary (`brainrot-valgrind`):
 
 ```bash
-sudo chmod +x run_valgrind_tests.sh
+make valgrind
 ```
 
-Run:
+Alternatively, make `run_valgrind_tests.sh` executable and run it directly (defaults to `./brainrot-valgrind`):
 
 ```bash
+chmod +x run_valgrind_tests.sh
 ./run_valgrind_tests.sh
 ```
 

Makefile

@@ -6,7 +6,9 @@ PYTHON := python3
 EMCC := emcc
 
 # Compiler and linker flags
-CFLAGS := -Wall -Wextra -Wpedantic -Werror -O2 -Wuninitialized -fsanitize=address,undefined -fno-omit-frame-pointer -g
+SANITIZER_FLAGS := -fsanitize=address,undefined
+CFLAGS := -Wall -Wextra -Wpedantic -Werror -O2 -Wuninitialized $(SANITIZER_FLAGS) -fno-omit-frame-pointer -g
+VALGRIND_CFLAGS := $(filter-out $(SANITIZER_FLAGS),$(CFLAGS))
 LDFLAGS := -lfl -lm -ldl -rdynamic
 SO_CFLAGS := -fPIC -shared
 
@@ -24,6 +26,7 @@ STDROT_LIB := libstdrot.so
 
 # Output files
 TARGET := brainrot
+VALGRIND_TARGET := brainrot-valgrind
 BISON_OUTPUT := lang.tab.c
 FLEX_OUTPUT := lex.yy.c
 
@@ -91,6 +94,11 @@ $(TARGET): $(ALL_SRCS) $(STDROT_LIB)
 	$(CC) $(CFLAGS) -o $@ $(ALL_SRCS) $(LDFLAGS)
 	@echo "Skibidi toilet: $(TARGET) compiled with max gyatt."
 
+# Valgrind executable build (built without ASan/UBSan for Valgrind compatibility)
+$(VALGRIND_TARGET): $(ALL_SRCS) $(STDROT_LIB)
+	$(CC) $(VALGRIND_CFLAGS) -o $@ $(ALL_SRCS) $(LDFLAGS)
+	@echo "brainrot-valgrind compiled without sanitizers."
+
 # WebAssembly build: stdrot sources go straight into the same binary
 # instead of a separate $(STDROT_LIB), so this does NOT depend on it.
 .PHONY: wasm
@@ -118,15 +126,15 @@ test: ensure-stdrot $(TARGET)
 # Clean build artifacts
 .PHONY: clean
 clean:
-	rm -f $(TARGET) $(STDROT_LIB) $(GENERATED_SRCS) lang.tab.h
+	rm -f $(TARGET) $(VALGRIND_TARGET) $(STDROT_LIB) $(GENERATED_SRCS) lang.tab.h
 	rm -f $(WASM_TARGET) $(WASM_JS)
 	rm -f *.o
 	@echo "Blud cleaned up the mess like a true sigma coder."
 
 # Run Valgrind on all .brainrot tests
 .PHONY: valgrind
-valgrind: ensure-stdrot $(TARGET)
-	@./run_valgrind_tests.sh
+valgrind: ensure-stdrot $(VALGRIND_TARGET)
+	@./run_valgrind_tests.sh ./$(VALGRIND_TARGET)
 	@echo "Valgrind check done. If anything was sus, it'll show up with a non-zero exit code. No cap."
 
 # Install target

lang.y

@@ -70,6 +70,10 @@ static Interpreter *global_interpreter = NULL;
     EnumConstant *econst;
 }
 
+/* Free heap-allocated strings when bison discards symbols during parse error recovery */
+%destructor { SAFE_FREE($$.data); } <strval>
+%destructor { SAFE_FREE($$.name.data); } <declarator>
+
 /* Define token types */
 %token SKIBIDI RIZZ YAP BAKA MAIN BUSSIN FLEX CAP RANT
 %token PLUS MINUS TIMES DIVIDE MOD SEMICOLON COLON COMMA
@@ -242,13 +246,10 @@ struct_field
                (sizeof(uintptr_t)) doesn't depend on the pointee being
                complete yet.
 
-               Note: we deliberately don't YYABORT here. Aborting mid-way
-               through the still-open outer struct_def rule would strand
-               that rule's own pending IDENTIFIER token on the parser value
-               stack un-freed (this grammar has no %destructor entries), so
-               instead we record the error and let parsing finish normally;
-               main() checks struct_def_had_error after yyparse() and exits
-               the same way it does for a hard parse failure. */
+               Note: we deliberately don't YYABORT here. Finishing the outer
+               struct_def rule keeps struct_def_had_error and the partially
+               computed layout coherent; main() checks the flag after
+               yyparse() and exits as it does for a hard parse failure. */
             bool is_self = current_struct_def_name.data &&
                           strcmp($2.data, current_struct_def_name.data) == 0;
             if (is_self && $3.pointer_level == 0)

run_valgrind_tests.sh

@@ -1,32 +1,54 @@
 #!/bin/bash
 
+TARGET="${1:-./brainrot-valgrind}"
+
+if ! command -v valgrind >/dev/null 2>&1; then
+    echo "Error: valgrind is not installed or not in PATH" >&2
+    exit 1
+fi
+
+if [[ ! -x "$TARGET" ]]; then
+    echo "Error: Valgrind target '$TARGET' is not executable" >&2
+    exit 1
+fi
+
 for f in test_cases/*.brainrot; do
     echo "Running Valgrind on $f..."
     base=$(basename "$f" .brainrot)
 
     case "$base" in
-        slorp_int)    input="42" ;;
-        slorp_short)  input="69" ;;
-        slorp_float)  input="3.14" ;;
-        slorp_double) input="3.141592" ;;
-        slorp_char)   input="c" ;;
-        slorp_string) input="skibidi bop bop yes yes" ;;
-        *)            input="" ;;
+        slorp_int)               input="42" ;;
+        slorp_short)             input="69" ;;
+        slorp_float)             input="3.14" ;;
+        slorp_double)            input="3.141592" ;;
+        slorp_char)              input="c" ;;
+        slorp_string)            input="skibidi bop bop yes yes" ;;
+        native_call_self_init)   input="42" ;;
+        native_call_loop)        input=$'1\n2\n3' ;;
+        native_call_string_arg)  input=$'skibidi\nq' ;;
+        native_call_do_while)    input=$'5\n50\n6\n150' ;;
+        *)                       input="" ;;
     esac
 
     if [[ -n "$input" ]]; then
-        echo "$input" | valgrind --leak-check=full --error-exitcode=100 ./brainrot "$f"
+        echo "$input" | valgrind --leak-check=full --error-exitcode=100 "$TARGET" "$f"
     else
-        valgrind --track-origins=yes --leak-check=full --error-exitcode=100 ./brainrot "$f"
+        valgrind --leak-check=full --error-exitcode=100 "$TARGET" "$f"
     fi
 
     valgrind_exit_code=$?  # Capture only valgrind’s exit code
 
-    if [[ $valgrind_exit_code -eq 100 ]]; then
-        echo "Valgrind detected memory issues in $f"
-        exit 1
-    fi
+    case $valgrind_exit_code in
+        0|1) ;;
+        100)
+            echo "Valgrind detected memory issues in $f" >&2
+            exit 1
+            ;;
+        *)
+            echo "Valgrind failed while running $f (exit $valgrind_exit_code)" >&2
+            exit 1
+            ;;
+    esac
 
     echo
 done
-