Steps 290-294: Phase 11a — Semanno format, annotation codegen, visitor dispatch (60/60 tests)
Semanno comment format standard (@semanno:type(key=value)) with emitter/parser covering all 67+ annotation types. SemannoAnnotationImpl CRTP mixin provides default visitor implementations for all 56 extended annotation methods across 7 language generators. Virtual inheritance resolves diamond ambiguity between ProjectionGenerator and SemannoAnnotationImpl. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Bill
87
editor/src/ast/AnnotationVisitors.h
Normal file
87
editor/src/ast/AnnotationVisitors.h
Normal file
@@ -0,0 +1,87 @@
|
||||
#pragma once
|
||||
#include "Annotation.h"
|
||||
#include "../EnvironmentSpec.h"
|
||||
|
||||
// Pure virtual interface for Subject 2-8 annotation visitors.
|
||||
// Generators that support these annotations inherit from this.
|
||||
class AnnotationVisitorExtended {
|
||||
public:
|
||||
virtual ~AnnotationVisitorExtended() = default;
|
||||
|
||||
// Subject 2: Type System
|
||||
virtual std::string visitBitWidthAnnotation(const BitWidthAnnotation*) = 0;
|
||||
virtual std::string visitEndianAnnotation(const EndianAnnotation*) = 0;
|
||||
virtual std::string visitLayoutAnnotation(const LayoutAnnotation*) = 0;
|
||||
virtual std::string visitNullabilityAnnotation(const NullabilityAnnotation*) = 0;
|
||||
virtual std::string visitVarianceAnnotation(const VarianceAnnotation*) = 0;
|
||||
virtual std::string visitIdentityAnnotation(const IdentityAnnotation*) = 0;
|
||||
virtual std::string visitMutAnnotation(const MutAnnotation*) = 0;
|
||||
virtual std::string visitTypeStateAnnotation(const TypeStateAnnotation*) = 0;
|
||||
|
||||
// Subject 3: Concurrency
|
||||
virtual std::string visitAtomicAnnotation(const AtomicAnnotation*) = 0;
|
||||
virtual std::string visitSyncAnnotation(const SyncAnnotation*) = 0;
|
||||
virtual std::string visitThreadModelAnnotation(const ThreadModelAnnotation*) = 0;
|
||||
virtual std::string visitMemoryBarrierAnnotation(const MemoryBarrierAnnotation*) = 0;
|
||||
virtual std::string visitExecAnnotation(const ExecAnnotation*) = 0;
|
||||
virtual std::string visitBlockingAnnotation(const BlockingAnnotation*) = 0;
|
||||
virtual std::string visitParallelAnnotation(const ParallelAnnotation*) = 0;
|
||||
virtual std::string visitTrapAnnotation(const TrapAnnotation*) = 0;
|
||||
virtual std::string visitExceptionAnnotation(const ExceptionAnnotation*) = 0;
|
||||
virtual std::string visitPanicAnnotation(const PanicAnnotation*) = 0;
|
||||
|
||||
// Subject 4: Scope
|
||||
virtual std::string visitBindingAnnotation(const BindingAnnotation*) = 0;
|
||||
virtual std::string visitLookupAnnotation(const LookupAnnotation*) = 0;
|
||||
virtual std::string visitCaptureAnnotation(const CaptureAnnotation*) = 0;
|
||||
virtual std::string visitVisibilityAnnotation(const VisibilityAnnotation*) = 0;
|
||||
virtual std::string visitNamespaceAnnotation(const NamespaceAnnotation*) = 0;
|
||||
virtual std::string visitScopeAnnotation(const ScopeAnnotation*) = 0;
|
||||
|
||||
// Subject 5: Shims & Platform
|
||||
virtual std::string visitIntrinsicAnnotation(const IntrinsicAnnotation*) = 0;
|
||||
virtual std::string visitRawAnnotation(const RawAnnotation*) = 0;
|
||||
virtual std::string visitCallingConvAnnotation(const CallingConvAnnotation*) = 0;
|
||||
virtual std::string visitLinkAnnotation(const LinkAnnotation*) = 0;
|
||||
virtual std::string visitShimAnnotation(const ShimAnnotation*) = 0;
|
||||
virtual std::string visitPointerArithmeticAnnotation(const PointerArithmeticAnnotation*) = 0;
|
||||
virtual std::string visitOpaqueAnnotation(const OpaqueAnnotation*) = 0;
|
||||
virtual std::string visitTargetAnnotation(const TargetAnnotation*) = 0;
|
||||
virtual std::string visitFeatureAnnotation(const FeatureAnnotation*) = 0;
|
||||
virtual std::string visitOriginalAnnotation(const OriginalAnnotation*) = 0;
|
||||
virtual std::string visitMappingAnnotation(const MappingAnnotation*) = 0;
|
||||
|
||||
// Subject 6: Optimization
|
||||
virtual std::string visitTailCallAnnotation(const TailCallAnnotation*) = 0;
|
||||
virtual std::string visitLoopAnnotation(const LoopAnnotation*) = 0;
|
||||
virtual std::string visitDataAnnotation(const DataAnnotation*) = 0;
|
||||
virtual std::string visitAlignAnnotation(const AlignAnnotation*) = 0;
|
||||
virtual std::string visitPackAnnotation(const PackAnnotation*) = 0;
|
||||
virtual std::string visitBoundsCheckAnnotation(const BoundsCheckAnnotation*) = 0;
|
||||
virtual std::string visitOverflowAnnotation(const OverflowAnnotation*) = 0;
|
||||
|
||||
// Subject 7: Meta-Programming
|
||||
virtual std::string visitMetaAnnotation(const MetaAnnotation*) = 0;
|
||||
virtual std::string visitSymbolAnnotation(const SymbolAnnotation*) = 0;
|
||||
virtual std::string visitEvaluateAnnotation(const EvaluateAnnotation*) = 0;
|
||||
virtual std::string visitTemplateAnnotation(const TemplateAnnotation*) = 0;
|
||||
virtual std::string visitSyntheticAnnotation(const SyntheticAnnotation*) = 0;
|
||||
|
||||
// Subject 8: Policy
|
||||
virtual std::string visitPolicyAnnotation(const PolicyAnnotation*) = 0;
|
||||
virtual std::string visitAmbiguityAnnotation(const AmbiguityAnnotation*) = 0;
|
||||
virtual std::string visitCandidateAnnotation(const CandidateAnnotation*) = 0;
|
||||
virtual std::string visitTradeoffAnnotation(const TradeoffAnnotation*) = 0;
|
||||
virtual std::string visitChoiceAnnotation(const ChoiceAnnotation*) = 0;
|
||||
virtual std::string visitDecisionAnnotation(const DecisionAnnotation*) = 0;
|
||||
|
||||
// Semantic Core
|
||||
virtual std::string visitIntentAnnotation(const IntentAnnotation*) = 0;
|
||||
virtual std::string visitComplexityAnnotation(const ComplexityAnnotation*) = 0;
|
||||
virtual std::string visitRiskAnnotation(const RiskAnnotation*) = 0;
|
||||
virtual std::string visitContractAnnotation(const ContractAnnotation*) = 0;
|
||||
virtual std::string visitSemanticTagAnnotation(const SemanticTagAnnotation*) = 0;
|
||||
|
||||
// Environment
|
||||
virtual std::string visitCapabilityRequirement(const CapabilityRequirement*) = 0;
|
||||
};
|
||||
@@ -1,9 +1,12 @@
|
||||
#pragma once
|
||||
#include "ProjectionGenerator.h"
|
||||
#include "../TypeAwareMappings.h"
|
||||
#include "../SemannoAnnotationImpl.h"
|
||||
|
||||
class CppGenerator : public ProjectionGenerator {
|
||||
class CppGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<CppGenerator> {
|
||||
public:
|
||||
std::string commentPrefix() const { return "// "; }
|
||||
|
||||
std::string generate(const ASTNode* node) override {
|
||||
return dispatchGenerate(this, node, "// Unknown concept: ");
|
||||
}
|
||||
|
||||
@@ -1,8 +1,11 @@
|
||||
#pragma once
|
||||
#include "ProjectionGenerator.h"
|
||||
#include "../SemannoAnnotationImpl.h"
|
||||
|
||||
class ElispGenerator : public ProjectionGenerator {
|
||||
class ElispGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<ElispGenerator> {
|
||||
public:
|
||||
std::string commentPrefix() const { return ";; "; }
|
||||
|
||||
std::string generate(const ASTNode* node) override {
|
||||
return dispatchGenerate(this, node, "; Unknown concept: ");
|
||||
}
|
||||
|
||||
@@ -9,3 +9,5 @@
|
||||
#include "JavaGenerator.h"
|
||||
#include "RustGenerator.h"
|
||||
#include "GoGenerator.h"
|
||||
#include "KotlinGenerator.h"
|
||||
#include "CSharpGenerator.h"
|
||||
|
||||
@@ -1,9 +1,12 @@
|
||||
#pragma once
|
||||
#include "ProjectionGenerator.h"
|
||||
#include "Import.h"
|
||||
#include "../SemannoAnnotationImpl.h"
|
||||
|
||||
class GoGenerator : public ProjectionGenerator {
|
||||
class GoGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<GoGenerator> {
|
||||
public:
|
||||
std::string commentPrefix() const { return "// "; }
|
||||
|
||||
std::string generate(const ASTNode* node) override {
|
||||
return dispatchGenerate(this, node, "// Unknown concept: ");
|
||||
}
|
||||
|
||||
@@ -1,11 +1,14 @@
|
||||
#pragma once
|
||||
#include "ProjectionGenerator.h"
|
||||
#include "Import.h"
|
||||
#include "../SemannoAnnotationImpl.h"
|
||||
#include <map>
|
||||
#include <unordered_map>
|
||||
|
||||
class JavaGenerator : public ProjectionGenerator {
|
||||
class JavaGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<JavaGenerator> {
|
||||
public:
|
||||
std::string commentPrefix() const { return "// "; }
|
||||
|
||||
std::string generate(const ASTNode* node) override {
|
||||
return dispatchGenerate(this, node, "// Unknown concept: ");
|
||||
}
|
||||
|
||||
@@ -1,11 +1,14 @@
|
||||
#pragma once
|
||||
#include "ProjectionGenerator.h"
|
||||
#include "Import.h"
|
||||
#include "../SemannoAnnotationImpl.h"
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
|
||||
class JavaScriptGenerator : public ProjectionGenerator {
|
||||
class JavaScriptGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<JavaScriptGenerator> {
|
||||
public:
|
||||
std::string commentPrefix() const { return "// "; }
|
||||
|
||||
explicit JavaScriptGenerator(bool includeTypes = false)
|
||||
: includeTypes_(includeTypes) {}
|
||||
|
||||
|
||||
@@ -153,5 +153,7 @@ public:
|
||||
#include "ast/JavaParser.h"
|
||||
#include "ast/RustParser.h"
|
||||
#include "ast/GoParser.h"
|
||||
#include "ast/KotlinParser.h"
|
||||
#include "ast/CSharpParser.h"
|
||||
private:
|
||||
};
|
||||
|
||||
@@ -12,8 +12,10 @@
|
||||
#include "Expression.h"
|
||||
#include "Type.h"
|
||||
#include "Annotation.h"
|
||||
#include "AnnotationVisitors.h"
|
||||
#include "HostBoundary.h"
|
||||
|
||||
class ProjectionGenerator {
|
||||
class ProjectionGenerator : public virtual AnnotationVisitorExtended {
|
||||
public:
|
||||
virtual ~ProjectionGenerator() = default;
|
||||
|
||||
@@ -61,6 +63,22 @@ public:
|
||||
virtual std::string visitInlineAnnotation(const InlineAnnotation* annotation) = 0;
|
||||
virtual std::string visitPureAnnotation(const PureAnnotation* annotation) = 0;
|
||||
virtual std::string visitConstExprAnnotation(const ConstExprAnnotation* annotation) = 0;
|
||||
|
||||
// New AST node visitors (Phase 11c)
|
||||
virtual std::string visitClassDeclaration(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitInterfaceDeclaration(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitMethodDeclaration(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitGenericType(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitTypeParameter(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitAsyncFunction(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitAwaitExpression(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitLambdaExpression(const ASTNode* node) { return ""; }
|
||||
virtual std::string visitDecoratorAnnotation(const ASTNode* node) { return ""; }
|
||||
|
||||
// Host boundary visitors
|
||||
virtual std::string visitHostCall(const HostCall* node) { return ""; }
|
||||
virtual std::string visitScheduleTask(const ScheduleTask* node) { return ""; }
|
||||
virtual std::string visitModuleLoad(const ModuleLoad* node) { return ""; }
|
||||
};
|
||||
|
||||
// Shared dispatch: maps conceptType string to the appropriate visit call.
|
||||
@@ -156,6 +174,170 @@ std::string dispatchGenerate(Gen* gen, const ASTNode* node, const std::string& u
|
||||
} else if (node->conceptType == "ConstExprAnnotation") {
|
||||
return gen->visitConstExprAnnotation(static_cast<const ConstExprAnnotation*>(node));
|
||||
}
|
||||
// Subject 2: Type System (Steps 291-292)
|
||||
else if (node->conceptType == "BitWidthAnnotation") {
|
||||
return gen->visitBitWidthAnnotation(static_cast<const BitWidthAnnotation*>(node));
|
||||
} else if (node->conceptType == "EndianAnnotation") {
|
||||
return gen->visitEndianAnnotation(static_cast<const EndianAnnotation*>(node));
|
||||
} else if (node->conceptType == "LayoutAnnotation") {
|
||||
return gen->visitLayoutAnnotation(static_cast<const LayoutAnnotation*>(node));
|
||||
} else if (node->conceptType == "NullabilityAnnotation") {
|
||||
return gen->visitNullabilityAnnotation(static_cast<const NullabilityAnnotation*>(node));
|
||||
} else if (node->conceptType == "VarianceAnnotation") {
|
||||
return gen->visitVarianceAnnotation(static_cast<const VarianceAnnotation*>(node));
|
||||
} else if (node->conceptType == "IdentityAnnotation") {
|
||||
return gen->visitIdentityAnnotation(static_cast<const IdentityAnnotation*>(node));
|
||||
} else if (node->conceptType == "MutAnnotation") {
|
||||
return gen->visitMutAnnotation(static_cast<const MutAnnotation*>(node));
|
||||
} else if (node->conceptType == "TypeStateAnnotation") {
|
||||
return gen->visitTypeStateAnnotation(static_cast<const TypeStateAnnotation*>(node));
|
||||
}
|
||||
// Subject 3: Concurrency
|
||||
else if (node->conceptType == "AtomicAnnotation") {
|
||||
return gen->visitAtomicAnnotation(static_cast<const AtomicAnnotation*>(node));
|
||||
} else if (node->conceptType == "SyncAnnotation") {
|
||||
return gen->visitSyncAnnotation(static_cast<const SyncAnnotation*>(node));
|
||||
} else if (node->conceptType == "ThreadModelAnnotation") {
|
||||
return gen->visitThreadModelAnnotation(static_cast<const ThreadModelAnnotation*>(node));
|
||||
} else if (node->conceptType == "MemoryBarrierAnnotation") {
|
||||
return gen->visitMemoryBarrierAnnotation(static_cast<const MemoryBarrierAnnotation*>(node));
|
||||
} else if (node->conceptType == "ExecAnnotation") {
|
||||
return gen->visitExecAnnotation(static_cast<const ExecAnnotation*>(node));
|
||||
} else if (node->conceptType == "BlockingAnnotation") {
|
||||
return gen->visitBlockingAnnotation(static_cast<const BlockingAnnotation*>(node));
|
||||
} else if (node->conceptType == "ParallelAnnotation") {
|
||||
return gen->visitParallelAnnotation(static_cast<const ParallelAnnotation*>(node));
|
||||
} else if (node->conceptType == "TrapAnnotation") {
|
||||
return gen->visitTrapAnnotation(static_cast<const TrapAnnotation*>(node));
|
||||
} else if (node->conceptType == "ExceptionAnnotation") {
|
||||
return gen->visitExceptionAnnotation(static_cast<const ExceptionAnnotation*>(node));
|
||||
} else if (node->conceptType == "PanicAnnotation") {
|
||||
return gen->visitPanicAnnotation(static_cast<const PanicAnnotation*>(node));
|
||||
}
|
||||
// Subject 4: Scope
|
||||
else if (node->conceptType == "BindingAnnotation") {
|
||||
return gen->visitBindingAnnotation(static_cast<const BindingAnnotation*>(node));
|
||||
} else if (node->conceptType == "LookupAnnotation") {
|
||||
return gen->visitLookupAnnotation(static_cast<const LookupAnnotation*>(node));
|
||||
} else if (node->conceptType == "CaptureAnnotation") {
|
||||
return gen->visitCaptureAnnotation(static_cast<const CaptureAnnotation*>(node));
|
||||
} else if (node->conceptType == "VisibilityAnnotation") {
|
||||
return gen->visitVisibilityAnnotation(static_cast<const VisibilityAnnotation*>(node));
|
||||
} else if (node->conceptType == "NamespaceAnnotation") {
|
||||
return gen->visitNamespaceAnnotation(static_cast<const NamespaceAnnotation*>(node));
|
||||
} else if (node->conceptType == "ScopeAnnotation") {
|
||||
return gen->visitScopeAnnotation(static_cast<const ScopeAnnotation*>(node));
|
||||
}
|
||||
// Subject 5: Shims & Platform
|
||||
else if (node->conceptType == "IntrinsicAnnotation") {
|
||||
return gen->visitIntrinsicAnnotation(static_cast<const IntrinsicAnnotation*>(node));
|
||||
} else if (node->conceptType == "RawAnnotation") {
|
||||
return gen->visitRawAnnotation(static_cast<const RawAnnotation*>(node));
|
||||
} else if (node->conceptType == "CallingConvAnnotation") {
|
||||
return gen->visitCallingConvAnnotation(static_cast<const CallingConvAnnotation*>(node));
|
||||
} else if (node->conceptType == "LinkAnnotation") {
|
||||
return gen->visitLinkAnnotation(static_cast<const LinkAnnotation*>(node));
|
||||
} else if (node->conceptType == "ShimAnnotation") {
|
||||
return gen->visitShimAnnotation(static_cast<const ShimAnnotation*>(node));
|
||||
} else if (node->conceptType == "PointerArithmeticAnnotation") {
|
||||
return gen->visitPointerArithmeticAnnotation(static_cast<const PointerArithmeticAnnotation*>(node));
|
||||
} else if (node->conceptType == "OpaqueAnnotation") {
|
||||
return gen->visitOpaqueAnnotation(static_cast<const OpaqueAnnotation*>(node));
|
||||
} else if (node->conceptType == "TargetAnnotation") {
|
||||
return gen->visitTargetAnnotation(static_cast<const TargetAnnotation*>(node));
|
||||
} else if (node->conceptType == "FeatureAnnotation") {
|
||||
return gen->visitFeatureAnnotation(static_cast<const FeatureAnnotation*>(node));
|
||||
} else if (node->conceptType == "OriginalAnnotation") {
|
||||
return gen->visitOriginalAnnotation(static_cast<const OriginalAnnotation*>(node));
|
||||
} else if (node->conceptType == "MappingAnnotation") {
|
||||
return gen->visitMappingAnnotation(static_cast<const MappingAnnotation*>(node));
|
||||
}
|
||||
// Subject 6: Optimization
|
||||
else if (node->conceptType == "TailCallAnnotation") {
|
||||
return gen->visitTailCallAnnotation(static_cast<const TailCallAnnotation*>(node));
|
||||
} else if (node->conceptType == "LoopAnnotation") {
|
||||
return gen->visitLoopAnnotation(static_cast<const LoopAnnotation*>(node));
|
||||
} else if (node->conceptType == "DataAnnotation") {
|
||||
return gen->visitDataAnnotation(static_cast<const DataAnnotation*>(node));
|
||||
} else if (node->conceptType == "AlignAnnotation") {
|
||||
return gen->visitAlignAnnotation(static_cast<const AlignAnnotation*>(node));
|
||||
} else if (node->conceptType == "PackAnnotation") {
|
||||
return gen->visitPackAnnotation(static_cast<const PackAnnotation*>(node));
|
||||
} else if (node->conceptType == "BoundsCheckAnnotation") {
|
||||
return gen->visitBoundsCheckAnnotation(static_cast<const BoundsCheckAnnotation*>(node));
|
||||
} else if (node->conceptType == "OverflowAnnotation") {
|
||||
return gen->visitOverflowAnnotation(static_cast<const OverflowAnnotation*>(node));
|
||||
}
|
||||
// Subject 7: Meta-Programming
|
||||
else if (node->conceptType == "MetaAnnotation") {
|
||||
return gen->visitMetaAnnotation(static_cast<const MetaAnnotation*>(node));
|
||||
} else if (node->conceptType == "SymbolAnnotation") {
|
||||
return gen->visitSymbolAnnotation(static_cast<const SymbolAnnotation*>(node));
|
||||
} else if (node->conceptType == "EvaluateAnnotation") {
|
||||
return gen->visitEvaluateAnnotation(static_cast<const EvaluateAnnotation*>(node));
|
||||
} else if (node->conceptType == "TemplateAnnotation") {
|
||||
return gen->visitTemplateAnnotation(static_cast<const TemplateAnnotation*>(node));
|
||||
} else if (node->conceptType == "SyntheticAnnotation") {
|
||||
return gen->visitSyntheticAnnotation(static_cast<const SyntheticAnnotation*>(node));
|
||||
}
|
||||
// Subject 8: Policy
|
||||
else if (node->conceptType == "PolicyAnnotation") {
|
||||
return gen->visitPolicyAnnotation(static_cast<const PolicyAnnotation*>(node));
|
||||
} else if (node->conceptType == "AmbiguityAnnotation") {
|
||||
return gen->visitAmbiguityAnnotation(static_cast<const AmbiguityAnnotation*>(node));
|
||||
} else if (node->conceptType == "CandidateAnnotation") {
|
||||
return gen->visitCandidateAnnotation(static_cast<const CandidateAnnotation*>(node));
|
||||
} else if (node->conceptType == "TradeoffAnnotation") {
|
||||
return gen->visitTradeoffAnnotation(static_cast<const TradeoffAnnotation*>(node));
|
||||
} else if (node->conceptType == "ChoiceAnnotation") {
|
||||
return gen->visitChoiceAnnotation(static_cast<const ChoiceAnnotation*>(node));
|
||||
} else if (node->conceptType == "DecisionAnnotation") {
|
||||
return gen->visitDecisionAnnotation(static_cast<const DecisionAnnotation*>(node));
|
||||
}
|
||||
// Semantic Core
|
||||
else if (node->conceptType == "IntentAnnotation") {
|
||||
return gen->visitIntentAnnotation(static_cast<const IntentAnnotation*>(node));
|
||||
} else if (node->conceptType == "ComplexityAnnotation") {
|
||||
return gen->visitComplexityAnnotation(static_cast<const ComplexityAnnotation*>(node));
|
||||
} else if (node->conceptType == "RiskAnnotation") {
|
||||
return gen->visitRiskAnnotation(static_cast<const RiskAnnotation*>(node));
|
||||
} else if (node->conceptType == "ContractAnnotation") {
|
||||
return gen->visitContractAnnotation(static_cast<const ContractAnnotation*>(node));
|
||||
} else if (node->conceptType == "SemanticTagAnnotation") {
|
||||
return gen->visitSemanticTagAnnotation(static_cast<const SemanticTagAnnotation*>(node));
|
||||
}
|
||||
// Environment
|
||||
else if (node->conceptType == "CapabilityRequirement") {
|
||||
return gen->visitCapabilityRequirement(static_cast<const CapabilityRequirement*>(node));
|
||||
}
|
||||
// Host Boundary (Step 288)
|
||||
else if (node->conceptType == "HostCall") {
|
||||
return gen->visitHostCall(static_cast<const HostCall*>(node));
|
||||
} else if (node->conceptType == "ScheduleTask") {
|
||||
return gen->visitScheduleTask(static_cast<const ScheduleTask*>(node));
|
||||
} else if (node->conceptType == "ModuleLoad") {
|
||||
return gen->visitModuleLoad(static_cast<const ModuleLoad*>(node));
|
||||
}
|
||||
// New AST nodes (Phase 11c)
|
||||
else if (node->conceptType == "ClassDeclaration") {
|
||||
return gen->visitClassDeclaration(node);
|
||||
} else if (node->conceptType == "InterfaceDeclaration") {
|
||||
return gen->visitInterfaceDeclaration(node);
|
||||
} else if (node->conceptType == "MethodDeclaration") {
|
||||
return gen->visitMethodDeclaration(node);
|
||||
} else if (node->conceptType == "GenericType") {
|
||||
return gen->visitGenericType(node);
|
||||
} else if (node->conceptType == "TypeParameter") {
|
||||
return gen->visitTypeParameter(node);
|
||||
} else if (node->conceptType == "AsyncFunction") {
|
||||
return gen->visitAsyncFunction(node);
|
||||
} else if (node->conceptType == "AwaitExpression") {
|
||||
return gen->visitAwaitExpression(node);
|
||||
} else if (node->conceptType == "LambdaExpression") {
|
||||
return gen->visitLambdaExpression(node);
|
||||
} else if (node->conceptType == "DecoratorAnnotation") {
|
||||
return gen->visitDecoratorAnnotation(node);
|
||||
}
|
||||
|
||||
return unknownPrefix + node->conceptType;
|
||||
}
|
||||
|
||||
@@ -1,9 +1,12 @@
|
||||
#pragma once
|
||||
|
||||
#include "ProjectionGenerator.h"
|
||||
#include "../SemannoAnnotationImpl.h"
|
||||
|
||||
class PythonGenerator : public ProjectionGenerator {
|
||||
class PythonGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<PythonGenerator> {
|
||||
public:
|
||||
std::string commentPrefix() const { return "# "; }
|
||||
|
||||
std::string generate(const ASTNode* node) override {
|
||||
return dispatchGenerate(this, node, "# Unknown concept: ");
|
||||
}
|
||||
|
||||
@@ -1,9 +1,12 @@
|
||||
#pragma once
|
||||
#include "ProjectionGenerator.h"
|
||||
#include "Import.h"
|
||||
#include "../SemannoAnnotationImpl.h"
|
||||
|
||||
class RustGenerator : public ProjectionGenerator {
|
||||
class RustGenerator : public ProjectionGenerator, public SemannoAnnotationImpl<RustGenerator> {
|
||||
public:
|
||||
std::string commentPrefix() const { return "// "; }
|
||||
|
||||
std::string generate(const ASTNode* node) override {
|
||||
return dispatchGenerate(this, node, "// Unknown concept: ");
|
||||
}
|
||||
|
||||
@@ -14,6 +14,9 @@
|
||||
#include "Import.h"
|
||||
#include "ExternalModule.h"
|
||||
#include "TypeSignature.h"
|
||||
#include "ClassDeclaration.h"
|
||||
#include "GenericType.h"
|
||||
#include "AsyncNodes.h"
|
||||
|
||||
using json = nlohmann::json;
|
||||
|
||||
@@ -418,6 +421,49 @@ inline json propertiesToJson(const ASTNode* 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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
else if (ct == "TypeParameter") {
|
||||
auto* n = static_cast<const TypeParameter*>(node);
|
||||
props["name"] = n->name;
|
||||
if (!n->constraint.empty()) props["constraint"] = n->constraint;
|
||||
}
|
||||
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;
|
||||
}
|
||||
// NullLiteral, ListLiteral, IndexAccess, Block, Assignment, IfStatement,
|
||||
// WhileLoop, Return, ExpressionStatement, ListType, SetType, MapType,
|
||||
// TupleType, ArrayType, OptionalType — no extra properties
|
||||
@@ -565,6 +611,16 @@ inline ASTNode* createNode(const std::string& conceptName) {
|
||||
// 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();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
@@ -990,6 +1046,53 @@ inline void setPropertiesFromJson(ASTNode* node, const json& props) {
|
||||
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>();
|
||||
}
|
||||
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>();
|
||||
}
|
||||
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>();
|
||||
}
|
||||
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>();
|
||||
}
|
||||
}
|
||||
|
||||
inline std::string generateNodeId() {
|
||||
|
||||
Reference in New Issue
Block a user