ut.meta.functions source code

1 module ut.meta.functions;
2 
3 
4 import ut.meta;
5 import std.meta: AliasSeq;
6 
7 
8 @("functions.bySymbol")
9 @safe pure unittest {
10     alias mod = Module!("modules.functions");
11     import modules.functions;
12 
13     alias expected = AliasSeq!(
14         FunctionSymbol!(add1, Protection.public_, Linkage.D),
15         FunctionSymbol!(withDefault, Protection.public_, Linkage.D),
16         FunctionSymbol!(storageClasses, Protection.public_, Linkage.D),
17         FunctionSymbol!(exportedFunc, Protection.export_, Linkage.D),
18         FunctionSymbol!(externC, Protection.public_, Linkage.C),
19         FunctionSymbol!(externCpp, Protection.public_, Linkage.Cpp),
20         FunctionSymbol!(identityInt, Protection.public_, Linkage.D, "identityInt", modules.functions),
21     );
22 
23     // pragma(msg, "\n", mod.FunctionsBySymbol.stringof, "\n");
24     shouldEqual!(mod.FunctionsBySymbol, expected);
25 
26     static assert(mod.FunctionsBySymbol[0].overloads.length == 2); // add1
27     static foreach(i; 1..expected.length)
28         static assert(mod.FunctionsBySymbol[i].overloads.length == 1); // everything else
29 }
30 
31 
32 @("functions.byOverload")
33 @safe pure unittest {
34     alias mod = Module!("modules.functions");
35     import modules.functions;
36 
37     alias add1Int = __traits(getOverloads, modules.functions, "add1")[0];
38     alias add1Double = __traits(getOverloads, modules.functions, "add1")[1];
39 
40     alias expected = AliasSeq!(
41         FunctionOverload!(add1Int, Protection.public_, Linkage.D),
42         FunctionOverload!(add1Double, Protection.public_, Linkage.D),
43         FunctionOverload!(withDefault, Protection.public_, Linkage.D),
44         FunctionOverload!(storageClasses, Protection.public_, Linkage.D),
45         FunctionOverload!(exportedFunc, Protection.export_, Linkage.D),
46         FunctionOverload!(externC, Protection.public_, Linkage.C),
47         FunctionOverload!(externCpp, Protection.public_, Linkage.Cpp),
48         FunctionOverload!(identityInt, Protection.public_, Linkage.D, "identityInt", modules.functions),
49     );
50 
51     // pragma(msg, "\n", mod.FunctionsByOverload.stringof, "\n");
52     shouldEqual!(mod.FunctionsByOverload, expected);
53 }
54 
55 
56 @("problems")
57 @safe pure unittest {
58     alias mod = Module!("modules.problems");
59     static assert(mod.FunctionsBySymbol.length == 0, mod.FunctionsBySymbol.stringof);
60 }
61 
62 
63 
64 @("parameters.add1.bySymbol")
65 @safe pure unittest {
66 
67     alias mod = Module!("modules.functions");
68     alias add1Int = mod.FunctionsBySymbol[0].overloads[0];
69     alias add1Double = mod.FunctionsBySymbol[0].overloads[1];
70     alias withDefaults = mod.FunctionsBySymbol[1].overloads[0];
71 
72     shouldEqual!(
73         add1Int.parameters,
74         AliasSeq!(
75             Parameter!(int, void, "i"),
76             Parameter!(int, void, "j"),
77         )
78     );
79 
80     shouldEqual!(
81         add1Double.parameters,
82         AliasSeq!(
83             Parameter!(double, void, "d0"),
84             Parameter!(double, void, "d1"),
85         )
86     );
87 
88     shouldEqual!(
89         withDefaults.parameters,
90         AliasSeq!(
91             Parameter!(double, void, "fst"),
92             Parameter!(double, 33.3, "snd"),
93         )
94     );
95 }
96 
97 
98 @("parameters.add1.byOverload")
99 @safe pure unittest {
100     alias mod = Module!("modules.functions");
101     alias add1Int = mod.FunctionsByOverload[0];
102     alias add1Double = mod.FunctionsByOverload[1];
103 
104     shouldEqual!(
105         add1Int.parameters,
106         AliasSeq!(
107             Parameter!(int, void, "i"),
108             Parameter!(int, void, "j"),
109         )
110     );
111 
112     shouldEqual!(
113         add1Double.parameters,
114         AliasSeq!(
115             Parameter!(double, void, "d0"),
116             Parameter!(double, void, "d1"),
117         )
118     );
119 }
120 
121 
122 
123 @("return.bySymbol")
124 @safe pure unittest {
125     import std.meta: staticMap;
126 
127     alias mod = Module!("modules.functions");
128     alias functions = mod.FunctionsBySymbol;
129 
130     static assert(is(functions[0].overloads[0].ReturnType == int));
131     static assert(is(functions[0].overloads[1].ReturnType == double));
132     static assert(is(functions[1].overloads[0].ReturnType == double));
133     static assert(is(functions[2].overloads[0].ReturnType == void));
134 }
135 
136 
137 @("return.byOverload")
138 @safe pure unittest {
139     import std.meta: staticMap;
140 
141     alias mod = Module!("modules.functions");
142     alias return_(alias F) = F.ReturnType;
143     alias returnTypes = staticMap!(return_, mod.FunctionsByOverload);
144 
145     shouldEqual!(
146         returnTypes,
147         AliasSeq!(
148             int, double, double, void, void, void, void, int,
149         ),
150     );
151 }