gcc/d/dmd/aliasthis.c

   1
   2 /* Compiler implementation of the D programming language
   3  * Copyright (C) 2009-2018 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 }