|
145
|
1
|
|
|
2 /* Compiler implementation of the D programming language
|
|
|
3 * Copyright (C) 2009-2019 by The D Language Foundation, All Rights Reserved
|
|
|
4 * written by Walter Bright
|
|
|
5 * http://www.digitalmars.com
|
|
|
6 * Distributed under the Boost Software License, Version 1.0.
|
|
|
7 * http://www.boost.org/LICENSE_1_0.txt
|
|
|
8 * https://github.com/D-Programming-Language/dmd/blob/master/src/aliasthis.c
|
|
|
9 */
|
|
|
10
|
|
|
11 #include "root/dsystem.h"
|
|
|
12
|
|
|
13 #include "mars.h"
|
|
|
14 #include "identifier.h"
|
|
|
15 #include "aliasthis.h"
|
|
|
16 #include "scope.h"
|
|
|
17 #include "aggregate.h"
|
|
|
18 #include "dsymbol.h"
|
|
|
19 #include "mtype.h"
|
|
|
20 #include "declaration.h"
|
|
|
21 #include "tokens.h"
|
|
|
22
|
|
|
23 Expression *semantic(Expression *e, Scope *sc);
|
|
|
24
|
|
|
25 Expression *resolveAliasThis(Scope *sc, Expression *e, bool gag)
|
|
|
26 {
|
|
|
27 AggregateDeclaration *ad = isAggregate(e->type);
|
|
|
28
|
|
|
29 if (ad && ad->aliasthis)
|
|
|
30 {
|
|
|
31 unsigned olderrors = gag ? global.startGagging() : 0;
|
|
|
32
|
|
|
33 Loc loc = e->loc;
|
|
|
34 Type *tthis = (e->op == TOKtype ? e->type : NULL);
|
|
|
35 e = new DotIdExp(loc, e, ad->aliasthis->ident);
|
|
|
36 e = semantic(e, sc);
|
|
|
37 if (tthis && ad->aliasthis->needThis())
|
|
|
38 {
|
|
|
39 if (e->op == TOKvar)
|
|
|
40 {
|
|
|
41 if (FuncDeclaration *fd = ((VarExp *)e)->var->isFuncDeclaration())
|
|
|
42 {
|
|
|
43 // Bugzilla 13009: Support better match for the overloaded alias this.
|
|
|
44 bool hasOverloads = false;
|
|
|
45 if (FuncDeclaration *f = fd->overloadModMatch(loc, tthis, hasOverloads))
|
|
|
46 {
|
|
|
47 if (!hasOverloads)
|
|
|
48 fd = f; // use exact match
|
|
|
49 e = new VarExp(loc, fd, hasOverloads);
|
|
|
50 e->type = f->type;
|
|
|
51 e = new CallExp(loc, e);
|
|
|
52 goto L1;
|
|
|
53 }
|
|
|
54 }
|
|
|
55 }
|
|
|
56 /* non-@property function is not called inside typeof(),
|
|
|
57 * so resolve it ahead.
|
|
|
58 */
|
|
|
59 {
|
|
|
60 int save = sc->intypeof;
|
|
|
61 sc->intypeof = 1; // bypass "need this" error check
|
|
|
62 e = resolveProperties(sc, e);
|
|
|
63 sc->intypeof = save;
|
|
|
64 }
|
|
|
65
|
|
|
66 L1:
|
|
|
67 e = new TypeExp(loc, new TypeTypeof(loc, e));
|
|
|
68 e = semantic(e, sc);
|
|
|
69 }
|
|
|
70 e = resolveProperties(sc, e);
|
|
|
71
|
|
|
72 if (gag && global.endGagging(olderrors))
|
|
|
73 e = NULL;
|
|
|
74 }
|
|
|
75
|
|
|
76 return e;
|
|
|
77 }
|
|
|
78
|
|
|
79 AliasThis::AliasThis(Loc loc, Identifier *ident)
|
|
|
80 : Dsymbol(NULL) // it's anonymous (no identifier)
|
|
|
81 {
|
|
|
82 this->loc = loc;
|
|
|
83 this->ident = ident;
|
|
|
84 }
|
|
|
85
|
|
|
86 Dsymbol *AliasThis::syntaxCopy(Dsymbol *s)
|
|
|
87 {
|
|
|
88 assert(!s);
|
|
|
89 return new AliasThis(loc, ident);
|
|
|
90 }
|
|
|
91
|
|
|
92 void AliasThis::semantic(Scope *sc)
|
|
|
93 {
|
|
|
94 if (semanticRun != PASSinit)
|
|
|
95 return;
|
|
|
96
|
|
|
97 if (_scope)
|
|
|
98 {
|
|
|
99 sc = _scope;
|
|
|
100 _scope = NULL;
|
|
|
101 }
|
|
|
102
|
|
|
103 if (!sc)
|
|
|
104 return;
|
|
|
105
|
|
|
106 semanticRun = PASSsemantic;
|
|
|
107
|
|
|
108 Dsymbol *p = sc->parent->pastMixin();
|
|
|
109 AggregateDeclaration *ad = p->isAggregateDeclaration();
|
|
|
110 if (!ad)
|
|
|
111 {
|
|
|
112 ::error(loc, "alias this can only be a member of aggregate, not %s %s",
|
|
|
113 p->kind(), p->toChars());
|
|
|
114 return;
|
|
|
115 }
|
|
|
116
|
|
|
117 assert(ad->members);
|
|
|
118 Dsymbol *s = ad->search(loc, ident);
|
|
|
119 if (!s)
|
|
|
120 {
|
|
|
121 s = sc->search(loc, ident, NULL);
|
|
|
122 if (s)
|
|
|
123 ::error(loc, "%s is not a member of %s", s->toChars(), ad->toChars());
|
|
|
124 else
|
|
|
125 ::error(loc, "undefined identifier %s", ident->toChars());
|
|
|
126 return;
|
|
|
127 }
|
|
|
128 else if (ad->aliasthis && s != ad->aliasthis)
|
|
|
129 {
|
|
|
130 ::error(loc, "there can be only one alias this");
|
|
|
131 return;
|
|
|
132 }
|
|
|
133
|
|
|
134 if (ad->type->ty == Tstruct && ((TypeStruct *)ad->type)->sym != ad)
|
|
|
135 {
|
|
|
136 AggregateDeclaration *ad2 = ((TypeStruct *)ad->type)->sym;
|
|
|
137 assert(ad2->type == Type::terror);
|
|
|
138 ad->aliasthis = ad2->aliasthis;
|
|
|
139 return;
|
|
|
140 }
|
|
|
141
|
|
|
142 /* disable the alias this conversion so the implicit conversion check
|
|
|
143 * doesn't use it.
|
|
|
144 */
|
|
|
145 ad->aliasthis = NULL;
|
|
|
146
|
|
|
147 Dsymbol *sx = s;
|
|
|
148 if (sx->isAliasDeclaration())
|
|
|
149 sx = sx->toAlias();
|
|
|
150 Declaration *d = sx->isDeclaration();
|
|
|
151 if (d && !d->isTupleDeclaration())
|
|
|
152 {
|
|
|
153 Type *t = d->type;
|
|
|
154 assert(t);
|
|
|
155 if (ad->type->implicitConvTo(t) > MATCHnomatch)
|
|
|
156 {
|
|
|
157 ::error(loc, "alias this is not reachable as %s already converts to %s", ad->toChars(), t->toChars());
|
|
|
158 }
|
|
|
159 }
|
|
|
160
|
|
|
161 ad->aliasthis = s;
|
|
|
162 semanticRun = PASSsemanticdone;
|
|
|
163 }
|
|
|
164
|
|
|
165 const char *AliasThis::kind() const
|
|
|
166 {
|
|
|
167 return "alias this";
|
|
|
168 }
|
