Optimize playground: extract JS, use file-based examples, remove unused clangd

cs01 · cs01 · commit 804da697c1d3 · 2025-11-25T12:48:11.000-08:00
- Extract JavaScript from HTML to separate playground.js file for better maintainability
- Move all code examples to individual .c files in examples/ directory
- Load examples via fetch() to avoid template literal escaping issues
- Fix initial page load to show default example immediately
- Update UI: smaller, right-aligned compilation timing display
- Remove unused clangd WASM files and LSP worker (42MB savings)
- Optimize CI workflow to only build clang (not clang-tools-extra)
- Update .gitignore to reflect simplified build artifacts
diff --git a/.github/workflows/build-playground.yml b/.github/workflows/build-playground.yml
@@ -42,7 +42,7 @@ jobs:
           cd build-wasm
           emcmake cmake -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
-            -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" \
+            -DLLVM_ENABLE_PROJECTS="clang" \
             -DLLVM_TARGETS_TO_BUILD="WebAssembly" \
             -DLLVM_ENABLE_THREADS=OFF \
             -DLLVM_ENABLE_EH=OFF \
@@ -59,24 +59,20 @@ jobs:
             -DCMAKE_EXE_LINKER_FLAGS="-sEXPORTED_RUNTIME_METHODS=callMain -sEXIT_RUNTIME=0 -sALLOW_MEMORY_GROWTH=1" \
             ../llvm
 
-      - name: Build Null-Safe Clang and clangd WASM
+      - name: Build Null-Safe Clang WASM
         run: |
           cd build-wasm
-          ninja clang clangd
+          ninja clang
 
       - name: Prepare artifacts
         run: |
           mkdir -p artifacts
           cp build-wasm/bin/clang.wasm artifacts/clang-nullsafe.wasm
           cp build-wasm/bin/clang.js artifacts/clang-nullsafe.js
-          cp build-wasm/bin/clangd.wasm artifacts/clangd-nullsafe.wasm
-          cp build-wasm/bin/clangd.js artifacts/clangd-nullsafe.js
 
           # Compress for better download speeds
           gzip -k artifacts/clang-nullsafe.wasm
           gzip -k artifacts/clang-nullsafe.js
-          gzip -k artifacts/clangd-nullsafe.wasm
-          gzip -k artifacts/clangd-nullsafe.js
 
           ls -lh artifacts/
 
@@ -95,20 +91,14 @@ jobs:
             artifacts/clang-nullsafe.js
             artifacts/clang-nullsafe.wasm.gz
             artifacts/clang-nullsafe.js.gz
-            artifacts/clangd-nullsafe.wasm
-            artifacts/clangd-nullsafe.js
-            artifacts/clangd-nullsafe.wasm.gz
-            artifacts/clangd-nullsafe.js.gz
           body: |
             ## Null-Safe Clang Playground WASM Files
 
-            This release contains the WebAssembly build of Null-Safe Clang and clangd for use in the browser playground.
+            This release contains the WebAssembly build of Null-Safe Clang for use in the browser playground.
 
             ### Files:
             - `clang-nullsafe.wasm` - WebAssembly compiler binary (~63MB)
             - `clang-nullsafe.js` - Emscripten JavaScript glue code
-            - `clangd-nullsafe.wasm` - WebAssembly language server binary (~80MB)
-            - `clangd-nullsafe.js` - Emscripten JavaScript glue code for clangd
             - `*.gz` - Compressed versions for faster downloads
 
             ### Usage:
diff --git a/nullsafe-playground/.gitignore b/nullsafe-playground/.gitignore
@@ -1,14 +1,6 @@
 # Generated WASM files (too large to commit, will be built from source or downloaded from releases)
 clang.wasm
 clang.js
-clangd.wasm
-clangd.js
-clang-nullsafe.wasm
-clang-nullsafe.js
-clangd-nullsafe.wasm
-clangd-nullsafe.js
-clang-mainline.wasm
-clang-mainline.js
 
 # Python cache
 __pycache__/
diff --git a/nullsafe-playground/clangd.js b/nullsafe-playground/clangd.js
diff --git a/nullsafe-playground/clangd.wasm b/nullsafe-playground/clangd.wasm
diff --git a/nullsafe-playground/examples/and-pattern.c b/nullsafe-playground/examples/and-pattern.c
@@ -0,0 +1,12 @@
+// AND pattern narrows both operands
+void process(int* p, int* q) {
+    if (p && q) {
+        *p = *q;  // OK - both non-null
+    }
+}
+
+void either_or(int* p, int* q) {
+    if (p || q) {
+        *p = 42;  // warning - p might still be null!
+    }
+}
diff --git a/nullsafe-playground/examples/cjson-escape.c b/nullsafe-playground/examples/cjson-escape.c
@@ -0,0 +1,30 @@
+// From cJSON.c:1019-1027 (print_string_ptr function)
+// https://github.com/DaveGamble/cJSON/blob/c859b25da0/cJSON.c#L1019-L1027
+// Null-safety warning: dereferencing nullable pointer at line 1022
+#define NULL ((void*)0)
+
+typedef unsigned char * output_t;
+
+// Simplified version of actual cJSON code with null-safety warning
+void escape_json_string(const unsigned char *input, output_t output_pointer) {
+    *output_pointer++ = '"';
+
+    // Line 1022: warning on *input_pointer dereference
+    for (const unsigned char *input_pointer = input;
+         *input_pointer != '\0';  // warning: input_pointer might be NULL!
+         (void)input_pointer++, output_pointer++) {
+
+        if ((*input_pointer > 31) && (*input_pointer != '"')) {
+            *output_pointer = *input_pointer;  // warnings here too
+        } else {
+            *output_pointer++ = '\\';
+            *output_pointer = *input_pointer;
+        }
+    }
+    *output_pointer = '"';
+}
+
+void example(void) {
+    unsigned char buf[100];
+    escape_json_string(NULL, buf);  // Crash!
+}
diff --git a/nullsafe-playground/examples/dereference-context.c b/nullsafe-playground/examples/dereference-context.c
@@ -0,0 +1,6 @@
+// Null check required before dereference
+void process(int* data) {
+    if (!data) {
+        // process...
+    }
+}
diff --git a/nullsafe-playground/examples/early-return.c b/nullsafe-playground/examples/early-return.c
@@ -0,0 +1,14 @@
+// Early returns narrow type for rest of function
+void process(char* str) {
+    if (!str) return;  // guard clause
+
+    // str is now proven non-null
+    *str = 'x';  // OK
+}
+
+void multi_guard(char* p, char* q) {
+    if (!p || !q) return;
+
+    // Both p and q are non-null here
+    *p = *q;  // OK
+}
diff --git a/nullsafe-playground/examples/else-branch.c b/nullsafe-playground/examples/else-branch.c
@@ -0,0 +1,15 @@
+// Else branch knows condition was false
+void example(int* data) {
+    if (data) {
+        *data = 42;  // OK
+    } else {
+        *data = 0;  // warning - data is null here!
+    }
+}
+
+void inverted(int* data) {
+    if (!data) {
+        return;
+    }
+    *data = 42;  // OK - data is non-null
+}
diff --git a/nullsafe-playground/examples/function-invalidates.c b/nullsafe-playground/examples/function-invalidates.c
@@ -0,0 +1,9 @@
+// Functions can invalidate narrowing
+void may_modify(int** ptr);
+
+void example(int* data) {
+    if (data) {
+        may_modify(&data);  // might set data to null
+        *data = 42;  // warning - data might be null now!
+    }
+}
diff --git a/nullsafe-playground/examples/loop-narrowing.c b/nullsafe-playground/examples/loop-narrowing.c
@@ -0,0 +1,6 @@
+// Loop conditions narrow the variable
+void process_items(int* items, int count) {
+    for (int i = 0; items && i < count; i++) {
+        items[i] = 0;  // OK - items is non-null in loop
+    }
+}
diff --git a/nullsafe-playground/examples/multi-level.c b/nullsafe-playground/examples/multi-level.c
@@ -0,0 +1,10 @@
+// Multi-level pointers require careful handling
+void deref_twice(int** pp) {
+    **pp = 42;  // warning - *pp might be null!
+}
+
+void safe_deref(int** pp) {
+    if (pp && *pp) {
+        **pp = 42;  // OK
+    }
+}
diff --git a/nullsafe-playground/examples/nonnull-annotation.c b/nullsafe-playground/examples/nonnull-annotation.c
@@ -0,0 +1,9 @@
+// _Nonnull annotations guarantee non-null
+void process(_Nonnull int* data) {
+    *data = 42;  // OK - data is guaranteed non-null
+}
+
+void example(int* _Nullable x, int* _Nonnull y) {
+    process(x);  // warning - passing nullable to nonnull
+    process(y);  // OK
+}
diff --git a/nullsafe-playground/examples/null-check.c b/nullsafe-playground/examples/null-check.c
@@ -0,0 +1,10 @@
+// Flow-sensitive null checking catches bugs at compile-time
+void safe(int* data) {
+    if (data) {
+        *data = 42;  // OK - data is non-null here
+    }
+}
+
+void unsafe(int* data) {
+    *data = 42;  // warning - data might be null!
+}
diff --git a/nullsafe-playground/examples/pure-function.c b/nullsafe-playground/examples/pure-function.c
@@ -0,0 +1,10 @@
+// Pure functions preserve narrowing across calls
+int is_valid(int* ptr) {
+    return ptr != 0;  // Pure function
+}
+
+void example(int* data) {
+    if (is_valid(data)) {
+        *data = 42;  // OK - narrowing preserved
+    }
+}
diff --git a/nullsafe-playground/examples/redis-sds.c b/nullsafe-playground/examples/redis-sds.c
@@ -0,0 +1,20 @@
+// From Redis src/sds.h:113-118 (sdssetlen function)
+// https://github.com/redis/redis/blob/c8e1e833cdab/src/sds.h#L113-L118
+// Null-safety warning: dereferencing nullable pointer at line 118
+
+#define NULL ((void*)0)
+#define SDS_TYPE_5 0
+#define SDS_TYPE_BITS 3
+
+typedef char *sds;
+
+// Actual code from Redis that triggers null-safety warning
+static inline void sdssetlen(sds s, unsigned long newlen) {
+    unsigned char *fp = ((unsigned char*)s)-1;  // warning: s might be NULL!
+    *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);  // Dereferences fp
+}
+
+void example(void) {
+    sds str = NULL;
+    sdssetlen(str, 5);  // Crash! Pointer arithmetic on NULL
+}
diff --git a/nullsafe-playground/favicon.ico b/nullsafe-playground/favicon.ico
@@ -0,0 +1 @@
+data:image/x-icon;base64,AA
diff --git a/nullsafe-playground/index.html b/nullsafe-playground/index.html
diff --git a/nullsafe-playground/lsp-worker.js b/nullsafe-playground/lsp-worker.js
diff --git a/nullsafe-playground/playground.js b/nullsafe-playground/playground.js
