diag.hpp

Go to the documentation of this file.

#pragma once

 
namespace welder::inline v0::diag {

struct lang_out_of_mask_range {
    const char* what =
        "welder: this lang value is not a language-mask bit index (it lies "
        "past the 32-bit mask); mint user languages with "
        "welder::user_lang<Slot>, which cannot go out of range";
};

struct dangling_return_policy {
    const char* what =
        "welder: return_policy requests a reference-category policy "
        "(rv::reference / rv::reference_internal) on a callable returning BY "
        "VALUE - the target-language view would reference a destroyed "
        "temporary; drop the policy, or return a pointer/reference";
};

struct bare_mark_only {
    const char* what =
        "welder: a bare [[=welder::mark::only]] is meaningless ('only, for "
        "every language' restricts nothing); call it with the languages the "
        "member may bind for: mark::only(welder::lang::py, ...)";
};

struct no_matching_virtual_slot {
    const char* what =
        "welder: no overridable virtual of this class matches the given name "
        "and function type; check the spelling and the FULL function type - "
        "parameter types and trailing cv/ref qualifiers included - against "
        "the base's declaration";
};

struct stale_hook_signature {
    const char* what =
        "welder: this resolution's protected_participates hook gained a "
        "trailing `std::meta::info bound_into` parameter (the entity whose "
        "binding receives the member); update its signature to "
        "(mem, lang, bound_into)";
};

struct marked_move_constructor {
    const char* what =
        "welder: a move constructor carries an include/only mark, but move "
        "construction never binds - no target language has move semantics. "
        "Remove the mark; copying is what crosses the boundary (the copy "
        "constructor binds as Python __copy__/__deepcopy__)";
};

struct accessor_name_too_long {
    const char* what =
        "welder: this getter/setter explicit property name is longer than the "
        "64-character inline capacity; choose a shorter target-language name";
};

struct malformed_getter {
    const char* what =
        "welder: a [[=welder::getter]] must mark a CONST member function with "
        "no parameters and a non-void return - a property read takes nothing "
        "and must not mutate; move side effects to a method, or drop the mark";
};

struct malformed_setter {
    const char* what =
        "welder: a [[=welder::setter]] must mark a member function taking "
        "exactly ONE parameter (the new value); a multi-argument update is a "
        "method, not a property write";
};

struct accessor_role_conflict {
    const char* what =
        "welder: this function carries BOTH a getter and a setter mark for one "
        "language; a function supplies one property half - split the accessors, "
        "or scope the marks to different languages";
};

struct duplicate_property_accessor {
    const char* what =
        "welder: two getters (or two setters) resolve to the SAME property "
        "name for one language; a property has one function per half - "
        "mark::exclude one, scope the marks by language, or rename one with an "
        "explicit getter(\"name\")/setter(\"name\")";
};

struct setter_without_getter {
    const char* what =
        "welder: this setter's property has NO participating getter for one "
        "language (a write-only property is not idiomatic anywhere welder "
        "binds); mark the matching getter, make the names pair (an explicit "
        "getter(\"name\")/setter(\"name\") always pairs), or exclude the "
        "setter for that language too";
};

struct accessor_weld_as_conflict {
    const char* what =
        "welder: a getter/setter-marked function also carries weld_as, but an "
        "accessor's target name is the PROPERTY name - spell it in the mark "
        "instead: [[=welder::getter(\"name\")]]";
};

struct static_property_accessor {
    const char* what =
        "welder: getter/setter marks on a STATIC member function are not "
        "supported yet; bind it as a static method (drop the mark), or expose "
        "a namespace variable instead";
};

struct virtual_property_accessor {
    const char* what =
        "welder: getter/setter marks on a VIRTUAL member function are not "
        "supported (a property under the method's name breaks Python override "
        "dispatch, which looks overrides up by name); bind it as a method "
        "(drop the mark), or wrap the virtual in non-virtual accessors";
};

struct property_name_collision {
    const char* what =
        "welder: a property's name collides with a bound data member or "
        "method of the same class (compared word-wise, so spelling-convention "
        "variants count); rename the property with an explicit "
        "getter(\"name\"), or exclude the colliding member";
};
 
 
} // namespace welder::inline v0::diag