Lines Matching refs:alias
176 alias staticMap = staticMapMeta;
263 alias CentTypeList = AliasSeq!(cent, ucent);
264 alias SignedCentTypeList = AliasSeq!(cent);
265 alias UnsignedCentTypeList = AliasSeq!(ucent);
269 alias CentTypeList = AliasSeq!();
270 alias SignedCentTypeList = AliasSeq!();
271 alias UnsignedCentTypeList = AliasSeq!();
274 alias IntegralTypeList = AliasSeq!(byte, ubyte, short, ushort, int, uint, long, ulong, CentTypeList);
275 alias SignedIntTypeList = AliasSeq!(byte, short, int, long, SignedCentTypeList);
276 alias UnsignedIntTypeList = AliasSeq!(ubyte, ushort, uint, ulong, UnsignedCentTypeList);
277 alias FloatingPointTypeList = AliasSeq!(float, double, real);
278 alias ImaginaryTypeList = AliasSeq!(ifloat, idouble, ireal);
279 alias ComplexTypeList = AliasSeq!(cfloat, cdouble, creal);
280 alias NumericTypeList = AliasSeq!(IntegralTypeList, FloatingPointTypeList);
281 alias CharTypeList = AliasSeq!(char, wchar, dchar);
287 template MutableOf(T) { alias MutableOf = T ; }
291 template InoutOf(T) { alias InoutOf = inout(T) ; }
293 template ConstOf(T) { alias ConstOf = const(T) ; }
295 template SharedOf(T) { alias SharedOf = shared(T) ; }
297 template SharedInoutOf(T) { alias SharedInoutOf = shared(inout(T)); }
299 template SharedConstOf(T) { alias SharedConstOf = shared(const(T)); }
301 template ImmutableOf(T) { alias ImmutableOf = immutable(T) ; }
317 static if (is(T == shared(const U), U)) alias QualifierOf = SharedConstOf;
318 else static if (is(T == const U , U)) alias QualifierOf = ConstOf;
319 else static if (is(T == shared(inout U), U)) alias QualifierOf = SharedInoutOf;
320 else static if (is(T == inout U , U)) alias QualifierOf = InoutOf;
321 else static if (is(T == immutable U , U)) alias QualifierOf = ImmutableOf;
322 else static if (is(T == shared U , U)) alias QualifierOf = SharedOf;
323 else alias QualifierOf = MutableOf;
328 alias Qual1 = QualifierOf!( int); static assert(is(Qual1!long == long));
329 alias Qual2 = QualifierOf!( inout int); static assert(is(Qual2!long == inout long));
330 alias Qual3 = QualifierOf!( const int); static assert(is(Qual3!long == const long));
331 alias Qual4 = QualifierOf!(shared int); static assert(is(Qual4!long == shared long));
332 alias Qual5 = QualifierOf!(shared inout int); static assert(is(Qual5!long == shared inout long));
333 alias Qual6 = QualifierOf!(shared const int); static assert(is(Qual6!long == shared const long));
334 alias Qual7 = QualifierOf!( immutable int); static assert(is(Qual7!long == immutable long));
339 alias TypeQualifierList = AliasSeq!(MutableOf, ConstOf, SharedOf, SharedConstOf, ImmutableOf);
344 alias val this;
348 private alias parentOf(alias sym) = Identity!(__traits(parent, sym));
349 private alias parentOf(alias sym : T!Args, alias T, Args...) = Identity!(__traits(parent, T));
354 template packageName(alias T)
408 template moduleName(alias T)
424 alias moduleName = moduleName!(parentOf!T); // If you use enum, it will cause compiler ICE
520 template Inst(alias A) { int x; }
531 private template fqnSym(alias T : X!A, alias X, A...)
553 private template fqnSym(alias T)
573 alias fqn = fullyQualifiedName;
580 alias qnTests = QualifiedNameTests;
603 alias TemplatedStructAlias = TemplatedStruct;
620 alias qualifiers = AliasSeq!(is(T == const), is(T == immutable), is(T == shared), is(T == inout));
621 alias noQualifiers = AliasSeq!(false, false, false, false);
625 alias PSC = ParameterStorageClass;
638 alias parameters = Parameters!(T);
639 alias parameterStC = ParameterStorageClassTuple!(T);
686 alias FA = FunctionAttribute;
820 alias fqn = fullyQualifiedName;
823 alias Ambiguous = const(QualifiedNameTests.Inner);
900 alias ReturnType = R;
919 alias ShouldBeInt = ReturnType!G;
926 alias pg = ReturnType!p;
943 alias R_Test_prop = ReturnType!(Test.prop);
946 alias R_dglit = ReturnType!((int a) { return a; });
959 alias Parameters = P;
975 alias ParameterTypeTuple = Parameters;
993 alias P_Test_prop = ParameterTypeTuple!(Test.prop);
996 alias P_dglit = ParameterTypeTuple!((int a){});
1005 template arity(alias func)
1047 alias Func = FunctionTypeOf!func;
1055 alias StorageClass = AliasSeq!(
1060 alias StorageClass = AliasSeq!();
1062 alias ParameterStorageClassTuple = StorageClass!0;
1067 alias ParameterStorageClassTuple = AliasSeq!();
1074 alias STC = ParameterStorageClass; // shorten the enum name
1079 alias pstc = ParameterStorageClassTuple!func;
1123 alias STC = ParameterStorageClass;
1129 alias test_pstc = ParameterStorageClassTuple!test;
1145 alias test_const_pstc = ParameterStorageClassTuple!(Test.test_const);
1149 alias test_sharedconst_pstc = ParameterStorageClassTuple!(testi.test_sharedconst);
1153 alias dglit_pstc = ParameterStorageClassTuple!((ref int a) {});
1169 alias tup = ParameterStorageClassTuple!(__traits(getOverloads, Foo, "opAssign")[0]);
1201 alias PT = AliasSeq!();
1207 alias Impl = AliasSeq!();
1209 alias Impl = AliasSeq!(Get!i, Impl!(i+1));
1212 alias ParameterIdentifierTuple = Impl!();
1224 alias PIT = ParameterIdentifierTuple;
1266 alias param_names = ParameterIdentifierTuple!func;
1295 alias Get = void;
1305 alias PT = AliasSeq!();
1311 alias Impl = AliasSeq!();
1313 alias Impl = AliasSeq!(Get!i, Impl!(i+1));
1316 alias ParameterDefaults = Impl!();
1335 alias Voids = ParameterDefaults!func;
1343 alias ParameterDefaultValueTuple = ParameterDefaults;
1347 alias PDVT = ParameterDefaultValueTuple;
1415 alias FuncSym = Select!(is(typeof(__traits(getFunctionAttributes, func))),
1427 alias FA = FunctionAttribute; // shorten the enum name
1440 alias FA = FunctionAttribute;
1773 template isSafe(alias func)
1852 template isUnsafe(alias func)
2041 alias FunctionTypeOf = Fsym; // HIT: (nested) function symbol
2045 alias FunctionTypeOf = Fobj; // HIT: callable object
2049 alias FunctionTypeOf = Ftyp; // HIT: callable type
2054 alias FunctionTypeOf = T; // HIT: function
2056 alias FunctionTypeOf = Fptr; // HIT: function pointer
2058 alias FunctionTypeOf = Fdlg; // HIT: delegate
2088 alias int GetterType() @property;
2089 alias int SetterType(int) @property;
2115 alias ov = AliasSeq!(__traits(getVirtualFunctions, Overloads, "test"));
2116 alias F_ov0 = FunctionTypeOf!(ov[0]);
2117 alias F_ov1 = FunctionTypeOf!(ov[1]);
2118 alias F_ov2 = FunctionTypeOf!(ov[2]);
2119 alias F_ov3 = FunctionTypeOf!(ov[3]);
2125 alias F_dglit = FunctionTypeOf!((int a){ return a; });
2155 string result = "alias ";
2222 alias SetFunctionAttributes = FunctionTypeOf!(SetFunctionAttributes!(T*, linkage, attrs));
2228 alias ExternC(T) = SetFunctionAttributes!(T, "C", functionAttributes!T);
2251 alias FA = FunctionAttribute;
2268 alias New = SetFunctionAttributes!(T, newLinkage, attrs);
2276 alias T1 = SetFunctionAttributes!(T, functionLinkage!T, FA.safe);
2284 alias T2 = SetFunctionAttributes!(T1, functionLinkage!T, allAttrs);
2288 alias T3 = SetFunctionAttributes!(T2, functionLinkage!T, FA.none);
2476 alias Fields = typeof(T.tupleof[0 .. $ - isNested!T]);
2478 alias Fields = typeof(T.tupleof);
2480 alias Fields = AliasSeq!T;
2493 alias FieldTypeTuple = Fields;
2519 private enum NameOf(alias T) = T.stringof;
2532 alias FieldNameTuple = staticMap!(NameOf, T.tupleof[0 .. $ - isNested!T]);
2534 alias FieldNameTuple = staticMap!(NameOf, T.tupleof);
2536 alias FieldNameTuple = AliasSeq!"";
2580 alias Impl = AliasSeq!();
2588 alias Impl = Impl!(Impl!R, T[1 .. $]);
2593 //alias .RepresentationTypes!(T[0].tupleof)
2595 alias Impl = Impl!(FieldTypeTuple!(T[0]), T[1 .. $]);
2599 alias Impl = AliasSeq!(T[0], Impl!(T[1 .. $]));
2606 alias RepresentationTypeTuple = Impl!(FieldTypeTuple!T);
2610 alias RepresentationTypeTuple = Impl!T;
2619 alias R = RepresentationTypeTuple!S2;
2627 alias S1 = RepresentationTypeTuple!int;
2639 alias R = RepresentationTypeTuple!S21;
2645 alias R1 = RepresentationTypeTuple!C;
2652 alias R2 = RepresentationTypeTuple!S5;
3566 package alias Identity(alias A) = A;
3599 alias t this;
3604 alias t this;
3644 alias sym = Alias!(__traits(getMember, T, member));
3879 template Symbolize(alias value)
3886 mixin("template Symbolize(alias "~ ident ~")"
3888 ~"alias Symbolize = "~ ident ~";"
3897 alias EnumSpecificMembers = AliasSeq!(WithIdentifier!(names[0])
3902 alias EnumSpecificMembers =
3912 alias EnumSpecificMembers = AliasSeq!();
3916 alias EnumMembers = EnumSpecificMembers!(__traits(allMembers, E));
3997 alias BaseTypeTuple = P;
4022 alias TL = BaseTypeTuple!C;
4041 alias BaseClassesTuple = AliasSeq!();
4045 alias BaseClassesTuple = AliasSeq!Object;
4049 alias BaseClassesTuple =
4091 alias Flatten = AliasSeq!(Flatten!H, Flatten!T);
4096 alias Flatten = AliasSeq!(H, InterfacesTuple!H);
4098 alias Flatten = InterfacesTuple!H;
4103 alias InterfacesTuple = NoDuplicates!(Flatten!S);
4105 alias InterfacesTuple = AliasSeq!();
4116 alias TL = InterfacesTuple!C;
4148 alias TransitiveBaseTypeTuple = AliasSeq!();
4150 alias TransitiveBaseTypeTuple =
4162 alias TL = TransitiveBaseTypeTuple!B3;
4192 alias inSight = AliasSeq!(__traits(getVirtualFunctions, Node, name));
4199 alias walkThru = AliasSeq!(
4204 alias walkThru = AliasSeq!();
4208 alias CollectOverloads = AliasSeq!(inSight, walkThru!Parents);
4210 alias CollectOverloads = AliasSeq!inSight;
4213 alias CollectOverloads = AliasSeq!(); // no overloads in this hierarchy
4217 alias overloads = CollectOverloads!C;
4221 template shrinkOne(/+ alias target, rest... +/ args...)
4224 alias target = args[0 .. 1]; // prevent property functions from being evaluated
4225 alias rest = args[1 .. $];
4229 alias Target = FunctionTypeOf!target;
4230 alias Rest0 = FunctionTypeOf!(rest[0]);
4236 alias shrinkOne = shrinkOne!(target, rest[1 .. $]);
4238 alias shrinkOne = shrinkOne!(rest[0], rest[1 .. $]);
4242 alias shrinkOne = shrinkOne!(target, rest[1 .. $]);
4245 alias shrinkOne = shrinkOne!(rest[0], rest[1 .. $]);
4248 alias shrinkOne = AliasSeq!(
4254 alias shrinkOne = AliasSeq!target; // done
4264 alias temp = shrinkOne!overloads;
4265 alias shrink = AliasSeq!(temp[0], shrink!(temp[1 .. $]));
4268 alias shrink = AliasSeq!(); // done
4272 alias MemberFunctionsTuple = shrink!overloads;
4275 alias MemberFunctionsTuple = AliasSeq!();
4290 alias foos = MemberFunctionsTuple!(C, "foo");
4309 alias fs = MemberFunctionsTuple!(B, "f");
4310 alias bfs = AliasSeq!(__traits(getOverloads, B, "f"));
4330 alias test =MemberFunctionsTuple!(C, "test");
4334 alias noexist = MemberFunctionsTuple!(C, "noexist");
4338 alias prop = MemberFunctionsTuple!(L, "prop");
4348 alias Test_foo = MemberFunctionsTuple!(Test, "foo");
4357 Returns an alias to the template that $(D T) is an instance of.
4359 template TemplateOf(alias T : Base!Args, alias Base, Args...)
4361 alias TemplateOf = Base;
4365 template TemplateOf(T : Base!Args, alias Base, Args...)
4367 alias TemplateOf = Base;
4381 template Foo3(alias A) {}
4385 struct Foo7(alias A) {}
4404 template TemplateArgsOf(alias T : Base!Args, alias Base, Args...)
4406 alias TemplateArgsOf = Args;
4410 template TemplateArgsOf(T : Base!Args, alias Base, Args...)
4412 alias TemplateArgsOf = Args;
4426 template Foo3(alias A) {}
4430 struct Foo7(alias A) {}
4468 alias classInstanceAlignment = maxAlignment!(void*, typeof(T.tupleof));
4497 alias CommonType = void;
4503 alias CommonType = typeof(T[0]);
4507 alias CommonType = T[0];
4512 alias CommonType = CommonType!(U, T[2 .. $]);
4515 alias CommonType = void;
4521 alias X = CommonType!(int, long, short);
4523 alias Y = CommonType!(int, char[], short);
4549 alias ImplicitConversionTargets =
4553 alias ImplicitConversionTargets =
4557 alias ImplicitConversionTargets =
4561 alias ImplicitConversionTargets =
4564 alias ImplicitConversionTargets =
4567 alias ImplicitConversionTargets =
4570 alias ImplicitConversionTargets =
4573 alias ImplicitConversionTargets = AliasSeq!(float, double, real);
4575 alias ImplicitConversionTargets = AliasSeq!(float, double, real);
4577 alias ImplicitConversionTargets = AliasSeq!(float, double, real);
4579 alias ImplicitConversionTargets = AliasSeq!(float, double, real);
4581 alias ImplicitConversionTargets = AliasSeq!(double, real);
4583 alias ImplicitConversionTargets = AliasSeq!real;
4585 alias ImplicitConversionTargets =
4589 alias ImplicitConversionTargets =
4593 alias ImplicitConversionTargets =
4596 alias ImplicitConversionTargets = AliasSeq!(typeof(null));
4598 alias ImplicitConversionTargets = TransitiveBaseTypeTuple!(T);
4600 alias ImplicitConversionTargets =
4603 alias ImplicitConversionTargets = AliasSeq!(void*);
4605 alias ImplicitConversionTargets = AliasSeq!();
4829 alias foo this;
4843 alias Pointify(T) = void*;
4873 alias Upr = F;
4874 alias Lwr = G;
4908 alias FA = FunctionAttribute;
4935 alias STC = ParameterStorageClass;
4936 alias UprParams = Parameters!Upr;
4937 alias LwrParams = Parameters!Lwr;
4938 alias UprPSTCs = ParameterStorageClassTuple!Upr;
4939 alias LwrPSTCs = ParameterStorageClassTuple!Lwr;
4997 enum bool isCovariantWith(alias f, alias g) = .isCovariantWith!(typeof(f), typeof(g));
5113 alias members = AliasSeq!(__traits(getAliasThis, T));
5117 alias AliasThisTypeOf = typeof(__traits(getMember, T.init, members[0]));
5120 static assert(0, T.stringof~" does not have alias this type");
5128 alias X = BooleanTypeOf!AT;
5130 alias X = OriginalType!T;
5134 alias BooleanTypeOf = X;
5163 alias val this;
5168 alias b this;
5180 alias X = IntegralTypeOf!AT;
5182 alias X = OriginalType!T;
5186 alias IntegralTypeOf = X;
5215 alias X = FloatingPointTypeOf!AT;
5217 alias X = OriginalType!T;
5221 alias FloatingPointTypeOf = X;
5250 alias NumericTypeOf = X;
5280 alias UnsignedTypeOf = X;
5292 alias SignedTypeOf = X;
5294 alias SignedTypeOf = X;
5305 alias X = CharTypeOf!AT;
5307 alias X = OriginalType!T;
5311 alias CharTypeOf = X;
5346 alias X = StaticArrayTypeOf!AT;
5348 alias X = OriginalType!T;
5351 alias StaticArrayTypeOf = X;
5381 alias X = DynamicArrayTypeOf!AT;
5383 alias X = OriginalType!T;
5387 alias DynamicArrayTypeOf = X;
5419 alias ArrayTypeOf = X;
5440 alias StringTypeOf = U[];
5459 alias Str = Q!T[];
5460 class C(S) { S val; alias val this; }
5482 alias X = AssocArrayTypeOf!AT;
5484 alias X = OriginalType!T;
5488 alias AssocArrayTypeOf = X;
5518 static if (is(T : void)) alias BuiltinTypeOf = void;
5519 else static if (is(BooleanTypeOf!T X)) alias BuiltinTypeOf = X;
5520 else static if (is(IntegralTypeOf!T X)) alias BuiltinTypeOf = X;
5521 else static if (is(FloatingPointTypeOf!T X))alias BuiltinTypeOf = X;
5522 else static if (is(T : const(ireal))) alias BuiltinTypeOf = ireal; //TODO
5523 else static if (is(T : const(creal))) alias BuiltinTypeOf = creal; //TODO
5524 else static if (is(CharTypeOf!T X)) alias BuiltinTypeOf = X;
5525 else static if (is(ArrayTypeOf!T X)) alias BuiltinTypeOf = X;
5526 else static if (is(AssocArrayTypeOf!T X)) alias BuiltinTypeOf = X;
5553 alias t this;
5586 alias val this;
5644 alias val this;
5719 alias val this;
5739 alias t this;
5772 alias t this;
5840 alias t this;
5884 alias t this;
5937 // alias-this types are not allowed
5941 alias t this;
6099 alias s this;
6122 alias convertToString = StringTypeOf!T;
6124 alias convertToString = T;
6151 alias s this;
6321 alias SimdVec = __vector(float[4]);
6354 alias PointerTarget(T : T*) = T;
6444 enum bool isInstanceOf(alias S, T) = is(T == S!Args, Args...);
6446 template isInstanceOf(alias S, alias T)
6448 enum impl(alias T : S!Args, Args...) = true;
6449 enum impl(alias T) = false;
6515 alias isExpressionTuple = isExpressions;
6522 alias myint = int;
6798 template isNestedFunction(alias f)
6870 version (none) // Error: recursive alias declaration @@@BUG1308@@@
6872 static if (is(T U == const U)) alias Unqual = Unqual!U;
6873 else static if (is(T U == immutable U)) alias Unqual = Unqual!U;
6874 else static if (is(T U == inout U)) alias Unqual = Unqual!U;
6875 else static if (is(T U == shared U)) alias Unqual = Unqual!U;
6876 else alias Unqual = T;
6880 static if (is(T U == immutable U)) alias Unqual = U;
6881 else static if (is(T U == shared inout const U)) alias Unqual = U;
6882 else static if (is(T U == shared inout U)) alias Unqual = U;
6883 else static if (is(T U == shared const U)) alias Unqual = U;
6884 else static if (is(T U == shared U)) alias Unqual = U;
6885 else static if (is(T U == inout const U)) alias Unqual = U;
6886 else static if (is(T U == inout U)) alias Unqual = U;
6887 else static if (is(T U == const U)) alias Unqual = U;
6888 else alias Unqual = T;
6914 alias ImmIntArr = immutable(int[]);
6919 package template ModifyTypePreservingTQ(alias Modifier, T)
6921 static if (is(T U == immutable U)) alias ModifyTypePreservingTQ = immutable Modifier!U;
6922 else static if (is(T U == shared inout const U)) alias ModifyTypePreservingTQ = shared inout const Modifier!U;
6923 else static if (is(T U == shared inout U)) alias ModifyTypePreservingTQ = shared inout Modifier!U;
6924 else static if (is(T U == shared const U)) alias ModifyTypePreservingTQ = shared const Modifier!U;
6925 else static if (is(T U == shared U)) alias ModifyTypePreservingTQ = shared Modifier!U;
6926 else static if (is(T U == inout const U)) alias ModifyTypePreservingTQ = inout const Modifier!U;
6927 else static if (is(T U == inout U)) alias ModifyTypePreservingTQ = inout Modifier!U;
6928 else static if (is(T U == const U)) alias ModifyTypePreservingTQ = const Modifier!U;
6929 else alias ModifyTypePreservingTQ = Modifier!T;
6934 alias Intify(T) = int;
6959 alias T(U) = ToType;
6960 alias CopyTypeQualifiers = ModifyTypePreservingTQ!(T, FromType);
6989 alias Unshared(T) = T;
6990 alias Unshared(T: shared U, U) = U;
6992 alias CopyConstness = Unshared!(CopyTypeQualifiers!(FromType, ToType));
7012 alias MutT = CopyConstness!(const(int)[], int);
7016 alias CstT = CopyConstness!(const(int[]), int);
7064 alias ForeachType = ReturnType!(typeof(
7092 static if (is(T U == enum)) alias Impl = OriginalType!U;
7093 else alias Impl = T;
7096 alias OriginalType = ModifyTypePreservingTQ!(Impl, T);
7104 alias G = const(F);
7113 alias KeyType(V : V[K], K) = K;
7119 alias Hash = int[string];
7129 alias ValueType(V : V[K], K) = V;
7135 alias Hash = int[string];
7151 alias Impl = __vector(Impl!V[N]);
7153 alias Impl = T;
7156 static if (is(T == byte )) alias Impl = ubyte;
7157 static if (is(T == short)) alias Impl = ushort;
7158 static if (is(T == int )) alias Impl = uint;
7159 static if (is(T == long )) alias Impl = ulong;
7160 static if (is(ucent) && is(T == cent )) alias Impl = ucent;
7167 alias Unsigned = ModifyTypePreservingTQ!(Impl, OriginalType!T);
7172 alias U1 = Unsigned!int;
7173 alias U2 = Unsigned!(const(int));
7174 alias U3 = Unsigned!(immutable(int));
7180 alias UV1 = Unsigned!(__vector(int[4]));
7181 alias UV2 = Unsigned!(const(__vector(int[4])));
7186 //alias U2 = Unsigned!S;
7187 //alias U3 = Unsigned!double;
7190 alias U4 = Unsigned!cent;
7191 alias U5 = Unsigned!(const(cent));
7192 alias U6 = Unsigned!(immutable(cent));
7208 alias Largest = T[0];
7214 alias Largest = T[0];
7218 alias Largest = T[1];
7223 alias Largest = Largest!(Largest!(T[0 .. $/2]), Largest!(T[$/2 .. $]));
7247 alias Impl = __vector(Impl!V[N]);
7249 alias Impl = T;
7252 static if (is(T == ubyte )) alias Impl = byte;
7253 static if (is(T == ushort)) alias Impl = short;
7254 static if (is(T == uint )) alias Impl = int;
7255 static if (is(T == ulong )) alias Impl = long;
7256 static if (is(ucent) && is(T == ucent )) alias Impl = cent;
7263 alias Signed = ModifyTypePreservingTQ!(Impl, OriginalType!T);
7269 alias S1 = Signed!uint;
7271 alias S2 = Signed!(const(uint));
7273 alias S3 = Signed!(immutable(uint));
7277 alias S4 = Signed!ucent;
7287 alias SV1 = Signed!(__vector(uint[4]));
7288 alias SV2 = Signed!(const(__vector(uint[4])));
7335 alias Promoted = CopyTypeQualifiers!(T, typeof(T.init + T.init));
7387 alias TL = staticMap!(mangledName, int, const int, immutable int);
7435 alias Select = Alias!(T[!condition]);
7450 alias selA = Select!(true, a, b);
7451 alias selB = Select!(false, a, b);
7485 template hasUDA(alias symbol, alias attribute)
7559 struct FuncAttr(alias f) { alias func = f; }
7590 template getUDAs(alias symbol, alias attribute)
7594 template isDesiredUDA(alias toCheck)
7615 alias getUDAs = Filter!(isDesiredUDA, __traits(getAttributes, symbol));
7681 struct FuncAttr(alias f) { alias func = f; }
7725 template getSymbolsByUDA(alias symbol, alias attribute)
7730 // translate a list of strings into symbols. mixing in the entire alias
7735 alias toSymbols = AliasSeq!();
7737 mixin("alias toSymbols = AliasSeq!(symbol.%s, toSymbols!(names[1..$]));"
7743 alias accessibleMembers = Filter!(isAccessibleMember, __traits(allMembers, symbol));
7745 // filtering not compiled members such as alias of basic types
7749 alias correctMembers = Filter!(isCorrectMember, accessibleMembers);
7750 alias membersWithUDA = toSymbols!(Filter!(hasSpecificUDA, correctMembers));
7754 alias getSymbolsByUDA = AliasSeq!(symbol, membersWithUDA);
7756 alias getSymbolsByUDA = membersWithUDA;
7841 alias int INT;
7842 alias void function(INT) SomeFunction;
7864 alias res = getSymbolsByUDA!(A, Attr);
7900 enum ifTestable(T, alias pred = a => a) = __traits(compiles, { if (pred(T.init)) {} });