From 3f00e8dcc82bc3076aa3ddd1d6e4dcb3377f351a Mon Sep 17 00:00:00 2001 From: Bill Date: Tue, 17 Feb 2026 09:43:08 -0700 Subject: [PATCH] Step 541: add Rust/Go constructive edit adapter --- editor/CMakeLists.txt | 9 ++ editor/src/RustGoConstructiveEditAdapter.h | 91 +++++++++++++++ editor/tests/step541_test.cpp | 127 +++++++++++++++++++++ progress.md | 34 ++++++ 4 files changed, 261 insertions(+) create mode 100644 editor/src/RustGoConstructiveEditAdapter.h create mode 100644 editor/tests/step541_test.cpp diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index 29603f5..e725810 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -3748,4 +3748,13 @@ target_link_libraries(step540_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step541_test tests/step541_test.cpp) +target_include_directories(step541_test PRIVATE src) +target_link_libraries(step541_test PRIVATE + nlohmann_json::nlohmann_json + unofficial::tree-sitter::tree-sitter + tree_sitter_python tree_sitter_cpp tree_sitter_elisp + tree_sitter_javascript tree_sitter_typescript + tree_sitter_java tree_sitter_rust tree_sitter_go) + # Step 12: Dear ImGui shell scaffolding created (main.cpp exists but not built due to dependencies) diff --git a/editor/src/RustGoConstructiveEditAdapter.h b/editor/src/RustGoConstructiveEditAdapter.h new file mode 100644 index 0000000..9d7f8ce --- /dev/null +++ b/editor/src/RustGoConstructiveEditAdapter.h @@ -0,0 +1,91 @@ +#pragma once +// Step 541: Rust/Go Constructive Edit Adapter + +#include +#include +#include + +struct RustGoConstructiveEditRequest { + std::string language; // rust/go + std::string constructKind; // function/struct/impl/import/channel/borrow_region + std::string operation; + bool borrowOrLifetimeRisk = false; + bool concurrencyRisk = false; +}; + +struct RustGoConstructiveEditResult { + bool supported = false; + bool allowed = false; + std::vector legalOperations; + std::vector diagnostics; +}; + +class RustGoConstructiveEditAdapter { +public: + static RustGoConstructiveEditResult evaluate(const RustGoConstructiveEditRequest& request) { + RustGoConstructiveEditResult result; + if (request.language != "rust" && request.language != "go") { + result.diagnostics.push_back("unsupported_language"); + return result; + } + + result.supported = true; + result.legalOperations = legalOps(request.constructKind); + if (result.legalOperations.empty()) { + result.supported = false; + result.diagnostics.push_back("unsupported_construct"); + return result; + } + + if (!contains(result.legalOperations, request.operation)) { + result.diagnostics.push_back("operation_not_legal_for_construct"); + return result; + } + + auto guard = safetyGuard(request); + if (!guard.empty()) { + result.diagnostics.push_back(guard); + return result; + } + + result.allowed = true; + return result; + } + +private: + static std::vector legalOps(const std::string& kind) { + if (kind == "function") return {"rename", "update", "extract"}; + if (kind == "struct") return {"rename", "update"}; + if (kind == "impl") return {"update", "extract"}; + if (kind == "import") return {"insert", "delete", "reorder"}; + if (kind == "channel") return {"update", "extract"}; + if (kind == "borrow_region") return {"update", "extract"}; + return {}; + } + + static std::string safetyGuard(const RustGoConstructiveEditRequest& request) { + if (request.language == "rust" && request.borrowOrLifetimeRisk) { + if (request.constructKind == "borrow_region" && request.operation == "extract") { + return "rust_borrow_lifetime_extract_blocked"; + } + if (request.constructKind == "struct" && request.operation == "rename") { + return "rust_lifetime_sensitive_rename_blocked"; + } + } + + if (request.language == "go" && request.concurrencyRisk) { + if (request.constructKind == "channel" && request.operation == "extract") { + return "go_concurrency_extract_blocked"; + } + if (request.constructKind == "function" && request.operation == "update") { + return "go_concurrency_update_blocked"; + } + } + return ""; + } + + static bool contains(const std::vector& values, + const std::string& value) { + return std::set(values.begin(), values.end()).count(value) != 0; + } +}; diff --git a/editor/tests/step541_test.cpp b/editor/tests/step541_test.cpp new file mode 100644 index 0000000..79ee062 --- /dev/null +++ b/editor/tests/step541_test.cpp @@ -0,0 +1,127 @@ +// Step 541: Rust/Go Constructive Edit Adapter (12 tests) + +#include "RustGoConstructiveEditAdapter.h" + +#include + +static int passed = 0, failed = 0; +#define TEST(name) { std::cout << " " << #name << "... "; } +#define PASS() { std::cout << "PASS\n"; ++passed; } +#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; } +#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {} + +static bool hasDiag(const RustGoConstructiveEditResult& r, const std::string& d) { + for (const auto& x : r.diagnostics) if (x == d) return true; + return false; +} + +void test_rust_function_rename_allowed() { + TEST(rust_function_rename_allowed); + auto r = RustGoConstructiveEditAdapter::evaluate({"rust", "function", "rename", false, false}); + CHECK(r.supported && r.allowed, "rust function rename should be allowed"); + PASS(); +} + +void test_rust_borrow_region_extract_blocked_on_risk() { + TEST(rust_borrow_region_extract_blocked_on_risk); + auto r = RustGoConstructiveEditAdapter::evaluate({"rust", "borrow_region", "extract", true, false}); + CHECK(!r.allowed, "rust borrow extract should be blocked on risk"); + CHECK(hasDiag(r, "rust_borrow_lifetime_extract_blocked"), "borrow/lifetime guard expected"); + PASS(); +} + +void test_rust_struct_rename_blocked_on_lifetime_risk() { + TEST(rust_struct_rename_blocked_on_lifetime_risk); + auto r = RustGoConstructiveEditAdapter::evaluate({"rust", "struct", "rename", true, false}); + CHECK(!r.allowed, "rust struct rename should be blocked on risk"); + CHECK(hasDiag(r, "rust_lifetime_sensitive_rename_blocked"), "lifetime guard expected"); + PASS(); +} + +void test_rust_impl_extract_allowed_without_risk() { + TEST(rust_impl_extract_allowed_without_risk); + auto r = RustGoConstructiveEditAdapter::evaluate({"rust", "impl", "extract", false, false}); + CHECK(r.allowed, "rust impl extract should be allowed without risk"); + PASS(); +} + +void test_go_channel_extract_blocked_on_concurrency_risk() { + TEST(go_channel_extract_blocked_on_concurrency_risk); + auto r = RustGoConstructiveEditAdapter::evaluate({"go", "channel", "extract", false, true}); + CHECK(!r.allowed, "go channel extract should be blocked on concurrency risk"); + CHECK(hasDiag(r, "go_concurrency_extract_blocked"), "go concurrency guard expected"); + PASS(); +} + +void test_go_function_update_blocked_on_concurrency_risk() { + TEST(go_function_update_blocked_on_concurrency_risk); + auto r = RustGoConstructiveEditAdapter::evaluate({"go", "function", "update", false, true}); + CHECK(!r.allowed, "go function update should be blocked on risk"); + CHECK(hasDiag(r, "go_concurrency_update_blocked"), "go update guard expected"); + PASS(); +} + +void test_go_function_update_allowed_without_risk() { + TEST(go_function_update_allowed_without_risk); + auto r = RustGoConstructiveEditAdapter::evaluate({"go", "function", "update", false, false}); + CHECK(r.allowed, "go function update should be allowed without risk"); + PASS(); +} + +void test_go_import_reorder_allowed() { + TEST(go_import_reorder_allowed); + auto r = RustGoConstructiveEditAdapter::evaluate({"go", "import", "reorder", false, false}); + CHECK(r.allowed, "go import reorder should be allowed"); + PASS(); +} + +void test_illegal_operation_for_construct_rejected() { + TEST(illegal_operation_for_construct_rejected); + auto r = RustGoConstructiveEditAdapter::evaluate({"rust", "struct", "extract", false, false}); + CHECK(!r.allowed, "illegal op should be rejected"); + CHECK(hasDiag(r, "operation_not_legal_for_construct"), "illegal op diag expected"); + PASS(); +} + +void test_unsupported_construct_rejected() { + TEST(unsupported_construct_rejected); + auto r = RustGoConstructiveEditAdapter::evaluate({"rust", "trait_object_magic", "update", false, false}); + CHECK(!r.supported, "unsupported construct should fail"); + CHECK(hasDiag(r, "unsupported_construct"), "unsupported construct diag expected"); + PASS(); +} + +void test_unsupported_language_rejected() { + TEST(unsupported_language_rejected); + auto r = RustGoConstructiveEditAdapter::evaluate({"python", "function", "rename", false, false}); + CHECK(!r.supported, "unsupported language should fail"); + CHECK(hasDiag(r, "unsupported_language"), "unsupported language diag expected"); + PASS(); +} + +void test_rust_import_insert_allowed() { + TEST(rust_import_insert_allowed); + auto r = RustGoConstructiveEditAdapter::evaluate({"rust", "import", "insert", false, false}); + CHECK(r.allowed, "rust import insert should be allowed"); + PASS(); +} + +int main() { + std::cout << "Step 541: Rust/Go Constructive Edit Adapter\n"; + + test_rust_function_rename_allowed(); // 1 + test_rust_borrow_region_extract_blocked_on_risk(); // 2 + test_rust_struct_rename_blocked_on_lifetime_risk(); // 3 + test_rust_impl_extract_allowed_without_risk(); // 4 + test_go_channel_extract_blocked_on_concurrency_risk(); // 5 + test_go_function_update_blocked_on_concurrency_risk(); // 6 + test_go_function_update_allowed_without_risk(); // 7 + test_go_import_reorder_allowed(); // 8 + test_illegal_operation_for_construct_rejected(); // 9 + test_unsupported_construct_rejected(); // 10 + test_unsupported_language_rejected(); // 11 + test_rust_import_insert_allowed(); // 12 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index 148b394..08eee80 100644 --- a/progress.md +++ b/progress.md @@ -9213,3 +9213,37 @@ legal operation mappings and module-level side-effect protection guards. - `editor/src/PythonTypeScriptConstructiveEditAdapter.h` within header-size limit (`84` <= `600`) - `editor/tests/step540_test.cpp` within test-file size guidance (`126` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 541: Rust/Go Constructive Edit Adapter +**Status:** PASS (12/12 tests) + +Implements Rust/Go constructive edit adaptation with ownership/lifetime and +concurrency-sensitive guardrails for high-risk transform paths. + +**Files added:** +- `editor/src/RustGoConstructiveEditAdapter.h` - Rust/Go adapter module: + - legal operation mappings for functions/structs/impl/import/channel/borrow regions + - shared support for both `rust` and `go` + - borrow/lifetime safety guards for Rust-sensitive operations + - concurrency safety guards for Go-sensitive operations + - structured diagnostics for unsupported constructs/languages and illegal ops +- `editor/tests/step541_test.cpp` - 12 tests covering: + - legal operation paths across Rust and Go constructs + - ownership/lifetime guard behavior in Rust + - concurrency guard behavior in Go + - illegal operation rejections + - unsupported construct/language behavior + +**Files modified:** +- `editor/CMakeLists.txt` - `step541_test` target + +**Verification run:** +- `cmake -S editor -B editor/build-native` - PASS +- `cmake --build editor/build-native --target step541_test step540_test` - PASS +- `./editor/build-native/step541_test` - PASS (12/12) +- `./editor/build-native/step540_test` - PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/RustGoConstructiveEditAdapter.h` within header-size limit (`91` <= `600`) +- `editor/tests/step541_test.cpp` within test-file size guidance (`127` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md`