31#include <QtCore/QMultiMap>
33#include <QtCore/QString>
34#include <QtCore/QStringView>
35#include <QtCore/QDebug>
36#include <QtCore/QDateTime>
37#include <QtCore/QMutex>
38#include <QtCore/QCborValue>
39#include <QtCore/QTimeZone>
40#include <QtQml/private/qqmljssourcelocation_p.h>
41#include <QtQmlCompiler/private/qqmljsscope_p.h>
103struct IsMultiMap : std::false_type
107template<
typename Key,
typename T>
113struct IsMap : std::false_type
117template<
typename Key,
typename T>
118struct IsMap<
QMap<
Key, T>> : std::true_type
122template<
typename... Ts>
125template<
typename T,
typename =
void>
126struct IsDomObject : std::false_type
131struct IsDomObject<T, void_t<decltype(T::kindValue)>> : std::true_type
135template<
typename T,
typename =
void>
136struct IsInlineDom : std::false_type
141struct IsInlineDom<T, void_t<decltype(T::kindValue)>>
142 : std::integral_constant<bool, domTypeCanBeInline(T::kindValue)>
147struct IsInlineDom<T *, void_t<
decltype(T::kindValue)>> : std::true_type
152struct IsInlineDom<
std::shared_ptr<T>, void_t<decltype(T::kindValue)>> : std::true_type
157struct IsSharedPointerToDomObject : std::false_type
162struct IsSharedPointerToDomObject<
std::shared_ptr<T>> : IsDomObject<T>
166template<
typename T,
typename =
void>
167struct IsList : std::false_type
172struct IsList<T, void_t<typename T::
value_type>> : std::true_type
184 T *
data() {
return reinterpret_cast<T *
>(
this); }
185 const T *
data()
const {
return reinterpret_cast<const T *
>(
this); }
195 o.data()->copyTo(
data());
213 virtual DomKind domKind()
const;
224 virtual DomItem containingObject(
230 virtual QList<QString> fields(
const DomItem &self)
const;
236 virtual QSet<QString>
const keys(
const DomItem &self)
const;
268 constexpr static DomType kindValue = DomType::Empty;
300 Path m_pathFromOwner;
306 constexpr static DomType kindValue = DomType::Map;
324 static Map fromMultiMapRef(
const Path &pathFromOwner,
const QMultiMap<QString, T> &mmap);
330 const Path &pathFromOwner,
const QMap<QString, T> &mmap,
334 static Map fromFileRegionMap(
335 const Path &pathFromOwner,
const QMap<FileLocationRegion, T> &
map);
337 static Map fromFileRegionListMap(
341 template<
typename MapT>
342 static QSet<QString> fileRegionKeysFromMap(
const MapT &
map);
351 constexpr static DomType kindValue = DomType::List;
376 fromQList(
const Path &pathFromOwner,
const QList<T> &
list,
381 fromQListRef(
const Path &pathFromOwner,
const QList<T> &
list,
388 LookupFunction m_lookup;
390 IteratorFunction m_iterator;
397 constexpr static DomType kindValue = DomType::ListP;
401 :
DomElement(pathFromOwner), m_pList(pList), m_elType(elType)
429 "ListPT does not have the same size as ListPBase");
431 "ListPT does not have the same size as ListPBase");
434 for (
const void *
p : pList)
454 constexpr static DomType kindValue = DomType::ListP;
458 :
list(
ListPT<T>(pathFromOwner, pList, elType, options))
469 SubclassStorage<ListPBase>
list;
475 constexpr static DomType kindValue = DomType::ConstantData;
489 Options options = Options::MapIsMap);
503 constexpr static DomType kindValue = DomType::SimpleObjectWrap;
509 template <
typename T>
512 if (
m_options & SimpleWrapOption::ValueType) {
513 if (m_value.metaType() == QMetaType::fromType<T>())
514 return static_cast<const T *
>(m_value.constData());
517 return m_value.value<
const T *>();
531 friend class TestDomItem;
534 SimpleWrapOptions options = SimpleWrapOption::None)
559 return asT()->iterateDirectSubpaths(self, visitor);
574 static_assert(!std::is_same_v<T, T>,
"wrapping of unexpected type");
582 "Size mismatch in SimpleObjectWrapT");
584 "Size mismatch in SimpleObjectWrapT");
591 "Size mismatch in SimpleObjectWrapT");
593 "Size mismatch in SimpleObjectWrapT");
608 constexpr static DomType kindValue = DomType::SimpleObjectWrap;
626 using BaseT = std::decay_t<T>;
632 quintptr(0), SimpleWrapOption::ValueType);
634 qCWarning(domLog) <<
"Unexpected object to wrap in SimpleObjectWrap: "
637 "simple wrap of unexpected object");
639 SimpleObjectWrapT<BaseT>(pathFromOwner,
nullptr, 0, SimpleWrapOption::None);
642 SubclassStorage<SimpleObjectWrapBase>
wrap;
649 constexpr static DomType kindValue = DomType::Reference;
666 QSet<QString>
const keys(
const DomItem &)
const override {
return {}; }
670 QList<Path> *visitedRefs =
nullptr)
const;
672 QList<Path> *visitedRefs =
nullptr)
const;
677template<
typename Info>
699 const std::shared_ptr<AttachedInfoT<FileLocations>> &fileLocationOfOwner) = 0;
715 template<
typename... T>
716 using VariantOfPointer = std::variant<ScriptElement::PointerType<T>...>;
718 template<
typename T,
typename Variant>
719 struct TypeIsInVariant;
721 template<
typename T,
typename... Ts>
722 struct TypeIsInVariant<T,
std::
variant<Ts...>> :
public std::disjunction<std::is_same<T, Ts>...>
737 static_assert(TypeIsInVariant<T, ScriptElementT>::value,
738 "Cannot construct ScriptElementVariant from T, as it is missing from the "
747 operator bool()
const {
return m_data.has_value(); }
753 std::visit(std::forward<F>(visitor), *m_data);
760 std::visit(std::forward<F>(visitor), *m_data);
762 std::optional<ScriptElementT>
data() {
return m_data; }
766 std::optional<ScriptElementT> m_data;
833 std::shared_ptr<DomEnvironment>,
834 std::shared_ptr<DomUniverse>>;
838 std::shared_ptr<ModuleIndex>,
839 std::shared_ptr<MockOwner>,
840 std::shared_ptr<ExternalItemInfoBase>,
841 std::shared_ptr<ExternalItemPairBase>,
842 std::shared_ptr<QmlDirectory>,
843 std::shared_ptr<QmldirFile>,
844 std::shared_ptr<JsFile>,
845 std::shared_ptr<QmlFile>,
846 std::shared_ptr<QmltypesFile>,
847 std::shared_ptr<GlobalScope>,
848 std::shared_ptr<ScriptExpression>,
849 std::shared_ptr<AstComments>,
850 std::shared_ptr<LoadInfo>,
851 std::shared_ptr<AttachedInfo>,
852 std::shared_ptr<DomEnvironment>,
853 std::shared_ptr<DomUniverse>>;
880 std::weak_ptr<DomEnvironment>
environment()
const {
return m_environment; }
883 std::optional<InMemoryContents>
content()
const {
return m_content; }
886 std::weak_ptr<DomEnvironment> m_environment;
889 std::optional<InMemoryContents> m_content;
911 return std::visit(
f, this->m_element);
914 explicit operator bool()
const {
return m_kind != DomType::Empty; }
921 if (m_kind == DomType::ConstantData)
922 return std::get<ConstantData>(m_element).domKind();
962 QString name()
const {
return field(Fields::name).value().toString(); }
965 QString idStr()
const {
return field(Fields::idStr).value().toString(); }
977 if (hasAnnotations())
978 return field(Fields::annotations);
984 ResolveOptions options = ResolveOption::None,
const Path &fullPath =
Path(),
985 QList<Path> *visitedRefs =
nullptr)
const;
1023 WriteOutChecks extraChecks = WriteOutCheck::Default)
const;
1026 VisitOptions options = VisitOption::Default,
1031 VisitPrototypesOptions options = VisitPrototypesOption::Normal,
1032 const ErrorHandler &
h =
nullptr, QSet<quintptr> *visited =
nullptr,
1033 QList<Path> *visitedRefs =
nullptr)
const;
1035 VisitPrototypesOptions options = VisitPrototypesOption::Normal,
1036 const ErrorHandler &
h =
nullptr, QSet<quintptr> *visited =
nullptr,
1037 QList<Path> *visitedRefs =
nullptr)
const;
1040 VisitPrototypesOptions options = VisitPrototypesOption::Normal,
1041 const ErrorHandler &
h =
nullptr, QSet<quintptr> *visited =
nullptr,
1042 QList<Path> *visitedRefs =
nullptr)
const;
1047 const ErrorHandler &
h =
nullptr, QSet<quintptr> *visited =
nullptr,
1048 QList<Path> *visitedRefs =
nullptr)
const;
1053 LookupOptions = LookupOption::Normal,
const ErrorHandler &
h =
nullptr,
1054 QSet<quintptr> *visited =
nullptr, QList<Path> *visitedRefs =
nullptr)
const;
1057 LookupType type = LookupType::Symbol, LookupOptions = LookupOption::Normal,
1058 const ErrorHandler &errorHandler =
nullptr, QSet<quintptr> *visited =
nullptr,
1059 QList<Path> *visitedRefs =
nullptr)
const;
1063 const ErrorHandler &
h =
nullptr, QList<Path> *visitedRefs =
nullptr)
const;
1066 LookupOptions = LookupOption::Normal,
const ErrorHandler &errorHandler =
nullptr)
const;
1069 LookupOptions = LookupOption::Normal,
const ErrorHandler &errorHandler =
nullptr)
const;
1077 bool commitToBase(
const std::shared_ptr<DomEnvironment> &validPtr =
nullptr)
const;
1088 int nBackups = 2,
int indent = 0,
FileWriter *fw =
nullptr)
const;
1109 template<
typename T>
1112 template<
typename T>
1118 template<
typename T>
1121 template<
typename T>
1124 template<
typename T>
1130 template<
typename F>
1133 template<
typename F>
1137 return this->dvValueLazy(std::move(visitor),
PathEls::Field(
f), valueF, options);
1149 return dvItem(std::move(visitor),
c, [
c,
this, referencedObject]() {
1150 return this->subReferenceItem(
c, referencedObject);
1156 return dvItem(std::move(visitor),
c, [
c,
this,
paths]() {
1157 return this->subReferencesItem(
c,
paths);
1162 return dvReference(std::move(visitor),
PathEls::Field(
f), referencedObject);
1170 return visitor(
c,
it);
1180 return DomItem(m_top, m_owner, m_ownerPath,
obj);
1189 template<
typename Owner>
1197 template<
typename T>
1199 template<
typename T>
1204 template<
typename T>
1206 template<
typename T>
1225 template<
typename T,
typename std::enable_if<std::is_base_of_v<DomBase, T>,
bool>::type = true>
1228 if (m_kind == T::kindValue) {
1230 return std::get<SimpleObjectWrap>(m_element)->as<T>();
1232 return static_cast<T
const *
>(
base());
1237 template<
typename T,
typename std::enable_if<!std::is_base_of_v<DomBase, T>,
bool>::type = true>
1240 if (m_kind == T::kindValue) {
1242 return std::get<SimpleObjectWrap>(m_element)->as<T>();
1247 template<
typename T>
1248 std::shared_ptr<T> ownerAs()
const;
1250 template<
typename Owner,
typename T>
1253 Q_ASSERT(!std::holds_alternative<std::monostate>(m_top));
1254 static_assert(IsInlineDom<std::decay_t<T>>
::value,
"Expected an inline item or pointer");
1258 template<
typename Owner>
1261 Q_ASSERT(!std::holds_alternative<std::monostate>(m_top));
1262 return DomItem(m_top, owner, ownerPath, owner.get());
1265 template<
typename T>
1268 Q_ASSERT(!std::holds_alternative<std::monostate>(m_top));
1269 using BaseT = std::decay_t<T>;
1270 static_assert(!std::is_same_v<BaseT, ElementT>,
1271 "variant not supported, pass in the stored types");
1272 static_assert(IsInlineDom<BaseT>::value || std::is_same_v<BaseT, std::monostate>,
1273 "expected either a pointer or an inline item");
1275 if constexpr (IsSharedPointerToDomObject<BaseT>::value)
1277 else if constexpr (IsInlineDom<BaseT>::value)
1278 return DomItem(m_top, m_owner, m_ownerPath,
base);
1280 Q_UNREACHABLE_RETURN(
DomItem(m_top, m_owner, m_ownerPath,
nullptr));
1284 enum class WriteOutCheckResult {
Success, Failed };
1285 WriteOutCheckResult performWriteOutChecks(
const DomItem &,
const DomItem &, OutWriter &, WriteOutChecks)
const;
1286 const DomBase *
base()
const;
1288 template<
typename Env,
typename Owner>
1293 template<
typename Env,
typename Owner,
typename T,
1294 typename = std::enable_if_t<IsInlineDom<std::decay_t<T>>
::value>>
1295 DomItem(Env env, Owner owner,
const Path &ownerPath,
const T &
el)
1296 : m_top(env), m_owner(owner), m_ownerPath(ownerPath), m_element(
el)
1298 using BaseT = std::decay_t<T>;
1299 if constexpr (std::is_pointer_v<BaseT>) {
1300 if (!
el ||
el->kind() == DomType::Empty) {
1302 m_kind = DomType::Empty;
1303 m_top = std::monostate();
1304 m_owner = std::monostate();
1305 m_ownerPath = Path();
1306 m_element =
Empty();
1308 using DomT = std::remove_pointer_t<BaseT>;
1310 m_kind = DomT::kindValue;
1313 static_assert(!std::is_same_v<BaseT, ElementT>,
1314 "variant not supported, pass in the internal type");
1315 m_kind =
el->kind();
1331 friend class TestDomItem;
1333 DomType m_kind = DomType::Empty;
1349 const QMultiMap<QString, T> &mmap)
1352 auto end = mmap.cend();
1362 return self.copy(ll);
1367Map Map::fromMultiMapRef(
const Path &pathFromOwner,
const QMultiMap<QString, T> &mmap)
1374 [&mmap](
const DomItem &) {
return QSet<QString>(mmap.keyBegin(), mmap.keyEnd()); },
1380 const Path &pathFromOwner,
const QMap<QString, T> &
map,
1395template<
typename MapT>
1396QSet<QString> Map::fileRegionKeysFromMap(
const MapT &
map)
1404Map Map::fromFileRegionMap(
const Path &pathFromOwner,
const QMap<FileLocationRegion, T> &
map)
1415 [&
map](
const DomItem &) {
return fileRegionKeysFromMap(
map); },
1421Map Map::fromFileRegionListMap(
const Path &pathFromOwner,
1432 auto list = List::fromQList<SourceLocation>(
1436 return self.subLocationItem(path, location);
1438 return mapItem.subListItem(
list);
1440 [&
map](
const DomItem &) {
return fileRegionKeysFromMap(
map); },
1447 const Path &pathFromOwner,
const QList<T> &
list,
1475 const Path &pathFromOwner,
const QList<T> &
list,
1556 QMultiMap<Path, ErrorMessage> m_errors;
1557 QMap<ErrorMessage, quint32> m_errorsCounts;
1564 if (!std::holds_alternative<std::monostate>(m_owner)) {
1566 if (std::holds_alternative<std::shared_ptr<AttachedInfo>>(m_owner))
1567 return std::static_pointer_cast<T>(
1568 std::get<std::shared_ptr<AttachedInfo>>(m_owner));
1570 if (std::holds_alternative<std::shared_ptr<ExternalItemInfoBase>>(m_owner))
1571 return std::static_pointer_cast<T>(
1572 std::get<std::shared_ptr<ExternalItemInfoBase>>(m_owner));
1574 if (std::holds_alternative<std::shared_ptr<ExternalItemPairBase>>(m_owner))
1575 return std::static_pointer_cast<T>(
1576 std::get<std::shared_ptr<ExternalItemPairBase>>(m_owner));
1578 if (std::holds_alternative<std::shared_ptr<T>>(m_owner)) {
1579 return std::get<std::shared_ptr<T>>(m_owner);
1584 Q_ASSERT_X(
false,
"DomItem::ownerAs",
"unexpected non owning value in ownerAs");
1586 return std::shared_ptr<T> {};
1592 static_assert(I > 0,
"");
1601 ->
decltype(
t.writeOut(self, lw))
1603 t.writeOut(self, lw);
1609 qCWarning(writeOutLog) <<
"Ignoring writeout to wrapped object not supporting it ("
1610 <<
typeid(T).
name();
1621 writeOutWrap<T>(*asT(), self, lw);
1630 explicit operator bool()
const
1632 return bool(m_owner);
1641 if (m_pathFromOwner)
1642 return MutableDomItem(m_owner, m_pathFromOwner.split().pathToSource);
1651 if (m_pathFromOwner)
1718 int nBackups = 2,
int indent = 0,
FileWriter *fw =
nullptr)
1734 bool commitToBase(
const std::shared_ptr<DomEnvironment> &validEnvPtr =
nullptr)
1736 return item().commitToBase(validEnvPtr);
1792 m_owner(owner), m_pathFromOwner(pathFromOwner)
1795 m_owner(
item.owner()), m_pathFromOwner(
item.pathFromOwner())
1798 std::shared_ptr<DomTop>
topPtr() {
return m_owner.topPtr(); }
1801 template<
typename T>
1804 return item().as<T>();
1807 template <
typename T>
1809 Q_ASSERT(!m_owner || !m_owner.owningItemPtr()->frozen());
1812 if (self.m_kind != T::kindValue)
1815 const T *
t =
nullptr;
1818 else if constexpr (std::is_base_of<DomBase, T>::value)
1819 t =
static_cast<const T *
>(self.base());
1821 Q_UNREACHABLE_RETURN(
nullptr);
1824 return const_cast<T *
>(
t);
1827 template<
typename T>
1830 return m_owner.ownerAs<T>();
1837 return o1.m_owner == o2.m_owner && o1.m_pathFromOwner == o2.m_pathFromOwner;
1846 Path m_pathFromOwner;
1851template<
typename K,
typename T>
1854 T **valuePtr =
nullptr)
1858 if (
it != mmap.
end()) {
1863 <<
" that contains aleready multiple entries in" << mapPathFromOwner;
1866 v.updatePathFromOwner(newPath);
1876 while (it2 != mmap.end() && it2.key() ==
key) {
1882 v.updatePathFromOwner(newPath);
1894 Path newPath = listPathFromOwner.
index(idx);
1895 T &targetV =
list[idx];
1896 targetV.updatePathFromOwner(newPath);
1902template <
typename T,
typename K = QString>
1906 auto end = mmap.end();
1911 if (
i > 0 &&
name !=
it.key()) {
1914 el->updatePathFromOwner(pName.index(--
i));
1928 el->updatePathFromOwner(pName.index(--
i));
1931template <
typename T>
1938 (
it++)->updatePathFromOwner(newPath.index(
i++));
2053 using BaseT = std::remove_cv_t<std::remove_reference_t<T>>;
2057 BaseT> || std::is_base_of_v<QCborArray, BaseT> || std::is_base_of_v<QCborMap, BaseT>) {
2058 return DomItem(m_top, m_owner, m_ownerPath,
2060 }
else if constexpr (std::is_same_v<DomItem, BaseT>) {
2063 }
else if constexpr (IsList<T>::value && !std::is_convertible_v<BaseT, QStringView>) {
2064 return subListItem(List::fromQList<typename BaseT::value_type>(
2067 const typename T::value_type &
v) {
return list.subValueItem(
p,
v, options); }));
2068 }
else if constexpr (IsSharedPointerToDomObject<BaseT>::value) {
2080 using BaseT = std::remove_cv_t<std::remove_reference_t<T>>;
2081 if constexpr (std::is_same_v<BaseT, ConstantData>) {
2082 return this->
copy(value);
2083 }
else if constexpr (std::is_base_of_v<QCborValue, BaseT>) {
2084 return DomItem(m_top, m_owner, m_ownerPath,
2088 m_top, m_owner, m_ownerPath,
2097 auto lazyWrap = [
this, &
c, &
value, options]() {
2098 return this->subValueItem<T>(
c,
value, options);
2100 return visitor(
c, lazyWrap);
2107 auto lazyWrap = [
this, &
c, &valueF, options]() {
2108 return this->subValueItem<decltype(valueF())>(
c, valueF(), options);
2110 return visitor(
c, lazyWrap);
2116 using BaseT = std::decay_t<T>;
2117 if constexpr (std::is_same_v<QString, BaseT> || std::is_arithmetic_v<BaseT>) {
2119 }
else if constexpr (std::is_same_v<SourceLocation, BaseT>) {
2121 }
else if constexpr (std::is_same_v<BaseT, Reference>) {
2123 "wrapping a reference object, probably an error (wrap the target path instead)");
2124 return this->
copy(obj);
2125 }
else if constexpr (std::is_same_v<BaseT, ConstantData>) {
2127 }
else if constexpr (std::is_same_v<BaseT, Map>) {
2129 }
else if constexpr (std::is_same_v<BaseT, List>) {
2131 }
else if constexpr (std::is_base_of_v<ListPBase, BaseT>) {
2133 }
else if constexpr (std::is_same_v<BaseT, SimpleObjectWrap>) {
2135 }
else if constexpr (IsDomObject<BaseT>::value) {
2140 return this->
copy(&obj);
2143 <<
" in DomItem::wrap, not using a shared_ptr for an "
2144 <<
"OwningItem, or unexpected wrapped object?";
2147 }
else if constexpr (IsSharedPointerToDomObject<BaseT>::value) {
2151 Q_ASSERT_X(
false,
"DomItem::wrap",
"shared_ptr with non owning item");
2154 }
else if constexpr (IsMultiMap<BaseT>::value) {
2155 if constexpr (std::is_same_v<typename BaseT::key_type, QString>) {
2156 return subMapItem(Map::fromMultiMapRef<typename BaseT::mapped_type>(
2159 Q_ASSERT_X(
false,
"DomItem::wrap",
"non string keys not supported (try .toString()?)");
2161 }
else if constexpr (IsMap<BaseT>::value) {
2162 if constexpr (std::is_same_v<typename BaseT::key_type, QString>) {
2163 return subMapItem(Map::fromMapRef<typename BaseT::mapped_type>(
2166 const typename BaseT::mapped_type &
el) {
return map.wrap(
p,
el); }));
2168 Q_ASSERT_X(
false,
"DomItem::wrap",
"non string keys not supported (try .toString()?)");
2170 }
else if constexpr (IsList<BaseT>::value) {
2171 if constexpr (IsDomObject<typename BaseT::value_type>::value) {
2172 return subListItem(List::fromQListRef<typename BaseT::value_type>(
2175 const typename BaseT::value_type &
el) {
return list.wrap(
p,
el); }));
2177 Q_ASSERT_X(
false,
"DomItem::wrap",
"Unsupported list type T");
2181 qCWarning(domLog) <<
"Cannot wrap " <<
typeid(BaseT).
name();
2182 Q_ASSERT_X(
false,
"DomItem::wrap",
"Do not know how to wrap type T");
2190 auto lazyWrap = [
this, &
c, &
obj]() {
return this->wrap<T>(
c,
obj); };
2191 return visitor(
c, lazyWrap);
2222 return self.iterateDirectSubpaths(std::move(visitor));
2251 if (
c.kind() == Path::Kind::Field)
2252 res.append(
c.name());
2261 self.iterateDirectSubpaths(
2263 if (
c.kind() == Path::Kind::Field &&
c.checkName(
name)) {
2276 if (
c.kind() == Path::Kind::Index) {
2277 index_type i = c.index() + 1;
2289 self.iterateDirectSubpaths(
2291 if (
c.kind() == Path::Kind::Index &&
c.index() ==
index) {
2304 if (
c.kind() == Path::Kind::Key)
2305 res.insert(
c.name());
2314 self.iterateDirectSubpaths(
2316 if (
c.kind() == Path::Kind::Key &&
c.checkName(
name)) {
2327 return DomItem(m_top, m_owner, m_ownerPath,
list);
2332 return DomItem(m_top, m_owner, m_ownerPath,
map);
\inmodule QtCore\reentrant
\inmodule QtCore\reentrant
static QDateTime currentDateTimeUtc()
qsizetype size() const noexcept
void reserve(qsizetype size)
void append(parameter_type t)
T value(const Key &key, const T &defaultValue=T()) const
const_iterator constFind(const Key &key) const
key_iterator keyBegin() const
const_iterator constEnd() const
key_iterator keyEnd() const
Attached info creates a tree to attach extra info to DomItems.
DomKind domKind() const override
ConstantData(const Path &pathFromOwner, const QCborValue &value, Options options=Options::MapIsMap)
QCborValue value() const override
quintptr id() const override
DomType kind() const override
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const override
ConstantData & operator*()
const ConstantData & operator*() const
const ConstantData * operator->() const
ConstantData * operator->()
bool iterateDirectSubpathsConst(const DomItem &self, DirectVisitor) const
virtual DomType kind() const =0
virtual DomKind domKind() const
virtual Path canonicalPath(const DomItem &self) const =0
virtual Path pathFromOwner(const DomItem &self) const =0
virtual QList< QString > fields(const DomItem &self) const
virtual bool iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const =0
virtual index_type indexes(const DomItem &self) const
const DomBase * domBase() const
virtual void writeOut(const DomItem &self, OutWriter &lw) const
virtual DomItem containingObject(const DomItem &self) const
virtual QString canonicalFilePath(const DomItem &self) const
virtual QSet< QString > const keys(const DomItem &self) const
virtual DomItem field(const DomItem &self, QStringView name) const
virtual quintptr id() const
virtual QCborValue value() const
virtual ~DomBase()=default
virtual DomItem key(const DomItem &self, const QString &name) const
virtual DomItem index(const DomItem &self, index_type index) const
virtual void dump(const DomItem &, const Sink &sink, int indent, FilterT filter) const
DomElement & operator=(const DomElement &)=default
Path canonicalPath(const DomItem &self) const override
DomElement(const DomElement &o)=default
DomElement(const Path &pathFromOwner=Path())
virtual void updatePathFromOwner(const Path &newPath)
Path pathFromOwner(const DomItem &self) const override
Path pathFromOwner() const
DomItem containingObject(const DomItem &self) const override
Represents a consistent set of types organized in modules, it is the top level of the DOM.
DomItem fileLocations() const
bool dvReferences(DirectVisitor visitor, const PathEls::PathComponent &c, const QList< Path > &paths) const
DomItem fileLocationsTree() const
bool visitKeys(function_ref< bool(const QString &, const DomItem &)> visitor) const
static ErrorGroup domErrorGroup
bool isCanonicalChild(const DomItem &child) const
DomItem operator[](int i) const
QSet< QString > propertyInfoNames() const
QSet< QString > keys() const
bool visitLookup1(const QString &symbolName, function_ref< bool(const DomItem &)> visitor, LookupOptions=LookupOption::Normal, const ErrorHandler &h=nullptr, QSet< quintptr > *visited=nullptr, QList< Path > *visitedRefs=nullptr) const
DomItem operator[](index_type i) const
static ErrorGroups myResolveErrors()
QString internalKindStr() const
DomItem enumerations() const
DomItem subOwnerItem(const PathEls::PathComponent &c, Owner o) const
DomItem child(index_type i) const
static ErrorGroups myErrors()
DomItem fileObject(GoTo option=GoTo::Strict) const
bool dvValue(DirectVisitor visitor, const PathEls::PathComponent &c, const T &value, ConstantData::Options options=ConstantData::Options::MapIsMap) const
DomItem environment() const
DomItem key(QStringView name) const
std::shared_ptr< T > ownerAs() const
DomItem directParent() const
bool commitToBase(const std::shared_ptr< DomEnvironment > &validPtr=nullptr) const
DomItem container() const
index_type indexes() const
DomItem operator[](const char16_t *component) const
DomItem field(QStringView name) const
Path pathFromOwner() const
QDateTime createdAt() const
QStringList sortedKeys() const
DomItem refreshed() const
function< void(const Path &, const DomItem &, const DomItem &)> Callback
bool dvItem(DirectVisitor visitor, const PathEls::PathComponent &c, function_ref< DomItem()> it) const
bool visitIndexes(function_ref< bool(const DomItem &)> visitor) const
bool visitPrototypeChain(function_ref< bool(const DomItem &)> visitor, VisitPrototypesOptions options=VisitPrototypesOption::Normal, const ErrorHandler &h=nullptr, QSet< quintptr > *visited=nullptr, QList< Path > *visitedRefs=nullptr) const
bool visitDirectAccessibleScopes(function_ref< bool(const DomItem &)> visitor, VisitPrototypesOptions options=VisitPrototypesOption::Normal, const ErrorHandler &h=nullptr, QSet< quintptr > *visited=nullptr, QList< Path > *visitedRefs=nullptr) const
DomItem containingObject() const
DomItem(const std::shared_ptr< DomEnvironment > &)
bool dvReferenceField(DirectVisitor visitor, QStringView f, const Path &referencedObject) const
bool dvWrapField(DirectVisitor visitor, QStringView f, T &obj) const
DomItem subDataItemField(QStringView f, const T &value, ConstantData::Options options=ConstantData::Options::MapIsMap) const
DomItem path(QStringView p, const ErrorHandler &h=&defaultErrorHandler) const
bool writeOutForFile(OutWriter &ow, WriteOutChecks extraChecks) const
DomItem copy(const T &base) const
bool visitLookup(const QString &symbolName, function_ref< bool(const DomItem &)> visitor, LookupType type=LookupType::Symbol, LookupOptions=LookupOption::Normal, const ErrorHandler &errorHandler=nullptr, QSet< quintptr > *visited=nullptr, QList< Path > *visitedRefs=nullptr) const
DomItem path(const QString &p, const ErrorHandler &h=&defaultErrorHandler) const
DomItem rootQmlObject(GoTo option=GoTo::Strict) const
DomItem operator[](const QString &component) const
bool dvReferencesField(DirectVisitor visitor, QStringView f, const QList< Path > &paths) const
DomItem get(const ErrorHandler &h=nullptr, QList< Path > *visitedRefs=nullptr) const
DomItem subListItem(const List &list) const
void addError(ErrorMessage &&msg) const
DomItem path(const Path &p, const ErrorHandler &h=&defaultErrorHandler) const
std::shared_ptr< OwningItem > owningItemPtr() const
FileWriter::Status dump(const QString &path, function_ref< bool(const DomItem &, const PathEls::PathComponent &, const DomItem &)> filter=noFilter, int nBackups=2, int indent=0, FileWriter *fw=nullptr) const
bool dvReference(DirectVisitor visitor, const PathEls::PathComponent &c, const Path &referencedObject) const
function_ref< bool(const Path &, const DomItem &)> Visitor
bool iterateDirectSubpaths(DirectVisitor v) const
std::shared_ptr< DomTop > topPtr() const
DomItem lookupFirst(const QString &symbolName, LookupType type=LookupType::Symbol, LookupOptions=LookupOption::Normal, const ErrorHandler &errorHandler=nullptr) const
DomItem operator[](const Path &path) const
DomItem filterUp(function_ref< bool(DomType k, const DomItem &)> filter, FilterUpOptions options) const
DomItem subReferenceItem(const PathEls::PathComponent &c, const Path &referencedObject) const
DomItem copy(const Owner &owner, const Path &ownerPath) const
bool dvItemField(DirectVisitor visitor, QStringView f, function_ref< DomItem()> it) const
bool visitSubSymbolsNamed(const QString &name, function_ref< bool(const DomItem &)> visitor) const
bool dvValueLazyField(DirectVisitor visitor, QStringView f, F valueF, ConstantData::Options options=ConstantData::Options::MapIsMap) const
DomItem operator[](QStringView component) const
DomItem containingScriptExpression() const
DomItem wrap(const PathEls::PathComponent &c, const T &obj) const
void clearErrors(const ErrorGroups &groups=ErrorGroups({}), bool iterate=true) const
bool dvWrap(DirectVisitor visitor, const PathEls::PathComponent &c, T &obj) const
QQmlJSScope::ConstPtr nearestSemanticScope() const
MutableDomItem makeCopy(CopyOption option=CopyOption::EnvConnected) const
bool visitScopeChain(function_ref< bool(const DomItem &)> visitor, LookupOptions=LookupOption::Normal, const ErrorHandler &h=nullptr, QSet< quintptr > *visited=nullptr, QList< Path > *visitedRefs=nullptr) const
bool dvValueLazy(DirectVisitor visitor, const PathEls::PathComponent &c, F valueF, ConstantData::Options options=ConstantData::Options::MapIsMap) const
DomItem wrapField(QStringView f, const T &obj) const
DomItem scope(FilterUpOptions options=FilterUpOptions::ReturnOuter) const
QDateTime lastDataUpdateAt() const
friend QMLDOM_EXPORT bool operator==(const DomItem &, const DomItem &)
friend class ConstantData
index_type length() const
bool visitStaticTypePrototypeChains(function_ref< bool(const DomItem &)> visitor, VisitPrototypesOptions options=VisitPrototypesOption::Normal, const ErrorHandler &h=nullptr, QSet< quintptr > *visited=nullptr, QList< Path > *visitedRefs=nullptr) const
DomItem subValueItem(const PathEls::PathComponent &c, const T &value, ConstantData::Options options=ConstantData::Options::MapIsMap) const
DomItem globalScope() const
QString canonicalFilePath() const
DomItem annotations() const
bool visitTree(const Path &basePath, ChildrenVisitor visitor, VisitOptions options=VisitOption::Default, ChildrenVisitor openingVisitor=emptyChildrenVisitor, ChildrenVisitor closingVisitor=emptyChildrenVisitor, const FieldFilter &filter=FieldFilter::noFilter()) const
bool resolve(const Path &path, Visitor visitor, const ErrorHandler &errorHandler, ResolveOptions options=ResolveOption::None, const Path &fullPath=Path(), QList< Path > *visitedRefs=nullptr) const
bool iterateSubOwners(function_ref< bool(const DomItem &owner)> visitor) const
QDateTime frozenAt() const
DomItem(const std::shared_ptr< DomUniverse > &)
QList< DomItem > getAll(const ErrorHandler &h=nullptr, QList< Path > *visitedRefs=nullptr) const
bool dvValueField(DirectVisitor visitor, QStringView f, const T &value, ConstantData::Options options=ConstantData::Options::MapIsMap) const
DomItem subMapItem(const Map &map) const
DomItem proceedToScope(const ErrorHandler &h=nullptr, QList< Path > *visitedRefs=nullptr) const
QList< DomItem > values() const
bool isExternalItem() const
bool writeOut(const QString &path, int nBackups=2, const LineWriterOptions &opt=LineWriterOptions(), FileWriter *fw=nullptr, WriteOutChecks extraChecks=WriteOutCheck::Default) const
ErrorHandler errorHandler() const
DomItem index(index_type) const
InternalKind internalKind() const
bool isOwningItem() const
Path canonicalPath() const
bool hasAnnotations() const
DomItem subObjectWrapItem(SimpleObjectWrap obj) const
DomItem subDataItem(const PathEls::PathComponent &c, const T &value, ConstantData::Options options=ConstantData::Options::MapIsMap) const
void writeOut(OutWriter &lw) const
bool visitUp(function_ref< bool(const DomItem &)> visitor) const
QList< DomItem > lookup(const QString &symbolName, LookupType type=LookupType::Symbol, LookupOptions=LookupOption::Normal, const ErrorHandler &errorHandler=nullptr) const
static DomItem fromCode(const QString &code, DomType fileType=DomType::QmlFile)
DomItem containingFile() const
void dump(const Sink &, int indent=0, function_ref< bool(const DomItem &, const PathEls::PathComponent &, const DomItem &)> filter=noFilter) const
function_ref< bool(const Path &, const DomItem &, bool)> ChildrenVisitor
DomItem subScriptElementWrapperItem(const ScriptElementVariant &obj) const
DomItem copy(const Owner &owner, const Path &ownerPath, const T &base) const
QList< QString > fields() const
DomItem goToFile(const QString &filePath) const
DomItem component(GoTo option=GoTo::Strict) const
void writeOutPost(OutWriter &lw) const
void writeOutPre(OutWriter &lw) const
bool iterateErrors(function_ref< bool(const DomItem &, const ErrorMessage &)> visitor, bool iterate, Path inPath=Path()) const
PropertyInfo propertyInfoWithName(const QString &name) const
bool visitLocalSymbolsNamed(const QString &name, function_ref< bool(const DomItem &)> visitor) const
DomItem propertyDefs() const
DomItem subLocationItem(const PathEls::PathComponent &c, SourceLocation loc) const
DomItem subReferencesItem(const PathEls::PathComponent &c, const QList< Path > &paths) const
void dumpPtr(const Sink &sink) const
DomItem qmlObject(GoTo option=GoTo::Strict, FilterUpOptions options=FilterUpOptions::ReturnOuter) const
DomItem key(const QString &name) const
QQmlJSScope::ConstPtr semanticScope() const
DomItem propertyInfos() const
Represents a set of parsed/loaded modules libraries and a plugins.
void dump(const DomItem &, const Sink &s, int indent, function_ref< bool(const DomItem &, const PathEls::PathComponent &, const DomItem &)> filter) const override
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const override
Path pathFromOwner(const DomItem &self) const override
Path canonicalPath(const DomItem &self) const override
const Empty & operator*() const
const Empty * operator->() const
DomType kind() const override
DomItem containingObject(const DomItem &self) const override
quintptr id() const override
convenience macro creating a new ErrorGroup and registering its groupId as translatable string
Represents a set of tags grouping a set of related error messages.
Represents an error message connected to the dom.
Represents and maintains a mapping between elements and their location in a file.
QString logicalPath() const
QString canonicalPath() const
static FileToLoad fromFileSystem(const std::weak_ptr< DomEnvironment > &environment, const QString &canonicalPath)
static FileToLoad fromMemory(const std::weak_ptr< DomEnvironment > &environment, const QString &path, const QString &data)
std::optional< InMemoryContents > content() const
FileToLoad(const std::weak_ptr< DomEnvironment > &environment, const QString &canonicalPath, const QString &logicalPath, const std::optional< InMemoryContents > &content)
std::weak_ptr< DomEnvironment > environment() const
quintptr id() const override
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor v) const override
void writeOut(const DomItem &self, OutWriter &ow, bool compact) const
index_type indexes(const DomItem &) const override
virtual void copyTo(ListPBase *) const
virtual void moveTo(ListPBase *) const
void writeOut(const DomItem &self, OutWriter &ow) const override
DomType kind() const override
QList< const void * > m_pList
ListPBase(const Path &pathFromOwner, const QList< const void * > &pList, const QString &elType)
void moveTo(ListPBase *t) const override
ListPT(const Path &pathFromOwner, const QList< T * > &pList, const QString &elType=QString(), ListOptions options=ListOptions::Normal)
DomItem index(const DomItem &self, index_type index) const override
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor v) const override
void copyTo(ListPBase *t) const override
static constexpr DomType kindValue
const ListPBase * operator->() const
ListP(const Path &pathFromOwner, const QList< T * > &pList, const QString &elType=QString(), ListOptions options=ListOptions::Normal)
const ListPBase & operator*() const
void writeOut(const DomItem &self, OutWriter &ow, bool compact) const
List(const Path &pathFromOwner, const LookupFunction &lookup, const Length &length, const IteratorFunction &iterator, const QString &elType)
DomType kind() const override
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const override
const List & operator*() const
static List fromQList(const Path &pathFromOwner, const QList< T > &list, const std::function< DomItem(const DomItem &, const PathEls::PathComponent &, const T &)> &elWrapper, ListOptions options=ListOptions::Normal)
std::function< bool(const DomItem &, function_ref< bool(index_type, function_ref< DomItem()>)>)> IteratorFunction
static List fromQListRef(const Path &pathFromOwner, const QList< T > &list, const std::function< DomItem(const DomItem &, const PathEls::PathComponent &, const T &)> &elWrapper, ListOptions options=ListOptions::Normal)
void dump(const DomItem &, const Sink &s, int indent, function_ref< bool(const DomItem &, const PathEls::PathComponent &, const DomItem &)>) const override
std::function< DomItem(const DomItem &, index_type)> LookupFunction
void writeOut(const DomItem &self, OutWriter &ow) const override
quintptr id() const override
const List * operator->() const
index_type indexes(const DomItem &self) const override
DomItem index(const DomItem &self, index_type index) const override
std::function< index_type(const DomItem &)> Length
std::function< DomItem(const DomItem &, QString)> LookupFunction
const Map * operator->() const
QSet< QString > const keys(const DomItem &self) const override
Map(const Path &pathFromOwner, const LookupFunction &lookup, const Keys &keys, const QString &targetType)
const Map & operator*() const
static Map fromMultiMap(const Path &pathFromOwner, const QMultiMap< QString, T > &mmap)
std::function< QSet< QString >(const DomItem &)> Keys
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const override
quintptr id() const override
DomItem key(const DomItem &self, const QString &name) const override
DomType kind() const override
MutableDomItem setCode(const QString &code)
std::shared_ptr< T > ownerAs() const
MutableDomItem environment()
MutableDomItem annotations()
MutableDomItem addChild(QmlObject child)
MutableDomItem setMethods(QMultiMap< QString, MethodInfo > functionDefs)
QQmlJSScope::ConstPtr semanticScope()
Path canonicalPath() const
MutableDomItem setBindings(QMultiMap< QString, Binding > bindings)
FileWriter::Status dump(const QString &path, function_ref< bool(const DomItem &, const PathEls::PathComponent &, const DomItem &)> filter=noFilter, int nBackups=2, int indent=0, FileWriter *fw=nullptr)
MutableDomItem globalScope()
bool writeOut(const QString &path, int nBackups=2, const LineWriterOptions &opt=LineWriterOptions(), FileWriter *fw=nullptr)
QString internalKindStr()
friend bool operator==(const MutableDomItem &o1, const MutableDomItem &o2)
MutableDomItem bindings()
MutableDomItem addPropertyDef(const PropertyDefinition &propertyDef, AddOption option=AddOption::Overwrite)
void setSemanticScope(const QQmlJSScope::ConstPtr &scope)
bool commitToBase(const std::shared_ptr< DomEnvironment > &validEnvPtr=nullptr)
MutableDomItem addPrototypePath(const Path &prototypePath)
QString canonicalFilePath() const
MutableDomItem propertyDefs()
MutableDomItem fileObject(GoTo option=GoTo::Strict)
MutableDomItem operator[](const char16_t *component)
MutableDomItem addAnnotation(QmlObject child)
MutableDomItem setPropertyDefs(QMultiMap< QString, PropertyDefinition > propertyDefs)
MutableDomItem key(QStringView name)
MutableDomItem operator[](const QString &component)
ErrorHandler errorHandler()
MutableDomItem setNextScopePath(const Path &nextScopePath)
MutableDomItem addMethod(const MethodInfo &functionDef, AddOption option=AddOption::Overwrite)
MutableDomItem operator[](index_type i)
MutableDomItem field(QStringView name)
void dump(const Sink &s, int indent=0, function_ref< bool(const DomItem &, const PathEls::PathComponent &, const DomItem &)> filter=noFilter)
void writeOut(OutWriter &lw)
MutableDomItem(const DomItem &owner, const Path &pathFromOwner)
MutableDomItem containingObject()
MutableDomItem container()
MutableDomItem refreshed()
void addError(ErrorMessage &&msg)
MutableDomItem path(const QString &p)
std::shared_ptr< DomTop > topPtr()
MutableDomItem setAnnotations(const QList< QmlObject > &annotations)
MutableDomItem key(const QString &name)
QSet< QString > const keys()
MutableDomItem qmlObject(GoTo option=GoTo::Strict, FilterUpOptions fOptions=FilterUpOptions::ReturnOuter)
QList< QString > const fields()
MutableDomItem component(GoTo option=GoTo::Strict)
MutableDomItem path(const Path &p)
MutableDomItem makeCopy(CopyOption option=CopyOption::EnvConnected)
MutableDomItem operator[](const Path &path)
MutableDomItem setChildren(const QList< QmlObject > &children)
MutableDomItem index(index_type i)
MutableDomItem child(index_type i)
MutableDomItem addPreComment(const Comment &comment, FileLocationRegion region)
QDateTime lastDataUpdateAt()
MutableDomItem children()
MutableDomItem(const DomItem &item)
std::shared_ptr< OwningItem > owningItemPtr()
MutableDomItem universe()
friend bool operator!=(const MutableDomItem &o1, const MutableDomItem &o2)
MutableDomItem rootQmlObject(GoTo option=GoTo::Strict)
MutableDomItem fileLocations()
MutableDomItem operator[](QStringView component)
MutableDomItem path(QStringView p)
MutableDomItem setScript(const std::shared_ptr< ScriptExpression > &exp)
MutableDomItem addBinding(Binding binding, AddOption option=AddOption::Overwrite)
MutableDomItem addPostComment(const Comment &comment, FileLocationRegion region)
virtual void addError(const DomItem &self, ErrorMessage &&msg)
QDateTime createdAt() const
virtual QDateTime lastDataUpdateAt() const
Path pathFromOwner(const DomItem &) const override final
QBasicMutex * mutex() const
DomItem containingObject(const DomItem &self) const override
virtual std::shared_ptr< OwningItem > doCopy(const DomItem &self) const =0
std::shared_ptr< OwningItem > makeCopy(const DomItem &self) const
virtual bool frozen() const
OwningItem(const OwningItem &&)=delete
bool iterateErrors(const DomItem &self, function_ref< bool(const DomItem &source, const ErrorMessage &msg)> visitor, const Path &inPath=Path())
virtual int revision() const
Path pathFromOwner() const
QDateTime frozenAt() const
void addErrorLocal(ErrorMessage &&msg)
void clearErrors(const ErrorGroups &groups=ErrorGroups({}))
Path canonicalPath(const DomItem &self) const override=0
QMultiMap< Path, ErrorMessage > localErrors() const
OwningItem & operator=(const OwningItem &&)=delete
virtual void refreshedDataAt(QDateTime tNew)
OwningItem(int derivedFrom, const QDateTime &lastDataUpdateAt)
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const override
static int nextRevision()
virtual bool iterateSubOwners(const DomItem &self, function_ref< bool(const DomItem &owner)> visitor)
OwningItem(int derivedFrom=0)
OwningItem(const OwningItem &o)
Path key(const QString &name) const
Path path(const Path &toAdd, bool avoidToAddAsBase=false) const
Path index(index_type i) const
A QmlFile, when loaded in a DomEnvironment that has the DomCreationOption::WithSemanticAnalysis,...
QList< QString > fields(const DomItem &self) const override
quintptr id() const override
const Reference & operator*() const
DomItem index(const DomItem &, index_type) const override
DomItem field(const DomItem &self, QStringView name) const override
DomItem get(const DomItem &self, const ErrorHandler &h=nullptr, QList< Path > *visitedRefs=nullptr) const
QList< DomItem > getAll(const DomItem &self, const ErrorHandler &h=nullptr, QList< Path > *visitedRefs=nullptr) const
index_type indexes(const DomItem &) const override
DomType kind() const override
QSet< QString > const keys(const DomItem &) const override
const Reference * operator->() const
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const override
Reference(const Path &referredObject=Path(), const Path &pathFromOwner=Path(), const SourceLocation &loc=SourceLocation())
DomItem key(const DomItem &, const QString &) const override
const DomBase & operator*() const
const DomBase * operator->() const
static constexpr DomType kindValue
ScriptElementVariant element() const
ScriptElementDomWrapper(const ScriptElementVariant &element)
Use this to contain any script element.
void visitConst(F &&visitor) const
std::optional< ScriptElementT > data()
ScriptElement::PointerType< ScriptElement > base() const
static ScriptElementVariant fromElement(const T &element)
void setData(const ScriptElementT &data)
VariantOfPointer< ScriptElements::BlockStatement, ScriptElements::IdentifierExpression, ScriptElements::ForStatement, ScriptElements::BinaryExpression, ScriptElements::VariableDeclarationEntry, ScriptElements::Literal, ScriptElements::IfStatement, ScriptElements::GenericScriptElement, ScriptElements::VariableDeclaration, ScriptElements::ReturnStatement > ScriptElementT
bool iterateDirectSubpaths(const DomItem &, DirectVisitor) const override
SimpleWrapOptions m_options
SimpleObjectWrapBase(const Path &pathFromOwner, const QVariant &value, quintptr idValue, DomType kind=kindValue, SimpleWrapOptions options=SimpleWrapOption::None)
virtual void moveTo(SimpleObjectWrapBase *) const
DomKind domKind() const final override
virtual void copyTo(SimpleObjectWrapBase *) const
SimpleObjectWrapBase()=delete
DomType kind() const final override
quintptr id() const final override
SimpleObjectWrapT(const Path &pathFromOwner, const QVariant &v, quintptr idValue, SimpleWrapOptions o)
void moveTo(SimpleObjectWrapBase *target) const override
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const override
static constexpr DomType kindValue
void writeOut(const DomItem &self, OutWriter &lw) const override
void copyTo(SimpleObjectWrapBase *target) const override
const SimpleObjectWrapBase & operator*() const
SimpleObjectWrapBase & operator*()
static SimpleObjectWrap fromObjectRef(const Path &pathFromOwner, T &value)
SimpleObjectWrap()=delete
const SimpleObjectWrapBase * operator->() const
SimpleObjectWrapBase * operator->()
iterator find(const T &value)
\macro QT_RESTRICTED_CAST_FROM_ASCII
static QString fromLatin1(QByteArrayView ba)
This is an overloaded member function, provided for convenience. It differs from the above function o...
static auto fromValue(T &&value) noexcept(std::is_nothrow_copy_constructible_v< T > &&Private::CanUseInternalSpace< T >) -> std::enable_if_t< std::conjunction_v< std::is_copy_constructible< T >, std::is_destructible< T > >, QVariant >
QMetaType metaType() const
const void * constData() const
QMap< QString, QString > map
[6]
list append(new Employee("Blackpool", "Stephen"))
QSet< QString >::iterator it
constexpr bool domTypeIsOwningItem(DomType)
Path appendUpdatableElementInQList(const Path &listPathFromOwner, QList< T > &list, const T &value, T **vPtr=nullptr)
constexpr bool domTypeIsValueWrap(DomType k)
QDebug operator<<(QDebug d, AST::Node *n)
Path insertUpdatableElementInMultiMap(const Path &mapPathFromOwner, QMultiMap< K, T > &mmap, K key, const T &value, AddOption option=AddOption::KeepExisting, T **valuePtr=nullptr)
bool operator!=(const Version &v1, const Version &v2)
std::variant< std::monostate, std::shared_ptr< DomEnvironment >, std::shared_ptr< DomUniverse > > TopT
bool noFilter(const DomItem &, const PathEls::PathComponent &, const DomItem &)
DomKind kind2domKind(DomType k)
static DomItem keyMultiMapHelper(const DomItem &self, const QString &key, const QMultiMap< QString, T > &mmap)
constexpr bool domTypeIsUnattachedOwningItem(DomType)
QMLDOM_EXPORT QString domTypeToString(DomType k)
std::variant< ConstantData, Empty, List, ListP, Map, Reference, ScriptElementDomWrapper, SimpleObjectWrap, const AstComments *, const AttachedInfo *, const DomEnvironment *, const DomUniverse *, const EnumDecl *, const ExternalItemInfoBase *, const ExternalItemPairBase *, const GlobalComponent *, const GlobalScope *, const JsFile *, const JsResource *, const LoadInfo *, const MockObject *, const MockOwner *, const ModuleIndex *, const ModuleScope *, const QmlComponent *, const QmlDirectory *, const QmlFile *, const QmlObject *, const QmldirFile *, const QmltypesComponent *, const QmltypesFile *, const ScriptExpression * > ElementT
constexpr bool domTypeIsScriptElement(DomType)
QMLDOM_EXPORT bool domTypeIsScope(DomType k)
constexpr bool domTypeIsDomElement(DomType)
QMLDOM_EXPORT bool domTypeIsExternalItem(DomType k)
QString fileLocationRegionName(FileLocationRegion region)
void updatePathFromOwnerQList(QList< T > &list, const Path &newPath)
constexpr bool domTypeCanBeInline(DomType k)
FileLocationRegion fileLocationRegionValue(QStringView region)
QMLDOM_EXPORT QMap< DomType, QString > domTypeToStringMap()
auto writeOutWrap(const T &t, const DomItem &self, OutWriter &lw, rank< 1 >) -> decltype(t.writeOut(self, lw))
std::variant< std::monostate, std::shared_ptr< ModuleIndex >, std::shared_ptr< MockOwner >, std::shared_ptr< ExternalItemInfoBase >, std::shared_ptr< ExternalItemPairBase >, std::shared_ptr< QmlDirectory >, std::shared_ptr< QmldirFile >, std::shared_ptr< JsFile >, std::shared_ptr< QmlFile >, std::shared_ptr< QmltypesFile >, std::shared_ptr< GlobalScope >, std::shared_ptr< ScriptExpression >, std::shared_ptr< AstComments >, std::shared_ptr< LoadInfo >, std::shared_ptr< AttachedInfo >, std::shared_ptr< DomEnvironment >, std::shared_ptr< DomUniverse > > OwnerT
QMLDOM_EXPORT bool domTypeIsTopItem(DomType k)
std::function< void(const ErrorMessage &)> ErrorHandler
bool operator==(const Version &v1, const Version &v2)
void updatePathFromOwnerMultiMap(QMultiMap< K, T > &mmap, const Path &newPath)
constexpr bool domTypeIsObjWrap(DomType k)
@ UpdatedScriptExpression
QMLDOM_EXPORT QString domKindToString(DomKind k)
bool emptyChildrenVisitor(Path, const DomItem &, bool)
QMLDOM_EXPORT bool domTypeIsContainer(DomType k)
QCborValue sourceLocationToQCborValue(QQmlJS::SourceLocation loc)
QMLDOM_EXPORT QMap< DomKind, QString > domKindToStringMap()
Combined button and popup list for selecting options.
SharedPointerFileDialogOptions m_options
#define Q_DECLARE_TR_FUNCTIONS(context)
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char return DBusMessage return DBusMessage const char return DBusMessage dbus_bool_t return DBusMessage dbus_uint32_t return DBusMessage void
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
#define qCWarning(category,...)
#define Q_DECLARE_LOGGING_CATEGORY(name)
GLenum GLsizei GLsizei GLint * values
[15]
GLsizei const GLfloat * v
[13]
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLenum GLuint GLenum GLsizei length
GLdouble GLdouble GLdouble GLdouble top
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
GLsizei const GLuint * paths
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
GLfloat GLfloat GLfloat GLfloat h
GLsizei GLsizei GLchar * source
GLsizei const GLchar *const * path
GLsizei GLenum GLboolean sink
GLuint const GLint * locations
static qreal component(const QPointF &point, unsigned int i)
QQmlJS::Dom::DomItem DomItem
#define Q_ASSERT_X(cond, x, msg)
static QT_BEGIN_NAMESPACE QAsn1Element wrap(quint8 type, const QAsn1Element &child)
static QString canonicalPath(const QString &rootPath)
QLatin1StringView QLatin1String
static FileType fileType(const QFileInfo &fi)
QCborValue(QCborTag(2), QByteArray("\x01\0\0\0\0\0\0\0\0", 9))
[0]
A common base class for all the script elements.
void setSemanticScope(const QQmlJSScope::ConstPtr &scope)
std::shared_ptr< T > PointerType
virtual void createFileLocations(const std::shared_ptr< AttachedInfoT< FileLocations > > &fileLocationOfOwner)=0
QQmlJSScope::ConstPtr semanticScope()
SubclassStorage & operator=(const SubclassStorage &o)
SubclassStorage(const SubclassStorage &&o)
SubclassStorage(const SubclassStorage &o)
SubclassStorage(const T *el)