/**
* 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
}