Step 394: add TypeAlias + nested type access tests
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Bill
@@ -2425,4 +2425,58 @@ target_link_libraries(step393_test PRIVATE
|
||||
tree_sitter_javascript tree_sitter_typescript
|
||||
tree_sitter_java tree_sitter_rust tree_sitter_go)
|
||||
|
||||
add_executable(step394_test tests/step394_test.cpp)
|
||||
target_include_directories(step394_test PRIVATE src)
|
||||
target_link_libraries(step394_test PRIVATE
|
||||
nlohmann_json::nlohmann_json
|
||||
unofficial::tree-sitter::tree-sitter
|
||||
tree_sitter_python tree_sitter_cpp tree_sitter_elisp
|
||||
tree_sitter_javascript tree_sitter_typescript
|
||||
tree_sitter_java tree_sitter_rust tree_sitter_go)
|
||||
|
||||
add_executable(step395_test tests/step395_test.cpp)
|
||||
target_include_directories(step395_test PRIVATE src)
|
||||
target_link_libraries(step395_test PRIVATE
|
||||
nlohmann_json::nlohmann_json
|
||||
unofficial::tree-sitter::tree-sitter
|
||||
tree_sitter_python tree_sitter_cpp tree_sitter_elisp
|
||||
tree_sitter_javascript tree_sitter_typescript
|
||||
tree_sitter_java tree_sitter_rust tree_sitter_go)
|
||||
|
||||
add_executable(step396_test tests/step396_test.cpp)
|
||||
target_include_directories(step396_test PRIVATE src)
|
||||
target_link_libraries(step396_test PRIVATE
|
||||
nlohmann_json::nlohmann_json
|
||||
unofficial::tree-sitter::tree-sitter
|
||||
tree_sitter_python tree_sitter_cpp tree_sitter_elisp
|
||||
tree_sitter_javascript tree_sitter_typescript
|
||||
tree_sitter_java tree_sitter_rust tree_sitter_go)
|
||||
|
||||
add_executable(step397_test tests/step397_test.cpp)
|
||||
target_include_directories(step397_test PRIVATE src)
|
||||
target_link_libraries(step397_test PRIVATE
|
||||
nlohmann_json::nlohmann_json
|
||||
unofficial::tree-sitter::tree-sitter
|
||||
tree_sitter_python tree_sitter_cpp tree_sitter_elisp
|
||||
tree_sitter_javascript tree_sitter_typescript
|
||||
tree_sitter_java tree_sitter_rust tree_sitter_go)
|
||||
|
||||
add_executable(step398_test tests/step398_test.cpp)
|
||||
target_include_directories(step398_test PRIVATE src)
|
||||
target_link_libraries(step398_test PRIVATE
|
||||
nlohmann_json::nlohmann_json
|
||||
unofficial::tree-sitter::tree-sitter
|
||||
tree_sitter_python tree_sitter_cpp tree_sitter_elisp
|
||||
tree_sitter_javascript tree_sitter_typescript
|
||||
tree_sitter_java tree_sitter_rust tree_sitter_go)
|
||||
|
||||
add_executable(step399_test tests/step399_test.cpp)
|
||||
target_include_directories(step399_test PRIVATE src)
|
||||
target_link_libraries(step399_test PRIVATE
|
||||
nlohmann_json::nlohmann_json
|
||||
unofficial::tree-sitter::tree-sitter
|
||||
tree_sitter_python tree_sitter_cpp tree_sitter_elisp
|
||||
tree_sitter_javascript tree_sitter_typescript
|
||||
tree_sitter_java tree_sitter_rust tree_sitter_go)
|
||||
|
||||
# Step 12: Dear ImGui shell scaffolding created (main.cpp exists but not built due to dependencies)
|
||||
|
||||
159
editor/src/ast/CppAdvancedNodes.h
Normal file
159
editor/src/ast/CppAdvancedNodes.h
Normal file
@@ -0,0 +1,159 @@
|
||||
#pragma once
|
||||
// Steps 394-398: Advanced C++ AST node types
|
||||
//
|
||||
// Adds: const/constexpr/static flags on Variable/Function/MethodDeclaration,
|
||||
// smart pointer recognition, auto type deduction, and cast expressions.
|
||||
|
||||
#include "ASTNode.h"
|
||||
#include "Expression.h"
|
||||
#include "Type.h"
|
||||
#include <nlohmann/json.hpp>
|
||||
#include <string>
|
||||
|
||||
// --- Extended Variable flags (Step 395) ---
|
||||
// Rather than modify Variable.h (which is a tiny class used everywhere),
|
||||
// we use a companion struct stored as annotation metadata.
|
||||
|
||||
struct CppQualifiers {
|
||||
bool isConst = false;
|
||||
bool isConstexpr = false;
|
||||
bool isStatic = false;
|
||||
bool isMutable = false;
|
||||
std::string smartPointerKind; // "" | "unique_ptr" | "shared_ptr" | "weak_ptr"
|
||||
|
||||
nlohmann::json toJson() const {
|
||||
nlohmann::json j;
|
||||
if (isConst) j["isConst"] = true;
|
||||
if (isConstexpr) j["isConstexpr"] = true;
|
||||
if (isStatic) j["isStatic"] = true;
|
||||
if (isMutable) j["isMutable"] = true;
|
||||
if (!smartPointerKind.empty()) j["smartPointerKind"] = smartPointerKind;
|
||||
return j;
|
||||
}
|
||||
|
||||
static CppQualifiers fromJson(const nlohmann::json& j) {
|
||||
CppQualifiers q;
|
||||
if (j.contains("isConst")) q.isConst = j["isConst"].get<bool>();
|
||||
if (j.contains("isConstexpr")) q.isConstexpr = j["isConstexpr"].get<bool>();
|
||||
if (j.contains("isStatic")) q.isStatic = j["isStatic"].get<bool>();
|
||||
if (j.contains("isMutable")) q.isMutable = j["isMutable"].get<bool>();
|
||||
if (j.contains("smartPointerKind")) q.smartPointerKind = j["smartPointerKind"].get<std::string>();
|
||||
return q;
|
||||
}
|
||||
};
|
||||
|
||||
// --- AutoType (Step 397) ---
|
||||
|
||||
class AutoType : public ASTNode {
|
||||
public:
|
||||
std::string modifiers; // "" | "*" | "&" | "const &" | "const *"
|
||||
|
||||
AutoType() { conceptType = "AutoType"; }
|
||||
AutoType(const std::string& id_, const std::string& mods = "")
|
||||
: modifiers(mods) {
|
||||
this->id = id_;
|
||||
conceptType = "AutoType";
|
||||
}
|
||||
};
|
||||
|
||||
// --- CastExpression (Step 398) ---
|
||||
|
||||
class CastExpression : public Expression {
|
||||
public:
|
||||
std::string castKind; // "static_cast" | "dynamic_cast" | "reinterpret_cast" | "const_cast"
|
||||
std::string targetType; // The target type as string
|
||||
// children: "operand" (1) via setChild
|
||||
|
||||
CastExpression() { conceptType = "CastExpression"; }
|
||||
CastExpression(const std::string& id_, const std::string& kind, const std::string& target = "")
|
||||
: castKind(kind), targetType(target) {
|
||||
this->id = id_;
|
||||
conceptType = "CastExpression";
|
||||
}
|
||||
};
|
||||
|
||||
// --- Helper: detect smart pointer type from text ---
|
||||
|
||||
inline std::string detectSmartPointerKind(const std::string& typeText) {
|
||||
if (typeText.find("unique_ptr") != std::string::npos) return "unique_ptr";
|
||||
if (typeText.find("shared_ptr") != std::string::npos) return "shared_ptr";
|
||||
if (typeText.find("weak_ptr") != std::string::npos) return "weak_ptr";
|
||||
return "";
|
||||
}
|
||||
|
||||
// --- Helper: extract inner type from smart pointer ---
|
||||
|
||||
inline std::string extractSmartPointerInner(const std::string& typeText) {
|
||||
auto start = typeText.find('<');
|
||||
auto end = typeText.rfind('>');
|
||||
if (start != std::string::npos && end != std::string::npos && end > start) {
|
||||
return typeText.substr(start + 1, end - start - 1);
|
||||
}
|
||||
return typeText;
|
||||
}
|
||||
|
||||
// --- Helper: detect qualifiers from declaration text ---
|
||||
|
||||
inline CppQualifiers detectQualifiers(const std::string& text) {
|
||||
CppQualifiers q;
|
||||
if (text.find("constexpr ") != std::string::npos || text.find("constexpr\t") != std::string::npos)
|
||||
q.isConstexpr = true;
|
||||
if (text.find("const ") != std::string::npos || text.find("const\t") != std::string::npos)
|
||||
q.isConst = true;
|
||||
if (text.find("static ") != std::string::npos || text.find("static\t") != std::string::npos)
|
||||
q.isStatic = true;
|
||||
if (text.find("mutable ") != std::string::npos)
|
||||
q.isMutable = true;
|
||||
q.smartPointerKind = detectSmartPointerKind(text);
|
||||
return q;
|
||||
}
|
||||
|
||||
// --- Helper: detect auto type from text ---
|
||||
|
||||
inline bool isAutoType(const std::string& typeText) {
|
||||
return typeText == "auto" || typeText.find("auto ") == 0 ||
|
||||
typeText.find("auto*") == 0 || typeText.find("auto&") == 0 ||
|
||||
typeText == "const auto" || typeText.find("const auto") == 0;
|
||||
}
|
||||
|
||||
// --- Helper: detect const method (trailing const) ---
|
||||
|
||||
inline bool isConstMethod(const std::string& fullText) {
|
||||
// Look for ") const" or ") const {" or ") const;" pattern
|
||||
auto pos = fullText.rfind(')');
|
||||
if (pos != std::string::npos) {
|
||||
auto remainder = fullText.substr(pos + 1);
|
||||
return remainder.find("const") != std::string::npos &&
|
||||
remainder.find("const_cast") == std::string::npos;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// --- Helper: detect cast kind from text ---
|
||||
|
||||
inline std::string detectCastKind(const std::string& text) {
|
||||
if (text.find("dynamic_cast") != std::string::npos) return "dynamic_cast";
|
||||
if (text.find("reinterpret_cast") != std::string::npos) return "reinterpret_cast";
|
||||
if (text.find("const_cast") != std::string::npos) return "const_cast";
|
||||
if (text.find("static_cast") != std::string::npos) return "static_cast";
|
||||
return "static_cast"; // default
|
||||
}
|
||||
|
||||
// --- Helper: map smart pointer to ownership annotation ---
|
||||
|
||||
inline std::string smartPointerOwnership(const std::string& kind) {
|
||||
if (kind == "unique_ptr") return "Unique";
|
||||
if (kind == "shared_ptr") return "Shared_ARC";
|
||||
if (kind == "weak_ptr") return "Weak";
|
||||
return "";
|
||||
}
|
||||
|
||||
// --- Helper: risk level for cast ---
|
||||
|
||||
inline std::string castRiskLevel(const std::string& castKind) {
|
||||
if (castKind == "reinterpret_cast") return "high";
|
||||
if (castKind == "dynamic_cast") return "medium";
|
||||
if (castKind == "const_cast") return "medium";
|
||||
if (castKind == "static_cast") return "low";
|
||||
return "low";
|
||||
}
|
||||
204
editor/tests/step394_test.cpp
Normal file
204
editor/tests/step394_test.cpp
Normal file
@@ -0,0 +1,204 @@
|
||||
// Step 394: TypeAlias + Nested Type Access (12 tests)
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include "ast/Parser.h"
|
||||
#include "ast/Generator.h"
|
||||
#include "ast/EnumNamespaceNodes.h"
|
||||
#include "ast/CppAdvancedNodes.h"
|
||||
|
||||
int main() {
|
||||
int passed = 0;
|
||||
|
||||
// Test 1: Parse using type alias
|
||||
{
|
||||
std::string src = "using json = nlohmann::json;\n";
|
||||
auto mod = TreeSitterParser::parseCpp(src);
|
||||
auto& stmts = mod->getChildren("statements");
|
||||
bool found = false;
|
||||
for (auto* s : stmts) {
|
||||
if (s->conceptType == "TypeAlias") {
|
||||
auto* ta = static_cast<TypeAlias*>(s);
|
||||
assert(ta->aliasName == "json");
|
||||
assert(ta->isUsing == true);
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
assert(found);
|
||||
std::cout << "PASS: test 1 — parse using type alias\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 2: Parse typedef type alias
|
||||
{
|
||||
std::string src = "typedef int IntType;\n";
|
||||
auto mod = TreeSitterParser::parseCpp(src);
|
||||
auto& stmts = mod->getChildren("statements");
|
||||
bool found = false;
|
||||
for (auto* s : stmts) {
|
||||
if (s->conceptType == "TypeAlias") {
|
||||
auto* ta = static_cast<TypeAlias*>(s);
|
||||
assert(ta->aliasName == "IntType");
|
||||
assert(ta->isUsing == false);
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
assert(found);
|
||||
std::cout << "PASS: test 2 — parse typedef type alias\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 3: Nested type access in alias target (qualified name)
|
||||
{
|
||||
std::string src = "using json = nlohmann::json;\n";
|
||||
auto mod = TreeSitterParser::parseCpp(src);
|
||||
auto& stmts = mod->getChildren("statements");
|
||||
for (auto* s : stmts) {
|
||||
if (s->conceptType == "TypeAlias") {
|
||||
auto* ta = static_cast<TypeAlias*>(s);
|
||||
// Target type should preserve the qualified name
|
||||
assert(ta->targetType.find("nlohmann") != std::string::npos ||
|
||||
ta->targetType.find("json") != std::string::npos);
|
||||
}
|
||||
}
|
||||
std::cout << "PASS: test 3 — nested type access in alias\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 4: TypeAlias construction with qualified name
|
||||
{
|
||||
TypeAlias ta("ta_1", "StringVec", "std::vector<std::string>", true);
|
||||
assert(ta.aliasName == "StringVec");
|
||||
assert(ta.targetType == "std::vector<std::string>");
|
||||
assert(ta.isUsing == true);
|
||||
assert(ta.conceptType == "TypeAlias");
|
||||
std::cout << "PASS: test 4 — TypeAlias construction\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 5: Multiple type aliases in one module
|
||||
{
|
||||
std::string src = R"(
|
||||
using json = nlohmann::json;
|
||||
using string = std::string;
|
||||
)";
|
||||
auto mod = TreeSitterParser::parseCpp(src);
|
||||
int count = 0;
|
||||
for (auto* s : mod->getChildren("statements")) {
|
||||
if (s->conceptType == "TypeAlias") count++;
|
||||
}
|
||||
assert(count == 2);
|
||||
std::cout << "PASS: test 5 — multiple type aliases\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 6: TypeAlias in generator produces using declaration
|
||||
{
|
||||
TypeAlias ta("ta_1", "Vec", "std::vector<int>", true);
|
||||
// CppGenerator would produce: "using Vec = std::vector<int>;"
|
||||
// But we just test that the node round-trips correctly
|
||||
assert(ta.aliasName == "Vec");
|
||||
assert(ta.targetType == "std::vector<int>");
|
||||
|
||||
TypeAlias td("ta_2", "IntPtr", "int*", false);
|
||||
assert(td.isUsing == false);
|
||||
// typedef int* IntPtr;
|
||||
std::cout << "PASS: test 6 — TypeAlias generator format\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 7: Deeply nested qualified type
|
||||
{
|
||||
TypeAlias ta("ta_1", "Iter", "Foo::Bar::Baz::iterator", true);
|
||||
assert(ta.targetType == "Foo::Bar::Baz::iterator");
|
||||
// Verify :: count
|
||||
int colons = 0;
|
||||
for (size_t i = 0; i + 1 < ta.targetType.size(); ++i) {
|
||||
if (ta.targetType[i] == ':' && ta.targetType[i + 1] == ':') colons++;
|
||||
}
|
||||
assert(colons == 3);
|
||||
std::cout << "PASS: test 7 — deeply nested qualified type\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 8: Parse class with type alias inside namespace
|
||||
{
|
||||
std::string src = R"(
|
||||
namespace detail {
|
||||
using size_type = std::size_t;
|
||||
}
|
||||
)";
|
||||
auto mod = TreeSitterParser::parseCpp(src);
|
||||
auto& stmts = mod->getChildren("statements");
|
||||
bool nsFound = false;
|
||||
for (auto* s : stmts) {
|
||||
if (s->conceptType == "NamespaceDeclaration") {
|
||||
auto* ns = static_cast<NamespaceDeclaration*>(s);
|
||||
assert(ns->name == "detail");
|
||||
nsFound = true;
|
||||
}
|
||||
}
|
||||
assert(nsFound);
|
||||
std::cout << "PASS: test 8 — type alias in namespace\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 9: TypeAlias span tracking
|
||||
{
|
||||
TypeAlias ta("ta_1", "MyType", "int", true);
|
||||
ta.setSpan(5, 0, 5, 20);
|
||||
assert(ta.spanStartLine == 5);
|
||||
assert(ta.spanEndCol == 20);
|
||||
std::cout << "PASS: test 9 — TypeAlias span tracking\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 10: Template type in alias target
|
||||
{
|
||||
std::string src = "using Strings = std::vector<std::string>;\n";
|
||||
auto mod = TreeSitterParser::parseCpp(src);
|
||||
bool found = false;
|
||||
for (auto* s : mod->getChildren("statements")) {
|
||||
if (s->conceptType == "TypeAlias") {
|
||||
auto* ta = static_cast<TypeAlias*>(s);
|
||||
assert(ta->aliasName == "Strings");
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
assert(found);
|
||||
std::cout << "PASS: test 10 — template type in alias target\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 11: Typedef with pointer
|
||||
{
|
||||
std::string src = "typedef void (*Callback)(int);\n";
|
||||
auto mod = TreeSitterParser::parseCpp(src);
|
||||
// This may or may not parse as TypeAlias depending on tree-sitter
|
||||
// Just verify no crash
|
||||
assert(mod != nullptr);
|
||||
std::cout << "PASS: test 11 — typedef with pointer (no crash)\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 12: CppQualifiers helper on qualified type text
|
||||
{
|
||||
auto q1 = detectQualifiers("static constexpr int MAX = 100;");
|
||||
assert(q1.isStatic == true);
|
||||
assert(q1.isConstexpr == true);
|
||||
|
||||
auto q2 = detectQualifiers("const std::string& name");
|
||||
assert(q2.isConst == true);
|
||||
assert(q2.isStatic == false);
|
||||
|
||||
auto q3 = detectQualifiers("std::unique_ptr<Widget> w;");
|
||||
assert(q3.smartPointerKind == "unique_ptr");
|
||||
|
||||
std::cout << "PASS: test 12 — CppQualifiers detection helpers\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
std::cout << "\nStep 394 result: " << passed << "/12 tests passed\n";
|
||||
return (passed == 12) ? 0 : 1;
|
||||
}
|
||||
Reference in New Issue
Block a user