mirror of
https://github.com/beefytech/Beef.git
synced 2025-06-17 23:56:05 +02:00
528 lines
9.5 KiB
Beef
528 lines
9.5 KiB
Beef
using System.Reflection;
|
|
namespace System
|
|
{
|
|
public struct Attribute
|
|
{
|
|
}
|
|
|
|
public enum AttributeTargets
|
|
{
|
|
Assembly = 0x0001,
|
|
Module = 0x0002,
|
|
Class = 0x0004,
|
|
Struct = 0x0008,
|
|
Enum = 0x0010,
|
|
Constructor = 0x0020,
|
|
Method = 0x0040,
|
|
Property = 0x0080,
|
|
Field = 0x0100,
|
|
StaticField = 0x0200,
|
|
Interface = 0x0400,
|
|
Parameter = 0x0800,
|
|
Delegate = 0x1000,
|
|
Function = 0x2000,
|
|
ReturnValue = 0x4000,
|
|
//@todo GENERICS: document GenericParameter
|
|
GenericParameter = 0x8000,
|
|
Invocation = 0x10000,
|
|
MemberAccess = 0x20000,
|
|
Alloc = 0x40000,
|
|
Delete = 0x80000,
|
|
Alias = 0x100000,
|
|
Block = 0x200000,
|
|
|
|
All = Assembly | Module | Class | Struct | Enum | Constructor |
|
|
Method | Property | Field | StaticField | Interface | Parameter |
|
|
Delegate | Function | ReturnValue | GenericParameter | Invocation | MemberAccess |
|
|
Alloc | Delete | Alias | Block,
|
|
}
|
|
|
|
public enum ReflectKind
|
|
{
|
|
None = 0,
|
|
Type = 1,
|
|
NonStaticFields = 2,
|
|
StaticFields = 4,
|
|
DefaultConstructor = 8,
|
|
Constructors = 0x10,
|
|
StaticMethods = 0x20,
|
|
Methods = 0x40,
|
|
All = 0x7F,
|
|
|
|
ApplyToInnerTypes = 0x80,
|
|
}
|
|
|
|
public enum AttributeFlags
|
|
{
|
|
None,
|
|
DisallowAllowMultiple = 1,
|
|
NotInherited = 2,
|
|
ReflectAttribute = 4,
|
|
AlwaysIncludeTarget = 8
|
|
}
|
|
|
|
public sealed struct AttributeUsageAttribute : Attribute
|
|
{
|
|
AttributeTargets mAttributeTarget = .All;
|
|
AttributeFlags mAttributeFlags = .None;
|
|
ReflectKind mReflectUser = .None;
|
|
|
|
public this(AttributeTargets validOn)
|
|
{
|
|
mAttributeTarget = validOn;
|
|
}
|
|
|
|
public this(AttributeTargets validOn, AttributeFlags flags)
|
|
{
|
|
mAttributeTarget = validOn;
|
|
mAttributeFlags = flags;
|
|
}
|
|
|
|
public this(AttributeTargets validOn, bool allowMultiple, bool inherited)
|
|
{
|
|
mAttributeTarget = validOn;
|
|
if (!allowMultiple)
|
|
mAttributeFlags |= .DisallowAllowMultiple;
|
|
if (!inherited)
|
|
mAttributeFlags |= .NotInherited;
|
|
}
|
|
|
|
public AttributeTargets ValidOn
|
|
{
|
|
get { return mAttributeTarget; }
|
|
}
|
|
|
|
public ReflectKind ReflectUser
|
|
{
|
|
get { return mReflectUser; }
|
|
set mut { mReflectUser = value; }
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.All)]
|
|
public struct ReflectAttribute : Attribute
|
|
{
|
|
public this(ReflectKind reflectKind = .All)
|
|
{
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Method | .Constructor | .Invocation)]
|
|
public struct InlineAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Invocation)]
|
|
public struct UnboundAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Class | .Struct | .Interface | .Method | .Constructor)]
|
|
public struct AlwaysIncludeAttribute : Attribute
|
|
{
|
|
public bool AssumeInstantiated
|
|
{
|
|
set { }
|
|
}
|
|
|
|
public bool IncludeAllMethods
|
|
{
|
|
set { }
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.MemberAccess | .Alloc)]
|
|
public struct FriendAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.MemberAccess)]
|
|
public struct NoExtensionAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Block)]
|
|
public struct IgnoreErrorsAttribute : Attribute
|
|
{
|
|
public this(bool stopOnErrors = false)
|
|
{
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Method | .Class | .Struct | .Enum)]
|
|
public struct OptimizeAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method | .Class | .Struct | .Enum)]
|
|
public struct UseLLVMAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method /*2*/ | .StaticField)]
|
|
public struct CLinkAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method /*2*/ | .StaticField)]
|
|
public struct LinkNameAttribute : Attribute
|
|
{
|
|
public enum MangleKind
|
|
{
|
|
Beef,
|
|
C,
|
|
CPP
|
|
}
|
|
|
|
public this(String linkName)
|
|
{
|
|
}
|
|
|
|
public this(MangleKind mangleKind)
|
|
{
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Method | .Delegate | .Function)]
|
|
public struct CallingConventionAttribute : Attribute
|
|
{
|
|
public enum Kind
|
|
{
|
|
Unspecified,
|
|
Cdecl,
|
|
Stdcall,
|
|
Fastcall,
|
|
}
|
|
|
|
public this(Kind callingConvention)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Obsolete("Use [CallingConvention(.Stdcall)]", false)]
|
|
[AttributeUsage(.Method | .Delegate | .Function)]
|
|
public struct StdCallAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method /*2*/)]
|
|
public struct CVarArgsAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method /*2*/)]
|
|
public struct NoReturnAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method /*2*/)]
|
|
public struct SkipCallAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method)]
|
|
struct OnCompileAttribute : Attribute
|
|
{
|
|
public enum Kind
|
|
{
|
|
None,
|
|
TypeInit,
|
|
TypeDone
|
|
}
|
|
|
|
public this(Kind kind)
|
|
{
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Method)]
|
|
public struct ComptimeAttribute : Attribute
|
|
{
|
|
public this()
|
|
{
|
|
|
|
}
|
|
|
|
public bool OnlyFromComptime
|
|
{
|
|
set
|
|
{
|
|
}
|
|
}
|
|
|
|
public bool ConstEval
|
|
{
|
|
set
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Invocation)]
|
|
public struct ConstEvalAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method /*2*/)]
|
|
public struct IntrinsicAttribute : Attribute
|
|
{
|
|
public this(String intrinName)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Class | .Struct /*2*/)]
|
|
public struct StaticInitPriorityAttribute : Attribute
|
|
{
|
|
public this(int priority)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Class /*2*/ | .Struct /*2*/)]
|
|
public struct StaticInitAfterAttribute : Attribute
|
|
{
|
|
public this()
|
|
{
|
|
|
|
}
|
|
|
|
public this(Type afterType)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Struct)]
|
|
public struct ForceAddrAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
/// This attribute is required on constructors that include 'append' allocations.
|
|
[AttributeUsage(.Constructor)]
|
|
public struct AllowAppendAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Class | .Struct)]
|
|
public struct PackedAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Class | .Struct | .Alloc)]
|
|
public struct AlignAttribute : Attribute
|
|
{
|
|
public this(int align)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Enum)]
|
|
public struct AllowDuplicatesAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Class | .Struct)]
|
|
public struct UnionAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Class | .Struct)]
|
|
public struct CReprAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Class | .Struct)]
|
|
public struct OrderedAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Struct)]
|
|
public struct UnderlyingArrayAttribute : Attribute
|
|
{
|
|
public this(Type t, int size, bool isVector)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Field | .Method /*2*/)]
|
|
public struct NoShowAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Field | .Method /*2*/)]
|
|
public struct HideAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
|
|
[AttributeUsage(.Parameter)]
|
|
public struct HideNameAttribute : Attribute
|
|
{
|
|
}
|
|
|
|
[AttributeUsage(.Method/*, AlwaysIncludeTarget=true*/)]
|
|
public struct TestAttribute : Attribute
|
|
{
|
|
public bool ShouldFail;
|
|
public bool Ignore;
|
|
public bool Profile;
|
|
}
|
|
|
|
public struct ImportAttribute : Attribute
|
|
{
|
|
public this(String libName)
|
|
{
|
|
}
|
|
}
|
|
|
|
public struct ExportAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.StaticField | .Field, .NotInherited)]
|
|
public struct ThreadStaticAttribute : Attribute
|
|
{
|
|
public this()
|
|
{
|
|
}
|
|
}
|
|
|
|
/// The [Checked] attribute is used to mark a method or a method invocation as being "checked", meaning
|
|
/// that the method applies extra runtime checks such as bounds checking or other parameter or state validation.
|
|
[AttributeUsage(.Invocation | .Method | .Property)]
|
|
public struct CheckedAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
/// The [Unchecked] attribute is used to mark a method or a method invocation as being "unchecked", meaning
|
|
/// that the method omits runtime checks such as bounds checking or other parameter or state validation.
|
|
[AttributeUsage(.Invocation | .Method | .Property)]
|
|
public struct UncheckedAttribute : Attribute
|
|
{
|
|
}
|
|
|
|
/// Generally used as a per-method optimization, [DisableChecks] will cause calls within this method to
|
|
/// call the unchecked version of methods. By default, only debug builds perform checked calls.
|
|
[AttributeUsage(.Method | .Constructor)]
|
|
public struct DisableChecksAttribute : Attribute
|
|
{
|
|
}
|
|
|
|
/// Generally used as a per-method optimization, [DisableObjectAccessChecks] will avoid the runtime per-object-access
|
|
/// checks which by default are only applied in debug builds anyway.
|
|
[AttributeUsage(.Method | .MemberAccess)]
|
|
public struct DisableObjectAccessChecksAttribute : Attribute
|
|
{
|
|
}
|
|
|
|
[AttributeUsage(.Method | .Constructor | .Class | .Struct | .Alias | .Interface)]
|
|
public struct ObsoleteAttribute : Attribute
|
|
{
|
|
public this(bool isError)
|
|
{
|
|
|
|
}
|
|
|
|
public this(String error, bool isError)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Method)]
|
|
public struct CommutableAttribute : Attribute
|
|
{
|
|
|
|
}
|
|
|
|
[AttributeUsage(.Method | .Constructor | .Class | .Struct | .Alias)]
|
|
public struct ErrorAttribute : Attribute
|
|
{
|
|
public this(String error)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[AttributeUsage(.Method | .Constructor | .Class | .Struct | .Alias)]
|
|
public struct WarnAttribute : Attribute
|
|
{
|
|
public this(String error)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
/// If [NoDiscard] is used on a method, the the compiler will show a warning if the result is discarded.
|
|
/// If used on a type, the compiler will show an warning if any method returns that type and the caller discards the result.
|
|
[AttributeUsage(.Method | .Class | .Struct)]
|
|
public struct NoDiscardAttribute : Attribute
|
|
{
|
|
public this()
|
|
{
|
|
}
|
|
|
|
public this(String message)
|
|
{
|
|
}
|
|
}
|
|
|
|
interface IOnTypeInit
|
|
{
|
|
void OnTypeInit(Type type, Self* prev) mut;
|
|
}
|
|
|
|
interface IOnTypeDone
|
|
{
|
|
void OnTypeDone(Type type, Self* prev) mut;
|
|
}
|
|
|
|
interface IOnFieldInit
|
|
{
|
|
void OnFieldInit(FieldInfo type, Self* prev) mut;
|
|
}
|
|
|
|
interface IOnMethodInit
|
|
{
|
|
void OnMethodInit(MethodInfo type, Self* prev) mut;
|
|
}
|
|
|
|
interface IComptimeTypeApply
|
|
{
|
|
void ApplyToType(Type type);
|
|
}
|
|
|
|
interface IComptimeMethodApply
|
|
{
|
|
void ApplyToMethod(Type type);
|
|
}
|
|
}
|