|
0
|
1 module dmd.TypeQualified;
|
|
|
2
|
|
114
|
3 import dmd.common;
|
|
0
|
4 import dmd.Type;
|
|
|
5 import dmd.Import;
|
|
73
|
6 import dmd.DsymbolExp;
|
|
0
|
7 import dmd.TypeExp;
|
|
|
8 import dmd.DotIdExp;
|
|
|
9 import dmd.VarDeclaration;
|
|
|
10 import dmd.EnumMember;
|
|
|
11 import dmd.TupleDeclaration;
|
|
|
12 import dmd.Id;
|
|
|
13 import dmd.VarExp;
|
|
|
14 import dmd.TemplateInstance;
|
|
|
15 import dmd.Loc;
|
|
|
16 import dmd.Array;
|
|
|
17 import dmd.TY;
|
|
|
18 import dmd.Identifier;
|
|
|
19 import dmd.OutBuffer;
|
|
|
20 import dmd.HdrGenState;
|
|
|
21 import dmd.Scope;
|
|
|
22 import dmd.Dsymbol;
|
|
|
23 import dmd.DYNCAST;
|
|
|
24 import dmd.Expression;
|
|
135
|
25 import dmd.FuncDeclaration;
|
|
0
|
26 import dmd.Util;
|
|
|
27
|
|
|
28 class TypeQualified : Type
|
|
|
29 {
|
|
|
30 Loc loc;
|
|
|
31 Array idents; // array of Identifier's representing ident.ident.ident etc.
|
|
|
32
|
|
|
33 this(TY ty, Loc loc)
|
|
|
34 {
|
|
178
|
35 register();
|
|
0
|
36 super(ty);
|
|
|
37 this.loc = loc;
|
|
|
38
|
|
|
39 idents = new Array();
|
|
|
40 }
|
|
|
41
|
|
|
42 void syntaxCopyHelper(TypeQualified t)
|
|
|
43 {
|
|
|
44 //printf("TypeQualified::syntaxCopyHelper(%s) %s\n", t->toChars(), toChars());
|
|
|
45 idents.setDim(t.idents.dim);
|
|
|
46 for (int i = 0; i < idents.dim; i++)
|
|
|
47 {
|
|
52
|
48 Object o = cast(Object)t.idents.data[i];
|
|
|
49 if (TemplateInstance ti = cast(TemplateInstance)o)
|
|
0
|
50 {
|
|
52
|
51 o = ti.syntaxCopy(null);
|
|
0
|
52 }
|
|
|
53
|
|
52
|
54 idents.data[i] = cast(void*)o;
|
|
0
|
55 }
|
|
|
56 }
|
|
|
57
|
|
52
|
58 void addIdent(Object ident)
|
|
0
|
59 {
|
|
56
|
60 assert(ident !is null);
|
|
0
|
61 idents.push(cast(void*)ident);
|
|
|
62 }
|
|
|
63
|
|
|
64 void toCBuffer2Helper(OutBuffer buf, HdrGenState* hgs)
|
|
|
65 {
|
|
|
66 int i;
|
|
|
67
|
|
|
68 for (i = 0; i < idents.dim; i++)
|
|
|
69 {
|
|
|
70 Identifier id = cast(Identifier)idents.data[i];
|
|
|
71 buf.writeByte('.');
|
|
|
72
|
|
|
73 if (id.dyncast() == DYNCAST.DYNCAST_DSYMBOL)
|
|
|
74 {
|
|
|
75 TemplateInstance ti = cast(TemplateInstance)id;
|
|
|
76 ti.toCBuffer(buf, hgs);
|
|
|
77 } else {
|
|
|
78 buf.writestring(id.toChars());
|
|
|
79 }
|
|
|
80 }
|
|
|
81 }
|
|
|
82
|
|
72
|
83 override ulong size(Loc loc)
|
|
0
|
84 {
|
|
|
85 assert(false);
|
|
|
86 }
|
|
|
87
|
|
|
88 /*************************************
|
|
|
89 * Takes an array of Identifiers and figures out if
|
|
|
90 * it represents a Type or an Expression.
|
|
|
91 * Output:
|
|
|
92 * if expression, *pe is set
|
|
|
93 * if type, *pt is set
|
|
|
94 */
|
|
|
95 void resolveHelper(Loc loc, Scope sc, Dsymbol s, Dsymbol scopesym, Expression* pe, Type* pt, Dsymbol* ps)
|
|
|
96 {
|
|
|
97 VarDeclaration v;
|
|
135
|
98 FuncDeclaration fd;
|
|
0
|
99 EnumMember em;
|
|
|
100 TupleDeclaration td;
|
|
|
101 Expression e;
|
|
|
102
|
|
|
103 static if (false) {
|
|
|
104 printf("TypeQualified.resolveHelper(sc = %p, idents = '%s')\n", sc, toChars());
|
|
|
105 if (scopesym)
|
|
|
106 printf("\tscopesym = '%s'\n", scopesym.toChars());
|
|
|
107 }
|
|
|
108 *pe = null;
|
|
|
109 *pt = null;
|
|
|
110 *ps = null;
|
|
|
111 if (s)
|
|
|
112 {
|
|
|
113 //printf("\t1: s = '%s' %p, kind = '%s'\n",s.toChars(), s, s.kind());
|
|
|
114 s.checkDeprecated(loc, sc); // check for deprecated aliases
|
|
|
115 s = s.toAlias();
|
|
|
116 //printf("\t2: s = '%s' %p, kind = '%s'\n",s.toChars(), s, s.kind());
|
|
|
117 for (int i = 0; i < idents.dim; i++)
|
|
|
118 {
|
|
56
|
119 Object o = cast(Object)idents.data[i];
|
|
|
120
|
|
|
121 Dsymbol sm = s.searchX(loc, sc, o);
|
|
|
122 Identifier id = cast(Identifier)o;
|
|
0
|
123 //printf("\t3: s = '%s' %p, kind = '%s'\n",s.toChars(), s, s.kind());
|
|
|
124 //printf("\tgetType = '%s'\n", s.getType().toChars());
|
|
|
125 if (!sm)
|
|
|
126 {
|
|
|
127 Type t;
|
|
|
128
|
|
|
129 v = s.isVarDeclaration();
|
|
|
130 if (v && id == Id.length)
|
|
|
131 {
|
|
|
132 e = v.getConstInitializer();
|
|
|
133 if (!e)
|
|
|
134 e = new VarExp(loc, v);
|
|
|
135 t = e.type;
|
|
|
136 if (!t)
|
|
|
137 goto Lerror;
|
|
|
138 goto L3;
|
|
|
139 }
|
|
73
|
140 else if (v && id == Id.stringof_)
|
|
|
141 {
|
|
|
142 e = new DsymbolExp(loc, s, 0);
|
|
|
143 do
|
|
|
144 {
|
|
|
145 id = cast(Identifier)idents.data[i];
|
|
|
146 e = new DotIdExp(loc, e, id);
|
|
|
147 } while (++i < idents.dim);
|
|
|
148 e = e.semantic(sc);
|
|
|
149 *pe = e;
|
|
|
150 return;
|
|
|
151 }
|
|
|
152
|
|
0
|
153 t = s.getType();
|
|
|
154 if (!t && s.isDeclaration())
|
|
|
155 t = s.isDeclaration().type;
|
|
|
156 if (t)
|
|
|
157 {
|
|
|
158 sm = t.toDsymbol(sc);
|
|
|
159 if (sm)
|
|
|
160 { sm = sm.search(loc, id, 0);
|
|
|
161 if (sm)
|
|
|
162 goto L2;
|
|
|
163 }
|
|
|
164 //e = t.getProperty(loc, id);
|
|
|
165 e = new TypeExp(loc, t);
|
|
|
166 e = t.dotExp(sc, e, id);
|
|
|
167 i++;
|
|
|
168 L3:
|
|
|
169 for (; i < idents.dim; i++)
|
|
|
170 {
|
|
|
171 id = cast(Identifier)idents.data[i];
|
|
|
172 //printf("e: '%s', id: '%s', type = %p\n", e.toChars(), id.toChars(), e.type);
|
|
135
|
173 if (id == Id.offsetof || !e.type)
|
|
0
|
174 { e = new DotIdExp(e.loc, e, id);
|
|
|
175 e = e.semantic(sc);
|
|
|
176 }
|
|
|
177 else
|
|
|
178 e = e.type.dotExp(sc, e, id);
|
|
|
179 }
|
|
|
180 *pe = e;
|
|
|
181 }
|
|
|
182 else
|
|
|
183 Lerror:
|
|
|
184 error(loc, "identifier '%s' of '%s' is not defined", id.toChars(), toChars());
|
|
|
185 return;
|
|
|
186 }
|
|
|
187 L2:
|
|
|
188 s = sm.toAlias();
|
|
|
189 }
|
|
|
190
|
|
|
191 v = s.isVarDeclaration();
|
|
|
192 if (v)
|
|
|
193 {
|
|
135
|
194 *pe = new VarExp(loc, v);
|
|
0
|
195 return;
|
|
|
196 }
|
|
135
|
197 //#if 0
|
|
|
198 // fd = s->isFuncDeclaration();
|
|
|
199 // if (fd)
|
|
|
200 // {
|
|
|
201 // *pe = new DsymbolExp(loc, fd, 1);
|
|
|
202 // return;
|
|
|
203 // }
|
|
|
204 //#endif
|
|
0
|
205 em = s.isEnumMember();
|
|
|
206 if (em)
|
|
|
207 {
|
|
|
208 // It's not a type, it's an expression
|
|
|
209 *pe = em.value.copy();
|
|
|
210 return;
|
|
|
211 }
|
|
|
212
|
|
|
213 L1:
|
|
|
214 Type t = s.getType();
|
|
|
215 if (!t)
|
|
|
216 {
|
|
|
217 // If the symbol is an import, try looking inside the import
|
|
|
218 Import si;
|
|
|
219
|
|
|
220 si = s.isImport();
|
|
|
221 if (si)
|
|
|
222 {
|
|
|
223 s = si.search(loc, s.ident, 0);
|
|
|
224 if (s && s != si)
|
|
|
225 goto L1;
|
|
|
226 s = si;
|
|
|
227 }
|
|
|
228 *ps = s;
|
|
|
229 return;
|
|
|
230 }
|
|
|
231 if (t.ty == TY.Tinstance && t != this && !t.deco)
|
|
|
232 {
|
|
|
233 error(loc, "forward reference to '%s'", t.toChars());
|
|
|
234 return;
|
|
|
235 }
|
|
|
236
|
|
|
237 if (t != this)
|
|
|
238 {
|
|
|
239 if (t.reliesOnTident())
|
|
|
240 {
|
|
73
|
241 if (s.scope_)
|
|
|
242 t = t.semantic(loc, s.scope_);
|
|
|
243 else
|
|
0
|
244 {
|
|
73
|
245 /* Attempt to find correct scope in which to evaluate t.
|
|
|
246 * Not sure if this is right or not, or if we should just
|
|
|
247 * give forward reference error if s.scope is not set.
|
|
|
248 */
|
|
|
249 for (Scope scx = sc; 1; scx = scx.enclosing)
|
|
|
250 {
|
|
|
251 if (!scx)
|
|
|
252 {
|
|
|
253 error(loc, "forward reference to '%s'", t.toChars());
|
|
|
254 return;
|
|
|
255 }
|
|
|
256 if (scx.scopesym == scopesym)
|
|
|
257 {
|
|
|
258 t = t.semantic(loc, scx);
|
|
|
259 break;
|
|
|
260 }
|
|
0
|
261 }
|
|
|
262 }
|
|
73
|
263
|
|
0
|
264 }
|
|
|
265 }
|
|
|
266 if (t.ty == TY.Ttuple)
|
|
|
267 *pt = t;
|
|
|
268 else
|
|
|
269 *pt = t.merge();
|
|
|
270 }
|
|
|
271 if (!s)
|
|
|
272 {
|
|
|
273 error(loc, "identifier '%s' is not defined", toChars());
|
|
|
274 }
|
|
|
275 }
|
|
72
|
276 }
|
