mirror of
https://github.com/logos-co/logos-cpp-sdk.git
synced 2026-08-30 01:01:12 +00:00
Dario LipicarandClaude Opus 5
667990f28c
* feat(sdk): aboutToUnload — a module's chance to finish before teardown
A module could not flush state or close handles on the way out: the host
stopped it, its destructors ran, and anything mid-flight was gone. This gives
LogosModuleContext the Qt Creator contract for exactly that problem.
enum class LogosShutdown { Synchronous, Asynchronous };
virtual LogosShutdown aboutToUnload() { return LogosShutdown::Synchronous; }
void unloadFinished() const; // any thread
Default Synchronous, so no existing module changes behaviour. A module with work
to finish returns Asynchronous and calls unloadFinished() when done; the host
waits, but only for a bounded grace period.
unloadFinished() is a NO-OP outside a framework context, and after the deadline
has passed. That matters more than it reads: a module needs no special case for
being torn down under a deadline it already missed.
Two SFINAE pairs mirror the existing maybeSet* helpers. maybeAboutToUnload
reports Synchronous for an impl that never inherited LogosModuleContext, which
is exactly right -- it has no hook, so there is nothing to wait for.
Both names join the reserved set beside onContextReady: an impl overriding
aboutToUnload is talking to the framework, not publishing API, and leaking
either would generate a consumer wrapper for a lifecycle hook (LogosShutdown
has no LIDL type to return anyway).
The cdylib backend emits the two optional C ABI exports. The completion
callback is installed BEFORE the impl is asked to unload, and that ordering is
the correctness of the whole async path: an impl that finishes INLINE would
otherwise signal into a slot that is still empty, and the host would wait out
its entire grace period for a module already done. There is a test for it,
because nothing about reading the code makes that failure visible.
294/294, 4 new. Requires logos-protocol#62; flake.lock pins that branch.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* chore(deps): track logos-protocol master now that the teardown ABI has landed
logos-co/logos-protocol#62 merged as 9664ae2. The lock pointed at the PR branch
while it was open.
The narHash is unchanged across the move (sha256-JTREoJn2kjQmYyYHg2RQb4...), so
the merged tree is byte-identical to the branch this was built and tested
against.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* fix(generator): guard the teardown emission on protocol 0.5
The emitted exports named logos_module_unload_done_cb unconditionally, so a
module built with this generator against an older logos-protocol failed to
compile on a typedef it never asked for:
error: 'logos_module_unload_done_cb' was not declared in this scope
in generated code the author never wrote and cannot see. That is what this PR's
doc-tests hit -- new generator, older protocol pin.
logos-protocol#63 gives the surface a MINOR (0.5) so it is detectable, and both
the statics and the exports now sit behind
#if defined(LOGOS_PROTOCOL_VERSION_MINOR) && LOGOS_PROTOCOL_VERSION_MINOR >= 5
the same way the 0.3 trust-root surface is guarded a few lines below. A module
built against 0.4 simply has no teardown entry point, which is the same state as
a module that never overrode the hook -- and the glue that would call it is
generated alongside, so nothing goes looking for the missing symbol.
Both halves need the guard, not just the exports: the typedef is what an older
header lacks, and it is the statics that name it. The test asserts both.
295/295. flake.lock tracks protocol master (0d2a3c0), where 0.5 landed.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
1419 lines
66 KiB
C++
1419 lines
66 KiB
C++
#include "impl_header_parser.h"
|
|
|
|
#include "metadata_dependencies.h"
|
|
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
#include <QRegularExpression>
|
|
#include <QSet>
|
|
|
|
#include <functional>
|
|
#include <set>
|
|
#include <QStringList>
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Strip leading declaration specifiers / attributes from a return-type string.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
static QString stripDeclarationSpecifiers(QString string)
|
|
{
|
|
static const QRegularExpression attributeRe("\\[\\[[^\\]]*\\]\\]");
|
|
static const QRegularExpression specifierRe(
|
|
"^(static|virtual|inline|explicit|constexpr|consteval|friend)\\s+");
|
|
|
|
string.remove(attributeRe);
|
|
string = string.trimmed();
|
|
|
|
QRegularExpressionMatch specifierMatch = specifierRe.match(string);
|
|
while (specifierMatch.hasMatch()) {
|
|
string = string.mid(specifierMatch.capturedLength()).trimmed();
|
|
specifierMatch = specifierRe.match(string);
|
|
}
|
|
|
|
return string;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// C++ type string → LIDL TypeExpr
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// The records the header declares, discovered by scanForRecords() before any
|
|
// method is parsed. A bare `Blob` in a signature is only a record if the header
|
|
// actually declared `struct Blob { ... };` — otherwise it stays the opaque
|
|
// `any` it always was.
|
|
static QSet<QString> g_recordNames;
|
|
|
|
// C++ spellings seen that have NO LIDL type, and were mapped onto the nearest
|
|
// one that does. Collected here because cppTypeToLidl has no diagnostic channel
|
|
// (same reason g_recordNames is file-static); parseImplHeader drains it.
|
|
static QStringList g_unmappableSpellings;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Spellings with NO LIDL type at all.
|
|
//
|
|
// These used to reach the `any` fallback at the bottom of cppTypeToLidl, and
|
|
// `any` is ADMITTED by every backend gate — so the declaration was accepted, the
|
|
// published contract said `any`, and the generated dispatch handed the raw
|
|
// nlohmann::json straight to the author's parameter. That either worked by luck
|
|
// through nlohmann's implicit conversions, threw at call time, or emitted a
|
|
// non-canonical wire value. Nothing said a word.
|
|
//
|
|
// Now every one of them is recorded here and parseImplHeader turns the list into
|
|
// a hard parse error naming the offending C++ type and the fix.
|
|
//
|
|
// cppTypeToLidl still RETURNS the historical `any` for these: the diagnostic and
|
|
// the mapping are separate, so a declaration whose diagnostic is later discarded
|
|
// (a helper struct that never reaches the contract, a reserved lifecycle hook)
|
|
// produces byte-identical output to before.
|
|
struct UnsupportedSpelling {
|
|
QString context; // "method 'foo': parameter 'bar'"
|
|
QString record; // non-empty when this came from a record field
|
|
QString declared; // the full spelling as written on the declaration
|
|
QString offending; // the spelling that has no LIDL type (may be nested)
|
|
QString hint; // what to write instead
|
|
};
|
|
static QList<UnsupportedSpelling> g_unsupported;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// STRUCTURE the record scanner could not read.
|
|
//
|
|
// #127 closed the hole where an unknown TYPE was admitted as `any`. This is the
|
|
// same hole one level down: a line inside a `struct` body that the scanner
|
|
// could not read as a field was `continue`d, and the struct was published
|
|
// anyway — MINUS that field. A field list is not a detail of a record, it IS
|
|
// the record: the promise every other language binds to. Publishing a shorter
|
|
// one silently ships a contract that disagrees with the header, and nothing
|
|
// downstream can tell, because a contract with three fields and a contract with
|
|
// two are both perfectly well-formed.
|
|
//
|
|
// Same discipline as g_unsupported: collected here, withdrawn when the struct
|
|
// turns out never to reach the contract (an internal helper promises nothing),
|
|
// and a hard parse error otherwise.
|
|
struct UnreadableDecl {
|
|
QString record; // the struct it was found in — the withdrawal key
|
|
QString text; // the declaration as written, comments removed
|
|
QString hint; // what to write instead
|
|
};
|
|
static QList<UnreadableDecl> g_unreadable;
|
|
|
|
// Structs that were opened but published no field at all. Referenced by the API
|
|
// they are still a defect — the emitted contract names a `type` it never
|
|
// declares — but no single line is at fault, so they are reported separately.
|
|
static QStringList g_emptyRecords;
|
|
|
|
// Drop the qualifiers that are about how a value is PASSED rather than what it
|
|
// is: cppTypeToLidl normalizes with this, and the diagnostics compare against it
|
|
// so `const nlohmann::json&` and `nlohmann::json` are recognised as the same
|
|
// spelling instead of reading as a type nested inside itself.
|
|
static QString normalizeCppSpelling(const QString& raw)
|
|
{
|
|
QString t = raw.trimmed();
|
|
t.remove(QRegularExpression("^const\\s+"));
|
|
t.remove(QRegularExpression("\\s*&$"));
|
|
return t.trimmed();
|
|
}
|
|
|
|
// Collapse whitespace so `unsigned long int` and `unsigned long int` are one
|
|
// key, and drop the redundant `int` from the multi-word integer spellings.
|
|
static QString normalizeNumericSpelling(QString t)
|
|
{
|
|
t = t.simplified();
|
|
static const QRegularExpression trailingInt("\\s+int$");
|
|
if (t != "int" && t.contains(' '))
|
|
t.remove(trailingInt);
|
|
return t;
|
|
}
|
|
|
|
// What to write instead. Every hint names a spelling that IS in the contract,
|
|
// because "unsupported" without a replacement just moves the guesswork.
|
|
static QString unsupportedHint(const QString& t)
|
|
{
|
|
static const QString kWidenNote =
|
|
"Widening is source-compatible for every caller; a narrow type on the "
|
|
"wire is not, which is why LIDL has none.";
|
|
|
|
// uint8_t has exactly ONE meaning in this contract and it is not a number.
|
|
if (t == "uint8_t" || t == "std::uint8_t")
|
|
return "uint8_t means BYTES here, and only as `std::vector<uint8_t>` "
|
|
"(LIDL `bstr`). For a small number declare `uint64_t` (LIDL "
|
|
"`uint`); for binary data declare `std::vector<uint8_t>`.";
|
|
|
|
const QString n = normalizeNumericSpelling(t);
|
|
static const QSet<QString> kUnsigned = {
|
|
"unsigned", "unsigned char", "unsigned short", "unsigned long",
|
|
"unsigned long long", "uint16_t", "uint32_t", "size_t",
|
|
"uintptr_t", "uintmax_t",
|
|
"std::uint16_t", "std::uint32_t", "std::size_t", "std::uintptr_t"
|
|
};
|
|
static const QSet<QString> kSigned = {
|
|
"char", "signed char", "signed", "short", "int", "long", "long long",
|
|
"int8_t", "int16_t", "int32_t", "ssize_t", "ptrdiff_t", "intptr_t",
|
|
"intmax_t", "std::int8_t", "std::int16_t", "std::int32_t",
|
|
"std::ptrdiff_t", "std::intptr_t"
|
|
};
|
|
static const QSet<QString> kFloating = { "float", "long double" };
|
|
|
|
if (kUnsigned.contains(n))
|
|
return "LIDL numbers are 64-bit only. Declare it `uint64_t` (LIDL "
|
|
"`uint`). " + kWidenNote;
|
|
if (kSigned.contains(n))
|
|
return "LIDL numbers are 64-bit only. Declare it `int64_t` (LIDL "
|
|
"`int`). " + kWidenNote;
|
|
if (kFloating.contains(n))
|
|
return "LIDL has one floating type, `float64`. Declare it `double`.";
|
|
|
|
if (t.startsWith("std::set<") || t.startsWith("std::unordered_set<")
|
|
|| t.startsWith("std::multiset<"))
|
|
return "LIDL has no set type. Declare it `std::vector<T>` (LIDL `[T]`); "
|
|
"uniqueness is not carried on the wire, so the module has to "
|
|
"enforce it either way.";
|
|
if (t.startsWith("std::pair<") || t.startsWith("std::tuple<"))
|
|
return "LIDL has no pair or tuple. Declare a `struct` in this header — "
|
|
"it becomes a contract `type` with named fields — or, for "
|
|
"key/value data, `std::map<std::string, V>` (LIDL `{tstr: V}`). "
|
|
"A struct is usually the right answer: positional pairs have no "
|
|
"field names for a consumer in another language to bind to.";
|
|
if (t.startsWith("std::map<") || t.startsWith("std::unordered_map<")
|
|
|| t.startsWith("std::multimap<"))
|
|
return "LIDL map keys are always `tstr`. Declare it "
|
|
"`std::map<std::string, V>` / `std::unordered_map<std::string, "
|
|
"V>`, or a `[T]` of a struct carrying the key as a field.";
|
|
if (t.startsWith("std::list<") || t.startsWith("std::deque<")
|
|
|| t.startsWith("std::array<") || t.startsWith("std::forward_list<"))
|
|
return "LIDL's sequence type is `[T]`, spelled `std::vector<T>`. "
|
|
"Declare it that way.";
|
|
if (t.startsWith("Q"))
|
|
return "Qt types cannot appear in a universal impl header — the "
|
|
"module's own translation units are Qt-free, and Qt is confined "
|
|
"to the generated glue. Use the std spelling (`std::string`, "
|
|
"`std::vector<T>`, `std::map<std::string, T>`) or the untyped "
|
|
"`LogosMap` / `LogosList`.";
|
|
if (t.endsWith("*") || t.endsWith("&&"))
|
|
return "A pointer or rvalue reference has no wire form. Pass the value "
|
|
"(by value or `const T&`), or a `struct` declared in this "
|
|
"header.";
|
|
|
|
return "The recognised spellings are: `bool`, `int64_t`, `uint64_t`, "
|
|
"`double`, `std::string`, `std::vector<uint8_t>` (bytes), "
|
|
"`std::optional<T>`, `std::vector<T>`, `std::map<std::string, T>`, "
|
|
"`std::unordered_map<std::string, T>`, `LogosMap` / `LogosList` / "
|
|
"`nlohmann::json` (untyped JSON), `StdLogosResult` and `void` as "
|
|
"returns, plus any `struct` declared in this header. Rewrite the "
|
|
"declaration with one of them, or declare a struct for it.";
|
|
}
|
|
|
|
// `context` names the declaration being typed ("method 'foo': parameter 'bar'")
|
|
// and `declared` the full spelling on it, so a nested offender reports both the
|
|
// element that has no LIDL type and the declaration that carries it. `record` is
|
|
// set only while typing a struct's fields, so a diagnostic can be withdrawn when
|
|
// the struct turns out never to reach the contract.
|
|
//
|
|
// `nameEmitted` marks the slots whose C++ spelling the generator WRITES OUT into
|
|
// code the author's own declaration has to match — a record field's codec, an
|
|
// event's generated body. In those the derived spelling is a constraint on the
|
|
// author; everywhere else the generated code only has to consume or produce a
|
|
// value, and can adapt to whatever the author declared.
|
|
static TypeExpr cppTypeToLidl(const QString& raw, const QString& context = QString(),
|
|
const QString& declared = QString(),
|
|
const QString& record = QString(),
|
|
bool nameEmitted = false)
|
|
{
|
|
// Normalize: strip const, &, leading/trailing whitespace
|
|
QString t = normalizeCppSpelling(raw);
|
|
|
|
// Primitives
|
|
if (t == "bool") return { TypeExpr::Primitive, "bool", {} };
|
|
if (t == "int64_t") return { TypeExpr::Primitive, "int", {} };
|
|
if (t == "uint64_t") return { TypeExpr::Primitive, "uint", {} };
|
|
if (t == "double") return { TypeExpr::Primitive, "float64", {} };
|
|
if (t == "void") return { TypeExpr::Primitive, "void", {} };
|
|
|
|
// std::string
|
|
if (t == "std::string")
|
|
return { TypeExpr::Primitive, "tstr", {} };
|
|
|
|
// std::vector<T>
|
|
static QRegularExpression vecRe("^std::vector\\s*<\\s*(.+)\\s*>$");
|
|
QRegularExpressionMatch m = vecRe.match(t);
|
|
if (m.hasMatch()) {
|
|
QString inner = m.captured(1).trimmed();
|
|
if (inner == "std::string") {
|
|
TypeExpr elem = { TypeExpr::Primitive, "tstr", {} };
|
|
return { TypeExpr::Array, "", { elem } };
|
|
}
|
|
if (inner == "uint8_t") {
|
|
return { TypeExpr::Primitive, "bstr", {} };
|
|
}
|
|
// std::vector<std::vector<uint8_t>> — an array of byte strings. Spelled
|
|
// out so it lands on `[bstr]` rather than the opaque `any` fallback
|
|
// below, which would emit a bare QVariant into the Qt-free TU. As
|
|
// `[bstr]` it goes through the cdylib list codec
|
|
// (lidlBytesListFromJson / lidlBytesListToJson), so each element keeps
|
|
// the canonical tagged {"_bytes": base64url} form on the wire.
|
|
if (inner == "std::vector<uint8_t>") {
|
|
TypeExpr elem = { TypeExpr::Primitive, "bstr", {} };
|
|
return { TypeExpr::Array, "", { elem } };
|
|
}
|
|
if (inner == "int64_t") {
|
|
TypeExpr elem = { TypeExpr::Primitive, "int", {} };
|
|
return { TypeExpr::Array, "", { elem } };
|
|
}
|
|
if (inner == "uint64_t") {
|
|
TypeExpr elem = { TypeExpr::Primitive, "uint", {} };
|
|
return { TypeExpr::Array, "", { elem } };
|
|
}
|
|
if (inner == "double") {
|
|
TypeExpr elem = { TypeExpr::Primitive, "float64", {} };
|
|
return { TypeExpr::Array, "", { elem } };
|
|
}
|
|
if (inner == "bool") {
|
|
TypeExpr elem = { TypeExpr::Primitive, "bool", {} };
|
|
return { TypeExpr::Array, "", { elem } };
|
|
}
|
|
// Anything else: recurse. That is what makes `std::vector<Blob>` a
|
|
// [Blob] and `std::vector<std::map<std::string, int64_t>>` a
|
|
// [{tstr: int}]. Without it the element list above was exhaustive and
|
|
// every other vector fell all the way through to the opaque `any`,
|
|
// which then encoded a record as a LogosMap.
|
|
return { TypeExpr::Array, "", { cppTypeToLidl(inner, context, declared, record, nameEmitted) } };
|
|
}
|
|
|
|
// Qt collection types — pass through directly (non-std-convertible)
|
|
if (t == "QVariantMap")
|
|
return { TypeExpr::Map, "", { {TypeExpr::Primitive, "tstr", {}}, {TypeExpr::Primitive, "any", {}} } };
|
|
if (t == "QVariantList")
|
|
return { TypeExpr::Array, "", { {TypeExpr::Primitive, "any", {}} } };
|
|
if (t == "QStringList")
|
|
return { TypeExpr::Array, "", { {TypeExpr::Primitive, "tstr", {}} } };
|
|
|
|
// LogosMap / LogosList — nlohmann::json aliases; same LIDL shape as the Qt types
|
|
// but flagged so the generator emits an nlohmann→Qt conversion in the glue.
|
|
if (t == "LogosMap")
|
|
return { TypeExpr::Map, "", { {TypeExpr::Primitive, "tstr", {}}, {TypeExpr::Primitive, "any", {}} } };
|
|
if (t == "LogosList")
|
|
return { TypeExpr::Array, "", { {TypeExpr::Primitive, "any", {}} } };
|
|
|
|
// The alias spelled out. LogosMap / LogosList ARE nlohmann::json, and real
|
|
// modules write the underlying name — test_fullapi_cpp's `echoAny` /
|
|
// `fireAnyEvent` / `anyEvent`, and both full_api interface headers, all
|
|
// declare `nlohmann::json`. It reached `any` ONLY through the fallback at
|
|
// the bottom of this function, so naming it here is a PREREQUISITE for
|
|
// turning that fallback into an error: without this branch the whole
|
|
// cross-language conformance chain stops building.
|
|
//
|
|
// Mapped to the bare `any` primitive rather than LogosMap's `{tstr: any}` /
|
|
// LogosList's `[any]`: `nlohmann::json` is an untyped value of ANY kind, not
|
|
// specifically an object or an array. That is the type the fallback already
|
|
// produced for it, so nothing about the published contract moves.
|
|
if (t == "nlohmann::json" || t == "json")
|
|
return { TypeExpr::Primitive, "any", {} };
|
|
|
|
// StdLogosResult — pure C++ result type for universal impls. The generator
|
|
// emits a StdLogosResult→Qt LogosResult conversion in the glue layer.
|
|
if (t == "StdLogosResult")
|
|
return { TypeExpr::Primitive, "result", {} };
|
|
|
|
// std::map / std::unordered_map<std::string, T> -> {tstr: T}. Absent before,
|
|
// so a typed map was unspellable header-first and fell through to `any`.
|
|
//
|
|
// Both containers, because logos_codec.h specializes Codec for both and they
|
|
// are the same wire shape — a JSON object. Only the KEY is constrained: a
|
|
// non-`std::string` key falls through to the unsupported report below, since
|
|
// `{tstr: T}` is the only map LIDL has.
|
|
static QRegularExpression mapRe(
|
|
"^std::(?:unordered_)?map\\s*<\\s*std::string\\s*,\\s*(.+)\\s*>$");
|
|
QRegularExpressionMatch mm = mapRe.match(t);
|
|
if (mm.hasMatch()) {
|
|
// ...with one boundary. In a `nameEmitted` slot the generator WRITES the
|
|
// spelling out — a record field's codec says `Codec<std::map<...>>` and
|
|
// an event's generated body repeats the parameter list the author
|
|
// declared. It has to pick one of the two container names there, and
|
|
// picking the wrong one is a compile error in code the author never
|
|
// wrote. Method parameters and returns have no such constraint: they go
|
|
// through logos::JsonArg / deduced logos::toJson, which instantiate with
|
|
// whatever the author declared.
|
|
if (t.startsWith("std::unordered_map") && nameEmitted && !context.isEmpty()) {
|
|
UnsupportedSpelling u;
|
|
u.context = context;
|
|
u.record = record;
|
|
u.declared = declared.isEmpty() ? t : declared;
|
|
u.offending = t;
|
|
u.hint = "`{tstr: T}` has two C++ spellings and this slot's spelling "
|
|
"is written into generated code your own declaration has to "
|
|
"match, so it can only be one of them: declare it "
|
|
"`std::map<std::string, T>`. (A method parameter or return "
|
|
"may use either container — those are decoded and encoded "
|
|
"through your declared type, not a named one.)";
|
|
g_unsupported.append(u);
|
|
}
|
|
TypeExpr val = cppTypeToLidl(mm.captured(1).trimmed(), context, declared, record, nameEmitted);
|
|
return { TypeExpr::Map, "", { {TypeExpr::Primitive, "tstr", {}}, val } };
|
|
}
|
|
|
|
// std::optional<T> -> ?T. Absent before, and the failure was silent: the
|
|
// fallback at the bottom of this function maps ANY unrecognised spelling to
|
|
// the opaque `any`, so a header-first C++ provider could not express
|
|
// optionality at all — it declared `std::optional<std::string>` and
|
|
// published a contract saying `any`, with no diagnostic.
|
|
//
|
|
// The derived contract uses the type-kind spelling (`name: ?T`). C++ has
|
|
// only one spelling, LIDL has two, and they are bound to the same meaning —
|
|
// so which one is emitted is a serialization choice, not a semantic one.
|
|
static QRegularExpression optRe("^std::optional\\s*<\\s*(.+)\\s*>$");
|
|
QRegularExpressionMatch om = optRe.match(t);
|
|
if (om.hasMatch()) {
|
|
TypeExpr inner = cppTypeToLidl(om.captured(1).trimmed(), context, declared, record, nameEmitted);
|
|
// std::optional<std::optional<T>> has NO LIDL type.
|
|
//
|
|
// `?T` is two-state, and optionality is idempotent under that rule — so
|
|
// the nearest contract type is plain `?T`, and that is what gets
|
|
// published. But the author's C++ has THREE states (nullopt / an engaged
|
|
// outer holding nullopt / a value), and the wire has two: accepting the
|
|
// declaration as-is would make `optional(nullopt)` and `nullopt` encode
|
|
// to the same null and decode back as one of them, silently. So it maps
|
|
// down, the generated codec is written for std::optional<T>, and the
|
|
// author's own declaration stops compiling against it — deliberately.
|
|
// Say why here, where the reason is known, rather than leaving a
|
|
// conversion error in generated code the author never wrote.
|
|
if (inner.kind == TypeExpr::Optional) {
|
|
g_unmappableSpellings << t;
|
|
return inner;
|
|
}
|
|
return { TypeExpr::Optional, "", { inner } };
|
|
}
|
|
|
|
// A record the header declared. Checked LAST so it can never shadow a
|
|
// builtin spelling, and gated on the declared set so an unknown type keeps
|
|
// the historical `any` fallback rather than naming a struct nobody emits.
|
|
if (g_recordNames.contains(t))
|
|
return { TypeExpr::Named, t.toStdString(), {} };
|
|
|
|
// NOTHING above matched: this spelling has no LIDL type.
|
|
//
|
|
// It used to return the opaque `any` right here, silently. `any` is admitted
|
|
// by every backend gate, so the declaration was accepted and the generated
|
|
// dispatch handed the raw nlohmann::json to the author's parameter with no
|
|
// `logos::fromJson<>` and no check — the one hole left open after #113-#122
|
|
// closed it for every TYPED slot. A `std::vector<uint32_t>` parameter
|
|
// published `[any]` and worked by accident; a
|
|
// `std::vector<std::pair<std::string, std::string>>` published `[any]` and
|
|
// shipped raw binary through a UTF-8 string.
|
|
//
|
|
// The return value is UNCHANGED (`any`) on purpose: mapping and diagnosis
|
|
// are separate concerns. A diagnostic that is later withdrawn — a helper
|
|
// struct that never reaches the contract, a reserved lifecycle hook — must
|
|
// leave the emitted output byte-identical to what it was.
|
|
//
|
|
// An empty spelling is not a C++ type at all, it is this line-based parser
|
|
// failing to find one (a macro, a member initialiser). Reporting "'' has no
|
|
// LIDL type" would be noise, so it keeps the old behaviour.
|
|
if (!t.isEmpty() && !context.isEmpty()) {
|
|
UnsupportedSpelling u;
|
|
u.context = context;
|
|
u.record = record;
|
|
u.declared = declared.isEmpty() ? t : declared;
|
|
u.offending = t;
|
|
u.hint = unsupportedHint(t);
|
|
g_unsupported.append(u);
|
|
}
|
|
return { TypeExpr::Primitive, "any", {} };
|
|
}
|
|
|
|
// Remove comments from the already-merged logical lines, honouring string and
|
|
// character literals and carrying block-comment state across lines.
|
|
//
|
|
// The record scanner used to strip with a bare `indexOf("//")`. That is right
|
|
// for `std::string name; // what it is` and WRONG for
|
|
// `std::string url = "http://x";`, which it truncates inside the literal — the
|
|
// declaration then no longer ends in ';', and the field vanished. Harmless
|
|
// enough while an unreadable line was merely skipped; now that it is a build
|
|
// error, the same truncation would reject valid code, so the strip has to know
|
|
// what a literal is. Block comments are removed for the same reason: a field
|
|
// annotated `std::string id; /* note */` did not end in ';' either.
|
|
static QStringList stripCommentsFrom(const QStringList& lines)
|
|
{
|
|
QStringList out;
|
|
bool inBlock = false;
|
|
for (const QString& line : lines) {
|
|
QString kept;
|
|
bool inStr = false;
|
|
bool inChr = false;
|
|
for (int i = 0; i < line.size(); ++i) {
|
|
const QChar c = line[i];
|
|
const QChar n = (i + 1 < line.size()) ? line[i + 1] : QChar();
|
|
if (inBlock) {
|
|
if (c == '*' && n == '/') { inBlock = false; ++i; }
|
|
continue;
|
|
}
|
|
if (inStr || inChr) {
|
|
kept += c;
|
|
if (c == '\\' && i + 1 < line.size()) { kept += n; ++i; }
|
|
else if (inStr && c == '"') inStr = false;
|
|
else if (inChr && c == '\'') inChr = false;
|
|
continue;
|
|
}
|
|
if (c == '/' && n == '*') { inBlock = true; ++i; continue; }
|
|
if (c == '/' && n == '/') break;
|
|
if (c == '"') inStr = true;
|
|
else if (c == '\'') inChr = true;
|
|
kept += c;
|
|
}
|
|
out.append(kept.trimmed());
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// A `struct` DEFINITION opening, in the forms C++ is actually written in:
|
|
//
|
|
// struct Name { K&R — the only form the scanner used to accept
|
|
//
|
|
// struct Name Allman — the opening brace on the next line
|
|
// {
|
|
//
|
|
// plus the base-clause spelling of either. `struct Name;` is a forward
|
|
// declaration and stays out: there is no body to read.
|
|
//
|
|
// Allman was not a harmless stylistic omission. The struct was not a record AT
|
|
// ALL, so every mention of it in a signature fell through to the `any` fallback
|
|
// — which since #127 is a hard error whose hint tells the author to "declare a
|
|
// struct", the very thing they did declare. Where a brace sits cannot decide
|
|
// what a header means.
|
|
struct StructOpen {
|
|
QString name;
|
|
QString text; // the opening as written, for diagnostics
|
|
bool hasBase = false;
|
|
bool bodyOnOpeningLine = false; // `struct P { int64_t a; };` all on one line
|
|
int bodyStart = -1; // index of the first line INSIDE the body
|
|
};
|
|
|
|
static bool matchStructOpen(const QStringList& code, int i, StructOpen& out)
|
|
{
|
|
// `[^{;]` in the base clause keeps `struct Name;` and the brace itself out
|
|
// of the capture.
|
|
static const QRegularExpression kandrRe(
|
|
"^struct\\s+(\\w+)\\s*(:[^{;]*)?\\{(.*)$");
|
|
static const QRegularExpression headRe("^struct\\s+(\\w+)\\s*(:[^{;]*)?$");
|
|
|
|
const QRegularExpressionMatch km = kandrRe.match(code.at(i));
|
|
if (km.hasMatch()) {
|
|
out.name = km.captured(1);
|
|
out.text = code.at(i);
|
|
out.hasBase = !km.captured(2).trimmed().isEmpty();
|
|
out.bodyOnOpeningLine = !km.captured(3).trimmed().isEmpty();
|
|
out.bodyStart = i + 1;
|
|
return true;
|
|
}
|
|
|
|
const QRegularExpressionMatch hm = headRe.match(code.at(i));
|
|
if (!hm.hasMatch()) return false;
|
|
// Allman: the next line carrying any code at all has to open the body.
|
|
// Anything else and this was not a definition (a `struct Name` mentioned in
|
|
// some other construct), so it is left alone exactly as before.
|
|
for (int j = i + 1; j < code.size(); ++j) {
|
|
if (code.at(j).isEmpty()) continue;
|
|
if (!code.at(j).startsWith('{')) return false;
|
|
out.name = hm.captured(1);
|
|
out.text = code.at(i);
|
|
out.hasBase = !hm.captured(2).trimmed().isEmpty();
|
|
out.bodyOnOpeningLine = !code.at(j).mid(1).trimmed().isEmpty();
|
|
out.bodyStart = j + 1;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void reportUnreadable(const QString& record, const QString& text,
|
|
const QString& hint)
|
|
{
|
|
g_unreadable.append({ record, text.trimmed(), hint });
|
|
}
|
|
|
|
// Net brace depth a line adds, ignoring braces inside string and character
|
|
// literals: `std::string s = "{";` is balanced code even though it is not
|
|
// balanced text, and a body scan that believed the text would never find the
|
|
// end of the struct.
|
|
static int braceDelta(const QString& line)
|
|
{
|
|
int delta = 0;
|
|
bool inStr = false;
|
|
bool inChr = false;
|
|
for (int i = 0; i < line.size(); ++i) {
|
|
const QChar c = line[i];
|
|
if (inStr || inChr) {
|
|
if (c == '\\') { ++i; continue; }
|
|
if (inStr && c == '"') inStr = false;
|
|
else if (inChr && c == '\'') inChr = false;
|
|
continue;
|
|
}
|
|
if (c == '"') inStr = true;
|
|
else if (c == '\'') inChr = true;
|
|
else if (c == '{') ++delta;
|
|
else if (c == '}') --delta;
|
|
}
|
|
return delta;
|
|
}
|
|
|
|
// What a contract field looks like. Named once because three diagnostics quote
|
|
// it, and a hint that describes a different grammar than the one enforced is
|
|
// worse than no hint.
|
|
static const QString kFieldFormHint = QStringLiteral(
|
|
"A contract field is ONE declaration per line, ending in `;` — `Type name;`, "
|
|
"optionally with a default (`= v` or `{v}`). A declaration wrapped across "
|
|
"several lines is joined for you; two declarations sharing one line are not.");
|
|
|
|
// Find `struct Name { Type field; ... };` blocks and turn them into `type`
|
|
// declarations.
|
|
//
|
|
// The parser used to SKIP any line starting with `struct`, which meant a record
|
|
// could not be declared header-first at all — the only way to get one was a
|
|
// hand-written .lidl. Worse, a method mentioning the struct still parsed: its
|
|
// type fell through to the opaque `any`, so the contract silently disagreed
|
|
// with the header.
|
|
//
|
|
// Two things beyond that are new here, and they are the same idea from opposite
|
|
// ends. The body is read as DECLARATIONS rather than lines — physical lines are
|
|
// joined until the `;`, exactly as the caller already joins a method signature
|
|
// until its parentheses balance — so a wrapped field is the field the author
|
|
// wrote rather than nothing at all. And whatever is left over after that, and
|
|
// after the constructs that definitively are NOT fields, is reported instead of
|
|
// skipped: the scanner may not quietly decide that a line it cannot read was
|
|
// not worth publishing.
|
|
static std::vector<TypeDecl> scanForRecords(const QStringList& lines)
|
|
{
|
|
// `\{[^;]*\}` accepts a brace initialiser beside the `=` form: a field
|
|
// written `std::string id{"none"};` is a field, and dropping it published a
|
|
// record whose defaults decided which members a consumer could see.
|
|
static QRegularExpression fieldRe(
|
|
"^([\\w:<>,\\s\\*]+?)\\s+(\\w+)\\s*(=[^;]*|\\{[^;]*\\})?;$");
|
|
static QRegularExpression accessRe("^(public|private|protected)\\s*:");
|
|
// Declarations that are legitimately not fields, and are skipped by rule
|
|
// rather than by failing to match. A `static` data member is not part of
|
|
// the object's value and never reaches the wire.
|
|
static QRegularExpression notAFieldRe(
|
|
"^(using|typedef|friend|template|static_assert|static|constexpr|inline)\\b");
|
|
static QRegularExpression nestedTypeRe("^(struct|class|union|enum)\\b");
|
|
|
|
// Comments come off ONCE, up front, so every rule below sees code.
|
|
const QStringList code = stripCommentsFrom(lines);
|
|
|
|
// TWO passes. A record field may name another record (`Blob inner;` inside
|
|
// Wrapper), and cppTypeToLidl only answers Named() for a name already in
|
|
// g_recordNames — so every struct name has to be registered before any
|
|
// field is typed. One pass silently typed such a field as `any`, and the
|
|
// generated codec then tried to encode a Blob as a LogosMap.
|
|
for (int i = 0; i < code.size(); ++i) {
|
|
StructOpen so;
|
|
if (matchStructOpen(code, i, so))
|
|
g_recordNames.insert(so.name);
|
|
}
|
|
|
|
std::vector<TypeDecl> out;
|
|
for (int i = 0; i < code.size(); ++i) {
|
|
StructOpen so;
|
|
if (!matchStructOpen(code, i, so)) continue;
|
|
|
|
TypeDecl td;
|
|
td.name = so.name.toStdString();
|
|
// Withdraw this struct's diagnostics if it turns out to declare no
|
|
// fields at all — nothing is published, so nothing is misreported.
|
|
const int diagMark = g_unsupported.size();
|
|
|
|
if (so.hasBase) {
|
|
reportUnreadable(
|
|
so.name, so.text,
|
|
QString("`struct %1` has a base class, and this parser reads one "
|
|
"header as text — the inherited members are not in front "
|
|
"of it. Publishing the struct would drop exactly the "
|
|
"fields it cannot see. Declare the record without a base "
|
|
"and give it the inherited fields explicitly.")
|
|
.arg(so.name));
|
|
}
|
|
|
|
if (so.bodyOnOpeningLine) {
|
|
// The body shares the opening line, and the scan below starts on the
|
|
// NEXT one, so there is nothing for it to read. Say so instead of
|
|
// publishing an empty record.
|
|
reportUnreadable(so.name, so.text,
|
|
QString("The body shares the line with the opening "
|
|
"brace. Put each field on its own line. %1")
|
|
.arg(kFieldFormHint));
|
|
} else {
|
|
// The body is read as DECLARATIONS, not lines: physical lines are
|
|
// joined until the declaration is whole, which is a `;` at the
|
|
// struct's own brace depth — or a `}` there, which is how a member
|
|
// function DEFINED inline ends. Depth is tracked because a member
|
|
// function's body, and a nested type's, are declarations of their
|
|
// own that a `;` inside them must not be mistaken for the end of.
|
|
QString acc;
|
|
int depth = 1; // inside the struct
|
|
for (int j = so.bodyStart; j >= 0 && j < code.size(); ++j) {
|
|
QString body = code.at(j);
|
|
// An access specifier may share the line with a declaration, as
|
|
// in the class-body parser. Strip it before anything else, or
|
|
// `public: std::string id;` reads as a field whose TYPE is
|
|
// `public: std::string`.
|
|
while (true) {
|
|
const QRegularExpressionMatch am = accessRe.match(body);
|
|
if (!am.hasMatch()) break;
|
|
body = body.mid(am.capturedEnd()).trimmed();
|
|
}
|
|
if (body.isEmpty()) continue;
|
|
|
|
const int delta = braceDelta(body);
|
|
if (depth + delta <= 0) {
|
|
// End of the struct. Anything still accumulating never
|
|
// became a whole declaration — report it rather than
|
|
// dropping it on the way out.
|
|
if (!acc.isEmpty())
|
|
reportUnreadable(so.name, acc, kFieldFormHint);
|
|
break;
|
|
}
|
|
|
|
acc = acc.isEmpty() ? body : acc + ' ' + body;
|
|
depth += delta;
|
|
// Not a whole declaration yet: a field wrapped across physical
|
|
// lines is still the same field, and a `;` inside an inline
|
|
// member-function body does not end the member.
|
|
if (depth != 1 || !(acc.endsWith(';') || acc.endsWith('}')))
|
|
continue;
|
|
|
|
const QString decl = acc;
|
|
acc.clear();
|
|
|
|
// The DECLARATOR is everything before the first `=` or `{`. A
|
|
// default value may legally contain parentheses
|
|
// (`std::string id = makeId();`), and only parentheses in the
|
|
// declarator make the line a member function.
|
|
qsizetype cut = decl.size();
|
|
const qsizetype eq = decl.indexOf('=');
|
|
const qsizetype brace = decl.indexOf('{');
|
|
if (eq >= 0) cut = qMin(cut, eq);
|
|
if (brace >= 0) cut = qMin(cut, brace);
|
|
if (decl.left(cut).contains('('))
|
|
continue; // member function / constructor / destructor
|
|
if (notAFieldRe.match(decl).hasMatch())
|
|
continue;
|
|
|
|
if (nestedTypeRe.match(decl).hasMatch()) {
|
|
// A nested type is not a field — and the scanner used to
|
|
// walk straight into its body, folding the INNER type's
|
|
// members into this record's field list and stopping at the
|
|
// inner `};`, so the published record was made of another
|
|
// type's fields and missing all of its own.
|
|
reportUnreadable(
|
|
so.name, decl,
|
|
QString("A nested type is not a field, and its own "
|
|
"members were being folded into `%1`. Declare it "
|
|
"at namespace scope — it becomes a contract "
|
|
"`type` of its own — and give `%1` a field of "
|
|
"that type.")
|
|
.arg(so.name));
|
|
continue;
|
|
}
|
|
|
|
const QRegularExpressionMatch fm = fieldRe.match(decl);
|
|
if (!fm.hasMatch()) {
|
|
reportUnreadable(so.name, decl, kFieldFormHint);
|
|
continue;
|
|
}
|
|
FieldDecl fd;
|
|
fd.name = fm.captured(2).toStdString();
|
|
const QString spelling = fm.captured(1).trimmed();
|
|
fd.type = cppTypeToLidl(
|
|
spelling,
|
|
QString("type '%1': field '%2'").arg(so.name, fm.captured(2)),
|
|
spelling, so.name, /*nameEmitted=*/true);
|
|
td.fields.push_back(fd);
|
|
}
|
|
}
|
|
|
|
if (!td.fields.empty()) {
|
|
out.push_back(td);
|
|
} else {
|
|
while (g_unsupported.size() > diagMark) g_unsupported.removeLast();
|
|
if (!g_emptyRecords.contains(so.name))
|
|
g_emptyRecords.append(so.name);
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Keep only the records the module's API actually mentions.
|
|
//
|
|
// An impl header routinely declares helper structs that are none of a
|
|
// consumer's business — `struct PendingAction` inside the class, a
|
|
// `struct ModuleSource` next to it. Publishing every struct as a contract
|
|
// `type` changes the module's PUBLISHED interface as a side effect of an
|
|
// internal refactor, which is not something deriving a contract from a header
|
|
// is allowed to do. A struct earns its place in the contract by appearing in a
|
|
// method or event signature — transitively, since a published record's own
|
|
// fields may name others.
|
|
//
|
|
// Returns that referenced set. It is the withdrawal key for BOTH diagnostic
|
|
// channels: a struct the API never names promises nothing, so neither an
|
|
// unsupported field type nor a line the scanner could not read is a defect in
|
|
// it. The set — not the published types — is what a structural diagnostic is
|
|
// tested against, because the very failures being reported are the ones that
|
|
// keep a struct OUT of module.types.
|
|
static std::set<std::string> keepOnlyReferencedRecords(ModuleDecl& module)
|
|
{
|
|
auto mention = [](const TypeExpr& te, std::set<std::string>& out) {
|
|
std::function<void(const TypeExpr&)> walk = [&](const TypeExpr& t) {
|
|
if (t.kind == TypeExpr::Named) out.insert(t.name);
|
|
for (const TypeExpr& e : t.elements) walk(e);
|
|
};
|
|
walk(te);
|
|
};
|
|
|
|
std::set<std::string> referenced;
|
|
for (const MethodDecl& md : module.methods) {
|
|
mention(md.returnType, referenced);
|
|
for (const ParamDecl& pd : md.params) mention(pd.type, referenced);
|
|
}
|
|
for (const EventDecl& ed : module.events)
|
|
for (const ParamDecl& pd : ed.params) mention(pd.type, referenced);
|
|
|
|
// Transitive closure: a referenced record's fields may name more records.
|
|
bool grew = true;
|
|
while (grew) {
|
|
grew = false;
|
|
for (const TypeDecl& td : module.types) {
|
|
if (!referenced.count(td.name)) continue;
|
|
for (const FieldDecl& fd : td.fields) {
|
|
std::set<std::string> here;
|
|
mention(fd.type, here);
|
|
for (const std::string& n : here)
|
|
if (referenced.insert(n).second) grew = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<TypeDecl> kept;
|
|
for (const TypeDecl& td : module.types)
|
|
if (referenced.count(td.name)) kept.push_back(td);
|
|
module.types = std::move(kept);
|
|
return referenced;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Parse a single method declaration line
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// `kind` is "method" or "event" — it only labels the diagnostics an unsupported
|
|
// C++ spelling produces, so the report matches the section the declaration was
|
|
// written in rather than the function that happens to parse both.
|
|
static bool parseMethodLine(const QString& line, MethodDecl& out,
|
|
const QString& kind = "method")
|
|
{
|
|
// Find the parameter list: everything between the last '(' and ')'
|
|
int parenOpen = -1;
|
|
int parenClose = -1;
|
|
int depth = 0;
|
|
for (int i = line.size() - 1; i >= 0; --i) {
|
|
if (line[i] == ')') {
|
|
if (parenClose < 0) parenClose = i;
|
|
depth++;
|
|
} else if (line[i] == '(') {
|
|
depth--;
|
|
if (depth == 0) {
|
|
parenOpen = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (parenOpen < 0 || parenClose < 0)
|
|
return false;
|
|
|
|
QString paramStr = line.mid(parenOpen + 1, parenClose - parenOpen - 1).trimmed();
|
|
|
|
// Everything before '(' is "returnType methodName"
|
|
QString prefix = line.left(parenOpen).trimmed();
|
|
|
|
// The method name is the last identifier token in prefix
|
|
int nameEnd = prefix.size();
|
|
while (nameEnd > 0 && prefix[nameEnd - 1].isSpace())
|
|
nameEnd--;
|
|
int nameStart = nameEnd;
|
|
while (nameStart > 0 && (prefix[nameStart - 1].isLetterOrNumber() || prefix[nameStart - 1] == '_'))
|
|
nameStart--;
|
|
|
|
if (nameStart >= nameEnd)
|
|
return false;
|
|
|
|
const QString methodName = prefix.mid(nameStart, nameEnd - nameStart);
|
|
|
|
// Reject if the extracted name is a C++ keyword — this filters out
|
|
// member variable declarations like "std::function<void(...)> onEvent"
|
|
// where the parser would mistakenly extract "void" as the method name.
|
|
static const QSet<QString> cppKeywords = {
|
|
"void", "int", "bool", "char", "short", "long", "double", "float",
|
|
"auto", "return", "if", "else", "for", "while", "do", "switch",
|
|
"case", "break", "continue", "const", "static", "inline", "virtual"
|
|
};
|
|
if (cppKeywords.contains(methodName))
|
|
return false;
|
|
out.name = methodName.toStdString();
|
|
QString retTypeStr = stripDeclarationSpecifiers(prefix.left(nameStart).trimmed());
|
|
out.returnType = cppTypeToLidl(
|
|
retTypeStr, QString("%1 '%2': return type").arg(kind, methodName), retTypeStr,
|
|
QString(), /*nameEmitted=*/kind == "event");
|
|
// Flag methods whose impl returns LogosMap / LogosList so the generator
|
|
// can emit nlohmann→Qt conversion code in the glue layer.
|
|
out.jsonReturn = (retTypeStr == "LogosMap" || retTypeStr == "LogosList");
|
|
// Flag methods whose impl returns StdLogosResult so the generator can
|
|
// emit a StdLogosResult→Qt LogosResult conversion in the glue layer.
|
|
out.resultReturn = (retTypeStr == "StdLogosResult");
|
|
|
|
// Parse parameters
|
|
out.params.clear();
|
|
if (!paramStr.isEmpty()) {
|
|
// Split by comma, respecting template depth
|
|
QStringList parts;
|
|
int start = 0;
|
|
int tdepth = 0;
|
|
for (int i = 0; i < paramStr.size(); ++i) {
|
|
if (paramStr[i] == '<') tdepth++;
|
|
else if (paramStr[i] == '>') tdepth--;
|
|
else if (paramStr[i] == ',' && tdepth == 0) {
|
|
parts.append(paramStr.mid(start, i - start).trimmed());
|
|
start = i + 1;
|
|
}
|
|
}
|
|
parts.append(paramStr.mid(start).trimmed());
|
|
|
|
for (const QString& part : parts) {
|
|
if (part.isEmpty()) continue;
|
|
QString p = part.trimmed();
|
|
int pNameEnd = p.size();
|
|
while (pNameEnd > 0 && p[pNameEnd - 1].isSpace())
|
|
pNameEnd--;
|
|
int pNameStart = pNameEnd;
|
|
while (pNameStart > 0 && (p[pNameStart - 1].isLetterOrNumber() || p[pNameStart - 1] == '_'))
|
|
pNameStart--;
|
|
|
|
if (pNameStart >= pNameEnd) continue;
|
|
|
|
ParamDecl pd;
|
|
const QString pName = p.mid(pNameStart, pNameEnd - pNameStart);
|
|
const QString pSpelling = p.left(pNameStart).trimmed();
|
|
pd.name = pName.toStdString();
|
|
pd.type = cppTypeToLidl(
|
|
p.left(pNameStart),
|
|
QString("%1 '%2': parameter '%3'").arg(kind, methodName, pName),
|
|
pSpelling, QString(), /*nameEmitted=*/kind == "event");
|
|
out.params.push_back(pd);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Main entry point
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Join doc-comment lines preserving line breaks (drop leading/trailing blanks).
|
|
static QString joinDocLines(QStringList lines)
|
|
{
|
|
while (!lines.isEmpty() && lines.first().trimmed().isEmpty()) lines.removeFirst();
|
|
while (!lines.isEmpty() && lines.last().trimmed().isEmpty()) lines.removeLast();
|
|
return lines.join('\n');
|
|
}
|
|
|
|
ImplParseResult parseImplHeader(const QString& headerPath,
|
|
const QString& className,
|
|
const QString& metadataPath,
|
|
QTextStream& err)
|
|
{
|
|
ImplParseResult result;
|
|
|
|
// Every file-static above is per-parse state: one process generates for more
|
|
// than one module. g_recordNames is cleared HERE as well as beside
|
|
// scanForRecords, because a name left over from the previous module's header
|
|
// would otherwise be visible while this one's metadata events are typed.
|
|
g_unmappableSpellings.clear();
|
|
g_unsupported.clear();
|
|
g_unreadable.clear();
|
|
g_emptyRecords.clear();
|
|
g_recordNames.clear();
|
|
|
|
QJsonArray metadataEvents;
|
|
|
|
// --- Read metadata.json ---
|
|
{
|
|
QFile mf(metadataPath);
|
|
if (!mf.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
result.error = "Failed to open metadata file: " + metadataPath;
|
|
return result;
|
|
}
|
|
QJsonParseError pe;
|
|
QJsonDocument doc = QJsonDocument::fromJson(mf.readAll(), &pe);
|
|
if (pe.error != QJsonParseError::NoError) {
|
|
result.error = "Failed to parse metadata JSON: " + pe.errorString();
|
|
return result;
|
|
}
|
|
QJsonObject obj = doc.object();
|
|
result.module.name = obj.value("name").toString().toStdString();
|
|
result.module.version = obj.value("version").toString().toStdString();
|
|
result.module.description = obj.value("description").toString().toStdString();
|
|
result.module.category = obj.value("category").toString().toStdString();
|
|
const QJsonArray deps = obj.value("dependencies").toArray();
|
|
for (const QString& depName : dependencyNames(deps))
|
|
result.module.depends.push_back(depName.toStdString());
|
|
|
|
// Events declared in metadata.json. Only READ here — their parameter
|
|
// types are C++ spellings like any other, and typing them requires the
|
|
// record set, which does not exist until the header has been scanned.
|
|
// They used to be typed right here, against whatever g_recordNames the
|
|
// PREVIOUS module's parse left behind.
|
|
metadataEvents = obj.value("events").toArray();
|
|
}
|
|
|
|
// --- Read and parse header ---
|
|
QFile hf(headerPath);
|
|
if (!hf.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
result.error = "Failed to open header file: " + headerPath;
|
|
return result;
|
|
}
|
|
QString source = QString::fromUtf8(hf.readAll());
|
|
hf.close();
|
|
|
|
// Records first: cppTypeToLidl consults the declared set, so the structs
|
|
// have to be known before a single signature is looked at.
|
|
// Split into physical lines, then merge any whose parentheses are still
|
|
// open into one logical line. The scanner below is line-based — it only
|
|
// accepts a method when a single trimmed line ends in ';' and
|
|
// parseMethodLine finds a balanced '(...)' on it — so without this a method
|
|
// signature wrapped across several physical lines is silently dropped.
|
|
// Parens inside comments / string / char literals are ignored.
|
|
QStringList lines;
|
|
{
|
|
const QStringList physical = source.split('\n');
|
|
QString acc;
|
|
int parenDepth = 0;
|
|
bool inBlockComment = false;
|
|
for (const QString& phys : physical) {
|
|
bool inStr = false;
|
|
bool inChr = false;
|
|
for (int i = 0; i < phys.size(); ++i) {
|
|
const QChar c = phys[i];
|
|
const QChar n = (i + 1 < phys.size()) ? phys[i + 1] : QChar();
|
|
if (inBlockComment) {
|
|
if (c == '*' && n == '/') { inBlockComment = false; ++i; }
|
|
} else if (inStr) {
|
|
if (c == '\\') ++i; else if (c == '"') inStr = false;
|
|
} else if (inChr) {
|
|
if (c == '\\') ++i; else if (c == '\'') inChr = false;
|
|
} else if (c == '/' && n == '*') {
|
|
inBlockComment = true; ++i;
|
|
} else if (c == '/' && n == '/') {
|
|
break;
|
|
} else if (c == '"') {
|
|
inStr = true;
|
|
} else if (c == '\'') {
|
|
inChr = true;
|
|
} else if (c == '(') {
|
|
++parenDepth;
|
|
} else if (c == ')') {
|
|
if (parenDepth > 0) --parenDepth;
|
|
}
|
|
}
|
|
if (acc.isEmpty())
|
|
acc = phys;
|
|
else
|
|
acc += ' ' + phys.trimmed();
|
|
if (parenDepth <= 0) {
|
|
lines.append(acc);
|
|
acc.clear();
|
|
}
|
|
}
|
|
if (!acc.isEmpty())
|
|
lines.append(acc);
|
|
}
|
|
|
|
// Records, before any signature is examined: cppTypeToLidl() consults the
|
|
// declared set, so a `Blob` parameter only becomes Named("Blob") once the
|
|
// struct has been seen. Reset per parse — the set is file-static and a
|
|
// single process generates for more than one module.
|
|
g_recordNames.clear();
|
|
result.module.types = scanForRecords(lines);
|
|
|
|
// Now the record set exists, the metadata-declared events can be typed. They
|
|
// stay AHEAD of the header's `logos_events:` events, as they always were.
|
|
for (const QJsonValue& ev : metadataEvents) {
|
|
QJsonObject evObj = ev.toObject();
|
|
EventDecl ed;
|
|
ed.name = evObj.value("name").toString().toStdString();
|
|
ed.description = evObj.value("description").toString().toStdString();
|
|
const QJsonArray params = evObj.value("params").toArray();
|
|
for (const QJsonValue& pv : params) {
|
|
QJsonObject po = pv.toObject();
|
|
ParamDecl pd;
|
|
const QString pName = po.value("name").toString();
|
|
const QString pType = po.value("type").toString();
|
|
pd.name = pName.toStdString();
|
|
pd.type = cppTypeToLidl(
|
|
pType,
|
|
QString("event '%1': parameter '%2' (declared in metadata.json)")
|
|
.arg(evObj.value("name").toString(), pName),
|
|
pType, QString(), /*nameEmitted=*/true);
|
|
ed.params.push_back(pd);
|
|
}
|
|
if (!ed.name.empty())
|
|
result.module.events.push_back(ed);
|
|
}
|
|
|
|
// State machine: find "class <className>", then collect declarations.
|
|
// `InLogosEvents` is entered by the literal `logos_events:` token
|
|
// (mirrors Qt's `signals:`) — methods declared there are parsed as
|
|
// EventDecls and appended to ModuleDecl.events instead of .methods.
|
|
enum State { LookingForClass, InClass, InPublic, InPrivate, InLogosEvents };
|
|
State state = LookingForClass;
|
|
int braceDepth = 0;
|
|
|
|
// Accumulates doc-comment lines adjacent to a method so the doc comment
|
|
// becomes the method's description. Reset on any blank / non-comment line.
|
|
QStringList pendingDoc;
|
|
bool inBlockComment = false;
|
|
|
|
QRegularExpression classRe("\\bclass\\s+" + QRegularExpression::escape(className) + "\\b");
|
|
QRegularExpression accessRe("^\\s*(public|private|protected)\\s*:");
|
|
QRegularExpression eventsRe("^\\s*logos_events\\s*:");
|
|
QRegularExpression ctorDtorRe("^\\s*~?" + QRegularExpression::escape(className) + "\\s*\\(");
|
|
|
|
for (const QString& rawLine : lines) {
|
|
QString line = rawLine.trimmed();
|
|
|
|
switch (state) {
|
|
case LookingForClass:
|
|
if (classRe.match(line).hasMatch()) {
|
|
state = InClass;
|
|
for (QChar c : line) {
|
|
if (c == '{') braceDepth++;
|
|
else if (c == '}') braceDepth--;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case InClass:
|
|
case InPublic:
|
|
case InPrivate:
|
|
case InLogosEvents:
|
|
// Inside a multi-line /** ... */ doc-comment block: capture its
|
|
// text (skip brace counting — comments don't affect scope).
|
|
if (inBlockComment) {
|
|
QString t = line;
|
|
int end = t.indexOf("*/");
|
|
if (end >= 0) { t = t.left(end); inBlockComment = false; }
|
|
t.remove(QRegularExpression(R"(^\*+\s?)"));
|
|
t = t.trimmed();
|
|
pendingDoc.append(t);
|
|
break;
|
|
}
|
|
|
|
// Count braces only on real code lines. Braces inside a doc/line
|
|
// comment (e.g. `/// returns { "k": v }`) must not affect scope
|
|
// tracking, or an unbalanced brace in a comment would make the
|
|
// parser think the class ended early and drop later declarations.
|
|
if (!(line.startsWith("//") || line.startsWith("/*") || line.startsWith("*"))) {
|
|
for (QChar c : line) {
|
|
if (c == '{') braceDepth++;
|
|
else if (c == '}') braceDepth--;
|
|
}
|
|
|
|
if (braceDepth <= 0) {
|
|
state = LookingForClass;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
// A section specifier may be followed by a declaration on the
|
|
// *same* physical line — e.g. clang-format / prettier collapse
|
|
// logos_events:
|
|
// void versionReady(const std::string& version);
|
|
// into `logos_events : void versionReady(const std::string& version);`.
|
|
// Strip any leading specifiers, updating the section state, and
|
|
// let whatever remains fall through to the declaration parser
|
|
// below — otherwise everything after the colon is discarded and
|
|
// the same valid C++ is parsed differently based on formatting.
|
|
//
|
|
// `logos_events:` takes precedence over the standard access
|
|
// specifiers: it's a separate section that the codegen pulls
|
|
// event prototypes from. (At preprocess time, `logos_events`
|
|
// expands to `public`, but the raw source still carries the
|
|
// token we recognise here.)
|
|
bool specifierStripped = false;
|
|
while (true) {
|
|
QRegularExpressionMatch em = eventsRe.match(line);
|
|
if (em.hasMatch()) {
|
|
state = InLogosEvents;
|
|
line = line.mid(em.capturedEnd()).trimmed();
|
|
specifierStripped = true;
|
|
continue;
|
|
}
|
|
QRegularExpressionMatch am = accessRe.match(line);
|
|
if (am.hasMatch()) {
|
|
QString spec = am.captured(1);
|
|
if (spec == "public") state = InPublic;
|
|
else state = InPrivate;
|
|
line = line.mid(am.capturedEnd()).trimmed();
|
|
specifierStripped = true;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
// A *bare* specifier (nothing after the colon) is a section
|
|
// boundary and resets any pending doc-comment, mirroring Qt's
|
|
// `signals:`. But when a declaration shares the line, the doc
|
|
// comment preceding the whole line must still attach to that
|
|
// declaration — otherwise documentation, like the declaration
|
|
// itself (#76), would become formatting-dependent. So only clear
|
|
// here for the bare form; the same-line form keeps pendingDoc and
|
|
// attaches it in the declaration parser below.
|
|
if (specifierStripped && line.isEmpty())
|
|
pendingDoc.clear();
|
|
|
|
// Only doc comments (/// or /** ... */ / /*! ... */) accumulate as
|
|
// the pending description for the next method. Plain // and /*
|
|
// comments are ignored but leave pending doc intact; blank /
|
|
// preprocessor lines reset it so only *adjacent* comments attach.
|
|
if (line.startsWith("///")) {
|
|
QString text = line.mid(3);
|
|
if (text.startsWith('<')) text = text.mid(1); // ///< trailing form
|
|
text = text.trimmed();
|
|
pendingDoc.append(text);
|
|
break;
|
|
}
|
|
if (line.startsWith("/**") || line.startsWith("/*!")) {
|
|
QString text = line.mid(3);
|
|
int end = text.indexOf("*/");
|
|
if (end >= 0) text = text.left(end);
|
|
else inBlockComment = true;
|
|
text.remove(QRegularExpression(R"(^\*+\s?)"));
|
|
text = text.trimmed();
|
|
pendingDoc.append(text);
|
|
break;
|
|
}
|
|
if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) {
|
|
break; // non-doc comment: ignore, keep pending doc
|
|
}
|
|
if (line.isEmpty() || line.startsWith("#")) {
|
|
pendingDoc.clear();
|
|
break;
|
|
}
|
|
|
|
if (ctorDtorRe.match(line).hasMatch()) {
|
|
pendingDoc.clear();
|
|
break;
|
|
}
|
|
|
|
if (line.startsWith("typedef") || line.startsWith("using")
|
|
|| line.startsWith("friend") || line.startsWith("enum")
|
|
|| line.startsWith("struct")) {
|
|
pendingDoc.clear();
|
|
break;
|
|
}
|
|
|
|
if (state == InLogosEvents) {
|
|
// Inside `logos_events:` — every bare prototype is an event.
|
|
// Events are always void-returning by definition, so we
|
|
// re-use parseMethodLine to extract name + params and
|
|
// discard the return type.
|
|
if (line.endsWith(';')) {
|
|
QString decl = line.left(line.size() - 1).trimmed();
|
|
MethodDecl md;
|
|
if (parseMethodLine(decl, md, "event")) {
|
|
EventDecl ed;
|
|
ed.name = md.name;
|
|
ed.params = md.params;
|
|
ed.description = joinDocLines(pendingDoc).toStdString();
|
|
result.module.events.push_back(ed);
|
|
}
|
|
}
|
|
pendingDoc.clear();
|
|
break;
|
|
}
|
|
|
|
if (state != InPublic) { pendingDoc.clear(); break; }
|
|
|
|
if (line.contains("std::function<")) {
|
|
// A std::function member is not a method — skip it so the
|
|
// `parseMethodLine` path below doesn't choke on the nested
|
|
// parens in its type. (Events are declared in a typed
|
|
// `logos_events:` section, parsed above — there is no longer
|
|
// any special `std::function emitEvent` member to detect.)
|
|
pendingDoc.clear();
|
|
break;
|
|
}
|
|
|
|
if (line.endsWith(';')) {
|
|
QString decl = line.left(line.size() - 1).trimmed();
|
|
MethodDecl md;
|
|
// Withdraw the declaration's diagnostics if it turns out to be a
|
|
// reserved lifecycle hook: it is not part of the contract, so an
|
|
// unsupported spelling in it is not a contract defect.
|
|
const int diagMark = g_unsupported.size();
|
|
if (parseMethodLine(decl, md)) {
|
|
// LogosModuleContext lifecycle hooks / context accessors are
|
|
// framework plumbing, not part of the module's API contract.
|
|
// An impl commonly overrides `onContextReady()` (and could
|
|
// re-declare an accessor) in its own public section, so the
|
|
// header parser would otherwise emit them into the derived
|
|
// LIDL — breaking cdylib eligibility (e.g. the inherited
|
|
// accessors' Qt-free-subset check) and exposing non-API
|
|
// methods. Skip the reserved names regardless of access.
|
|
static const QSet<QString> reserved = {
|
|
"onContextReady", "modules", "modulePath",
|
|
"instanceId", "instancePersistencePath",
|
|
// Teardown plumbing, same rule as onContextReady: an
|
|
// impl overriding aboutToUnload() (or calling
|
|
// unloadFinished()) is talking to the framework, not
|
|
// publishing API. Leaking either would generate a
|
|
// consumer wrapper for a lifecycle hook, and
|
|
// aboutToUnload's LogosShutdown return has no LIDL
|
|
// type anyway.
|
|
"aboutToUnload", "unloadFinished"
|
|
};
|
|
if (!reserved.contains(qs(md.name))) {
|
|
md.description = joinDocLines(pendingDoc).toStdString();
|
|
result.module.methods.push_back(md);
|
|
} else {
|
|
while (g_unsupported.size() > diagMark)
|
|
g_unsupported.removeLast();
|
|
}
|
|
}
|
|
}
|
|
pendingDoc.clear();
|
|
break;
|
|
}
|
|
}
|
|
|
|
done:
|
|
// Now that every signature is known, drop the structs the API never
|
|
// mentions — a header's internal helpers must not become published
|
|
// contract types.
|
|
const std::set<std::string> referenced = keepOnlyReferencedRecords(result.module);
|
|
|
|
// STRUCTURE the scanner could not read is a BUILD ERROR, not a shorter
|
|
// record.
|
|
//
|
|
// Reported before the type diagnostics below because it is the more
|
|
// fundamental failure: when the scanner could not read a struct's body, the
|
|
// types it did manage to read there are not a trustworthy account of it
|
|
// either. Reported after keepOnlyReferencedRecords, and tested against the
|
|
// REFERENCED set rather than the published one, for the reason given on that
|
|
// function: a helper struct the API never mentions may be as unreadable as
|
|
// it likes, while a struct that failed to publish anything is exactly the
|
|
// case that has to be caught.
|
|
{
|
|
QStringList reports;
|
|
QSet<QString> seen;
|
|
for (const UnreadableDecl& u : g_unreadable) {
|
|
if (!referenced.count(u.record.toStdString()))
|
|
continue; // struct never reaches the contract
|
|
const QString line =
|
|
QString(" type '%1': `%2`\n could not be read as a field. %3")
|
|
.arg(u.record, u.text, u.hint);
|
|
if (seen.contains(line)) continue;
|
|
seen.insert(line);
|
|
reports << line;
|
|
}
|
|
// A struct the API NAMES that published no field at all. Nothing above
|
|
// need have fired — a body of nothing but member functions reads
|
|
// perfectly well and yields no record — and the emitted contract would
|
|
// then reference a `type` it never declares, which no reader of the
|
|
// .lidl can resolve and no backend can generate.
|
|
for (const QString& name : g_emptyRecords) {
|
|
if (!referenced.count(name.toStdString())) continue;
|
|
bool explained = false;
|
|
for (const UnreadableDecl& u : g_unreadable)
|
|
if (u.record == name) { explained = true; break; }
|
|
if (explained) continue;
|
|
reports << QString(
|
|
" type '%1' is named by this module's API but declares "
|
|
"no field this parser could read, so no `type %1` is "
|
|
"emitted and the contract would name a type it never "
|
|
"declares.\n %2")
|
|
.arg(name, kFieldFormHint);
|
|
}
|
|
if (!reports.isEmpty()) {
|
|
result.error =
|
|
headerPath + ": " + QString::number(reports.size())
|
|
+ (reports.size() == 1 ? " declaration in a struct this module "
|
|
"publishes could not be read.\n\n"
|
|
: " declarations in structs this module "
|
|
"publishes could not be read.\n\n")
|
|
+ reports.join("\n\n")
|
|
+ "\n\nA `struct` in this header becomes a contract `type`, and its "
|
|
"field list IS the promise consumers in every language bind to. "
|
|
"Each of these used to be skipped, and the record published "
|
|
"without it — a contract missing a field is as well-formed as one "
|
|
"that has it, so nothing downstream could tell.\n";
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// A C++ spelling with no LIDL type is a BUILD ERROR, not a silent `any`.
|
|
//
|
|
// Reported after keepOnlyReferencedRecords so a helper struct that never
|
|
// reaches the contract cannot fail the build: publishing is what makes a
|
|
// declaration's type a promise, and an internal struct promises nothing.
|
|
{
|
|
std::set<std::string> published;
|
|
for (const TypeDecl& td : result.module.types) published.insert(td.name);
|
|
|
|
QStringList reports;
|
|
QSet<QString> seen;
|
|
for (const UnsupportedSpelling& u : g_unsupported) {
|
|
if (!u.record.isEmpty() && !published.count(u.record.toStdString()))
|
|
continue; // struct dropped: not part of the contract
|
|
QString line = " " + u.context;
|
|
// "declared X, whose element Y" only when Y really is nested inside
|
|
// X — not when the two differ by a `const` and an `&`.
|
|
if (normalizeCppSpelling(u.declared) != u.offending)
|
|
line += QString(" is declared `%1`, whose element `%2` has no "
|
|
"LIDL type.\n ").arg(u.declared, u.offending);
|
|
else
|
|
line += QString(" is `%1`, which has no LIDL type.\n ")
|
|
.arg(u.offending);
|
|
line += u.hint;
|
|
if (seen.contains(line)) continue;
|
|
seen.insert(line);
|
|
reports << line;
|
|
}
|
|
if (!reports.isEmpty()) {
|
|
result.error =
|
|
headerPath + ": " + QString::number(reports.size())
|
|
+ (reports.size() == 1 ? " declaration uses" : " declarations use")
|
|
+ " a C++ type that has no LIDL type.\n\n"
|
|
+ reports.join("\n\n")
|
|
+ "\n\nEach of these used to be published as the opaque `any`, with no "
|
|
"diagnostic. `any` is admitted by every backend gate, so the generated "
|
|
"dispatch handed the raw JSON straight to the parameter with no decode "
|
|
"and no check — the value either converted by luck, threw at call time, "
|
|
"or went onto the wire in a form no other language decodes.\n";
|
|
return result;
|
|
}
|
|
}
|
|
|
|
if (!g_unmappableSpellings.isEmpty()) {
|
|
g_unmappableSpellings.removeDuplicates();
|
|
err << "Warning: " << headerPath << ": " << g_unmappableSpellings.join(", ")
|
|
<< " has no LIDL type. `?T` is TWO-state — a value or empty — so a "
|
|
"nested optional cannot denote a third state; the contract "
|
|
"publishes the collapsed `?T`, and the generated codec is "
|
|
"written for std::optional<T>. Declare it that way, or the "
|
|
"generated code will not compile against this header.\n";
|
|
}
|
|
|
|
if (result.module.methods.empty()) {
|
|
err << "Warning: no public methods found in class " << className
|
|
<< " in " << headerPath << "\n";
|
|
}
|
|
|
|
return result;
|
|
}
|