1 files changed, 417 insertions, 0 deletions
diff --git a/src/qmldom/qqmldomconstants_p.h b/src/qmldom/qqmldomconstants_p.h
new file mode 100644
index 0000000000..ac5f8f67c4
--- /dev/null
+++ b/src/qmldom/qqmldomconstants_p.h
@@ -0,0 +1,417 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QQMLDOMCONSTANTS_P_H
+#define QQMLDOMCONSTANTS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qqmldom_global.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QMetaObject>
+#include <QtCore/private/qglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QQmlJS{
+namespace Dom {
+
+Q_NAMESPACE_EXPORT(QMLDOM_EXPORT)
+
+enum class PathRoot {
+    Other,
+    Modules,
+    Cpp,
+    Libs,
+    Top,
+    Env,
+    Universe
+};
+Q_ENUM_NS(PathRoot)
+
+enum class PathCurrent {
+    Other,
+    Obj,
+    ObjChain,
+    ScopeChain,
+    Component,
+    Module,
+    Ids,
+    Types,
+    LookupStrict,
+    LookupDynamic,
+    Lookup
+};
+Q_ENUM_NS(PathCurrent)
+
+enum class Language { QmlQuick1, QmlQuick2, QmlQuick3, QmlCompiled, QmlAnnotation, Qbs };
+Q_ENUM_NS(Language)
+
+enum class ResolveOption{
+    None=0,
+    TraceVisit=0x1 // call the function along all elements of the path, not just for the target (the function might be called even if the target is never reached)
+};
+Q_ENUM_NS(ResolveOption)
+Q_DECLARE_FLAGS(ResolveOptions, ResolveOption)
+Q_DECLARE_OPERATORS_FOR_FLAGS(ResolveOptions)
+
+enum class VisitOption {
+    None = 0,
+    VisitSelf = 0x1, // Visit the start item
+    VisitAdopted = 0x2, // Visit adopted types (but never recurses them)
+    Recurse = 0x4, // recurse non adopted types
+    NoPath = 0x8, // does not generate path consistent with visit
+    Default = VisitOption::VisitSelf | VisitOption::VisitAdopted | VisitOption::Recurse
+};
+Q_ENUM_NS(VisitOption)
+Q_DECLARE_FLAGS(VisitOptions, VisitOption)
+Q_DECLARE_OPERATORS_FOR_FLAGS(VisitOptions)
+
+enum class LookupOption {
+    Normal = 0,
+    Strict = 0x1,
+    VisitTopClassType = 0x2, // static lookup of class (singleton) or attached type, the default is
+                             // visiting instance methods
+    SkipFirstScope = 0x4
+};
+Q_ENUM_NS(LookupOption)
+Q_DECLARE_FLAGS(LookupOptions, LookupOption)
+Q_DECLARE_OPERATORS_FOR_FLAGS(LookupOptions)
+
+enum class LookupType { PropertyDef, Binding, Property, Method, Type, CppType, Symbol };
+Q_ENUM_NS(LookupType)
+
+enum class VisitPrototypesOption {
+    Normal = 0,
+    SkipFirst = 0x1,
+    RevisitWarn = 0x2,
+    ManualProceedToScope = 0x4
+};
+Q_ENUM_NS(VisitPrototypesOption)
+Q_DECLARE_FLAGS(VisitPrototypesOptions, VisitPrototypesOption)
+Q_DECLARE_OPERATORS_FOR_FLAGS(VisitPrototypesOptions)
+
+enum class DomKind { Empty, Object, List, Map, Value, ScriptElement };
+Q_ENUM_NS(DomKind)
+
+enum class DomType {
+    Empty, // only for default ctor
+
+    ExternalItemInfo, // base class for anything represented by an actual file
+    ExternalItemPair, // pair of newest version of item, and latest valid update ### REVISIT
+    // ExternalOwningItems refer to an external path and can be shared between environments
+    QmlDirectory, // dir e.g. used for implicit import
+    QmldirFile, // qmldir
+    JsFile, // file
+    QmlFile, // file
+    QmltypesFile, // qmltypes
+    GlobalScope, // language dependent (currently no difference)
+    /* enum A {  B, C }
+                 *  *
+    EnumItem  is marked with * */
+    EnumItem,
+
+    // types
+    EnumDecl, // A in above example
+    JsResource, // QML file contains QML object, JSFile contains JsResource
+    QmltypesComponent, // Component inside a qmltypes fles; compared to component it has exported
+                       // meta-object revisions; singleton flag; can export multiple names
+    QmlComponent, // "normal" QML file based Component; also can represent inline components
+    GlobalComponent, // component of global object ### REVISIT, try to replace with one of the above
+
+    ModuleAutoExport, // dependent imports to automatically load when a module is imported
+    ModuleIndex, // index for all the imports of a major version
+    ModuleScope, // a specific import with full version
+    ImportScope, // the scope including the types coming from one or more imports
+    Export, // An exported type
+
+    // header stuff
+    Import, // wrapped
+    Pragma,
+
+    // qml elements
+    Id,
+    QmlObject, // the Item in Item {}; also used to represent types in qmltype files
+    ConstantData, // the 2 in  "property int i: 2"; can be any generic data in a QML document
+    SimpleObjectWrap, // internal wrapping to give uniform DOMItem access; ### research more
+    ScriptExpression, // wraps an AST script expression as a DOMItem
+    Reference, // reference to another DOMItem; e.g. asking for a type of an object returns a
+               // Reference
+    PropertyDefinition, // _just_ the property definition; without the binding, even if it's one
+                        // line
+    Binding, // the part after the ":"
+    MethodParameter,
+    MethodInfo, // container of MethodParameter
+    Version, // wrapped
+    Comment,
+    CommentedElement, // attached to AST if they have pre-/post-comments?
+    RegionComments, // DomItems have attached RegionComments; can attach comments to fine grained
+                    // "regions" in a DomItem; like the default keyword of a property definition
+    AstComments, // hash-table from AST node to commented element
+    FileLocations, // mapping from DomItem to file location ### REVISIT: try to move out of
+                   // hierarchy?
+    UpdatedScriptExpression, // used in writeOut method when formatting changes ### Revisit: try to
+                             // move out of DOM hierarchy
+
+    // convenience collecting types
+    PropertyInfo, // not a DOM Item, just a convenience class
+
+    // Moc objects, mainly for testing ### Try to remove them; replace their usage in tests with
+    // "real" instances
+    MockObject,
+    MockOwner,
+
+    // containers
+    Map,
+    List,
+    ListP,
+
+    // supporting objects
+    LoadInfo, // owning, used inside DomEnvironment ### REVISIT: move out of hierarchy
+    ErrorMessage, // wrapped
+    AttachedInfo, // owning
+
+    // Dom top level
+    DomEnvironment, // a consistent view of modules, types, files, etc.
+    DomUniverse, // a cache of what can be found in the DomEnvironment, contains the latest valid
+                 // version for every file/type, etc. + latest overall
+
+    // Dom Script elements
+    // TODO
+    ScriptElementWrap, // internal wrapping to give uniform access of script elements (e.g. for
+                       // statement lists)
+    ScriptElementStart, // marker to check if a DomType is a scriptelement or not
+    ScriptBlockStatement = ScriptElementStart,
+    ScriptIdentifierExpression,
+    ScriptLiteral,
+    ScriptForStatement,
+    ScriptIfStatement,
+    ScriptPostExpression,
+    ScriptUnaryExpression,
+    ScriptBinaryExpression,
+    ScriptVariableDeclaration,
+    ScriptVariableDeclarationEntry,
+    ScriptReturnStatement,
+    ScriptGenericElement,
+    ScriptCallExpression,
+    ScriptFormalParameter,
+    ScriptArray,
+    ScriptObject,
+    ScriptProperty,
+    ScriptType,
+    ScriptElision,
+    ScriptArrayEntry,
+    ScriptPattern,
+    ScriptSwitchStatement,
+    ScriptCaseBlock,
+    ScriptCaseClause,
+    ScriptDefaultClause,
+    ScriptWhileStatement,
+    ScriptDoWhileStatement,
+    ScriptForEachStatement,
+    ScriptTryCatchStatement,
+    ScriptThrowStatement,
+    ScriptLabelledStatement,
+    ScriptBreakStatement,
+    ScriptContinueStatement,
+    ScriptConditionalExpression,
+    ScriptEmptyStatement,
+    ScriptParenthesizedExpression,
+    ScriptFunctionExpression,
+    ScriptYieldExpression,
+
+    ScriptElementStop, // marker to check if a DomType is a scriptelement or not
+};
+Q_ENUM_NS(DomType)
+
+enum class SimpleWrapOption { None = 0, ValueType = 1 };
+Q_ENUM_NS(SimpleWrapOption)
+Q_DECLARE_FLAGS(SimpleWrapOptions, SimpleWrapOption)
+Q_DECLARE_OPERATORS_FOR_FLAGS(SimpleWrapOptions)
+
+enum class BindingValueKind { Object, ScriptExpression, Array, Empty };
+Q_ENUM_NS(BindingValueKind)
+
+enum class BindingType { Normal, OnBinding };
+Q_ENUM_NS(BindingType)
+
+enum class ListOptions {
+    Normal,
+    Reverse
+};
+Q_ENUM_NS(ListOptions)
+
+enum class EscapeOptions{
+    OuterQuotes,
+    NoOuterQuotes
+};
+Q_ENUM_NS(EscapeOptions)
+
+enum class ErrorLevel{
+    Debug = QtMsgType::QtDebugMsg,
+    Info = QtMsgType::QtInfoMsg,
+    Warning = QtMsgType::QtWarningMsg,
+    Error = QtMsgType::QtCriticalMsg,
+    Fatal = QtMsgType::QtFatalMsg
+};
+Q_ENUM_NS(ErrorLevel)
+
+enum class AstDumperOption {
+    None=0,
+    NoLocations=0x1,
+    NoAnnotations=0x2,
+    DumpNode=0x4,
+    SloppyCompare=0x8
+};
+Q_ENUM_NS(AstDumperOption)
+Q_DECLARE_FLAGS(AstDumperOptions, AstDumperOption)
+Q_DECLARE_OPERATORS_FOR_FLAGS(AstDumperOptions)
+
+enum class GoTo {
+    Strict, // never go to an non uniquely defined result
+    MostLikely // if needed go up to the most likely location between multiple options
+};
+Q_ENUM_NS(GoTo)
+
+enum class AddOption { KeepExisting, Overwrite };
+Q_ENUM_NS(AddOption)
+
+/*!
+\internal
+FilterUpOptions decide in which direction the filtering is done.
+ReturnInner starts the search at top(), and work its way down to the current
+element.
+ReturnOuter and ReturnOuterNoSelf starts the search at the current element and
+works their way up to to top().
+*/
+enum class FilterUpOptions { ReturnOuter, ReturnOuterNoSelf, ReturnInner };
+Q_ENUM_NS(FilterUpOptions)
+
+enum class WriteOutCheck {
+    None = 0x0,
+    UpdatedDomCompare = 0x1,
+    UpdatedDomStable = 0x2,
+    Reparse = 0x4,
+    ReparseCompare = 0x8,
+    ReparseStable = 0x10,
+    DumpOnFailure = 0x20,
+    All = 0x3F,
+    Default = Reparse | ReparseCompare | ReparseStable
+};
+Q_ENUM_NS(WriteOutCheck)
+Q_DECLARE_FLAGS(WriteOutChecks, WriteOutCheck)
+Q_DECLARE_OPERATORS_FOR_FLAGS(WriteOutChecks)
+
+enum class LocalSymbolsType {
+    None = 0x0,
+    ObjectType = 0x1,
+    ValueType = 0x2,
+    Signal = 0x4,
+    Method = 0x8,
+    Attribute = 0x10,
+    Id = 0x20,
+    Namespace = 0x40,
+    Global = 0x80,
+    MethodParameter = 0x100,
+    Singleton = 0x200,
+    AttachedType = 0x400,
+};
+Q_ENUM_NS(LocalSymbolsType)
+Q_DECLARE_FLAGS(LocalSymbolsTypes, LocalSymbolsType)
+Q_DECLARE_OPERATORS_FOR_FLAGS(LocalSymbolsTypes)
+
+/*!
+\internal
+The FileLocationRegion allows to map the different FileLocation subregions to their position in
+the actual code. For example, \c{ColonTokenRegion} denotes the position of the ':' token in a
+binding like `myProperty: something()`, or the ':' token in a pragma like `pragma Hello: World`.
+
+These are used for formatting in qmlformat and autocompletion in qmlls.
+
+MainRegion denotes the entire FileLocation region.
+
+\sa{OutWriter::regionToString}, {FileLocations::regionName}
+*/
+enum FileLocationRegion : int {
+    AsTokenRegion,
+    BreakKeywordRegion,
+    DoKeywordRegion,
+    CaseKeywordRegion,
+    CatchKeywordRegion,
+    ColonTokenRegion,
+    CommaTokenRegion,
+    ComponentKeywordRegion,
+    ContinueKeywordRegion,
+    DefaultKeywordRegion,
+    EllipsisTokenRegion,
+    ElseKeywordRegion,
+    EnumKeywordRegion,
+    EnumValueRegion,
+    EqualTokenRegion,
+    ForKeywordRegion,
+    FinallyKeywordRegion,
+    FirstSemicolonTokenRegion,
+    FunctionKeywordRegion,
+    IdColonTokenRegion,
+    IdNameRegion,
+    IdTokenRegion,
+    IdentifierRegion,
+    IfKeywordRegion,
+    ImportTokenRegion,
+    ImportUriRegion,
+    InOfTokenRegion,
+    LeftBraceRegion,
+    LeftBracketRegion,
+    LeftParenthesisRegion,
+    MainRegion,
+    OperatorTokenRegion,
+    OnTargetRegion,
+    OnTokenRegion,
+    PragmaKeywordRegion,
+    PragmaValuesRegion,
+    PropertyKeywordRegion,
+    QuestionMarkTokenRegion,
+    ReadonlyKeywordRegion,
+    RequiredKeywordRegion,
+    ReturnKeywordRegion,
+    RightBraceRegion,
+    RightBracketRegion,
+    RightParenthesisRegion,
+    SecondSemicolonRegion,
+    SemicolonTokenRegion,
+    SignalKeywordRegion,
+    SwitchKeywordRegion,
+    ThrowKeywordRegion,
+    TryKeywordRegion,
+    TypeIdentifierRegion,
+    VersionRegion,
+    WhileKeywordRegion,
+    YieldKeywordRegion,
+};
+Q_ENUM_NS(FileLocationRegion);
+
+enum DomCreationOption : char {
+    None = 0,
+    WithSemanticAnalysis = 1,
+    WithScriptExpressions = 2,
+    WithRecovery = 4
+};
+
+Q_DECLARE_FLAGS(DomCreationOptions, DomCreationOption);
+
+} // end namespace Dom
+} // end namespace QQmlJS
+
+QT_END_NAMESPACE
+
+#endif // QQMLDOMCONSTANTS_P_H