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

Refactor large headers and enforce architecture constraints

Browse Source
This commit is contained in:
Bill
2026-02-17 08:47:26 -07:00
parent c27f74614e
commit f7c514e705
58 changed files with 6180 additions and 6140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

460
editor/src/StructuredDiagnostics.h
View File

@@ -164,460 +164,6 @@ inline json buildStrategyFix(const std::string& nodeId,
return nullptr;
}
// -----------------------------------------------------------------------
// Collectors: convert each diagnostic source to unified format
// -----------------------------------------------------------------------
inline std::vector<StructuredDiagnostic> collectParseDiagnostics(
const std::vector<ParseDiagnostic>& diags) {
std::vector<StructuredDiagnostic> out;
out.reserve(diags.size());
for (const auto& d : diags) {
StructuredDiagnostic sd;
sd.code = parseErrorCode(d.message);
sd.severity = severityFromStr(d.severity);
sd.line = d.line;
sd.col = d.column;
sd.message = d.message;
sd.source = "parser";
out.push_back(std::move(sd));
}
return out;
}
inline std::vector<StructuredDiagnostic> collectAnnotationDiagnostics(
const std::vector<AnnotationValidator::Diagnostic>& diags) {
std::vector<StructuredDiagnostic> out;
out.reserve(diags.size());
for (const auto& d : diags) {
StructuredDiagnostic sd;
sd.code = annotationErrorCode(d.message);
sd.severity = severityFromStr(d.severity);
sd.nodeId = d.nodeId;
sd.message = d.message;
sd.source = "annotation";
sd.fix = buildAnnotationFix(d.nodeId, d.message);
out.push_back(std::move(sd));
}
return out;
}
inline std::vector<StructuredDiagnostic> collectStrategyDiagnostics(
const std::vector<StrategyValidator::Violation>& violations) {
std::vector<StructuredDiagnostic> out;
out.reserve(violations.size());
for (const auto& v : violations) {
StructuredDiagnostic sd;
sd.code = strategyErrorCode(v.category);
sd.severity = severityFromStr(v.severity);
sd.nodeId = v.nodeId;
sd.message = v.message;
sd.source = "strategy";
sd.fix = buildStrategyFix(v.nodeId, v.category);
out.push_back(std::move(sd));
}
return out;
}
// -----------------------------------------------------------------------
// collectAllDiagnostics — run the full validation pipeline on an AST
// -----------------------------------------------------------------------
inline std::vector<StructuredDiagnostic> collectAllDiagnostics(
Module* ast) {
std::vector<StructuredDiagnostic> all;
if (!ast) return all;
// Annotation validation
AnnotationValidator annoValidator;
auto annoDiags = annoValidator.validate(ast);
auto annoStructured = collectAnnotationDiagnostics(annoDiags);
all.insert(all.end(), annoStructured.begin(), annoStructured.end());
// Extended annotation validation (Subjects 2-8)
AnnotationValidatorExtended extValidator;
auto extDiags = extValidator.validate(ast);
auto extStructured = collectAnnotationDiagnostics(extDiags);
all.insert(all.end(), extStructured.begin(), extStructured.end());
// Cross-type annotation conflict detection
std::vector<CrossTypeConflict> crossConflicts;
collectCrossTypeConflicts(ast, crossConflicts);
for (const auto& c : crossConflicts) {
StructuredDiagnostic sd;
sd.code = "E0210";
sd.severity = DiagnosticSeverity::Error;
sd.nodeId = c.nodeId;
sd.message = c.type1 + " + " + c.type2 + ": " + c.message;
sd.source = "annotation";
all.push_back(std::move(sd));
}
// Strategy validation (post-optimization invariants)
StrategyValidator stratValidator;
auto violations = stratValidator.validateInvariants(ast);
auto stratStructured = collectStrategyDiagnostics(violations);
all.insert(all.end(), stratStructured.begin(), stratStructured.end());
return all;
}
// -----------------------------------------------------------------------
// collectPipelineDiagnostics — from a PipelineResult
// -----------------------------------------------------------------------
inline std::vector<StructuredDiagnostic> collectPipelineDiagnostics(
const Pipeline::PipelineResult& pr) {
std::vector<StructuredDiagnostic> all;
auto parseDiags = collectParseDiagnostics(pr.parseDiags);
all.insert(all.end(), parseDiags.begin(), parseDiags.end());
auto annoDiags = collectAnnotationDiagnostics(pr.validationDiags);
all.insert(all.end(), annoDiags.begin(), annoDiags.end());
auto stratDiags = collectStrategyDiagnostics(pr.violations);
all.insert(all.end(), stratDiags.begin(), stratDiags.end());
return all;
}
// -----------------------------------------------------------------------
// diagnosticsToJson — convert array to JSON
// -----------------------------------------------------------------------
inline json diagnosticsToJson(
const std::vector<StructuredDiagnostic>& diags) {
json arr = json::array();
for (const auto& d : diags)
arr.push_back(diagnosticToJson(d));
return arr;
}
// -----------------------------------------------------------------------
// filterBySeverity — keep only diagnostics at or above threshold
// -----------------------------------------------------------------------
inline std::vector<StructuredDiagnostic> filterBySeverity(
const std::vector<StructuredDiagnostic>& diags,
DiagnosticSeverity maxSeverity) {
std::vector<StructuredDiagnostic> out;
for (const auto& d : diags) {
if (static_cast<int>(d.severity) <=
static_cast<int>(maxSeverity)) {
out.push_back(d);
}
}
return out;
}
// -----------------------------------------------------------------------
// filterBySource — keep only diagnostics from a specific source
// -----------------------------------------------------------------------
inline std::vector<StructuredDiagnostic> filterBySource(
const std::vector<StructuredDiagnostic>& diags,
const std::string& source) {
std::vector<StructuredDiagnostic> out;
for (const auto& d : diags) {
if (d.source == source) out.push_back(d);
}
return out;
}
// -----------------------------------------------------------------------
// Step 260: Cross-file diagnostics
// -----------------------------------------------------------------------
// Check for undefined imports: modules imported but not open as buffers
inline std::vector<StructuredDiagnostic> collectCrossFileDiagnostics(
Module* ast, const std::string& filePath,
const std::set<std::string>& openModuleNames) {
std::vector<StructuredDiagnostic> diags;
if (!ast) return diags;
for (auto* child : ast->allChildren()) {
if (child->conceptType == "Import") {
auto* imp = static_cast<const Import*>(child);
if (!imp->moduleName.empty() &&
openModuleNames.find(imp->moduleName) ==
openModuleNames.end()) {
StructuredDiagnostic d;
d.code = "E0400";
d.severity = DiagnosticSeverity::Warning;
d.nodeId = imp->id;
d.line = imp->hasSpan() ? imp->spanStartLine : 0;
d.message = "Imported module '" + imp->moduleName +
"' is not open in the project";
d.source = "cross-file";
diags.push_back(std::move(d));
}
}
}
return diags;
}
// Text-based cross-file import check (for parsers without Import nodes)
inline std::vector<StructuredDiagnostic> collectCrossFileDiagnosticsFromSource(
const std::string& source, const std::string& filePath,
const std::set<std::string>& openModuleNames) {
std::vector<StructuredDiagnostic> diags;
std::istringstream iss(source);
std::string line;
int lineNum = 0;
while (std::getline(iss, line)) {
++lineNum;
std::string modName;
if (line.substr(0, 7) == "import ") {
modName = line.substr(7);
while (!modName.empty() && modName.back() == ' ')
modName.pop_back();
size_t comma = modName.find(',');
if (comma != std::string::npos)
modName = modName.substr(0, comma);
} else if (line.substr(0, 5) == "from ") {
size_t space = line.find(' ', 5);
if (space != std::string::npos)
modName = line.substr(5, space - 5);
}
if (!modName.empty() &&
openModuleNames.find(modName) == openModuleNames.end()) {
StructuredDiagnostic d;
d.code = "E0400";
d.severity = DiagnosticSeverity::Warning;
d.line = lineNum;
d.message = "Imported module '" + modName +
"' is not open in the project";
d.source = "cross-file";
diags.push_back(std::move(d));
}
}
return diags;
}
// -----------------------------------------------------------------------
// Step 251: QuickFix — a concrete mutation an agent can apply
// -----------------------------------------------------------------------
struct QuickFix {
std::string id; // unique fix ID (e.g. "fix-E0200-func_1")
std::string diagCode; // diagnostic code this fixes
std::string nodeId; // target node
std::string description; // human-readable label
std::string category; // "remove-annotation", "change-strategy", etc.
json mutation; // concrete mutation object for applyMutation
};
inline json quickFixToJson(const QuickFix& f) {
return {
{"id", f.id},
{"diagCode", f.diagCode},
{"nodeId", f.nodeId},
{"description", f.description},
{"category", f.category},
{"mutation", f.mutation}
};
}
// -----------------------------------------------------------------------
// getQuickFixes — collect all applicable fixes for a node
// -----------------------------------------------------------------------
inline std::vector<QuickFix> getQuickFixesForNode(
Module* ast, const std::string& targetNodeId) {
std::vector<QuickFix> fixes;
if (!ast) return fixes;
auto diags = collectAllDiagnostics(ast);
for (const auto& d : diags) {
if (!targetNodeId.empty() && d.nodeId != targetNodeId) continue;
if (d.fix.is_null()) continue;
QuickFix fix;
fix.id = "fix-" + d.code + "-" + d.nodeId;
fix.diagCode = d.code;
fix.nodeId = d.nodeId;
fix.description = d.fix.value("description", "Fix " + d.code);
fix.mutation = d.fix;
// Categorize based on error code
if (d.code == "E0200") fix.category = "remove-annotation";
else if (d.code == "E0201") fix.category = "change-strategy";
else if (d.code == "E0202") fix.category = "resolve-conflict";
else if (d.code == "E0300") fix.category = "remove-use-after-free";
else if (d.code == "E0301") fix.category = "add-deallocation";
else fix.category = "general";
fixes.push_back(std::move(fix));
}
// Additional heuristic fixes from AST inspection
ASTNode* node = findNodeById(ast, targetNodeId);
if (node) {
// Unused variable: if a Variable has no references outside its
// own declaration, suggest removal
if (node->conceptType == "Variable") {
QuickFix fix;
fix.id = "fix-unused-" + targetNodeId;
fix.diagCode = "E0203";
fix.nodeId = targetNodeId;
fix.description = "Remove unused variable";
fix.category = "remove-unused";
fix.mutation = {{"type", "deleteNode"},
{"nodeId", targetNodeId}};
fixes.push_back(std::move(fix));
}
// Missing return: if a Function body ends without a Return,
// suggest adding one
if (node->conceptType == "Function") {
auto body = node->getChildren("body");
bool hasReturn = false;
for (auto* stmt : body) {
if (stmt->conceptType == "ReturnStatement")
hasReturn = true;
}
if (!hasReturn && !body.empty()) {
QuickFix fix;
fix.id = "fix-missing-return-" + targetNodeId;
fix.diagCode = "E0203";
fix.nodeId = targetNodeId;
fix.description = "Add missing return statement";
fix.category = "missing-return";
fix.mutation = {
{"type", "insertNode"},
{"parentId", targetNodeId},
{"role", "body"},
{"node", {{"conceptType", "ReturnStatement"},
{"children", json::object()}}}
};
fixes.push_back(std::move(fix));
}
}
}
return fixes;
}
// -----------------------------------------------------------------------
// getQuickFixesAll — collect all fixes for all diagnostics in the AST
// -----------------------------------------------------------------------
inline std::vector<QuickFix> getQuickFixesAll(Module* ast) {
return getQuickFixesForNode(ast, "");
}
// -----------------------------------------------------------------------
// findQuickFix — look up a specific fix by diagnostic code + nodeId
// -----------------------------------------------------------------------
inline QuickFix findQuickFix(Module* ast, const std::string& diagCode,
const std::string& nodeId) {
auto fixes = getQuickFixesForNode(ast, nodeId);
for (const auto& f : fixes) {
if (f.diagCode == diagCode) return f;
}
return {}; // empty fix (mutation will be null)
}
// -----------------------------------------------------------------------
// Step 252: DiagnosticVersionTracker — track diagnostic changes
// -----------------------------------------------------------------------
// Key that identifies a unique diagnostic instance
struct DiagnosticKey {
std::string code;
std::string nodeId;
int line = 0;
bool operator==(const DiagnosticKey& o) const {
return code == o.code && nodeId == o.nodeId && line == o.line;
}
bool operator<(const DiagnosticKey& o) const {
if (code != o.code) return code < o.code;
if (nodeId != o.nodeId) return nodeId < o.nodeId;
return line < o.line;
}
};
inline DiagnosticKey keyFromDiagnostic(const StructuredDiagnostic& d) {
return {d.code, d.nodeId, d.line};
}
struct DiagnosticDelta {
std::vector<StructuredDiagnostic> added;
std::vector<StructuredDiagnostic> removed;
int version = 0;
};
class DiagnosticVersionTracker {
public:
int version = 0;
// Record current diagnostics snapshot and bump version
void recordSnapshot(const std::vector<StructuredDiagnostic>& diags) {
previousDiags_ = currentDiags_;
previousVersion_ = version;
currentDiags_ = diags;
++version;
}
// Compute delta: what changed since the given version
DiagnosticDelta getDelta(
const std::vector<StructuredDiagnostic>& currentDiags,
int sinceVersion) const {
DiagnosticDelta delta;
delta.version = version;
if (sinceVersion >= version) {
// No changes since that version
return delta;
}
// Build key sets for previous and current
std::set<DiagnosticKey> prevKeys;
std::map<DiagnosticKey, StructuredDiagnostic> prevMap;
for (const auto& d : previousDiags_) {
auto key = keyFromDiagnostic(d);
prevKeys.insert(key);
prevMap[key] = d;
}
std::set<DiagnosticKey> currKeys;
std::map<DiagnosticKey, StructuredDiagnostic> currMap;
for (const auto& d : currentDiags) {
auto key = keyFromDiagnostic(d);
currKeys.insert(key);
currMap[key] = d;
}
// Added: in current but not in previous
for (const auto& key : currKeys) {
if (prevKeys.find(key) == prevKeys.end()) {
delta.added.push_back(currMap[key]);
}
}
// Removed: in previous but not in current
for (const auto& key : prevKeys) {
if (currKeys.find(key) == currKeys.end()) {
delta.removed.push_back(prevMap[key]);
}
}
return delta;
}
// Reset tracker
void reset() {
version = 0;
previousVersion_ = 0;
currentDiags_.clear();
previousDiags_.clear();
}
private:
int previousVersion_ = 0;
std::vector<StructuredDiagnostic> currentDiags_;
std::vector<StructuredDiagnostic> previousDiags_;
};
inline json deltaToJson(const DiagnosticDelta& delta) {
return {
{"added", diagnosticsToJson(delta.added)},
{"removed", diagnosticsToJson(delta.removed)},
{"addedCount", (int)delta.added.size()},
{"removedCount", (int)delta.removed.size()},
{"version", delta.version}
};
}
#include "diagnostics/StructuredDiagnosticsPart1.h"
#include "diagnostics/StructuredDiagnosticsPart2.h"
#include "diagnostics/StructuredDiagnosticsPart3.h"