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