bill/whetstone_DSL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Step 99: annotation context menu

Browse Source
This commit is contained in:
Bill
2026-02-09 10:32:19 -07:00
parent ad922fca7e
commit b987d45939
4 changed files with 250 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
PROGRESS.md
View File

@@ -199,6 +199,7 @@ All 38 steps implemented and passing. Each step has a corresponding test (`step1
- [x] Step 96: **IMPLEMENTED** — LSP server settings UI with defaults, auto-detect, and schema validation hook (2/2 tests pass)
- [x] Step 97: **IMPLEMENTED** — Annotation gutter markers with hover details and click-to-open placeholder editor (1/1 tests pass)
- [x] Step 98: **IMPLEMENTED** — Inline annotation tags with layout-aware placement and view toggle (1/1 tests pass)
- [x] Step 99: **IMPLEMENTED** — Annotation context menu for add/edit/remove via ASTMutationAPI (2/2 tests pass)
---
@@ -277,6 +278,7 @@ vcpkg's imgui 1.91.9 removed the `sdl2-binding` feature (only `sdl3-binding` exi
**Step 96:** Compile and pass (2/2)
**Step 97:** Compile and pass (1/1)
**Step 98:** Compile and pass (1/1)
**Step 99:** Compile and pass (2/2)
---
@@ -384,3 +386,4 @@ Sprint 4 in progress. Step 76 (LayoutManager) done. Next: Step 77 (custom code e
| 2026-02-09 | Codex | Step 96: LSP server settings UI with defaults, auto-detect, and schema validation hook. 2/2 tests pass. |
| 2026-02-09 | Codex | Step 97: Annotation gutter markers with hover details and click-to-open placeholder editor. 1/1 tests pass. |
| 2026-02-09 | Codex | Step 98: Inline annotation tags with layout-aware placement and view toggle. 1/1 tests pass. |
| 2026-02-09 | Codex | Step 99: Annotation context menu (add/edit/remove) via ASTMutationAPI. 2/2 tests pass. |

4
editor/CMakeLists.txt
View File

@@ -542,6 +542,10 @@ add_executable(step98_test tests/step98_test.cpp)
target_include_directories(step98_test PRIVATE src)
target_link_libraries(step98_test PRIVATE imgui::imgui unofficial::tree-sitter::tree-sitter tree_sitter_python tree_sitter_cpp tree_sitter_elisp)
add_executable(step99_test tests/step99_test.cpp)
target_include_directories(step99_test PRIVATE src)
target_link_libraries(step99_test PRIVATE nlohmann_json::nlohmann_json)
find_package(SDL2 CONFIG REQUIRED)
find_package(OpenGL REQUIRED)
find_package(glad CONFIG REQUIRED)

204
editor/src/main.cpp
View File

@@ -29,6 +29,7 @@
#include "Diagnostics.h"
#include "SettingsManager.h"
#include "LayoutManager.h"
#include "ASTMutationAPI.h"
#include "ast/Generator.h"
#include "ast/Annotation.h"
@@ -40,6 +41,7 @@
#include <sstream>
#include <cstring>
#include <cctype>
#include <climits>
#include <filesystem>
#include <map>
#include <memory>
@@ -107,6 +109,7 @@ struct EditorState {
std::vector<EditorDiagnostic> whetstoneDiagnostics;
SettingsManager settings;
bool showLspSettings = false;
ASTMutationAPI mutator;
BufferState* active() { return activeBuffer; }
@@ -528,6 +531,91 @@ static bool annotationInfo(const ASTNode* anno, ImU32& color, std::string& label
return false;
}
static std::string annotationLabel(const ASTNode* anno) {
if (!anno) return "";
if (anno->conceptType == "ReclaimAnnotation") {
auto* a = static_cast<const ReclaimAnnotation*>(anno);
return "@Reclaim(" + a->strategy + ")";
}
if (anno->conceptType == "OwnerAnnotation") {
auto* a = static_cast<const OwnerAnnotation*>(anno);
return "@Owner(" + a->strategy + ")";
}
if (anno->conceptType == "DeallocateAnnotation") {
auto* a = static_cast<const DeallocateAnnotation*>(anno);
return "@Deallocate(" + a->strategy + ")";
}
if (anno->conceptType == "LifetimeAnnotation") {
auto* a = static_cast<const LifetimeAnnotation*>(anno);
return "@Lifetime(" + a->strategy + ")";
}
if (anno->conceptType == "AllocateAnnotation") {
auto* a = static_cast<const AllocateAnnotation*>(anno);
return "@Allocate(" + a->strategy + ")";
}
return anno->conceptType;
}
static std::string nodeDisplayName(const ASTNode* node) {
if (!node) return "";
if (node->conceptType == "Function") return static_cast<const Function*>(node)->name;
if (node->conceptType == "Variable") return static_cast<const Variable*>(node)->name;
return node->conceptType;
}
static std::string nextAnnotationId() {
static int counter = 0;
return "anno_ui_" + std::to_string(counter++);
}
static Annotation* createAnnotationNode(const std::string& type, const std::string& strategy) {
if (type == "ReclaimAnnotation") {
auto* a = new ReclaimAnnotation(nextAnnotationId(), strategy);
return a;
}
if (type == "OwnerAnnotation") {
auto* a = new OwnerAnnotation(nextAnnotationId(), strategy);
return a;
}
if (type == "DeallocateAnnotation") {
auto* a = new DeallocateAnnotation(nextAnnotationId(), strategy);
return a;
}
if (type == "LifetimeAnnotation") {
auto* a = new LifetimeAnnotation(nextAnnotationId(), strategy);
return a;
}
if (type == "AllocateAnnotation") {
auto* a = new AllocateAnnotation(nextAnnotationId(), strategy);
return a;
}
return nullptr;
}
static int spanScore(const ASTNode* node) {
if (!node || !node->hasSpan()) return INT_MAX;
int lines = node->spanEndLine - node->spanStartLine;
int cols = node->spanEndCol - node->spanStartCol;
return lines * 10000 + cols;
}
static ASTNode* findAnnotationTarget(ASTNode* node, int line) {
if (!node) return nullptr;
ASTNode* best = nullptr;
if (node->hasSpan() && line >= node->spanStartLine && line <= node->spanEndLine) {
if (node->conceptType == "Function" || node->conceptType == "Variable") {
best = node;
}
}
for (auto* child : node->allChildren()) {
ASTNode* cand = findAnnotationTarget(child, line);
if (cand) {
if (!best || spanScore(cand) < spanScore(best)) best = cand;
}
}
return best;
}
static void collectAnnotationMarkers(const ASTNode* node, std::vector<AnnotationMarker>& out) {
if (!node) return;
if (node->hasSpan()) {
@@ -1320,6 +1408,122 @@ int main(int, char**) {
}
}
if (ImGui::BeginPopupContextWindow("AnnotationContext", ImGuiPopupFlags_MouseButtonRight)) {
Module* ast = state.active() ? state.active()->sync.getAST() : nullptr;
int lineZero = state.active() ? std::max(0, state.active()->cursorLine - 1) : 0;
ASTNode* target = ast ? findAnnotationTarget(ast, lineZero) : nullptr;
if (!target) {
ImGui::TextDisabled("No annotatable symbol on this line.");
} else {
ImGui::Text("Target: %s", nodeDisplayName(target).c_str());
ImGui::Separator();
if (ImGui::BeginMenu("Add Annotation")) {
if (ImGui::MenuItem("@Reclaim(Tracing)")) {
auto* anno = createAnnotationNode("ReclaimAnnotation", "Tracing");
if (anno) {
anno->setSpan(target->spanStartLine, target->spanStartCol,
target->spanEndLine, target->spanEndCol);
state.mutator.setRoot(ast);
auto res = state.mutator.insertNode(target->id, "annotations", anno);
if (!res.error.empty()) state.outputLog += res.error + "\n";
}
}
if (ImGui::MenuItem("@Owner(Single)")) {
auto* anno = createAnnotationNode("OwnerAnnotation", "Single");
if (anno) {
anno->setSpan(target->spanStartLine, target->spanStartCol,
target->spanEndLine, target->spanEndCol);
state.mutator.setRoot(ast);
auto res = state.mutator.insertNode(target->id, "annotations", anno);
if (!res.error.empty()) state.outputLog += res.error + "\n";
}
}
if (ImGui::MenuItem("@Deallocate(Explicit)")) {
auto* anno = createAnnotationNode("DeallocateAnnotation", "Explicit");
if (anno) {
anno->setSpan(target->spanStartLine, target->spanStartCol,
target->spanEndLine, target->spanEndCol);
state.mutator.setRoot(ast);
auto res = state.mutator.insertNode(target->id, "annotations", anno);
if (!res.error.empty()) state.outputLog += res.error + "\n";
}
}
if (ImGui::MenuItem("@Lifetime(RAII)")) {
auto* anno = createAnnotationNode("LifetimeAnnotation", "RAII");
if (anno) {
anno->setSpan(target->spanStartLine, target->spanStartCol,
target->spanEndLine, target->spanEndCol);
state.mutator.setRoot(ast);
auto res = state.mutator.insertNode(target->id, "annotations", anno);
if (!res.error.empty()) state.outputLog += res.error + "\n";
}
}
if (ImGui::MenuItem("@Allocate(Static)")) {
auto* anno = createAnnotationNode("AllocateAnnotation", "Static");
if (anno) {
anno->setSpan(target->spanStartLine, target->spanStartCol,
target->spanEndLine, target->spanEndCol);
state.mutator.setRoot(ast);
auto res = state.mutator.insertNode(target->id, "annotations", anno);
if (!res.error.empty()) state.outputLog += res.error + "\n";
}
}
ImGui::EndMenu();
}
const auto& annos = target->getChildren("annotations");
if (ImGui::BeginMenu("Edit Annotation", !annos.empty())) {
for (auto* anno : annos) {
std::string label = annotationLabel(anno);
if (ImGui::BeginMenu(label.c_str())) {
if (anno->conceptType == "ReclaimAnnotation") {
if (ImGui::MenuItem("Tracing")) {
state.mutator.setRoot(ast);
state.mutator.setProperty(anno->id, "strategy", "Tracing");
}
} else if (anno->conceptType == "OwnerAnnotation") {
if (ImGui::MenuItem("Single")) {
state.mutator.setRoot(ast);
state.mutator.setProperty(anno->id, "strategy", "Single");
}
} else if (anno->conceptType == "DeallocateAnnotation") {
if (ImGui::MenuItem("Explicit")) {
state.mutator.setRoot(ast);
state.mutator.setProperty(anno->id, "strategy", "Explicit");
}
} else if (anno->conceptType == "LifetimeAnnotation") {
if (ImGui::MenuItem("RAII")) {
state.mutator.setRoot(ast);
state.mutator.setProperty(anno->id, "strategy", "RAII");
}
} else if (anno->conceptType == "AllocateAnnotation") {
if (ImGui::MenuItem("Static")) {
state.mutator.setRoot(ast);
state.mutator.setProperty(anno->id, "strategy", "Static");
}
}
ImGui::EndMenu();
}
}
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Remove Annotation", !annos.empty())) {
for (auto* anno : annos) {
std::string label = annotationLabel(anno);
if (ImGui::MenuItem(label.c_str())) {
state.mutator.setRoot(ast);
auto res = state.mutator.deleteNode(anno->id);
if (!res.error.empty()) state.outputLog += res.error + "\n";
}
}
ImGui::EndMenu();
}
}
ImGui::EndPopup();
}
ImGui::EndTabItem();
}
if (!open) {

39
editor/tests/step99_test.cpp Normal file
View File

@@ -0,0 +1,39 @@
// Step 99 TDD Test: Annotation context menu mutations
//
// Tests:
// 1. ASTMutationAPI can add and remove annotation nodes
#include <cassert>
#include <iostream>
#include "ASTMutationAPI.h"
#include "ast/Module.h"
#include "ast/Function.h"
#include "ast/Annotation.h"
int main() {
int passed = 0;
int failed = 0;
Module* mod = new Module("m1", "mod", "python");
auto* fn = new Function("f1", "foo");
mod->addChild("functions", fn);
ASTMutationAPI api;
api.setRoot(mod);
auto* anno = new ReclaimAnnotation("a1", "Tracing");
auto res = api.insertNode(fn->id, "annotations", anno);
assert(res.success);
assert(fn->getChildren("annotations").size() == 1);
std::cout << "Test 1 PASS: annotation inserted" << std::endl;
++passed;
auto res2 = api.deleteNode("a1");
assert(res2.success);
assert(fn->getChildren("annotations").empty());
std::cout << "Test 2 PASS: annotation removed" << std::endl;
++passed;
std::cout << "\n=== Step 99 Results: " << passed << " passed, " << failed << " failed ===" << std::endl;
return failed > 0 ? 1 : 0;
}