1428 lines
68 KiB
C++
1428 lines
68 KiB
C++
#pragma once
|
|
#include <nlohmann/json.hpp>
|
|
#include "ASTNode.h"
|
|
#include "Module.h"
|
|
#include "Function.h"
|
|
#include "Variable.h"
|
|
#include "Parameter.h"
|
|
#include "Statement.h"
|
|
#include "Expression.h"
|
|
#include "Type.h"
|
|
#include "Annotation.h"
|
|
#include "HostBoundary.h"
|
|
#include "../EnvironmentSpec.h"
|
|
#include "Import.h"
|
|
#include "ExternalModule.h"
|
|
#include "TypeSignature.h"
|
|
#include "ClassDeclaration.h"
|
|
#include "GenericType.h"
|
|
#include "AsyncNodes.h"
|
|
#include "PreprocessorNodes.h"
|
|
#include "EnumNamespaceNodes.h"
|
|
#include "SqlNodes.h"
|
|
|
|
using json = nlohmann::json;
|
|
|
|
inline json propertiesToJson(const ASTNode* node) {
|
|
json props = json::object();
|
|
const auto& ct = node->conceptType;
|
|
|
|
// Module
|
|
if (ct == "Module") {
|
|
auto* n = static_cast<const Module*>(node);
|
|
props["name"] = n->name;
|
|
props["targetLanguage"] = n->targetLanguage;
|
|
}
|
|
// Function
|
|
else if (ct == "Function") {
|
|
auto* n = static_cast<const Function*>(node);
|
|
props["name"] = n->name;
|
|
}
|
|
// Variable
|
|
else if (ct == "Variable") {
|
|
auto* n = static_cast<const Variable*>(node);
|
|
props["name"] = n->name;
|
|
}
|
|
// Parameter
|
|
else if (ct == "Parameter") {
|
|
auto* n = static_cast<const Parameter*>(node);
|
|
props["name"] = n->name;
|
|
}
|
|
// Statements
|
|
else if (ct == "ForLoop") {
|
|
auto* n = static_cast<const ForLoop*>(node);
|
|
props["iteratorName"] = n->iteratorName;
|
|
}
|
|
// Expressions
|
|
else if (ct == "BinaryOperation") {
|
|
auto* n = static_cast<const BinaryOperation*>(node);
|
|
props["op"] = n->op;
|
|
}
|
|
else if (ct == "UnaryOperation") {
|
|
auto* n = static_cast<const UnaryOperation*>(node);
|
|
props["op"] = n->op;
|
|
}
|
|
else if (ct == "FunctionCall") {
|
|
auto* n = static_cast<const FunctionCall*>(node);
|
|
props["functionName"] = n->functionName;
|
|
}
|
|
else if (ct == "VariableReference") {
|
|
auto* n = static_cast<const VariableReference*>(node);
|
|
props["variableName"] = n->variableName;
|
|
}
|
|
else if (ct == "IntegerLiteral") {
|
|
auto* n = static_cast<const IntegerLiteral*>(node);
|
|
props["value"] = n->value;
|
|
}
|
|
else if (ct == "FloatLiteral") {
|
|
auto* n = static_cast<const FloatLiteral*>(node);
|
|
props["value"] = n->value;
|
|
}
|
|
else if (ct == "StringLiteral") {
|
|
auto* n = static_cast<const StringLiteral*>(node);
|
|
props["value"] = n->value;
|
|
}
|
|
else if (ct == "BooleanLiteral") {
|
|
auto* n = static_cast<const BooleanLiteral*>(node);
|
|
props["value"] = n->value;
|
|
}
|
|
else if (ct == "MemberAccess") {
|
|
auto* n = static_cast<const MemberAccess*>(node);
|
|
props["memberName"] = n->memberName;
|
|
}
|
|
// Types
|
|
else if (ct == "PrimitiveType") {
|
|
auto* n = static_cast<const PrimitiveType*>(node);
|
|
props["kind"] = n->kind;
|
|
}
|
|
else if (ct == "CustomType") {
|
|
auto* n = static_cast<const CustomType*>(node);
|
|
props["typeName"] = n->typeName;
|
|
}
|
|
// Imports / External modules
|
|
else if (ct == "Import") {
|
|
auto* n = static_cast<const Import*>(node);
|
|
props["moduleName"] = n->moduleName;
|
|
if (!n->alias.empty()) props["alias"] = n->alias;
|
|
if (!n->importKind.empty()) props["importKind"] = n->importKind;
|
|
}
|
|
else if (ct == "ExternalModule") {
|
|
auto* n = static_cast<const ExternalModule*>(node);
|
|
props["name"] = n->name;
|
|
if (!n->version.empty()) props["version"] = n->version;
|
|
if (!n->language.empty()) props["language"] = n->language;
|
|
if (!n->semanticTags.empty()) props["semanticTags"] = n->semanticTags;
|
|
}
|
|
else if (ct == "TypeSignature") {
|
|
auto* n = static_cast<const TypeSignature*>(node);
|
|
props["name"] = n->name;
|
|
props["variadic"] = n->variadic;
|
|
if (!n->semanticTags.empty()) props["semanticTags"] = n->semanticTags;
|
|
}
|
|
// Annotations
|
|
else if (ct == "DerefStrategy") {
|
|
auto* n = static_cast<const DerefStrategy*>(node);
|
|
props["strategy"] = n->strategy;
|
|
if (!n->derefLocation.empty()) props["derefLocation"] = n->derefLocation;
|
|
if (!n->owner.empty()) props["owner"] = n->owner;
|
|
}
|
|
else if (ct == "OptimizationLock") {
|
|
auto* n = static_cast<const OptimizationLock*>(node);
|
|
props["lockedBy"] = n->lockedBy;
|
|
props["lockReason"] = n->lockReason;
|
|
props["lockLevel"] = n->lockLevel;
|
|
if (!n->affectedStrategies.empty()) props["affectedStrategies"] = n->affectedStrategies;
|
|
if (!n->timestamp.empty()) props["timestamp"] = n->timestamp;
|
|
}
|
|
else if (ct == "LangSpecific") {
|
|
auto* n = static_cast<const LangSpecific*>(node);
|
|
props["language"] = n->language;
|
|
props["idiomType"] = n->idiomType;
|
|
props["rawSyntax"] = n->rawSyntax;
|
|
if (!n->semanticHint.empty()) props["semanticHint"] = n->semanticHint;
|
|
if (!n->position.empty()) props["position"] = n->position;
|
|
}
|
|
// Semantic annotations (Sprint 10)
|
|
else if (ct == "IntentAnnotation") {
|
|
auto* n = static_cast<const IntentAnnotation*>(node);
|
|
if (!n->summary.empty()) props["summary"] = n->summary;
|
|
if (!n->category.empty()) props["category"] = n->category;
|
|
}
|
|
else if (ct == "ComplexityAnnotation") {
|
|
auto* n = static_cast<const ComplexityAnnotation*>(node);
|
|
if (!n->timeComplexity.empty()) props["timeComplexity"] = n->timeComplexity;
|
|
props["cognitiveComplexity"] = n->cognitiveComplexity;
|
|
props["linesOfLogic"] = n->linesOfLogic;
|
|
}
|
|
else if (ct == "RiskAnnotation") {
|
|
auto* n = static_cast<const RiskAnnotation*>(node);
|
|
if (!n->level.empty()) props["level"] = n->level;
|
|
if (!n->reason.empty()) props["reason"] = n->reason;
|
|
props["dependentCount"] = n->dependentCount;
|
|
}
|
|
else if (ct == "ContractAnnotation") {
|
|
auto* n = static_cast<const ContractAnnotation*>(node);
|
|
if (!n->preconditions.empty()) props["preconditions"] = n->preconditions;
|
|
if (!n->postconditions.empty()) props["postconditions"] = n->postconditions;
|
|
if (!n->returnShape.empty()) props["returnShape"] = n->returnShape;
|
|
if (!n->sideEffects.empty()) props["sideEffects"] = n->sideEffects;
|
|
}
|
|
else if (ct == "SemanticTagAnnotation") {
|
|
auto* n = static_cast<const SemanticTagAnnotation*>(node);
|
|
if (!n->tags.empty()) props["tags"] = n->tags;
|
|
}
|
|
// Type System — Layout & Constraints (Step 272)
|
|
else if (ct == "BitWidthAnnotation") {
|
|
auto* n = static_cast<const BitWidthAnnotation*>(node);
|
|
props["width"] = n->width;
|
|
}
|
|
else if (ct == "EndianAnnotation") {
|
|
auto* n = static_cast<const EndianAnnotation*>(node);
|
|
if (!n->order.empty()) props["order"] = n->order;
|
|
}
|
|
else if (ct == "LayoutAnnotation") {
|
|
auto* n = static_cast<const LayoutAnnotation*>(node);
|
|
if (!n->mode.empty()) props["mode"] = n->mode;
|
|
props["alignment"] = n->alignment;
|
|
}
|
|
else if (ct == "NullabilityAnnotation") {
|
|
auto* n = static_cast<const NullabilityAnnotation*>(node);
|
|
props["nullable"] = n->nullable;
|
|
if (!n->strategy.empty()) props["strategy"] = n->strategy;
|
|
}
|
|
else if (ct == "VarianceAnnotation") {
|
|
auto* n = static_cast<const VarianceAnnotation*>(node);
|
|
if (!n->variance.empty()) props["variance"] = n->variance;
|
|
}
|
|
// Type System — Identity & Mutability (Step 273)
|
|
else if (ct == "IdentityAnnotation") {
|
|
auto* n = static_cast<const IdentityAnnotation*>(node);
|
|
if (!n->mode.empty()) props["mode"] = n->mode;
|
|
}
|
|
else if (ct == "MutAnnotation") {
|
|
auto* n = static_cast<const MutAnnotation*>(node);
|
|
if (!n->depth.empty()) props["depth"] = n->depth;
|
|
}
|
|
else if (ct == "TypeStateAnnotation") {
|
|
auto* n = static_cast<const TypeStateAnnotation*>(node);
|
|
if (!n->state.empty()) props["state"] = n->state;
|
|
}
|
|
// Concurrency — Primitives & Memory Model (Step 274)
|
|
else if (ct == "AtomicAnnotation") {
|
|
auto* n = static_cast<const AtomicAnnotation*>(node);
|
|
if (!n->consistency.empty()) props["consistency"] = n->consistency;
|
|
}
|
|
else if (ct == "SyncAnnotation") {
|
|
auto* n = static_cast<const SyncAnnotation*>(node);
|
|
if (!n->primitive.empty()) props["primitive"] = n->primitive;
|
|
}
|
|
else if (ct == "ThreadModelAnnotation") {
|
|
auto* n = static_cast<const ThreadModelAnnotation*>(node);
|
|
if (!n->model.empty()) props["model"] = n->model;
|
|
}
|
|
// MemoryBarrierAnnotation has no extra fields
|
|
// Async, Parallelism & Error Handling (Step 275)
|
|
else if (ct == "ExecAnnotation") {
|
|
auto* n = static_cast<const ExecAnnotation*>(node);
|
|
if (!n->mode.empty()) props["mode"] = n->mode;
|
|
if (!n->runtimeHint.empty()) props["runtimeHint"] = n->runtimeHint;
|
|
}
|
|
else if (ct == "BlockingAnnotation") {
|
|
auto* n = static_cast<const BlockingAnnotation*>(node);
|
|
if (!n->kind.empty()) props["kind"] = n->kind;
|
|
}
|
|
else if (ct == "ParallelAnnotation") {
|
|
auto* n = static_cast<const ParallelAnnotation*>(node);
|
|
if (!n->kind.empty()) props["kind"] = n->kind;
|
|
}
|
|
else if (ct == "TrapAnnotation") {
|
|
auto* n = static_cast<const TrapAnnotation*>(node);
|
|
if (!n->signal.empty()) props["signal"] = n->signal;
|
|
}
|
|
else if (ct == "ExceptionAnnotation") {
|
|
auto* n = static_cast<const ExceptionAnnotation*>(node);
|
|
if (!n->style.empty()) props["style"] = n->style;
|
|
}
|
|
else if (ct == "PanicAnnotation") {
|
|
auto* n = static_cast<const PanicAnnotation*>(node);
|
|
if (!n->behavior.empty()) props["behavior"] = n->behavior;
|
|
}
|
|
// Scope & Namespace (Step 276)
|
|
else if (ct == "BindingAnnotation") {
|
|
auto* n = static_cast<const BindingAnnotation*>(node);
|
|
if (!n->time.empty()) props["time"] = n->time;
|
|
}
|
|
else if (ct == "LookupAnnotation") {
|
|
auto* n = static_cast<const LookupAnnotation*>(node);
|
|
if (!n->mode.empty()) props["mode"] = n->mode;
|
|
}
|
|
else if (ct == "CaptureAnnotation") {
|
|
auto* n = static_cast<const CaptureAnnotation*>(node);
|
|
if (!n->strategy.empty()) props["strategy"] = n->strategy;
|
|
}
|
|
else if (ct == "VisibilityAnnotation") {
|
|
auto* n = static_cast<const VisibilityAnnotation*>(node);
|
|
if (!n->level.empty()) props["level"] = n->level;
|
|
}
|
|
else if (ct == "NamespaceAnnotation") {
|
|
auto* n = static_cast<const NamespaceAnnotation*>(node);
|
|
if (!n->style.empty()) props["style"] = n->style;
|
|
}
|
|
else if (ct == "ScopeAnnotation") {
|
|
auto* n = static_cast<const ScopeAnnotation*>(node);
|
|
if (!n->kind.empty()) props["kind"] = n->kind;
|
|
}
|
|
// Shim & Escape Hatch (Step 278)
|
|
else if (ct == "IntrinsicAnnotation") {
|
|
auto* n = static_cast<const IntrinsicAnnotation*>(node);
|
|
if (!n->instruction.empty()) props["instruction"] = n->instruction;
|
|
if (!n->arch.empty()) props["arch"] = n->arch;
|
|
}
|
|
else if (ct == "RawAnnotation") {
|
|
auto* n = static_cast<const RawAnnotation*>(node);
|
|
if (!n->language.empty()) props["language"] = n->language;
|
|
if (!n->code.empty()) props["code"] = n->code;
|
|
}
|
|
else if (ct == "CallingConvAnnotation") {
|
|
auto* n = static_cast<const CallingConvAnnotation*>(node);
|
|
if (!n->convention.empty()) props["convention"] = n->convention;
|
|
}
|
|
else if (ct == "LinkAnnotation") {
|
|
auto* n = static_cast<const LinkAnnotation*>(node);
|
|
if (!n->symbolName.empty()) props["symbolName"] = n->symbolName;
|
|
if (!n->library.empty()) props["library"] = n->library;
|
|
}
|
|
else if (ct == "ShimAnnotation") {
|
|
auto* n = static_cast<const ShimAnnotation*>(node);
|
|
if (!n->strategy.empty()) props["strategy"] = n->strategy;
|
|
}
|
|
// PointerArithmeticAnnotation — marker, no fields
|
|
else if (ct == "OpaqueAnnotation") {
|
|
auto* n = static_cast<const OpaqueAnnotation*>(node);
|
|
if (!n->reason.empty()) props["reason"] = n->reason;
|
|
}
|
|
// Platform & Provenance (Step 279)
|
|
else if (ct == "TargetAnnotation") {
|
|
auto* n = static_cast<const TargetAnnotation*>(node);
|
|
if (!n->platform.empty()) props["platform"] = n->platform;
|
|
if (!n->arch.empty()) props["arch"] = n->arch;
|
|
}
|
|
else if (ct == "FeatureAnnotation") {
|
|
auto* n = static_cast<const FeatureAnnotation*>(node);
|
|
if (!n->flag.empty()) props["flag"] = n->flag;
|
|
props["enabled"] = n->enabled;
|
|
}
|
|
else if (ct == "OriginalAnnotation") {
|
|
auto* n = static_cast<const OriginalAnnotation*>(node);
|
|
if (!n->sourceCode.empty()) props["sourceCode"] = n->sourceCode;
|
|
if (!n->sourceLanguage.empty()) props["sourceLanguage"] = n->sourceLanguage;
|
|
}
|
|
else if (ct == "MappingAnnotation") {
|
|
auto* n = static_cast<const MappingAnnotation*>(node);
|
|
if (!n->history.empty()) props["history"] = n->history;
|
|
}
|
|
// Optimization Completion (Step 280)
|
|
// TailCallAnnotation — marker, no fields
|
|
else if (ct == "LoopAnnotation") {
|
|
auto* n = static_cast<const LoopAnnotation*>(node);
|
|
if (!n->hint.empty()) props["hint"] = n->hint;
|
|
if (n->factor > 0) props["factor"] = n->factor;
|
|
}
|
|
else if (ct == "DataAnnotation") {
|
|
auto* n = static_cast<const DataAnnotation*>(node);
|
|
if (!n->hint.empty()) props["hint"] = n->hint;
|
|
}
|
|
else if (ct == "AlignAnnotation") {
|
|
auto* n = static_cast<const AlignAnnotation*>(node);
|
|
props["bytes"] = n->bytes;
|
|
}
|
|
// PackAnnotation — marker, no fields
|
|
else if (ct == "BoundsCheckAnnotation") {
|
|
auto* n = static_cast<const BoundsCheckAnnotation*>(node);
|
|
props["enabled"] = n->enabled;
|
|
}
|
|
else if (ct == "OverflowAnnotation") {
|
|
auto* n = static_cast<const OverflowAnnotation*>(node);
|
|
if (!n->behavior.empty()) props["behavior"] = n->behavior;
|
|
}
|
|
// Meta-Programming (Step 281)
|
|
else if (ct == "MetaAnnotation") {
|
|
auto* n = static_cast<const MetaAnnotation*>(node);
|
|
if (!n->state.empty()) props["state"] = n->state;
|
|
if (!n->phase.empty()) props["phase"] = n->phase;
|
|
}
|
|
else if (ct == "SymbolAnnotation") {
|
|
auto* n = static_cast<const SymbolAnnotation*>(node);
|
|
if (!n->mode.empty()) props["mode"] = n->mode;
|
|
}
|
|
else if (ct == "EvaluateAnnotation") {
|
|
auto* n = static_cast<const EvaluateAnnotation*>(node);
|
|
if (!n->phase.empty()) props["phase"] = n->phase;
|
|
}
|
|
else if (ct == "TemplateAnnotation") {
|
|
auto* n = static_cast<const TemplateAnnotation*>(node);
|
|
if (!n->specialization.empty()) props["specialization"] = n->specialization;
|
|
}
|
|
else if (ct == "SyntheticAnnotation") {
|
|
auto* n = static_cast<const SyntheticAnnotation*>(node);
|
|
if (!n->generator.empty()) props["generator"] = n->generator;
|
|
props["isStructuralRisk"] = n->isStructuralRisk;
|
|
}
|
|
// Strategy & Policy (Step 282)
|
|
else if (ct == "PolicyAnnotation") {
|
|
auto* n = static_cast<const PolicyAnnotation*>(node);
|
|
if (!n->strictness.empty()) props["strictness"] = n->strictness;
|
|
if (!n->perf.empty()) props["perf"] = n->perf;
|
|
if (!n->style.empty()) props["style"] = n->style;
|
|
props["binaryStable"] = n->binaryStable;
|
|
}
|
|
else if (ct == "AmbiguityAnnotation") {
|
|
auto* n = static_cast<const AmbiguityAnnotation*>(node);
|
|
if (!n->intent.empty()) props["intent"] = n->intent;
|
|
if (!n->options.empty()) props["options"] = n->options;
|
|
if (!n->level.empty()) props["level"] = n->level;
|
|
if (!n->description.empty()) props["description"] = n->description;
|
|
}
|
|
else if (ct == "CandidateAnnotation") {
|
|
auto* n = static_cast<const CandidateAnnotation*>(node);
|
|
if (!n->inferredTypes.empty()) props["inferredTypes"] = n->inferredTypes;
|
|
}
|
|
else if (ct == "TradeoffAnnotation") {
|
|
auto* n = static_cast<const TradeoffAnnotation*>(node);
|
|
if (!n->reason.empty()) props["reason"] = n->reason;
|
|
if (!n->safetyCost.empty()) props["safetyCost"] = n->safetyCost;
|
|
if (!n->perfCost.empty()) props["perfCost"] = n->perfCost;
|
|
}
|
|
else if (ct == "ChoiceAnnotation") {
|
|
auto* n = static_cast<const ChoiceAnnotation*>(node);
|
|
if (!n->choiceId.empty()) props["choiceId"] = n->choiceId;
|
|
if (!n->options.empty()) props["options"] = n->options;
|
|
}
|
|
else if (ct == "DecisionAnnotation") {
|
|
auto* n = static_cast<const DecisionAnnotation*>(node);
|
|
if (!n->choiceId.empty()) props["choiceId"] = n->choiceId;
|
|
if (!n->selection.empty()) props["selection"] = n->selection;
|
|
if (!n->author.empty()) props["author"] = n->author;
|
|
if (!n->reason.empty()) props["reason"] = n->reason;
|
|
}
|
|
// Subject 9: Workflow Routing (Step 315)
|
|
else if (ct == "ContextWidthAnnotation") {
|
|
auto* n = static_cast<const ContextWidthAnnotation*>(node);
|
|
if (!n->width.empty()) props["width"] = n->width;
|
|
}
|
|
else if (ct == "ReviewAnnotation") {
|
|
auto* n = static_cast<const ReviewAnnotation*>(node);
|
|
props["required"] = n->required;
|
|
if (!n->reviewer.empty()) props["reviewer"] = n->reviewer;
|
|
if (!n->reason.empty()) props["reason"] = n->reason;
|
|
}
|
|
else if (ct == "AutomatabilityAnnotation") {
|
|
auto* n = static_cast<const AutomatabilityAnnotation*>(node);
|
|
if (!n->strategy.empty()) props["strategy"] = n->strategy;
|
|
if (n->confidence > 0.0) props["confidence"] = n->confidence;
|
|
}
|
|
else if (ct == "PriorityAnnotation") {
|
|
auto* n = static_cast<const PriorityAnnotation*>(node);
|
|
if (!n->level.empty()) props["level"] = n->level;
|
|
if (!n->blockedBy.empty()) props["blockedBy"] = n->blockedBy;
|
|
}
|
|
else if (ct == "ImplementationStatusAnnotation") {
|
|
auto* n = static_cast<const ImplementationStatusAnnotation*>(node);
|
|
if (!n->status.empty()) props["status"] = n->status;
|
|
if (!n->assignee.empty()) props["assignee"] = n->assignee;
|
|
}
|
|
// Host Boundary (Step 288)
|
|
else if (ct == "HostCall") {
|
|
auto* n = static_cast<const HostCall*>(node);
|
|
if (!n->capability.empty()) props["capability"] = n->capability;
|
|
if (!n->name.empty()) props["name"] = n->name;
|
|
}
|
|
else if (ct == "ScheduleTask") {
|
|
auto* n = static_cast<const ScheduleTask*>(node);
|
|
if (!n->queue.empty()) props["queue"] = n->queue;
|
|
}
|
|
else if (ct == "ModuleLoad") {
|
|
auto* n = static_cast<const ModuleLoad*>(node);
|
|
if (!n->moduleName.empty()) props["moduleName"] = n->moduleName;
|
|
if (!n->mode.empty()) props["mode"] = n->mode;
|
|
}
|
|
// Environment Layer (Step 284-285)
|
|
else if (ct == "CapabilityRequirement") {
|
|
auto* n = static_cast<const CapabilityRequirement*>(node);
|
|
if (!n->capability.empty()) props["capability"] = n->capability;
|
|
props["required"] = n->required;
|
|
}
|
|
// New AST nodes (Sprint 11c)
|
|
else if (ct == "ClassDeclaration") {
|
|
auto* n = static_cast<const ClassDeclaration*>(node);
|
|
props["name"] = n->name;
|
|
if (!n->superClass.empty()) props["superClass"] = n->superClass;
|
|
props["isAbstract"] = n->isAbstract;
|
|
if (!n->baseClasses.empty()) {
|
|
json bases = json::array();
|
|
for (const auto& bc : n->baseClasses) {
|
|
json bj;
|
|
bj["name"] = bc.name;
|
|
bj["accessSpecifier"] = bc.accessSpecifier;
|
|
bj["isVirtual"] = bc.isVirtual;
|
|
bases.push_back(bj);
|
|
}
|
|
props["baseClasses"] = bases;
|
|
}
|
|
}
|
|
else if (ct == "InterfaceDeclaration") {
|
|
auto* n = static_cast<const InterfaceDeclaration*>(node);
|
|
props["name"] = n->name;
|
|
}
|
|
else if (ct == "MethodDeclaration") {
|
|
auto* n = static_cast<const MethodDeclaration*>(node);
|
|
props["name"] = n->name;
|
|
if (!n->className.empty()) props["className"] = n->className;
|
|
props["isStatic"] = n->isStatic;
|
|
if (!n->visibility.empty()) props["visibility"] = n->visibility;
|
|
props["isOverride"] = n->isOverride;
|
|
props["isVirtual"] = n->isVirtual;
|
|
}
|
|
else if (ct == "GenericType") {
|
|
auto* n = static_cast<const GenericType*>(node);
|
|
props["baseName"] = n->baseName;
|
|
if (n->isClassTemplate) props["isClassTemplate"] = n->isClassTemplate;
|
|
}
|
|
else if (ct == "TypeParameter") {
|
|
auto* n = static_cast<const TypeParameter*>(node);
|
|
props["name"] = n->name;
|
|
if (!n->constraint.empty()) props["constraint"] = n->constraint;
|
|
if (n->isVariadic) props["isVariadic"] = n->isVariadic;
|
|
}
|
|
else if (ct == "AsyncFunction") {
|
|
auto* n = static_cast<const AsyncFunction*>(node);
|
|
props["name"] = n->name;
|
|
props["isAsync"] = n->isAsync;
|
|
}
|
|
// AwaitExpression — no extra properties
|
|
else if (ct == "LambdaExpression") {
|
|
auto* n = static_cast<const LambdaExpression*>(node);
|
|
if (!n->captureList.empty()) props["captureList"] = n->captureList;
|
|
}
|
|
else if (ct == "DecoratorAnnotation") {
|
|
auto* n = static_cast<const DecoratorAnnotation*>(node);
|
|
props["name"] = n->name;
|
|
}
|
|
// Preprocessor nodes (Step 337)
|
|
else if (ct == "IncludeDirective") {
|
|
auto* n = static_cast<const IncludeDirective*>(node);
|
|
props["path"] = n->path;
|
|
if (n->isSystem) props["isSystem"] = n->isSystem;
|
|
}
|
|
else if (ct == "PragmaDirective") {
|
|
auto* n = static_cast<const PragmaDirective*>(node);
|
|
props["directive"] = n->directive;
|
|
}
|
|
else if (ct == "MacroDefinition") {
|
|
auto* n = static_cast<const MacroDefinition*>(node);
|
|
props["name"] = n->name;
|
|
if (!n->body.empty()) props["body"] = n->body;
|
|
if (n->isFunctionLike) props["isFunctionLike"] = n->isFunctionLike;
|
|
if (!n->parameters.empty()) props["parameters"] = n->parameters;
|
|
}
|
|
// Enum/Namespace/TypeAlias nodes (Step 338)
|
|
else if (ct == "EnumDeclaration") {
|
|
auto* n = static_cast<const EnumDeclaration*>(node);
|
|
props["name"] = n->name;
|
|
if (n->isScoped) props["isScoped"] = n->isScoped;
|
|
if (!n->underlyingType.empty()) props["underlyingType"] = n->underlyingType;
|
|
}
|
|
else if (ct == "EnumMember") {
|
|
auto* n = static_cast<const EnumMember*>(node);
|
|
props["name"] = n->name;
|
|
if (!n->value.empty()) props["value"] = n->value;
|
|
}
|
|
else if (ct == "NamespaceDeclaration") {
|
|
auto* n = static_cast<const NamespaceDeclaration*>(node);
|
|
props["name"] = n->name;
|
|
}
|
|
else if (ct == "TypeAlias") {
|
|
auto* n = static_cast<const TypeAlias*>(node);
|
|
props["aliasName"] = n->aliasName;
|
|
props["targetType"] = n->targetType;
|
|
if (!n->isUsing) props["isUsing"] = n->isUsing;
|
|
}
|
|
// SQL nodes (Step 410)
|
|
else if (ct == "TableDeclaration") {
|
|
auto* n = static_cast<const TableDeclaration*>(node);
|
|
if (!n->name.empty()) props["name"] = n->name;
|
|
if (!n->schema.empty()) props["schema"] = n->schema;
|
|
}
|
|
else if (ct == "ColumnDefinition") {
|
|
auto* n = static_cast<const ColumnDefinition*>(node);
|
|
if (!n->name.empty()) props["name"] = n->name;
|
|
if (!n->dataType.empty()) props["dataType"] = n->dataType;
|
|
props["nullable"] = n->nullable;
|
|
if (!n->defaultValue.empty()) props["defaultValue"] = n->defaultValue;
|
|
}
|
|
else if (ct == "SelectQuery") {
|
|
auto* n = static_cast<const SelectQuery*>(node);
|
|
if (n->distinct) props["distinct"] = n->distinct;
|
|
}
|
|
else if (ct == "InsertStatement") {
|
|
auto* n = static_cast<const InsertStatement*>(node);
|
|
if (!n->tableName.empty()) props["tableName"] = n->tableName;
|
|
}
|
|
else if (ct == "UpdateStatement") {
|
|
auto* n = static_cast<const UpdateStatement*>(node);
|
|
if (!n->tableName.empty()) props["tableName"] = n->tableName;
|
|
}
|
|
else if (ct == "DeleteStatement") {
|
|
auto* n = static_cast<const DeleteStatement*>(node);
|
|
if (!n->tableName.empty()) props["tableName"] = n->tableName;
|
|
}
|
|
else if (ct == "JoinClause") {
|
|
auto* n = static_cast<const JoinClause*>(node);
|
|
if (!n->joinType.empty()) props["joinType"] = n->joinType;
|
|
if (!n->tableName.empty()) props["tableName"] = n->tableName;
|
|
}
|
|
else if (ct == "WhereClause") {
|
|
auto* n = static_cast<const WhereClause*>(node);
|
|
if (!n->expression.empty()) props["expression"] = n->expression;
|
|
}
|
|
else if (ct == "IndexDefinition") {
|
|
auto* n = static_cast<const IndexDefinition*>(node);
|
|
if (!n->name.empty()) props["name"] = n->name;
|
|
if (!n->tableName.empty()) props["tableName"] = n->tableName;
|
|
if (n->unique) props["unique"] = n->unique;
|
|
}
|
|
// NullLiteral, ListLiteral, IndexAccess, Block, Assignment, IfStatement,
|
|
// WhileLoop, Return, ExpressionStatement, ListType, SetType, MapType,
|
|
// TupleType, ArrayType, OptionalType — no extra properties
|
|
|
|
return props;
|
|
}
|
|
|
|
inline json toJson(const ASTNode* node) {
|
|
json j;
|
|
j["id"] = node->id;
|
|
j["concept"] = node->conceptType;
|
|
j["properties"] = propertiesToJson(node);
|
|
if (node->hasSpan()) {
|
|
j["span"] = {
|
|
{"start", {{"line", node->spanStartLine}, {"col", node->spanStartCol}}},
|
|
{"end", {{"line", node->spanEndLine}, {"col", node->spanEndCol}}}
|
|
};
|
|
}
|
|
|
|
json children = json::object();
|
|
for (const auto& role : node->childRoles()) {
|
|
json arr = json::array();
|
|
for (const auto* child : node->getChildren(role)) {
|
|
arr.push_back(toJson(child));
|
|
}
|
|
children[role] = arr;
|
|
}
|
|
j["children"] = children;
|
|
|
|
return j;
|
|
}
|
|
|
|
// --- Deserialization ---
|
|
|
|
inline ASTNode* createNode(const std::string& conceptName) {
|
|
if (conceptName == "Module") return new Module();
|
|
if (conceptName == "Function") return new Function();
|
|
if (conceptName == "Variable") return new Variable();
|
|
if (conceptName == "Parameter") return new Parameter();
|
|
if (conceptName == "Block") return new Block();
|
|
if (conceptName == "Assignment") return new Assignment();
|
|
if (conceptName == "IfStatement") return new IfStatement();
|
|
if (conceptName == "WhileLoop") return new WhileLoop();
|
|
if (conceptName == "ForLoop") return new ForLoop();
|
|
if (conceptName == "Return") return new Return();
|
|
if (conceptName == "ExpressionStatement") return new ExpressionStatement();
|
|
if (conceptName == "BinaryOperation") return new BinaryOperation();
|
|
if (conceptName == "UnaryOperation") return new UnaryOperation();
|
|
if (conceptName == "FunctionCall") return new FunctionCall();
|
|
if (conceptName == "VariableReference") return new VariableReference();
|
|
if (conceptName == "IntegerLiteral") return new IntegerLiteral();
|
|
if (conceptName == "FloatLiteral") return new FloatLiteral();
|
|
if (conceptName == "StringLiteral") return new StringLiteral();
|
|
if (conceptName == "BooleanLiteral") return new BooleanLiteral();
|
|
if (conceptName == "NullLiteral") return new NullLiteral();
|
|
if (conceptName == "ListLiteral") return new ListLiteral();
|
|
if (conceptName == "IndexAccess") return new IndexAccess();
|
|
if (conceptName == "MemberAccess") return new MemberAccess();
|
|
if (conceptName == "PrimitiveType") return new PrimitiveType();
|
|
if (conceptName == "ListType") return new ListType();
|
|
if (conceptName == "SetType") return new SetType();
|
|
if (conceptName == "MapType") return new MapType();
|
|
if (conceptName == "TupleType") return new TupleType();
|
|
if (conceptName == "ArrayType") return new ArrayType();
|
|
if (conceptName == "OptionalType") return new OptionalType();
|
|
if (conceptName == "CustomType") return new CustomType();
|
|
if (conceptName == "Import") return new Import();
|
|
if (conceptName == "ExternalModule") return new ExternalModule();
|
|
if (conceptName == "TypeSignature") return new TypeSignature();
|
|
if (conceptName == "DerefStrategy") return new DerefStrategy();
|
|
if (conceptName == "OptimizationLock") return new OptimizationLock();
|
|
if (conceptName == "LangSpecific") return new LangSpecific();
|
|
if (conceptName == "IntentAnnotation") return new IntentAnnotation();
|
|
if (conceptName == "ComplexityAnnotation") return new ComplexityAnnotation();
|
|
if (conceptName == "RiskAnnotation") return new RiskAnnotation();
|
|
if (conceptName == "ContractAnnotation") return new ContractAnnotation();
|
|
if (conceptName == "SemanticTagAnnotation") return new SemanticTagAnnotation();
|
|
// Type System — Layout & Constraints (Step 272)
|
|
if (conceptName == "BitWidthAnnotation") return new BitWidthAnnotation();
|
|
if (conceptName == "EndianAnnotation") return new EndianAnnotation();
|
|
if (conceptName == "LayoutAnnotation") return new LayoutAnnotation();
|
|
if (conceptName == "NullabilityAnnotation") return new NullabilityAnnotation();
|
|
if (conceptName == "VarianceAnnotation") return new VarianceAnnotation();
|
|
// Type System — Identity & Mutability (Step 273)
|
|
if (conceptName == "IdentityAnnotation") return new IdentityAnnotation();
|
|
if (conceptName == "MutAnnotation") return new MutAnnotation();
|
|
if (conceptName == "TypeStateAnnotation") return new TypeStateAnnotation();
|
|
// Concurrency (Step 274)
|
|
if (conceptName == "AtomicAnnotation") return new AtomicAnnotation();
|
|
if (conceptName == "SyncAnnotation") return new SyncAnnotation();
|
|
if (conceptName == "ThreadModelAnnotation") return new ThreadModelAnnotation();
|
|
if (conceptName == "MemoryBarrierAnnotation") return new MemoryBarrierAnnotation();
|
|
// Async, Parallelism & Error Handling (Step 275)
|
|
if (conceptName == "ExecAnnotation") return new ExecAnnotation();
|
|
if (conceptName == "BlockingAnnotation") return new BlockingAnnotation();
|
|
if (conceptName == "ParallelAnnotation") return new ParallelAnnotation();
|
|
if (conceptName == "TrapAnnotation") return new TrapAnnotation();
|
|
if (conceptName == "ExceptionAnnotation") return new ExceptionAnnotation();
|
|
if (conceptName == "PanicAnnotation") return new PanicAnnotation();
|
|
// Scope & Namespace (Step 276)
|
|
if (conceptName == "BindingAnnotation") return new BindingAnnotation();
|
|
if (conceptName == "LookupAnnotation") return new LookupAnnotation();
|
|
if (conceptName == "CaptureAnnotation") return new CaptureAnnotation();
|
|
if (conceptName == "VisibilityAnnotation") return new VisibilityAnnotation();
|
|
if (conceptName == "NamespaceAnnotation") return new NamespaceAnnotation();
|
|
if (conceptName == "ScopeAnnotation") return new ScopeAnnotation();
|
|
// Shim & Escape Hatch (Step 278)
|
|
if (conceptName == "IntrinsicAnnotation") return new IntrinsicAnnotation();
|
|
if (conceptName == "RawAnnotation") return new RawAnnotation();
|
|
if (conceptName == "CallingConvAnnotation") return new CallingConvAnnotation();
|
|
if (conceptName == "LinkAnnotation") return new LinkAnnotation();
|
|
if (conceptName == "ShimAnnotation") return new ShimAnnotation();
|
|
if (conceptName == "PointerArithmeticAnnotation") return new PointerArithmeticAnnotation();
|
|
if (conceptName == "OpaqueAnnotation") return new OpaqueAnnotation();
|
|
// Platform & Provenance (Step 279)
|
|
if (conceptName == "TargetAnnotation") return new TargetAnnotation();
|
|
if (conceptName == "FeatureAnnotation") return new FeatureAnnotation();
|
|
if (conceptName == "OriginalAnnotation") return new OriginalAnnotation();
|
|
if (conceptName == "MappingAnnotation") return new MappingAnnotation();
|
|
// Optimization Completion (Step 280)
|
|
if (conceptName == "TailCallAnnotation") return new TailCallAnnotation();
|
|
if (conceptName == "LoopAnnotation") return new LoopAnnotation();
|
|
if (conceptName == "DataAnnotation") return new DataAnnotation();
|
|
if (conceptName == "AlignAnnotation") return new AlignAnnotation();
|
|
if (conceptName == "PackAnnotation") return new PackAnnotation();
|
|
if (conceptName == "BoundsCheckAnnotation") return new BoundsCheckAnnotation();
|
|
if (conceptName == "OverflowAnnotation") return new OverflowAnnotation();
|
|
// Meta-Programming (Step 281)
|
|
if (conceptName == "MetaAnnotation") return new MetaAnnotation();
|
|
if (conceptName == "SymbolAnnotation") return new SymbolAnnotation();
|
|
if (conceptName == "EvaluateAnnotation") return new EvaluateAnnotation();
|
|
if (conceptName == "TemplateAnnotation") return new TemplateAnnotation();
|
|
if (conceptName == "SyntheticAnnotation") return new SyntheticAnnotation();
|
|
// Strategy & Policy (Step 282)
|
|
if (conceptName == "PolicyAnnotation") return new PolicyAnnotation();
|
|
if (conceptName == "AmbiguityAnnotation") return new AmbiguityAnnotation();
|
|
if (conceptName == "CandidateAnnotation") return new CandidateAnnotation();
|
|
if (conceptName == "TradeoffAnnotation") return new TradeoffAnnotation();
|
|
if (conceptName == "ChoiceAnnotation") return new ChoiceAnnotation();
|
|
if (conceptName == "DecisionAnnotation") return new DecisionAnnotation();
|
|
// Subject 9: Workflow Routing (Step 315)
|
|
if (conceptName == "ContextWidthAnnotation") return new ContextWidthAnnotation();
|
|
if (conceptName == "ReviewAnnotation") return new ReviewAnnotation();
|
|
if (conceptName == "AutomatabilityAnnotation") return new AutomatabilityAnnotation();
|
|
if (conceptName == "PriorityAnnotation") return new PriorityAnnotation();
|
|
if (conceptName == "ImplementationStatusAnnotation") return new ImplementationStatusAnnotation();
|
|
// Host Boundary (Step 288)
|
|
if (conceptName == "HostCall") return new HostCall();
|
|
if (conceptName == "ScheduleTask") return new ScheduleTask();
|
|
if (conceptName == "ModuleLoad") return new ModuleLoad();
|
|
// Environment Layer (Step 284-285)
|
|
if (conceptName == "EnvironmentSpec") return new EnvironmentSpec();
|
|
if (conceptName == "CapabilityRequirement") return new CapabilityRequirement();
|
|
// New AST nodes (Sprint 11c)
|
|
if (conceptName == "ClassDeclaration") return new ClassDeclaration();
|
|
if (conceptName == "InterfaceDeclaration") return new InterfaceDeclaration();
|
|
if (conceptName == "MethodDeclaration") return new MethodDeclaration();
|
|
if (conceptName == "GenericType") return new GenericType();
|
|
if (conceptName == "TypeParameter") return new TypeParameter();
|
|
if (conceptName == "AsyncFunction") return new AsyncFunction();
|
|
if (conceptName == "AwaitExpression") return new AwaitExpression();
|
|
if (conceptName == "LambdaExpression") return new LambdaExpression();
|
|
if (conceptName == "DecoratorAnnotation") return new DecoratorAnnotation();
|
|
if (conceptName == "IncludeDirective") return new IncludeDirective();
|
|
if (conceptName == "PragmaDirective") return new PragmaDirective();
|
|
if (conceptName == "MacroDefinition") return new MacroDefinition();
|
|
if (conceptName == "EnumDeclaration") return new EnumDeclaration();
|
|
if (conceptName == "EnumMember") return new EnumMember();
|
|
if (conceptName == "NamespaceDeclaration") return new NamespaceDeclaration();
|
|
if (conceptName == "TypeAlias") return new TypeAlias();
|
|
if (conceptName == "TableDeclaration") return new TableDeclaration();
|
|
if (conceptName == "ColumnDefinition") return new ColumnDefinition();
|
|
if (conceptName == "SelectQuery") return new SelectQuery();
|
|
if (conceptName == "InsertStatement") return new InsertStatement();
|
|
if (conceptName == "UpdateStatement") return new UpdateStatement();
|
|
if (conceptName == "DeleteStatement") return new DeleteStatement();
|
|
if (conceptName == "JoinClause") return new JoinClause();
|
|
if (conceptName == "WhereClause") return new WhereClause();
|
|
if (conceptName == "IndexDefinition") return new IndexDefinition();
|
|
return nullptr;
|
|
}
|
|
|
|
inline void setPropertiesFromJson(ASTNode* node, const json& props) {
|
|
const auto& ct = node->conceptType;
|
|
|
|
if (ct == "Module") {
|
|
auto* n = static_cast<Module*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("targetLanguage")) n->targetLanguage = props["targetLanguage"].get<std::string>();
|
|
}
|
|
else if (ct == "Function") {
|
|
auto* n = static_cast<Function*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
}
|
|
else if (ct == "Variable") {
|
|
auto* n = static_cast<Variable*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
}
|
|
else if (ct == "Parameter") {
|
|
auto* n = static_cast<Parameter*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
}
|
|
else if (ct == "ForLoop") {
|
|
auto* n = static_cast<ForLoop*>(node);
|
|
if (props.contains("iteratorName")) n->iteratorName = props["iteratorName"].get<std::string>();
|
|
}
|
|
else if (ct == "BinaryOperation") {
|
|
auto* n = static_cast<BinaryOperation*>(node);
|
|
if (props.contains("op")) n->op = props["op"].get<std::string>();
|
|
}
|
|
else if (ct == "UnaryOperation") {
|
|
auto* n = static_cast<UnaryOperation*>(node);
|
|
if (props.contains("op")) n->op = props["op"].get<std::string>();
|
|
}
|
|
else if (ct == "FunctionCall") {
|
|
auto* n = static_cast<FunctionCall*>(node);
|
|
if (props.contains("functionName")) n->functionName = props["functionName"].get<std::string>();
|
|
}
|
|
else if (ct == "VariableReference") {
|
|
auto* n = static_cast<VariableReference*>(node);
|
|
if (props.contains("variableName")) n->variableName = props["variableName"].get<std::string>();
|
|
}
|
|
else if (ct == "IntegerLiteral") {
|
|
auto* n = static_cast<IntegerLiteral*>(node);
|
|
if (props.contains("value")) n->value = props["value"].get<int>();
|
|
}
|
|
else if (ct == "FloatLiteral") {
|
|
auto* n = static_cast<FloatLiteral*>(node);
|
|
if (props.contains("value")) n->value = props["value"].get<std::string>();
|
|
}
|
|
else if (ct == "StringLiteral") {
|
|
auto* n = static_cast<StringLiteral*>(node);
|
|
if (props.contains("value")) n->value = props["value"].get<std::string>();
|
|
}
|
|
else if (ct == "BooleanLiteral") {
|
|
auto* n = static_cast<BooleanLiteral*>(node);
|
|
if (props.contains("value")) n->value = props["value"].get<bool>();
|
|
}
|
|
else if (ct == "MemberAccess") {
|
|
auto* n = static_cast<MemberAccess*>(node);
|
|
if (props.contains("memberName")) n->memberName = props["memberName"].get<std::string>();
|
|
}
|
|
else if (ct == "PrimitiveType") {
|
|
auto* n = static_cast<PrimitiveType*>(node);
|
|
if (props.contains("kind")) n->kind = props["kind"].get<std::string>();
|
|
}
|
|
else if (ct == "CustomType") {
|
|
auto* n = static_cast<CustomType*>(node);
|
|
if (props.contains("typeName")) n->typeName = props["typeName"].get<std::string>();
|
|
}
|
|
else if (ct == "Import") {
|
|
auto* n = static_cast<Import*>(node);
|
|
if (props.contains("moduleName")) n->moduleName = props["moduleName"].get<std::string>();
|
|
if (props.contains("alias")) n->alias = props["alias"].get<std::string>();
|
|
if (props.contains("importKind")) n->importKind = props["importKind"].get<std::string>();
|
|
}
|
|
else if (ct == "ExternalModule") {
|
|
auto* n = static_cast<ExternalModule*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("version")) n->version = props["version"].get<std::string>();
|
|
if (props.contains("language")) n->language = props["language"].get<std::string>();
|
|
if (props.contains("semanticTags") && props["semanticTags"].is_array()) {
|
|
n->semanticTags.clear();
|
|
for (const auto& tag : props["semanticTags"]) {
|
|
if (tag.is_string()) n->semanticTags.push_back(tag.get<std::string>());
|
|
}
|
|
}
|
|
}
|
|
else if (ct == "TypeSignature") {
|
|
auto* n = static_cast<TypeSignature*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("variadic")) n->variadic = props["variadic"].get<bool>();
|
|
if (props.contains("semanticTags") && props["semanticTags"].is_array()) {
|
|
n->semanticTags.clear();
|
|
for (const auto& tag : props["semanticTags"]) {
|
|
if (tag.is_string()) n->semanticTags.push_back(tag.get<std::string>());
|
|
}
|
|
}
|
|
}
|
|
else if (ct == "DerefStrategy") {
|
|
auto* n = static_cast<DerefStrategy*>(node);
|
|
if (props.contains("strategy")) n->strategy = props["strategy"].get<std::string>();
|
|
if (props.contains("derefLocation")) n->derefLocation = props["derefLocation"].get<std::string>();
|
|
if (props.contains("owner")) n->owner = props["owner"].get<std::string>();
|
|
}
|
|
else if (ct == "OptimizationLock") {
|
|
auto* n = static_cast<OptimizationLock*>(node);
|
|
if (props.contains("lockedBy")) n->lockedBy = props["lockedBy"].get<std::string>();
|
|
if (props.contains("lockReason")) n->lockReason = props["lockReason"].get<std::string>();
|
|
if (props.contains("lockLevel")) n->lockLevel = props["lockLevel"].get<std::string>();
|
|
if (props.contains("affectedStrategies")) n->affectedStrategies = props["affectedStrategies"].get<std::string>();
|
|
if (props.contains("timestamp")) n->timestamp = props["timestamp"].get<std::string>();
|
|
}
|
|
else if (ct == "LangSpecific") {
|
|
auto* n = static_cast<LangSpecific*>(node);
|
|
if (props.contains("language")) n->language = props["language"].get<std::string>();
|
|
if (props.contains("idiomType")) n->idiomType = props["idiomType"].get<std::string>();
|
|
if (props.contains("rawSyntax")) n->rawSyntax = props["rawSyntax"].get<std::string>();
|
|
if (props.contains("semanticHint")) n->semanticHint = props["semanticHint"].get<std::string>();
|
|
if (props.contains("position")) n->position = props["position"].get<std::string>();
|
|
}
|
|
// Semantic annotations (Sprint 10)
|
|
else if (ct == "IntentAnnotation") {
|
|
auto* n = static_cast<IntentAnnotation*>(node);
|
|
if (props.contains("summary")) n->summary = props["summary"].get<std::string>();
|
|
if (props.contains("category")) n->category = props["category"].get<std::string>();
|
|
}
|
|
else if (ct == "ComplexityAnnotation") {
|
|
auto* n = static_cast<ComplexityAnnotation*>(node);
|
|
if (props.contains("timeComplexity")) n->timeComplexity = props["timeComplexity"].get<std::string>();
|
|
if (props.contains("cognitiveComplexity")) n->cognitiveComplexity = props["cognitiveComplexity"].get<int>();
|
|
if (props.contains("linesOfLogic")) n->linesOfLogic = props["linesOfLogic"].get<int>();
|
|
}
|
|
else if (ct == "RiskAnnotation") {
|
|
auto* n = static_cast<RiskAnnotation*>(node);
|
|
if (props.contains("level")) n->level = props["level"].get<std::string>();
|
|
if (props.contains("reason")) n->reason = props["reason"].get<std::string>();
|
|
if (props.contains("dependentCount")) n->dependentCount = props["dependentCount"].get<int>();
|
|
}
|
|
else if (ct == "ContractAnnotation") {
|
|
auto* n = static_cast<ContractAnnotation*>(node);
|
|
if (props.contains("preconditions")) n->preconditions = props["preconditions"].get<std::string>();
|
|
if (props.contains("postconditions")) n->postconditions = props["postconditions"].get<std::string>();
|
|
if (props.contains("returnShape")) n->returnShape = props["returnShape"].get<std::string>();
|
|
if (props.contains("sideEffects")) n->sideEffects = props["sideEffects"].get<std::string>();
|
|
}
|
|
else if (ct == "SemanticTagAnnotation") {
|
|
auto* n = static_cast<SemanticTagAnnotation*>(node);
|
|
if (props.contains("tags") && props["tags"].is_array()) {
|
|
n->tags.clear();
|
|
for (const auto& tag : props["tags"]) {
|
|
if (tag.is_string()) n->tags.push_back(tag.get<std::string>());
|
|
}
|
|
}
|
|
}
|
|
// Type System — Layout & Constraints (Step 272)
|
|
else if (ct == "BitWidthAnnotation") {
|
|
auto* n = static_cast<BitWidthAnnotation*>(node);
|
|
if (props.contains("width")) n->width = props["width"].get<int>();
|
|
}
|
|
else if (ct == "EndianAnnotation") {
|
|
auto* n = static_cast<EndianAnnotation*>(node);
|
|
if (props.contains("order")) n->order = props["order"].get<std::string>();
|
|
}
|
|
else if (ct == "LayoutAnnotation") {
|
|
auto* n = static_cast<LayoutAnnotation*>(node);
|
|
if (props.contains("mode")) n->mode = props["mode"].get<std::string>();
|
|
if (props.contains("alignment")) n->alignment = props["alignment"].get<int>();
|
|
}
|
|
else if (ct == "NullabilityAnnotation") {
|
|
auto* n = static_cast<NullabilityAnnotation*>(node);
|
|
if (props.contains("nullable")) n->nullable = props["nullable"].get<bool>();
|
|
if (props.contains("strategy")) n->strategy = props["strategy"].get<std::string>();
|
|
}
|
|
else if (ct == "VarianceAnnotation") {
|
|
auto* n = static_cast<VarianceAnnotation*>(node);
|
|
if (props.contains("variance")) n->variance = props["variance"].get<std::string>();
|
|
}
|
|
// Type System — Identity & Mutability (Step 273)
|
|
else if (ct == "IdentityAnnotation") {
|
|
auto* n = static_cast<IdentityAnnotation*>(node);
|
|
if (props.contains("mode")) n->mode = props["mode"].get<std::string>();
|
|
}
|
|
else if (ct == "MutAnnotation") {
|
|
auto* n = static_cast<MutAnnotation*>(node);
|
|
if (props.contains("depth")) n->depth = props["depth"].get<std::string>();
|
|
}
|
|
else if (ct == "TypeStateAnnotation") {
|
|
auto* n = static_cast<TypeStateAnnotation*>(node);
|
|
if (props.contains("state")) n->state = props["state"].get<std::string>();
|
|
}
|
|
// Concurrency (Step 274)
|
|
else if (ct == "AtomicAnnotation") {
|
|
auto* n = static_cast<AtomicAnnotation*>(node);
|
|
if (props.contains("consistency")) n->consistency = props["consistency"].get<std::string>();
|
|
}
|
|
else if (ct == "SyncAnnotation") {
|
|
auto* n = static_cast<SyncAnnotation*>(node);
|
|
if (props.contains("primitive")) n->primitive = props["primitive"].get<std::string>();
|
|
}
|
|
else if (ct == "ThreadModelAnnotation") {
|
|
auto* n = static_cast<ThreadModelAnnotation*>(node);
|
|
if (props.contains("model")) n->model = props["model"].get<std::string>();
|
|
}
|
|
// MemoryBarrierAnnotation has no extra fields
|
|
// Async, Parallelism & Error Handling (Step 275)
|
|
else if (ct == "ExecAnnotation") {
|
|
auto* n = static_cast<ExecAnnotation*>(node);
|
|
if (props.contains("mode")) n->mode = props["mode"].get<std::string>();
|
|
if (props.contains("runtimeHint")) n->runtimeHint = props["runtimeHint"].get<std::string>();
|
|
}
|
|
else if (ct == "BlockingAnnotation") {
|
|
auto* n = static_cast<BlockingAnnotation*>(node);
|
|
if (props.contains("kind")) n->kind = props["kind"].get<std::string>();
|
|
}
|
|
else if (ct == "ParallelAnnotation") {
|
|
auto* n = static_cast<ParallelAnnotation*>(node);
|
|
if (props.contains("kind")) n->kind = props["kind"].get<std::string>();
|
|
}
|
|
else if (ct == "TrapAnnotation") {
|
|
auto* n = static_cast<TrapAnnotation*>(node);
|
|
if (props.contains("signal")) n->signal = props["signal"].get<std::string>();
|
|
}
|
|
else if (ct == "ExceptionAnnotation") {
|
|
auto* n = static_cast<ExceptionAnnotation*>(node);
|
|
if (props.contains("style")) n->style = props["style"].get<std::string>();
|
|
}
|
|
else if (ct == "PanicAnnotation") {
|
|
auto* n = static_cast<PanicAnnotation*>(node);
|
|
if (props.contains("behavior")) n->behavior = props["behavior"].get<std::string>();
|
|
}
|
|
// Scope & Namespace (Step 276)
|
|
else if (ct == "BindingAnnotation") {
|
|
auto* n = static_cast<BindingAnnotation*>(node);
|
|
if (props.contains("time")) n->time = props["time"].get<std::string>();
|
|
}
|
|
else if (ct == "LookupAnnotation") {
|
|
auto* n = static_cast<LookupAnnotation*>(node);
|
|
if (props.contains("mode")) n->mode = props["mode"].get<std::string>();
|
|
}
|
|
else if (ct == "CaptureAnnotation") {
|
|
auto* n = static_cast<CaptureAnnotation*>(node);
|
|
if (props.contains("strategy")) n->strategy = props["strategy"].get<std::string>();
|
|
}
|
|
else if (ct == "VisibilityAnnotation") {
|
|
auto* n = static_cast<VisibilityAnnotation*>(node);
|
|
if (props.contains("level")) n->level = props["level"].get<std::string>();
|
|
}
|
|
else if (ct == "NamespaceAnnotation") {
|
|
auto* n = static_cast<NamespaceAnnotation*>(node);
|
|
if (props.contains("style")) n->style = props["style"].get<std::string>();
|
|
}
|
|
else if (ct == "ScopeAnnotation") {
|
|
auto* n = static_cast<ScopeAnnotation*>(node);
|
|
if (props.contains("kind")) n->kind = props["kind"].get<std::string>();
|
|
}
|
|
// Shim & Escape Hatch (Step 278)
|
|
else if (ct == "IntrinsicAnnotation") {
|
|
auto* n = static_cast<IntrinsicAnnotation*>(node);
|
|
if (props.contains("instruction")) n->instruction = props["instruction"].get<std::string>();
|
|
if (props.contains("arch")) n->arch = props["arch"].get<std::string>();
|
|
}
|
|
else if (ct == "RawAnnotation") {
|
|
auto* n = static_cast<RawAnnotation*>(node);
|
|
if (props.contains("language")) n->language = props["language"].get<std::string>();
|
|
if (props.contains("code")) n->code = props["code"].get<std::string>();
|
|
}
|
|
else if (ct == "CallingConvAnnotation") {
|
|
auto* n = static_cast<CallingConvAnnotation*>(node);
|
|
if (props.contains("convention")) n->convention = props["convention"].get<std::string>();
|
|
}
|
|
else if (ct == "LinkAnnotation") {
|
|
auto* n = static_cast<LinkAnnotation*>(node);
|
|
if (props.contains("symbolName")) n->symbolName = props["symbolName"].get<std::string>();
|
|
if (props.contains("library")) n->library = props["library"].get<std::string>();
|
|
}
|
|
else if (ct == "ShimAnnotation") {
|
|
auto* n = static_cast<ShimAnnotation*>(node);
|
|
if (props.contains("strategy")) n->strategy = props["strategy"].get<std::string>();
|
|
}
|
|
// PointerArithmeticAnnotation — no fields
|
|
else if (ct == "OpaqueAnnotation") {
|
|
auto* n = static_cast<OpaqueAnnotation*>(node);
|
|
if (props.contains("reason")) n->reason = props["reason"].get<std::string>();
|
|
}
|
|
// Platform & Provenance (Step 279)
|
|
else if (ct == "TargetAnnotation") {
|
|
auto* n = static_cast<TargetAnnotation*>(node);
|
|
if (props.contains("platform")) n->platform = props["platform"].get<std::string>();
|
|
if (props.contains("arch")) n->arch = props["arch"].get<std::string>();
|
|
}
|
|
else if (ct == "FeatureAnnotation") {
|
|
auto* n = static_cast<FeatureAnnotation*>(node);
|
|
if (props.contains("flag")) n->flag = props["flag"].get<std::string>();
|
|
if (props.contains("enabled")) n->enabled = props["enabled"].get<bool>();
|
|
}
|
|
else if (ct == "OriginalAnnotation") {
|
|
auto* n = static_cast<OriginalAnnotation*>(node);
|
|
if (props.contains("sourceCode")) n->sourceCode = props["sourceCode"].get<std::string>();
|
|
if (props.contains("sourceLanguage")) n->sourceLanguage = props["sourceLanguage"].get<std::string>();
|
|
}
|
|
else if (ct == "MappingAnnotation") {
|
|
auto* n = static_cast<MappingAnnotation*>(node);
|
|
if (props.contains("history") && props["history"].is_array()) {
|
|
n->history.clear();
|
|
for (const auto& h : props["history"])
|
|
if (h.is_string()) n->history.push_back(h.get<std::string>());
|
|
}
|
|
}
|
|
// Optimization Completion (Step 280)
|
|
// TailCallAnnotation — no fields
|
|
else if (ct == "LoopAnnotation") {
|
|
auto* n = static_cast<LoopAnnotation*>(node);
|
|
if (props.contains("hint")) n->hint = props["hint"].get<std::string>();
|
|
if (props.contains("factor")) n->factor = props["factor"].get<int>();
|
|
}
|
|
else if (ct == "DataAnnotation") {
|
|
auto* n = static_cast<DataAnnotation*>(node);
|
|
if (props.contains("hint")) n->hint = props["hint"].get<std::string>();
|
|
}
|
|
else if (ct == "AlignAnnotation") {
|
|
auto* n = static_cast<AlignAnnotation*>(node);
|
|
if (props.contains("bytes")) n->bytes = props["bytes"].get<int>();
|
|
}
|
|
// PackAnnotation — no fields
|
|
else if (ct == "BoundsCheckAnnotation") {
|
|
auto* n = static_cast<BoundsCheckAnnotation*>(node);
|
|
if (props.contains("enabled")) n->enabled = props["enabled"].get<bool>();
|
|
}
|
|
else if (ct == "OverflowAnnotation") {
|
|
auto* n = static_cast<OverflowAnnotation*>(node);
|
|
if (props.contains("behavior")) n->behavior = props["behavior"].get<std::string>();
|
|
}
|
|
// Meta-Programming (Step 281)
|
|
else if (ct == "MetaAnnotation") {
|
|
auto* n = static_cast<MetaAnnotation*>(node);
|
|
if (props.contains("state")) n->state = props["state"].get<std::string>();
|
|
if (props.contains("phase")) n->phase = props["phase"].get<std::string>();
|
|
}
|
|
else if (ct == "SymbolAnnotation") {
|
|
auto* n = static_cast<SymbolAnnotation*>(node);
|
|
if (props.contains("mode")) n->mode = props["mode"].get<std::string>();
|
|
}
|
|
else if (ct == "EvaluateAnnotation") {
|
|
auto* n = static_cast<EvaluateAnnotation*>(node);
|
|
if (props.contains("phase")) n->phase = props["phase"].get<std::string>();
|
|
}
|
|
else if (ct == "TemplateAnnotation") {
|
|
auto* n = static_cast<TemplateAnnotation*>(node);
|
|
if (props.contains("specialization")) n->specialization = props["specialization"].get<std::string>();
|
|
}
|
|
else if (ct == "SyntheticAnnotation") {
|
|
auto* n = static_cast<SyntheticAnnotation*>(node);
|
|
if (props.contains("generator")) n->generator = props["generator"].get<std::string>();
|
|
if (props.contains("isStructuralRisk")) n->isStructuralRisk = props["isStructuralRisk"].get<bool>();
|
|
}
|
|
// Strategy & Policy (Step 282)
|
|
else if (ct == "PolicyAnnotation") {
|
|
auto* n = static_cast<PolicyAnnotation*>(node);
|
|
if (props.contains("strictness")) n->strictness = props["strictness"].get<std::string>();
|
|
if (props.contains("perf")) n->perf = props["perf"].get<std::string>();
|
|
if (props.contains("style")) n->style = props["style"].get<std::string>();
|
|
if (props.contains("binaryStable")) n->binaryStable = props["binaryStable"].get<bool>();
|
|
}
|
|
else if (ct == "AmbiguityAnnotation") {
|
|
auto* n = static_cast<AmbiguityAnnotation*>(node);
|
|
if (props.contains("intent")) n->intent = props["intent"].get<std::string>();
|
|
if (props.contains("options") && props["options"].is_array()) {
|
|
n->options.clear();
|
|
for (const auto& o : props["options"])
|
|
if (o.is_string()) n->options.push_back(o.get<std::string>());
|
|
}
|
|
if (props.contains("level")) n->level = props["level"].get<std::string>();
|
|
if (props.contains("description")) n->description = props["description"].get<std::string>();
|
|
}
|
|
else if (ct == "CandidateAnnotation") {
|
|
auto* n = static_cast<CandidateAnnotation*>(node);
|
|
if (props.contains("inferredTypes") && props["inferredTypes"].is_array()) {
|
|
n->inferredTypes.clear();
|
|
for (const auto& t : props["inferredTypes"])
|
|
if (t.is_string()) n->inferredTypes.push_back(t.get<std::string>());
|
|
}
|
|
}
|
|
else if (ct == "TradeoffAnnotation") {
|
|
auto* n = static_cast<TradeoffAnnotation*>(node);
|
|
if (props.contains("reason")) n->reason = props["reason"].get<std::string>();
|
|
if (props.contains("safetyCost")) n->safetyCost = props["safetyCost"].get<std::string>();
|
|
if (props.contains("perfCost")) n->perfCost = props["perfCost"].get<std::string>();
|
|
}
|
|
else if (ct == "ChoiceAnnotation") {
|
|
auto* n = static_cast<ChoiceAnnotation*>(node);
|
|
if (props.contains("choiceId")) n->choiceId = props["choiceId"].get<std::string>();
|
|
if (props.contains("options") && props["options"].is_array()) {
|
|
n->options.clear();
|
|
for (const auto& o : props["options"])
|
|
if (o.is_string()) n->options.push_back(o.get<std::string>());
|
|
}
|
|
}
|
|
else if (ct == "DecisionAnnotation") {
|
|
auto* n = static_cast<DecisionAnnotation*>(node);
|
|
if (props.contains("choiceId")) n->choiceId = props["choiceId"].get<std::string>();
|
|
if (props.contains("selection")) n->selection = props["selection"].get<std::string>();
|
|
if (props.contains("author")) n->author = props["author"].get<std::string>();
|
|
if (props.contains("reason")) n->reason = props["reason"].get<std::string>();
|
|
}
|
|
// Subject 9: Workflow Routing (Step 315)
|
|
else if (ct == "ContextWidthAnnotation") {
|
|
auto* n = static_cast<ContextWidthAnnotation*>(node);
|
|
if (props.contains("width")) n->width = props["width"].get<std::string>();
|
|
}
|
|
else if (ct == "ReviewAnnotation") {
|
|
auto* n = static_cast<ReviewAnnotation*>(node);
|
|
if (props.contains("required")) n->required = props["required"].get<bool>();
|
|
if (props.contains("reviewer")) n->reviewer = props["reviewer"].get<std::string>();
|
|
if (props.contains("reason")) n->reason = props["reason"].get<std::string>();
|
|
}
|
|
else if (ct == "AutomatabilityAnnotation") {
|
|
auto* n = static_cast<AutomatabilityAnnotation*>(node);
|
|
if (props.contains("strategy")) n->strategy = props["strategy"].get<std::string>();
|
|
if (props.contains("confidence")) n->confidence = props["confidence"].get<double>();
|
|
}
|
|
else if (ct == "PriorityAnnotation") {
|
|
auto* n = static_cast<PriorityAnnotation*>(node);
|
|
if (props.contains("level")) n->level = props["level"].get<std::string>();
|
|
if (props.contains("blockedBy") && props["blockedBy"].is_array()) {
|
|
n->blockedBy.clear();
|
|
for (const auto& b : props["blockedBy"])
|
|
if (b.is_string()) n->blockedBy.push_back(b.get<std::string>());
|
|
}
|
|
}
|
|
else if (ct == "ImplementationStatusAnnotation") {
|
|
auto* n = static_cast<ImplementationStatusAnnotation*>(node);
|
|
if (props.contains("status")) n->status = props["status"].get<std::string>();
|
|
if (props.contains("assignee")) n->assignee = props["assignee"].get<std::string>();
|
|
}
|
|
// Host Boundary (Step 288)
|
|
else if (ct == "HostCall") {
|
|
auto* n = static_cast<HostCall*>(node);
|
|
if (props.contains("capability")) n->capability = props["capability"].get<std::string>();
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
}
|
|
else if (ct == "ScheduleTask") {
|
|
auto* n = static_cast<ScheduleTask*>(node);
|
|
if (props.contains("queue")) n->queue = props["queue"].get<std::string>();
|
|
}
|
|
else if (ct == "ModuleLoad") {
|
|
auto* n = static_cast<ModuleLoad*>(node);
|
|
if (props.contains("moduleName")) n->moduleName = props["moduleName"].get<std::string>();
|
|
if (props.contains("mode")) n->mode = props["mode"].get<std::string>();
|
|
}
|
|
// Environment Layer (Step 284-285)
|
|
else if (ct == "CapabilityRequirement") {
|
|
auto* n = static_cast<CapabilityRequirement*>(node);
|
|
if (props.contains("capability")) n->capability = props["capability"].get<std::string>();
|
|
if (props.contains("required")) n->required = props["required"].get<bool>();
|
|
}
|
|
// New AST nodes (Sprint 11c)
|
|
else if (ct == "ClassDeclaration") {
|
|
auto* n = static_cast<ClassDeclaration*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("superClass")) n->superClass = props["superClass"].get<std::string>();
|
|
if (props.contains("isAbstract")) n->isAbstract = props["isAbstract"].get<bool>();
|
|
if (props.contains("baseClasses")) {
|
|
n->baseClasses.clear();
|
|
for (const auto& bj : props["baseClasses"]) {
|
|
BaseClass bc;
|
|
bc.name = bj.value("name", "");
|
|
bc.accessSpecifier = bj.value("accessSpecifier", "public");
|
|
bc.isVirtual = bj.value("isVirtual", false);
|
|
n->baseClasses.push_back(bc);
|
|
}
|
|
// Sync superClass from first base for backward compat
|
|
if (!n->baseClasses.empty() && n->superClass.empty()) {
|
|
n->superClass = n->baseClasses[0].name;
|
|
}
|
|
}
|
|
}
|
|
else if (ct == "InterfaceDeclaration") {
|
|
auto* n = static_cast<InterfaceDeclaration*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
}
|
|
else if (ct == "MethodDeclaration") {
|
|
auto* n = static_cast<MethodDeclaration*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("className")) n->className = props["className"].get<std::string>();
|
|
if (props.contains("isStatic")) n->isStatic = props["isStatic"].get<bool>();
|
|
if (props.contains("visibility")) n->visibility = props["visibility"].get<std::string>();
|
|
if (props.contains("isOverride")) n->isOverride = props["isOverride"].get<bool>();
|
|
if (props.contains("isVirtual")) n->isVirtual = props["isVirtual"].get<bool>();
|
|
}
|
|
else if (ct == "GenericType") {
|
|
auto* n = static_cast<GenericType*>(node);
|
|
if (props.contains("baseName")) n->baseName = props["baseName"].get<std::string>();
|
|
if (props.contains("isClassTemplate")) n->isClassTemplate = props["isClassTemplate"].get<bool>();
|
|
}
|
|
else if (ct == "TypeParameter") {
|
|
auto* n = static_cast<TypeParameter*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("constraint")) n->constraint = props["constraint"].get<std::string>();
|
|
if (props.contains("isVariadic")) n->isVariadic = props["isVariadic"].get<bool>();
|
|
}
|
|
else if (ct == "AsyncFunction") {
|
|
auto* n = static_cast<AsyncFunction*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("isAsync")) n->isAsync = props["isAsync"].get<bool>();
|
|
}
|
|
// AwaitExpression — no extra properties
|
|
else if (ct == "LambdaExpression") {
|
|
auto* n = static_cast<LambdaExpression*>(node);
|
|
if (props.contains("captureList") && props["captureList"].is_array()) {
|
|
n->captureList.clear();
|
|
for (const auto& c : props["captureList"])
|
|
if (c.is_string()) n->captureList.push_back(c.get<std::string>());
|
|
}
|
|
}
|
|
else if (ct == "DecoratorAnnotation") {
|
|
auto* n = static_cast<DecoratorAnnotation*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
}
|
|
// Preprocessor nodes (Step 337)
|
|
else if (ct == "IncludeDirective") {
|
|
auto* n = static_cast<IncludeDirective*>(node);
|
|
if (props.contains("path")) n->path = props["path"].get<std::string>();
|
|
if (props.contains("isSystem")) n->isSystem = props["isSystem"].get<bool>();
|
|
}
|
|
else if (ct == "PragmaDirective") {
|
|
auto* n = static_cast<PragmaDirective*>(node);
|
|
if (props.contains("directive")) n->directive = props["directive"].get<std::string>();
|
|
}
|
|
else if (ct == "MacroDefinition") {
|
|
auto* n = static_cast<MacroDefinition*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("body")) n->body = props["body"].get<std::string>();
|
|
if (props.contains("isFunctionLike")) n->isFunctionLike = props["isFunctionLike"].get<bool>();
|
|
if (props.contains("parameters") && props["parameters"].is_array()) {
|
|
n->parameters.clear();
|
|
for (const auto& p : props["parameters"])
|
|
if (p.is_string()) n->parameters.push_back(p.get<std::string>());
|
|
}
|
|
}
|
|
// Enum/Namespace/TypeAlias nodes (Step 338)
|
|
else if (ct == "EnumDeclaration") {
|
|
auto* n = static_cast<EnumDeclaration*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("isScoped")) n->isScoped = props["isScoped"].get<bool>();
|
|
if (props.contains("underlyingType")) n->underlyingType = props["underlyingType"].get<std::string>();
|
|
}
|
|
else if (ct == "EnumMember") {
|
|
auto* n = static_cast<EnumMember*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("value")) n->value = props["value"].get<std::string>();
|
|
}
|
|
else if (ct == "NamespaceDeclaration") {
|
|
auto* n = static_cast<NamespaceDeclaration*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
}
|
|
else if (ct == "TypeAlias") {
|
|
auto* n = static_cast<TypeAlias*>(node);
|
|
if (props.contains("aliasName")) n->aliasName = props["aliasName"].get<std::string>();
|
|
if (props.contains("targetType")) n->targetType = props["targetType"].get<std::string>();
|
|
if (props.contains("isUsing")) n->isUsing = props["isUsing"].get<bool>();
|
|
}
|
|
// SQL nodes (Step 410)
|
|
else if (ct == "TableDeclaration") {
|
|
auto* n = static_cast<TableDeclaration*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("schema")) n->schema = props["schema"].get<std::string>();
|
|
}
|
|
else if (ct == "ColumnDefinition") {
|
|
auto* n = static_cast<ColumnDefinition*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("dataType")) n->dataType = props["dataType"].get<std::string>();
|
|
if (props.contains("nullable")) n->nullable = props["nullable"].get<bool>();
|
|
if (props.contains("defaultValue")) n->defaultValue = props["defaultValue"].get<std::string>();
|
|
}
|
|
else if (ct == "SelectQuery") {
|
|
auto* n = static_cast<SelectQuery*>(node);
|
|
if (props.contains("distinct")) n->distinct = props["distinct"].get<bool>();
|
|
}
|
|
else if (ct == "InsertStatement") {
|
|
auto* n = static_cast<InsertStatement*>(node);
|
|
if (props.contains("tableName")) n->tableName = props["tableName"].get<std::string>();
|
|
}
|
|
else if (ct == "UpdateStatement") {
|
|
auto* n = static_cast<UpdateStatement*>(node);
|
|
if (props.contains("tableName")) n->tableName = props["tableName"].get<std::string>();
|
|
}
|
|
else if (ct == "DeleteStatement") {
|
|
auto* n = static_cast<DeleteStatement*>(node);
|
|
if (props.contains("tableName")) n->tableName = props["tableName"].get<std::string>();
|
|
}
|
|
else if (ct == "JoinClause") {
|
|
auto* n = static_cast<JoinClause*>(node);
|
|
if (props.contains("joinType")) n->joinType = props["joinType"].get<std::string>();
|
|
if (props.contains("tableName")) n->tableName = props["tableName"].get<std::string>();
|
|
}
|
|
else if (ct == "WhereClause") {
|
|
auto* n = static_cast<WhereClause*>(node);
|
|
if (props.contains("expression")) n->expression = props["expression"].get<std::string>();
|
|
}
|
|
else if (ct == "IndexDefinition") {
|
|
auto* n = static_cast<IndexDefinition*>(node);
|
|
if (props.contains("name")) n->name = props["name"].get<std::string>();
|
|
if (props.contains("tableName")) n->tableName = props["tableName"].get<std::string>();
|
|
if (props.contains("unique")) n->unique = props["unique"].get<bool>();
|
|
}
|
|
}
|
|
|
|
inline std::string generateNodeId() {
|
|
static int counter = 0;
|
|
return "node_" + std::to_string(++counter);
|
|
}
|
|
|
|
inline ASTNode* fromJson(const json& j) {
|
|
ASTNode* node = createNode(j["concept"].get<std::string>());
|
|
if (!node) return nullptr;
|
|
|
|
node->id = j.contains("id") ? j["id"].get<std::string>()
|
|
: generateNodeId();
|
|
if (j.contains("span")) {
|
|
const auto& span = j["span"];
|
|
if (span.contains("start") && span.contains("end")) {
|
|
const auto& s = span["start"];
|
|
const auto& e = span["end"];
|
|
if (s.contains("line") && s.contains("col") && e.contains("line") && e.contains("col")) {
|
|
node->setSpan(s["line"].get<int>(), s["col"].get<int>(),
|
|
e["line"].get<int>(), e["col"].get<int>());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (j.contains("properties")) {
|
|
setPropertiesFromJson(node, j["properties"]);
|
|
}
|
|
|
|
if (j.contains("children")) {
|
|
for (auto& [role, arr] : j["children"].items()) {
|
|
for (auto& childJson : arr) {
|
|
ASTNode* child = fromJson(childJson);
|
|
if (child) node->addChild(role, child);
|
|
}
|
|
}
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
inline void deleteTree(ASTNode* node) {
|
|
if (!node) return;
|
|
for (auto* child : node->allChildren()) {
|
|
deleteTree(child);
|
|
}
|
|
delete node;
|
|
}
|