| /** |
| * Defines enums common to dmd and dmd as parse library. |
| * |
| * Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved |
| * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) |
| * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/astenums.d, _astenums.d) |
| * Documentation: https://dlang.org/phobos/dmd_astenums.html |
| * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/astenums.d |
| */ |
| |
| module dmd.astenums; |
| |
| enum Sizeok : ubyte |
| { |
| none, /// size of aggregate is not yet able to compute |
| fwd, /// size of aggregate is ready to compute |
| inProcess, /// in the midst of computing the size |
| done, /// size of aggregate is set correctly |
| } |
| |
| enum Baseok : ubyte |
| { |
| none, /// base classes not computed yet |
| start, /// in process of resolving base classes |
| done, /// all base classes are resolved |
| semanticdone, /// all base classes semantic done |
| } |
| |
| enum MODFlags : int |
| { |
| none = 0, // default (mutable) |
| const_ = 1, // type is const |
| immutable_ = 4, // type is immutable |
| shared_ = 2, // type is shared |
| wild = 8, // type is wild |
| wildconst = (MODFlags.wild | MODFlags.const_), // type is wild const |
| mutable = 0x10, // type is mutable (only used in wildcard matching) |
| } |
| |
| alias MOD = ubyte; |
| |
| enum STC : ulong // transfer changes to declaration.h |
| { |
| undefined_ = 0, |
| |
| static_ = 1, /// `static` |
| extern_ = 2, /// `extern` |
| const_ = 4, /// `const` |
| final_ = 8, /// `final` |
| |
| abstract_ = 0x10, /// `abstract` |
| parameter = 0x20, /// is function parameter |
| field = 0x40, /// is field of struct, union or class |
| override_ = 0x80, /// `override` |
| |
| auto_ = 0x100, /// `auto` |
| synchronized_ = 0x200, /// `synchronized` |
| deprecated_ = 0x400, /// `deprecated` |
| in_ = 0x800, /// `in` parameter |
| |
| out_ = 0x1000, /// `out` parameter |
| lazy_ = 0x2000, /// `lazy` parameter |
| foreach_ = 0x4000, /// variable for foreach loop |
| variadic = 0x8000, /// the `variadic` parameter in: T foo(T a, U b, V variadic...) |
| |
| // = 0x1_0000, |
| templateparameter = 0x2_0000, /// template parameter |
| ref_ = 0x4_0000, /// `ref` |
| scope_ = 0x8_0000, /// `scope` |
| |
| scopeinferred = 0x20_0000, /// `scope` has been inferred and should not be part of mangling, `scope_` must also be set |
| return_ = 0x40_0000, /// 'return ref' or 'return scope' for function parameters |
| returnScope = 0x80_0000, /// if `ref return scope` then resolve to `ref` and `return scope` |
| |
| returninferred = 0x100_0000, /// `return` has been inferred and should not be part of mangling, `return_` must also be set |
| immutable_ = 0x200_0000, /// `immutable` |
| // = 0x400_0000, |
| manifest = 0x800_0000, /// manifest constant |
| |
| nodtor = 0x1000_0000, /// do not run destructor |
| nothrow_ = 0x2000_0000, /// `nothrow` meaning never throws exceptions |
| pure_ = 0x4000_0000, /// `pure` function |
| tls = 0x8000_0000, /// thread local |
| |
| alias_ = 0x1_0000_0000, /// `alias` parameter |
| shared_ = 0x2_0000_0000, /// accessible from multiple threads |
| gshared = 0x4_0000_0000, /// accessible from multiple threads, but not typed as `shared` |
| wild = 0x8_0000_0000, /// for wild type constructor |
| |
| property = 0x10_0000_0000, /// `@property` |
| safe = 0x20_0000_0000, /// `@safe` |
| trusted = 0x40_0000_0000, /// `@trusted` |
| system = 0x80_0000_0000, /// `@system` |
| |
| ctfe = 0x100_0000_0000, /// can be used in CTFE, even if it is static |
| disable = 0x200_0000_0000, /// for functions that are not callable |
| result = 0x400_0000_0000, /// for result variables passed to out contracts |
| nodefaultctor = 0x800_0000_0000, /// must be set inside constructor |
| |
| temp = 0x1000_0000_0000, /// temporary variable |
| rvalue = 0x2000_0000_0000, /// force rvalue for variables |
| nogc = 0x4000_0000_0000, /// `@nogc` |
| autoref = 0x8000_0000_0000, /// Mark for the already deduced `auto ref` parameter |
| |
| inference = 0x1_0000_0000_0000, /// do attribute inference |
| exptemp = 0x2_0000_0000_0000, /// temporary variable that has lifetime restricted to an expression |
| future = 0x4_0000_0000_0000, /// introducing new base class function |
| local = 0x8_0000_0000_0000, /// do not forward (see dmd.dsymbol.ForwardingScopeDsymbol). |
| |
| live = 0x10_0000_0000_0000, /// function `@live` attribute |
| register = 0x20_0000_0000_0000, /// `register` storage class (ImportC) |
| volatile_ = 0x40_0000_0000_0000, /// destined for volatile in the back end |
| |
| safeGroup = STC.safe | STC.trusted | STC.system, |
| IOR = STC.in_ | STC.ref_ | STC.out_, |
| TYPECTOR = (STC.const_ | STC.immutable_ | STC.shared_ | STC.wild), |
| FUNCATTR = (STC.ref_ | STC.nothrow_ | STC.nogc | STC.pure_ | STC.property | STC.live | |
| safeGroup), |
| |
| /* These are visible to the user, i.e. are expressed by the user |
| */ |
| visibleStorageClasses = |
| (STC.auto_ | STC.scope_ | STC.static_ | STC.extern_ | STC.const_ | STC.final_ | STC.abstract_ | STC.synchronized_ | |
| STC.deprecated_ | STC.future | STC.override_ | STC.lazy_ | STC.alias_ | STC.out_ | STC.in_ | STC.manifest | |
| STC.immutable_ | STC.shared_ | STC.wild | STC.nothrow_ | STC.nogc | STC.pure_ | STC.ref_ | STC.return_ | STC.tls | STC.gshared | |
| STC.property | STC.safeGroup | STC.disable | STC.local | STC.live), |
| |
| /* These storage classes "flow through" to the inner scope of a Dsymbol |
| */ |
| flowThruAggregate = STC.safeGroup, /// for an AggregateDeclaration |
| flowThruFunction = ~(STC.auto_ | STC.scope_ | STC.static_ | STC.extern_ | STC.abstract_ | STC.deprecated_ | STC.override_ | |
| STC.TYPECTOR | STC.final_ | STC.tls | STC.gshared | STC.ref_ | STC.return_ | STC.property | |
| STC.nothrow_ | STC.pure_ | STC.safe | STC.trusted | STC.system), /// for a FuncDeclaration |
| |
| } |
| |
| alias StorageClass = ulong; |
| |
| /******** |
| * Determine if it's the ambigous case of where `return` attaches to. |
| * Params: |
| * stc = STC flags |
| * Returns: |
| * true if (`ref` | `out`) and `scope` and `return` |
| */ |
| @safe pure @nogc nothrow |
| bool isRefReturnScope(const ulong stc) |
| { |
| return (stc & (STC.scope_ | STC.return_)) == (STC.scope_ | STC.return_) && |
| stc & (STC.ref_ | STC.out_); |
| } |
| |
| /* This is different from the one in declaration.d, make that fix a separate PR */ |
| static if (0) |
| extern (C++) __gshared const(StorageClass) STCStorageClass = |
| (STC.auto_ | STC.scope_ | STC.static_ | STC.extern_ | STC.const_ | STC.final_ | |
| STC.abstract_ | STC.synchronized_ | STC.deprecated_ | STC.override_ | STC.lazy_ | |
| STC.alias_ | STC.out_ | STC.in_ | STC.manifest | STC.immutable_ | STC.shared_ | |
| STC.wild | STC.nothrow_ | STC.nogc | STC.pure_ | STC.ref_ | STC.return_ | STC.tls | |
| STC.gshared | STC.property | STC.live | |
| STC.safeGroup | STC.disable); |
| |
| enum TY : ubyte |
| { |
| Tarray, // slice array, aka T[] |
| Tsarray, // static array, aka T[dimension] |
| Taarray, // associative array, aka T[type] |
| Tpointer, |
| Treference, |
| Tfunction, |
| Tident, |
| Tclass, |
| Tstruct, |
| Tenum, |
| |
| Tdelegate, |
| Tnone, |
| Tvoid, |
| Tint8, |
| Tuns8, |
| Tint16, |
| Tuns16, |
| Tint32, |
| Tuns32, |
| Tint64, |
| |
| Tuns64, |
| Tfloat32, |
| Tfloat64, |
| Tfloat80, |
| Timaginary32, |
| Timaginary64, |
| Timaginary80, |
| Tcomplex32, |
| Tcomplex64, |
| Tcomplex80, |
| |
| Tbool, |
| Tchar, |
| Twchar, |
| Tdchar, |
| Terror, |
| Tinstance, |
| Ttypeof, |
| Ttuple, |
| Tslice, |
| Treturn, |
| |
| Tnull, |
| Tvector, |
| Tint128, |
| Tuns128, |
| Ttraits, |
| Tmixin, |
| Tnoreturn, |
| Ttag, |
| TMAX |
| } |
| |
| alias Tarray = TY.Tarray; |
| alias Tsarray = TY.Tsarray; |
| alias Taarray = TY.Taarray; |
| alias Tpointer = TY.Tpointer; |
| alias Treference = TY.Treference; |
| alias Tfunction = TY.Tfunction; |
| alias Tident = TY.Tident; |
| alias Tclass = TY.Tclass; |
| alias Tstruct = TY.Tstruct; |
| alias Tenum = TY.Tenum; |
| alias Tdelegate = TY.Tdelegate; |
| alias Tnone = TY.Tnone; |
| alias Tvoid = TY.Tvoid; |
| alias Tint8 = TY.Tint8; |
| alias Tuns8 = TY.Tuns8; |
| alias Tint16 = TY.Tint16; |
| alias Tuns16 = TY.Tuns16; |
| alias Tint32 = TY.Tint32; |
| alias Tuns32 = TY.Tuns32; |
| alias Tint64 = TY.Tint64; |
| alias Tuns64 = TY.Tuns64; |
| alias Tfloat32 = TY.Tfloat32; |
| alias Tfloat64 = TY.Tfloat64; |
| alias Tfloat80 = TY.Tfloat80; |
| alias Timaginary32 = TY.Timaginary32; |
| alias Timaginary64 = TY.Timaginary64; |
| alias Timaginary80 = TY.Timaginary80; |
| alias Tcomplex32 = TY.Tcomplex32; |
| alias Tcomplex64 = TY.Tcomplex64; |
| alias Tcomplex80 = TY.Tcomplex80; |
| alias Tbool = TY.Tbool; |
| alias Tchar = TY.Tchar; |
| alias Twchar = TY.Twchar; |
| alias Tdchar = TY.Tdchar; |
| alias Terror = TY.Terror; |
| alias Tinstance = TY.Tinstance; |
| alias Ttypeof = TY.Ttypeof; |
| alias Ttuple = TY.Ttuple; |
| alias Tslice = TY.Tslice; |
| alias Treturn = TY.Treturn; |
| alias Tnull = TY.Tnull; |
| alias Tvector = TY.Tvector; |
| alias Tint128 = TY.Tint128; |
| alias Tuns128 = TY.Tuns128; |
| alias Ttraits = TY.Ttraits; |
| alias Tmixin = TY.Tmixin; |
| alias Tnoreturn = TY.Tnoreturn; |
| alias Ttag = TY.Ttag; |
| alias TMAX = TY.TMAX; |
| |
| enum TFlags |
| { |
| integral = 1, |
| floating = 2, |
| unsigned = 4, |
| real_ = 8, |
| imaginary = 0x10, |
| complex = 0x20, |
| } |
| |
| enum PKG : int |
| { |
| unknown, /// not yet determined whether it's a package.d or not |
| module_, /// already determined that's an actual package.d |
| package_, /// already determined that's an actual package |
| } |
| |
| enum ThreeState : ubyte |
| { |
| none, /// state is not yet computed |
| no, /// state is false |
| yes, /// state is true |
| } |
| |
| enum TRUST : ubyte |
| { |
| default_ = 0, |
| system = 1, // @system (same as TRUST.default) |
| trusted = 2, // @trusted |
| safe = 3, // @safe |
| } |
| |
| enum PURE : ubyte |
| { |
| impure = 0, // not pure at all |
| fwdref = 1, // it's pure, but not known which level yet |
| weak = 2, // no mutable globals are read or written |
| const_ = 3, // parameters are values or const = strongly pure |
| } |
| |
| // Whether alias this dependency is recursive or not |
| enum AliasThisRec : int |
| { |
| no = 0, // no alias this recursion |
| yes = 1, // alias this has recursive dependency |
| fwdref = 2, // not yet known |
| typeMask = 3, // mask to read no/yes/fwdref |
| tracing = 0x4, // mark in progress of implicitConvTo/deduceWild |
| tracingDT = 0x8, // mark in progress of deduceType |
| } |
| |
| /*************** |
| * Variadic argument lists |
| * https://dlang.org/spec/function.html#variadic |
| */ |
| enum VarArg : ubyte |
| { |
| none = 0, /// fixed number of arguments |
| variadic = 1, /// (T t, ...) can be C-style (core.stdc.stdarg) or D-style (core.vararg) |
| typesafe = 2, /// (T t ...) typesafe https://dlang.org/spec/function.html#typesafe_variadic_functions |
| /// or https://dlang.org/spec/function.html#typesafe_variadic_functions |
| } |
| |
| /************************* |
| * Identify Statement types with this enum rather than |
| * virtual functions |
| */ |
| enum STMT : ubyte |
| { |
| Error, |
| Peel, |
| Exp, DtorExp, |
| Compile, |
| Compound, CompoundDeclaration, CompoundAsm, |
| UnrolledLoop, |
| Scope, |
| Forwarding, |
| While, |
| Do, |
| For, |
| Foreach, |
| ForeachRange, |
| If, |
| Conditional, |
| StaticForeach, |
| Pragma, |
| StaticAssert, |
| Switch, |
| Case, |
| CaseRange, |
| Default, |
| GotoDefault, |
| GotoCase, |
| SwitchError, |
| Return, |
| Break, |
| Continue, |
| Synchronized, |
| With, |
| TryCatch, |
| TryFinally, |
| ScopeGuard, |
| Throw, |
| Debug, |
| Goto, |
| Label, |
| Asm, InlineAsm, GccAsm, |
| Import, |
| } |
| |
| /********************** |
| * Discriminant for which kind of initializer |
| */ |
| enum InitKind : ubyte |
| { |
| void_, |
| error, |
| struct_, |
| array, |
| exp, |
| C_, |
| } |
| |
| /// A linkage attribute as defined by `extern(XXX)` |
| /// |
| /// https://dlang.org/spec/attribute.html#linkage |
| enum LINK : ubyte |
| { |
| default_, |
| d, |
| c, |
| cpp, |
| windows, |
| objc, |
| system, |
| } |
| |
| /// Whether to mangle an external aggregate as a struct or class, as set by `extern(C++, struct)` |
| enum CPPMANGLE : ubyte |
| { |
| def, /// default |
| asStruct, /// `extern(C++, struct)` |
| asClass, /// `extern(C++, class)` |
| } |
| |
| /// Function match levels |
| /// |
| /// https://dlang.org/spec/function.html#function-overloading |
| enum MATCH : int |
| { |
| nomatch, /// no match |
| convert, /// match with conversions |
| constant, /// match with conversion to const |
| exact, /// exact match |
| } |
| |
| /// Inline setting as defined by `pragma(inline, XXX)` |
| enum PINLINE : ubyte |
| { |
| default_, /// as specified on the command line |
| never, /// never inline |
| always, /// always inline |
| } |
| |
| /// Source file type |
| enum FileType : ubyte |
| { |
| d, /// normal D source file |
| dhdr, /// D header file (.di) |
| ddoc, /// Ddoc documentation file (.dd) |
| c, /// C source file |
| } |
