| |
| /* Compiler implementation of the D programming language |
| * Copyright (C) 1999-2019 by The D Language Foundation, All Rights Reserved |
| * written by Walter Bright |
| * http://www.digitalmars.com |
| * Distributed under the Boost Software License, Version 1.0. |
| * http://www.boost.org/LICENSE_1_0.txt |
| * https://github.com/D-Programming-Language/dmd/blob/master/src/declaration.c |
| */ |
| |
| #include "root/dsystem.h" |
| #include "root/checkedint.h" |
| |
| #include "errors.h" |
| #include "init.h" |
| #include "declaration.h" |
| #include "attrib.h" |
| #include "mtype.h" |
| #include "template.h" |
| #include "scope.h" |
| #include "aggregate.h" |
| #include "module.h" |
| #include "import.h" |
| #include "id.h" |
| #include "expression.h" |
| #include "statement.h" |
| #include "ctfe.h" |
| #include "target.h" |
| #include "hdrgen.h" |
| |
| bool checkNestedRef(Dsymbol *s, Dsymbol *p); |
| VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e); |
| Expression *semantic(Expression *e, Scope *sc); |
| Initializer *inferType(Initializer *init, Scope *sc); |
| Initializer *semantic(Initializer *init, Scope *sc, Type *t, NeedInterpret needInterpret); |
| |
| /************************************ |
| * Check to see the aggregate type is nested and its context pointer is |
| * accessible from the current scope. |
| * Returns true if error occurs. |
| */ |
| bool checkFrameAccess(Loc loc, Scope *sc, AggregateDeclaration *ad, size_t iStart = 0) |
| { |
| Dsymbol *sparent = ad->toParent2(); |
| Dsymbol *s = sc->func; |
| if (ad->isNested() && s) |
| { |
| //printf("ad = %p %s [%s], parent:%p\n", ad, ad->toChars(), ad->loc.toChars(), ad->parent); |
| //printf("sparent = %p %s [%s], parent: %s\n", sparent, sparent->toChars(), sparent->loc.toChars(), sparent->parent->toChars()); |
| if (checkNestedRef(s, sparent)) |
| { |
| error(loc, "cannot access frame pointer of %s", ad->toPrettyChars()); |
| return true; |
| } |
| } |
| |
| bool result = false; |
| for (size_t i = iStart; i < ad->fields.dim; i++) |
| { |
| VarDeclaration *vd = ad->fields[i]; |
| Type *tb = vd->type->baseElemOf(); |
| if (tb->ty == Tstruct) |
| { |
| result |= checkFrameAccess(loc, sc, ((TypeStruct *)tb)->sym); |
| } |
| } |
| return result; |
| } |
| |
| /********************************* Declaration ****************************/ |
| |
| Declaration::Declaration(Identifier *id) |
| : Dsymbol(id) |
| { |
| type = NULL; |
| originalType = NULL; |
| storage_class = STCundefined; |
| protection = Prot(PROTundefined); |
| linkage = LINKdefault; |
| inuse = 0; |
| mangleOverride = NULL; |
| } |
| |
| void Declaration::semantic(Scope *) |
| { |
| } |
| |
| const char *Declaration::kind() const |
| { |
| return "declaration"; |
| } |
| |
| d_uns64 Declaration::size(Loc) |
| { |
| assert(type); |
| return type->size(); |
| } |
| |
| bool Declaration::isDelete() |
| { |
| return false; |
| } |
| |
| bool Declaration::isDataseg() |
| { |
| return false; |
| } |
| |
| bool Declaration::isThreadlocal() |
| { |
| return false; |
| } |
| |
| bool Declaration::isCodeseg() const |
| { |
| return false; |
| } |
| |
| Prot Declaration::prot() |
| { |
| return protection; |
| } |
| |
| /************************************* |
| * Check to see if declaration can be modified in this context (sc). |
| * Issue error if not. |
| */ |
| |
| int Declaration::checkModify(Loc loc, Scope *sc, Type *, Expression *e1, int flag) |
| { |
| VarDeclaration *v = isVarDeclaration(); |
| if (v && v->canassign) |
| return 2; |
| |
| if (isParameter() || isResult()) |
| { |
| for (Scope *scx = sc; scx; scx = scx->enclosing) |
| { |
| if (scx->func == parent && (scx->flags & SCOPEcontract)) |
| { |
| const char *s = isParameter() && parent->ident != Id::ensure ? "parameter" : "result"; |
| if (!flag) error(loc, "cannot modify %s '%s' in contract", s, toChars()); |
| return 2; // do not report type related errors |
| } |
| } |
| } |
| |
| if (v && (isCtorinit() || isField())) |
| { |
| // It's only modifiable if inside the right constructor |
| if ((storage_class & (STCforeach | STCref)) == (STCforeach | STCref)) |
| return 2; |
| return modifyFieldVar(loc, sc, v, e1) ? 2 : 1; |
| } |
| return 1; |
| } |
| |
| Dsymbol *Declaration::search(const Loc &loc, Identifier *ident, int flags) |
| { |
| Dsymbol *s = Dsymbol::search(loc, ident, flags); |
| if (!s && type) |
| { |
| s = type->toDsymbol(_scope); |
| if (s) |
| s = s->search(loc, ident, flags); |
| } |
| return s; |
| } |
| |
| |
| /********************************* TupleDeclaration ****************************/ |
| |
| TupleDeclaration::TupleDeclaration(Loc loc, Identifier *id, Objects *objects) |
| : Declaration(id) |
| { |
| this->loc = loc; |
| this->type = NULL; |
| this->objects = objects; |
| this->isexp = false; |
| this->tupletype = NULL; |
| } |
| |
| Dsymbol *TupleDeclaration::syntaxCopy(Dsymbol *) |
| { |
| assert(0); |
| return NULL; |
| } |
| |
| const char *TupleDeclaration::kind() const |
| { |
| return "tuple"; |
| } |
| |
| Type *TupleDeclaration::getType() |
| { |
| /* If this tuple represents a type, return that type |
| */ |
| |
| //printf("TupleDeclaration::getType() %s\n", toChars()); |
| if (isexp) |
| return NULL; |
| if (!tupletype) |
| { |
| /* It's only a type tuple if all the Object's are types |
| */ |
| for (size_t i = 0; i < objects->dim; i++) |
| { |
| RootObject *o = (*objects)[i]; |
| if (o->dyncast() != DYNCAST_TYPE) |
| { |
| //printf("\tnot[%d], %p, %d\n", i, o, o->dyncast()); |
| return NULL; |
| } |
| } |
| |
| /* We know it's a type tuple, so build the TypeTuple |
| */ |
| Types *types = (Types *)objects; |
| Parameters *args = new Parameters(); |
| args->setDim(objects->dim); |
| OutBuffer buf; |
| int hasdeco = 1; |
| for (size_t i = 0; i < types->dim; i++) |
| { |
| Type *t = (*types)[i]; |
| //printf("type = %s\n", t->toChars()); |
| Parameter *arg = new Parameter(0, t, NULL, NULL); |
| (*args)[i] = arg; |
| if (!t->deco) |
| hasdeco = 0; |
| } |
| |
| tupletype = new TypeTuple(args); |
| if (hasdeco) |
| return tupletype->semantic(Loc(), NULL); |
| } |
| |
| return tupletype; |
| } |
| |
| Dsymbol *TupleDeclaration::toAlias2() |
| { |
| //printf("TupleDeclaration::toAlias2() '%s' objects = %s\n", toChars(), objects->toChars()); |
| |
| for (size_t i = 0; i < objects->dim; i++) |
| { |
| RootObject *o = (*objects)[i]; |
| if (Dsymbol *s = isDsymbol(o)) |
| { |
| s = s->toAlias2(); |
| (*objects)[i] = s; |
| } |
| } |
| return this; |
| } |
| |
| bool TupleDeclaration::needThis() |
| { |
| //printf("TupleDeclaration::needThis(%s)\n", toChars()); |
| for (size_t i = 0; i < objects->dim; i++) |
| { |
| RootObject *o = (*objects)[i]; |
| if (o->dyncast() == DYNCAST_EXPRESSION) |
| { |
| Expression *e = (Expression *)o; |
| if (e->op == TOKdsymbol) |
| { |
| DsymbolExp *ve = (DsymbolExp *)e; |
| Declaration *d = ve->s->isDeclaration(); |
| if (d && d->needThis()) |
| { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| /********************************* AliasDeclaration ****************************/ |
| |
| AliasDeclaration::AliasDeclaration(Loc loc, Identifier *id, Type *type) |
| : Declaration(id) |
| { |
| //printf("AliasDeclaration(id = '%s', type = %p)\n", id->toChars(), type); |
| //printf("type = '%s'\n", type->toChars()); |
| this->loc = loc; |
| this->type = type; |
| this->aliassym = NULL; |
| this->_import = NULL; |
| this->overnext = NULL; |
| assert(type); |
| } |
| |
| AliasDeclaration::AliasDeclaration(Loc loc, Identifier *id, Dsymbol *s) |
| : Declaration(id) |
| { |
| //printf("AliasDeclaration(id = '%s', s = %p)\n", id->toChars(), s); |
| assert(s != this); |
| this->loc = loc; |
| this->type = NULL; |
| this->aliassym = s; |
| this->_import = NULL; |
| this->overnext = NULL; |
| assert(s); |
| } |
| |
| AliasDeclaration *AliasDeclaration::create(Loc loc, Identifier *id, Type *type) |
| { |
| return new AliasDeclaration(loc, id, type); |
| } |
| |
| Dsymbol *AliasDeclaration::syntaxCopy(Dsymbol *s) |
| { |
| //printf("AliasDeclaration::syntaxCopy()\n"); |
| assert(!s); |
| AliasDeclaration *sa = |
| type ? new AliasDeclaration(loc, ident, type->syntaxCopy()) |
| : new AliasDeclaration(loc, ident, aliassym->syntaxCopy(NULL)); |
| sa->storage_class = storage_class; |
| return sa; |
| } |
| |
| void AliasDeclaration::semantic(Scope *sc) |
| { |
| if (semanticRun >= PASSsemanticdone) |
| return; |
| assert(semanticRun <= PASSsemantic); |
| |
| storage_class |= sc->stc & STCdeprecated; |
| protection = sc->protection; |
| userAttribDecl = sc->userAttribDecl; |
| |
| if (!sc->func && inNonRoot()) |
| return; |
| |
| aliasSemantic(sc); |
| } |
| |
| void AliasDeclaration::aliasSemantic(Scope *sc) |
| { |
| //printf("AliasDeclaration::semantic() %s\n", toChars()); |
| |
| // as AliasDeclaration::semantic, in case we're called first. |
| // see https://issues.dlang.org/show_bug.cgi?id=21001 |
| storage_class |= sc->stc & STCdeprecated; |
| protection = sc->protection; |
| userAttribDecl = sc->userAttribDecl; |
| |
| if (aliassym) |
| { |
| FuncDeclaration *fd = aliassym->isFuncLiteralDeclaration(); |
| TemplateDeclaration *td = aliassym->isTemplateDeclaration(); |
| if (fd || (td && td->literal)) |
| { |
| if (fd && fd->semanticRun >= PASSsemanticdone) |
| return; |
| |
| Expression *e = new FuncExp(loc, aliassym); |
| e = ::semantic(e, sc); |
| if (e->op == TOKfunction) |
| { |
| FuncExp *fe = (FuncExp *)e; |
| aliassym = fe->td ? (Dsymbol *)fe->td : fe->fd; |
| } |
| else |
| { |
| aliassym = NULL; |
| type = Type::terror; |
| } |
| return; |
| } |
| |
| if (aliassym->isTemplateInstance()) |
| aliassym->semantic(sc); |
| return; |
| } |
| inuse = 1; |
| |
| // Given: |
| // alias foo.bar.abc def; |
| // it is not knowable from the syntax whether this is an alias |
| // for a type or an alias for a symbol. It is up to the semantic() |
| // pass to distinguish. |
| // If it is a type, then type is set and getType() will return that |
| // type. If it is a symbol, then aliassym is set and type is NULL - |
| // toAlias() will return aliasssym. |
| |
| unsigned int errors = global.errors; |
| Type *oldtype = type; |
| |
| // Ungag errors when not instantiated DeclDefs scope alias |
| Ungag ungag(global.gag); |
| //printf("%s parent = %s, gag = %d, instantiated = %d\n", toChars(), parent, global.gag, isInstantiated()); |
| if (parent && global.gag && !isInstantiated() && !toParent2()->isFuncDeclaration()) |
| { |
| //printf("%s type = %s\n", toPrettyChars(), type->toChars()); |
| global.gag = 0; |
| } |
| |
| /* This section is needed because Type::resolve() will: |
| * const x = 3; |
| * alias y = x; |
| * try to convert identifier x to 3. |
| */ |
| Dsymbol *s = type->toDsymbol(sc); |
| if (errors != global.errors) |
| { |
| s = NULL; |
| type = Type::terror; |
| } |
| if (s && s == this) |
| { |
| error("cannot resolve"); |
| s = NULL; |
| type = Type::terror; |
| } |
| if (!s || !s->isEnumMember()) |
| { |
| Type *t; |
| Expression *e; |
| Scope *sc2 = sc; |
| if (storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCdisable)) |
| { |
| // For 'ref' to be attached to function types, and picked |
| // up by Type::resolve(), it has to go into sc. |
| sc2 = sc->push(); |
| sc2->stc |= storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCshared | STCdisable); |
| } |
| type = type->addSTC(storage_class); |
| type->resolve(loc, sc2, &e, &t, &s); |
| if (sc2 != sc) |
| sc2->pop(); |
| |
| if (e) // Try to convert Expression to Dsymbol |
| { |
| s = getDsymbol(e); |
| if (!s) |
| { |
| if (e->op != TOKerror) |
| error("cannot alias an expression %s", e->toChars()); |
| t = Type::terror; |
| } |
| } |
| type = t; |
| } |
| if (s == this) |
| { |
| assert(global.errors); |
| type = Type::terror; |
| s = NULL; |
| } |
| if (!s) // it's a type alias |
| { |
| //printf("alias %s resolved to type %s\n", toChars(), type->toChars()); |
| type = type->semantic(loc, sc); |
| aliassym = NULL; |
| } |
| else // it's a symbolic alias |
| { |
| //printf("alias %s resolved to %s %s\n", toChars(), s->kind(), s->toChars()); |
| type = NULL; |
| aliassym = s; |
| } |
| if (global.gag && errors != global.errors) |
| { |
| type = oldtype; |
| aliassym = NULL; |
| } |
| inuse = 0; |
| semanticRun = PASSsemanticdone; |
| |
| if (Dsymbol *sx = overnext) |
| { |
| overnext = NULL; |
| |
| if (!overloadInsert(sx)) |
| ScopeDsymbol::multiplyDefined(Loc(), sx, this); |
| } |
| } |
| |
| bool AliasDeclaration::overloadInsert(Dsymbol *s) |
| { |
| //printf("[%s] AliasDeclaration::overloadInsert('%s') s = %s %s @ [%s]\n", |
| // loc.toChars(), toChars(), s->kind(), s->toChars(), s->loc.toChars()); |
| |
| /** Aliases aren't overloadable themselves, but if their Aliasee is |
| * overloadable they are converted to an overloadable Alias (either |
| * FuncAliasDeclaration or OverDeclaration). |
| * |
| * This is done by moving the Aliasee into such an overloadable alias |
| * which is then used to replace the existing Aliasee. The original |
| * Alias (_this_) remains a useless shell. |
| * |
| * This is a horrible mess. It was probably done to avoid replacing |
| * existing AST nodes and references, but it needs a major |
| * simplification b/c it's too complex to maintain. |
| * |
| * A simpler approach might be to merge any colliding symbols into a |
| * simple Overload class (an array) and then later have that resolve |
| * all collisions. |
| */ |
| if (semanticRun >= PASSsemanticdone) |
| { |
| /* Semantic analysis is already finished, and the aliased entity |
| * is not overloadable. |
| */ |
| if (type) |
| return false; |
| |
| /* When s is added in member scope by static if, mixin("code") or others, |
| * aliassym is determined already. See the case in: test/compilable/test61.d |
| */ |
| Dsymbol *sa = aliassym->toAlias(); |
| if (FuncDeclaration *fd = sa->isFuncDeclaration()) |
| { |
| FuncAliasDeclaration *fa = new FuncAliasDeclaration(ident, fd); |
| fa->protection = protection; |
| fa->parent = parent; |
| aliassym = fa; |
| return aliassym->overloadInsert(s); |
| } |
| if (TemplateDeclaration *td = sa->isTemplateDeclaration()) |
| { |
| OverDeclaration *od = new OverDeclaration(ident, td); |
| od->protection = protection; |
| od->parent = parent; |
| aliassym = od; |
| return aliassym->overloadInsert(s); |
| } |
| if (OverDeclaration *od = sa->isOverDeclaration()) |
| { |
| if (sa->ident != ident || sa->parent != parent) |
| { |
| od = new OverDeclaration(ident, od); |
| od->protection = protection; |
| od->parent = parent; |
| aliassym = od; |
| } |
| return od->overloadInsert(s); |
| } |
| if (OverloadSet *os = sa->isOverloadSet()) |
| { |
| if (sa->ident != ident || sa->parent != parent) |
| { |
| os = new OverloadSet(ident, os); |
| // TODO: protection is lost here b/c OverloadSets have no protection attribute |
| // Might no be a practical issue, b/c the code below fails to resolve the overload anyhow. |
| // ---- |
| // module os1; |
| // import a, b; |
| // private alias merged = foo; // private alias to overload set of a.foo and b.foo |
| // ---- |
| // module os2; |
| // import a, b; |
| // public alias merged = bar; // public alias to overload set of a.bar and b.bar |
| // ---- |
| // module bug; |
| // import os1, os2; |
| // void test() { merged(123); } // should only look at os2.merged |
| // |
| // os.protection = protection; |
| os->parent = parent; |
| aliassym = os; |
| } |
| os->push(s); |
| return true; |
| } |
| return false; |
| } |
| |
| /* Don't know yet what the aliased symbol is, so assume it can |
| * be overloaded and check later for correctness. |
| */ |
| if (overnext) |
| return overnext->overloadInsert(s); |
| if (s == this) |
| return true; |
| overnext = s; |
| return true; |
| } |
| |
| const char *AliasDeclaration::kind() const |
| { |
| return "alias"; |
| } |
| |
| Type *AliasDeclaration::getType() |
| { |
| if (type) |
| return type; |
| return toAlias()->getType(); |
| } |
| |
| Dsymbol *AliasDeclaration::toAlias() |
| { |
| //printf("[%s] AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s', inuse = %d)\n", |
| // loc.toChars(), toChars(), this, aliassym, aliassym ? aliassym->kind() : "", inuse); |
| assert(this != aliassym); |
| //static int count; if (++count == 10) *(char*)0=0; |
| if (inuse == 1 && type && _scope) |
| { |
| inuse = 2; |
| unsigned olderrors = global.errors; |
| Dsymbol *s = type->toDsymbol(_scope); |
| //printf("[%s] type = %s, s = %p, this = %p\n", loc.toChars(), type->toChars(), s, this); |
| if (global.errors != olderrors) |
| goto Lerr; |
| if (s) |
| { |
| s = s->toAlias(); |
| if (global.errors != olderrors) |
| goto Lerr; |
| aliassym = s; |
| inuse = 0; |
| } |
| else |
| { |
| Type *t = type->semantic(loc, _scope); |
| if (t->ty == Terror) |
| goto Lerr; |
| if (global.errors != olderrors) |
| goto Lerr; |
| //printf("t = %s\n", t->toChars()); |
| inuse = 0; |
| } |
| } |
| if (inuse) |
| { |
| error("recursive alias declaration"); |
| |
| Lerr: |
| // Avoid breaking "recursive alias" state during errors gagged |
| if (global.gag) |
| return this; |
| |
| aliassym = new AliasDeclaration(loc, ident, Type::terror); |
| type = Type::terror; |
| return aliassym; |
| } |
| |
| if (semanticRun >= PASSsemanticdone) |
| { |
| // semantic is already done. |
| |
| // Do not see aliassym !is null, because of lambda aliases. |
| |
| // Do not see type.deco !is null, even so "alias T = const int;` needs |
| // semantic analysis to take the storage class `const` as type qualifier. |
| } |
| else |
| { |
| if (_import && _import->_scope) |
| { |
| /* If this is an internal alias for selective/renamed import, |
| * load the module first. |
| */ |
| _import->semantic(NULL); |
| } |
| if (_scope) |
| { |
| aliasSemantic(_scope); |
| } |
| } |
| |
| inuse = 1; |
| Dsymbol *s = aliassym ? aliassym->toAlias() : this; |
| inuse = 0; |
| return s; |
| } |
| |
| Dsymbol *AliasDeclaration::toAlias2() |
| { |
| if (inuse) |
| { |
| error("recursive alias declaration"); |
| return this; |
| } |
| inuse = 1; |
| Dsymbol *s = aliassym ? aliassym->toAlias2() : this; |
| inuse = 0; |
| return s; |
| } |
| |
| bool AliasDeclaration::isOverloadable() |
| { |
| // assume overloadable until alias is resolved |
| return semanticRun < PASSsemanticdone || |
| (aliassym && aliassym->isOverloadable()); |
| } |
| |
| /****************************** OverDeclaration **************************/ |
| |
| OverDeclaration::OverDeclaration(Identifier *ident, Dsymbol *s, bool hasOverloads) |
| : Declaration(ident) |
| { |
| this->overnext = NULL; |
| this->aliassym = s; |
| |
| this->hasOverloads = hasOverloads; |
| if (hasOverloads) |
| { |
| if (OverDeclaration *od = aliassym->isOverDeclaration()) |
| this->hasOverloads = od->hasOverloads; |
| } |
| else |
| { |
| // for internal use |
| assert(!aliassym->isOverDeclaration()); |
| } |
| } |
| |
| const char *OverDeclaration::kind() const |
| { |
| return "overload alias"; // todo |
| } |
| |
| void OverDeclaration::semantic(Scope *) |
| { |
| } |
| |
| bool OverDeclaration::equals(RootObject *o) |
| { |
| if (this == o) |
| return true; |
| |
| Dsymbol *s = isDsymbol(o); |
| if (!s) |
| return false; |
| |
| OverDeclaration *od1 = this; |
| if (OverDeclaration *od2 = s->isOverDeclaration()) |
| { |
| return od1->aliassym->equals(od2->aliassym) && |
| od1->hasOverloads == od2->hasOverloads; |
| } |
| if (aliassym == s) |
| { |
| if (hasOverloads) |
| return true; |
| if (FuncDeclaration *fd = s->isFuncDeclaration()) |
| { |
| return fd->isUnique() != NULL; |
| } |
| if (TemplateDeclaration *td = s->isTemplateDeclaration()) |
| { |
| return td->overnext == NULL; |
| } |
| } |
| return false; |
| } |
| |
| bool OverDeclaration::overloadInsert(Dsymbol *s) |
| { |
| //printf("OverDeclaration::overloadInsert('%s') aliassym = %p, overnext = %p\n", s->toChars(), aliassym, overnext); |
| if (overnext) |
| return overnext->overloadInsert(s); |
| if (s == this) |
| return true; |
| overnext = s; |
| return true; |
| } |
| |
| Dsymbol *OverDeclaration::toAlias() |
| { |
| return this; |
| } |
| |
| bool OverDeclaration::isOverloadable() |
| { |
| return true; |
| } |
| |
| Dsymbol *OverDeclaration::isUnique() |
| { |
| if (!hasOverloads) |
| { |
| if (aliassym->isFuncDeclaration() || |
| aliassym->isTemplateDeclaration()) |
| { |
| return aliassym; |
| } |
| } |
| |
| struct ParamUniqueSym |
| { |
| static int fp(void *param, Dsymbol *s) |
| { |
| Dsymbol **ps = (Dsymbol **)param; |
| if (*ps) |
| { |
| *ps = NULL; |
| return 1; // ambiguous, done |
| } |
| else |
| { |
| *ps = s; |
| return 0; |
| } |
| } |
| }; |
| Dsymbol *result = NULL; |
| overloadApply(aliassym, &result, &ParamUniqueSym::fp); |
| return result; |
| } |
| |
| /********************************* VarDeclaration ****************************/ |
| |
| VarDeclaration::VarDeclaration(Loc loc, Type *type, Identifier *id, Initializer *init) |
| : Declaration(id) |
| { |
| //printf("VarDeclaration('%s')\n", id->toChars()); |
| assert(id); |
| assert(type || init); |
| this->type = type; |
| this->_init = init; |
| this->loc = loc; |
| offset = 0; |
| isargptr = false; |
| alignment = 0; |
| ctorinit = 0; |
| aliassym = NULL; |
| onstack = false; |
| mynew = false; |
| canassign = 0; |
| overlapped = false; |
| overlapUnsafe = false; |
| doNotInferScope = false; |
| isdataseg = 0; |
| lastVar = NULL; |
| endlinnum = 0; |
| ctfeAdrOnStack = -1; |
| edtor = NULL; |
| range = NULL; |
| |
| static unsigned nextSequenceNumber = 0; |
| this->sequenceNumber = ++nextSequenceNumber; |
| } |
| |
| Dsymbol *VarDeclaration::syntaxCopy(Dsymbol *s) |
| { |
| //printf("VarDeclaration::syntaxCopy(%s)\n", toChars()); |
| assert(!s); |
| VarDeclaration *v = new VarDeclaration(loc, |
| type ? type->syntaxCopy() : NULL, |
| ident, |
| _init ? _init->syntaxCopy() : NULL); |
| v->storage_class = storage_class; |
| return v; |
| } |
| |
| |
| void VarDeclaration::semantic(Scope *sc) |
| { |
| // if (semanticRun > PASSinit) |
| // return; |
| // semanticRun = PASSsemantic; |
| |
| if (semanticRun >= PASSsemanticdone) |
| return; |
| |
| Scope *scx = NULL; |
| if (_scope) |
| { |
| sc = _scope; |
| scx = sc; |
| _scope = NULL; |
| } |
| |
| /* Pick up storage classes from context, but except synchronized, |
| * override, abstract, and final. |
| */ |
| storage_class |= (sc->stc & ~(STCsynchronized | STCoverride | STCabstract | STCfinal)); |
| if (storage_class & STCextern && _init) |
| error("extern symbols cannot have initializers"); |
| |
| userAttribDecl = sc->userAttribDecl; |
| |
| AggregateDeclaration *ad = isThis(); |
| if (ad) |
| storage_class |= ad->storage_class & STC_TYPECTOR; |
| |
| /* If auto type inference, do the inference |
| */ |
| int inferred = 0; |
| if (!type) |
| { |
| inuse++; |
| |
| // Infering the type requires running semantic, |
| // so mark the scope as ctfe if required |
| bool needctfe = (storage_class & (STCmanifest | STCstatic)) != 0; |
| if (needctfe) sc = sc->startCTFE(); |
| |
| //printf("inferring type for %s with init %s\n", toChars(), _init->toChars()); |
| _init = inferType(_init, sc); |
| type = initializerToExpression(_init)->type; |
| |
| if (needctfe) sc = sc->endCTFE(); |
| |
| inuse--; |
| inferred = 1; |
| |
| /* This is a kludge to support the existing syntax for RAII |
| * declarations. |
| */ |
| storage_class &= ~STCauto; |
| originalType = type->syntaxCopy(); |
| } |
| else |
| { |
| if (!originalType) |
| originalType = type->syntaxCopy(); |
| |
| /* Prefix function attributes of variable declaration can affect |
| * its type: |
| * pure nothrow void function() fp; |
| * static assert(is(typeof(fp) == void function() pure nothrow)); |
| */ |
| Scope *sc2 = sc->push(); |
| sc2->stc |= (storage_class & STC_FUNCATTR); |
| inuse++; |
| type = type->semantic(loc, sc2); |
| inuse--; |
| sc2->pop(); |
| } |
| //printf(" semantic type = %s\n", type ? type->toChars() : "null"); |
| if (type->ty == Terror) |
| errors = true; |
| |
| type->checkDeprecated(loc, sc); |
| linkage = sc->linkage; |
| this->parent = sc->parent; |
| //printf("this = %p, parent = %p, '%s'\n", this, parent, parent->toChars()); |
| protection = sc->protection; |
| |
| /* If scope's alignment is the default, use the type's alignment, |
| * otherwise the scope overrrides. |
| */ |
| alignment = sc->alignment(); |
| if (alignment == STRUCTALIGN_DEFAULT) |
| alignment = type->alignment(); // use type's alignment |
| |
| //printf("sc->stc = %x\n", sc->stc); |
| //printf("storage_class = x%x\n", storage_class); |
| |
| if (global.params.vcomplex) |
| type->checkComplexTransition(loc); |
| |
| // Calculate type size + safety checks |
| if (sc->func && !sc->intypeof) |
| { |
| if ((storage_class & STCgshared) && !isMember()) |
| { |
| if (sc->func->setUnsafe()) |
| error("__gshared not allowed in safe functions; use shared"); |
| } |
| } |
| |
| Dsymbol *parent = toParent(); |
| |
| Type *tb = type->toBasetype(); |
| Type *tbn = tb->baseElemOf(); |
| if (tb->ty == Tvoid && !(storage_class & STClazy)) |
| { |
| if (inferred) |
| { |
| error("type %s is inferred from initializer %s, and variables cannot be of type void", |
| type->toChars(), _init->toChars()); |
| } |
| else |
| error("variables cannot be of type void"); |
| type = Type::terror; |
| tb = type; |
| } |
| if (tb->ty == Tfunction) |
| { |
| error("cannot be declared to be a function"); |
| type = Type::terror; |
| tb = type; |
| } |
| if (tb->ty == Tstruct) |
| { |
| TypeStruct *ts = (TypeStruct *)tb; |
| if (!ts->sym->members) |
| { |
| error("no definition of struct %s", ts->toChars()); |
| } |
| } |
| if ((storage_class & STCauto) && !inferred) |
| error("storage class 'auto' has no effect if type is not inferred, did you mean 'scope'?"); |
| |
| if (tb->ty == Ttuple) |
| { |
| /* Instead, declare variables for each of the tuple elements |
| * and add those. |
| */ |
| TypeTuple *tt = (TypeTuple *)tb; |
| size_t nelems = Parameter::dim(tt->arguments); |
| Expression *ie = (_init && !_init->isVoidInitializer()) ? initializerToExpression(_init) : NULL; |
| if (ie) |
| ie = ::semantic(ie, sc); |
| |
| if (nelems > 0 && ie) |
| { |
| Expressions *iexps = new Expressions(); |
| iexps->push(ie); |
| |
| Expressions *exps = new Expressions(); |
| |
| for (size_t pos = 0; pos < iexps->dim; pos++) |
| { |
| Lexpand1: |
| Expression *e = (*iexps)[pos]; |
| Parameter *arg = Parameter::getNth(tt->arguments, pos); |
| arg->type = arg->type->semantic(loc, sc); |
| //printf("[%d] iexps->dim = %d, ", pos, iexps->dim); |
| //printf("e = (%s %s, %s), ", Token::tochars[e->op], e->toChars(), e->type->toChars()); |
| //printf("arg = (%s, %s)\n", arg->toChars(), arg->type->toChars()); |
| |
| if (e != ie) |
| { |
| if (iexps->dim > nelems) |
| goto Lnomatch; |
| if (e->type->implicitConvTo(arg->type)) |
| continue; |
| } |
| |
| if (e->op == TOKtuple) |
| { |
| TupleExp *te = (TupleExp *)e; |
| if (iexps->dim - 1 + te->exps->dim > nelems) |
| goto Lnomatch; |
| |
| iexps->remove(pos); |
| iexps->insert(pos, te->exps); |
| (*iexps)[pos] = Expression::combine(te->e0, (*iexps)[pos]); |
| goto Lexpand1; |
| } |
| else if (isAliasThisTuple(e)) |
| { |
| VarDeclaration *v = copyToTemp(0, "__tup", e); |
| VarExp *ve = new VarExp(loc, v); |
| ve->type = e->type; |
| |
| exps->setDim(1); |
| (*exps)[0] = ve; |
| expandAliasThisTuples(exps, 0); |
| |
| for (size_t u = 0; u < exps->dim ; u++) |
| { |
| Lexpand2: |
| Expression *ee = (*exps)[u]; |
| arg = Parameter::getNth(tt->arguments, pos + u); |
| arg->type = arg->type->semantic(loc, sc); |
| //printf("[%d+%d] exps->dim = %d, ", pos, u, exps->dim); |
| //printf("ee = (%s %s, %s), ", Token::tochars[ee->op], ee->toChars(), ee->type->toChars()); |
| //printf("arg = (%s, %s)\n", arg->toChars(), arg->type->toChars()); |
| |
| size_t iexps_dim = iexps->dim - 1 + exps->dim; |
| if (iexps_dim > nelems) |
| goto Lnomatch; |
| if (ee->type->implicitConvTo(arg->type)) |
| continue; |
| |
| if (expandAliasThisTuples(exps, u) != -1) |
| goto Lexpand2; |
| } |
| |
| if ((*exps)[0] != ve) |
| { |
| Expression *e0 = (*exps)[0]; |
| (*exps)[0] = new CommaExp(loc, new DeclarationExp(loc, v), e0); |
| (*exps)[0]->type = e0->type; |
| |
| iexps->remove(pos); |
| iexps->insert(pos, exps); |
| goto Lexpand1; |
| } |
| } |
| } |
| if (iexps->dim < nelems) |
| goto Lnomatch; |
| |
| ie = new TupleExp(_init->loc, iexps); |
| } |
| Lnomatch: |
| |
| if (ie && ie->op == TOKtuple) |
| { |
| TupleExp *te = (TupleExp *)ie; |
| size_t tedim = te->exps->dim; |
| if (tedim != nelems) |
| { |
| ::error(loc, "tuple of %d elements cannot be assigned to tuple of %d elements", (int)tedim, (int)nelems); |
| for (size_t u = tedim; u < nelems; u++) // fill dummy expression |
| te->exps->push(new ErrorExp()); |
| } |
| } |
| |
| Objects *exps = new Objects(); |
| exps->setDim(nelems); |
| for (size_t i = 0; i < nelems; i++) |
| { |
| Parameter *arg = Parameter::getNth(tt->arguments, i); |
| |
| OutBuffer buf; |
| buf.printf("__%s_field_%llu", ident->toChars(), (ulonglong)i); |
| const char *name = buf.extractString(); |
| Identifier *id = Identifier::idPool(name); |
| |
| Initializer *ti; |
| if (ie) |
| { |
| Expression *einit = ie; |
| if (ie->op == TOKtuple) |
| { |
| TupleExp *te = (TupleExp *)ie; |
| einit = (*te->exps)[i]; |
| if (i == 0) |
| einit = Expression::combine(te->e0, einit); |
| } |
| ti = new ExpInitializer(einit->loc, einit); |
| } |
| else |
| ti = _init ? _init->syntaxCopy() : NULL; |
| |
| VarDeclaration *v = new VarDeclaration(loc, arg->type, id, ti); |
| v->storage_class |= STCtemp | storage_class; |
| if (arg->storageClass & STCparameter) |
| v->storage_class |= arg->storageClass; |
| //printf("declaring field %s of type %s\n", v->toChars(), v->type->toChars()); |
| v->semantic(sc); |
| |
| if (sc->scopesym) |
| { |
| //printf("adding %s to %s\n", v->toChars(), sc->scopesym->toChars()); |
| if (sc->scopesym->members) |
| sc->scopesym->members->push(v); |
| } |
| |
| Expression *e = new DsymbolExp(loc, v); |
| (*exps)[i] = e; |
| } |
| TupleDeclaration *v2 = new TupleDeclaration(loc, ident, exps); |
| v2->parent = this->parent; |
| v2->isexp = true; |
| aliassym = v2; |
| semanticRun = PASSsemanticdone; |
| return; |
| } |
| |
| /* Storage class can modify the type |
| */ |
| type = type->addStorageClass(storage_class); |
| |
| /* Adjust storage class to reflect type |
| */ |
| if (type->isConst()) |
| { |
| storage_class |= STCconst; |
| if (type->isShared()) |
| storage_class |= STCshared; |
| } |
| else if (type->isImmutable()) |
| storage_class |= STCimmutable; |
| else if (type->isShared()) |
| storage_class |= STCshared; |
| else if (type->isWild()) |
| storage_class |= STCwild; |
| |
| if (StorageClass stc = storage_class & (STCsynchronized | STCoverride | STCabstract | STCfinal)) |
| { |
| if (stc == STCfinal) |
| error("cannot be final, perhaps you meant const?"); |
| else |
| { |
| OutBuffer buf; |
| stcToBuffer(&buf, stc); |
| error("cannot be %s", buf.peekString()); |
| } |
| storage_class &= ~stc; // strip off |
| } |
| |
| if (storage_class & STCscope) |
| { |
| StorageClass stc = storage_class & (STCstatic | STCextern | STCmanifest | STCtls | STCgshared); |
| if (stc) |
| { |
| OutBuffer buf; |
| stcToBuffer(&buf, stc); |
| error("cannot be 'scope' and '%s'", buf.peekString()); |
| } |
| else if (isMember()) |
| { |
| error("field cannot be 'scope'"); |
| } |
| else if (!type->hasPointers()) |
| { |
| storage_class &= ~STCscope; // silently ignore; may occur in generic code |
| } |
| } |
| |
| if (storage_class & (STCstatic | STCextern | STCmanifest | STCtemplateparameter | STCtls | STCgshared | STCctfe)) |
| { |
| } |
| else |
| { |
| AggregateDeclaration *aad = parent->isAggregateDeclaration(); |
| if (aad) |
| { |
| if (global.params.vfield && |
| storage_class & (STCconst | STCimmutable) && _init && !_init->isVoidInitializer()) |
| { |
| const char *s = (storage_class & STCimmutable) ? "immutable" : "const"; |
| message(loc, "`%s.%s` is `%s` field", ad->toPrettyChars(), toChars(), s); |
| } |
| storage_class |= STCfield; |
| if (tbn->ty == Tstruct && ((TypeStruct *)tbn)->sym->noDefaultCtor) |
| { |
| if (!isThisDeclaration() && !_init) |
| aad->noDefaultCtor = true; |
| } |
| } |
| |
| InterfaceDeclaration *id = parent->isInterfaceDeclaration(); |
| if (id) |
| { |
| error("field not allowed in interface"); |
| } |
| else if (aad && aad->sizeok == SIZEOKdone) |
| { |
| error("cannot be further field because it will change the determined %s size", aad->toChars()); |
| } |
| |
| /* Templates cannot add fields to aggregates |
| */ |
| TemplateInstance *ti = parent->isTemplateInstance(); |
| if (ti) |
| { |
| // Take care of nested templates |
| while (1) |
| { |
| TemplateInstance *ti2 = ti->tempdecl->parent->isTemplateInstance(); |
| if (!ti2) |
| break; |
| ti = ti2; |
| } |
| |
| // If it's a member template |
| AggregateDeclaration *ad2 = ti->tempdecl->isMember(); |
| if (ad2 && storage_class != STCundefined) |
| { |
| error("cannot use template to add field to aggregate '%s'", ad2->toChars()); |
| } |
| } |
| } |
| |
| if ((storage_class & (STCref | STCparameter | STCforeach | STCtemp | STCresult)) == STCref && ident != Id::This) |
| { |
| error("only parameters or foreach declarations can be ref"); |
| } |
| |
| if (type->hasWild()) |
| { |
| if (storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCfield) || |
| isDataseg() |
| ) |
| { |
| error("only parameters or stack based variables can be inout"); |
| } |
| FuncDeclaration *func = sc->func; |
| if (func) |
| { |
| if (func->fes) |
| func = func->fes->func; |
| bool isWild = false; |
| for (FuncDeclaration *fd = func; fd; fd = fd->toParent2()->isFuncDeclaration()) |
| { |
| if (((TypeFunction *)fd->type)->iswild) |
| { |
| isWild = true; |
| break; |
| } |
| } |
| if (!isWild) |
| { |
| error("inout variables can only be declared inside inout functions"); |
| } |
| } |
| } |
| |
| if (!(storage_class & (STCctfe | STCref | STCresult)) && tbn->ty == Tstruct && |
| ((TypeStruct *)tbn)->sym->noDefaultCtor) |
| { |
| if (!_init) |
| { |
| if (isField()) |
| { |
| /* For fields, we'll check the constructor later to make sure it is initialized |
| */ |
| storage_class |= STCnodefaultctor; |
| } |
| else if (storage_class & STCparameter) |
| ; |
| else |
| error("default construction is disabled for type %s", type->toChars()); |
| } |
| } |
| |
| FuncDeclaration *fd = parent->isFuncDeclaration(); |
| if (type->isscope() && !(storage_class & STCnodtor)) |
| { |
| if (storage_class & (STCfield | STCout | STCref | STCstatic | STCmanifest | STCtls | STCgshared) || !fd) |
| { |
| error("globals, statics, fields, manifest constants, ref and out parameters cannot be scope"); |
| } |
| |
| if (!(storage_class & STCscope)) |
| { |
| if (!(storage_class & STCparameter) && ident != Id::withSym) |
| error("reference to scope class must be scope"); |
| } |
| } |
| |
| // Calculate type size + safety checks |
| if (sc->func && !sc->intypeof) |
| { |
| if (_init && _init->isVoidInitializer() && type->hasPointers()) // get type size |
| { |
| if (sc->func->setUnsafe()) |
| error("void initializers for pointers not allowed in safe functions"); |
| } |
| else if (!_init && |
| !(storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCfield | STCparameter)) && |
| type->hasVoidInitPointers()) |
| { |
| if (sc->func->setUnsafe()) |
| error("void initializers for pointers not allowed in safe functions"); |
| } |
| } |
| |
| if (!_init && !fd) |
| { |
| // If not mutable, initializable by constructor only |
| storage_class |= STCctorinit; |
| } |
| |
| if (_init) |
| storage_class |= STCinit; // remember we had an explicit initializer |
| else if (storage_class & STCmanifest) |
| error("manifest constants must have initializers"); |
| |
| bool isBlit = false; |
| d_uns64 sz = 0; |
| if (!_init && !sc->inunion && !(storage_class & (STCstatic | STCgshared | STCextern)) && fd && |
| (!(storage_class & (STCfield | STCin | STCforeach | STCparameter | STCresult)) |
| || (storage_class & STCout)) && |
| (sz = type->size()) != 0) |
| { |
| // Provide a default initializer |
| //printf("Providing default initializer for '%s'\n", toChars()); |
| if (sz == SIZE_INVALID && type->ty != Terror) |
| error("size of type %s is invalid", type->toChars()); |
| |
| Type *tv = type; |
| while (tv->ty == Tsarray) // Don't skip Tenum |
| tv = tv->nextOf(); |
| if (tv->needsNested()) |
| { |
| /* Nested struct requires valid enclosing frame pointer. |
| * In StructLiteralExp::toElem(), it's calculated. |
| */ |
| assert(tv->toBasetype()->ty == Tstruct); |
| checkFrameAccess(loc, sc, ((TypeStruct *)tbn)->sym); |
| |
| Expression *e = tv->defaultInitLiteral(loc); |
| e = new BlitExp(loc, new VarExp(loc, this), e); |
| e = ::semantic(e, sc); |
| _init = new ExpInitializer(loc, e); |
| goto Ldtor; |
| } |
| if (tv->ty == Tstruct && ((TypeStruct *)tv)->sym->zeroInit == 1) |
| { |
| /* If a struct is all zeros, as a special case |
| * set it's initializer to the integer 0. |
| * In AssignExp::toElem(), we check for this and issue |
| * a memset() to initialize the struct. |
| * Must do same check in interpreter. |
| */ |
| Expression *e = new IntegerExp(loc, 0, Type::tint32); |
| e = new BlitExp(loc, new VarExp(loc, this), e); |
| e->type = type; // don't type check this, it would fail |
| _init = new ExpInitializer(loc, e); |
| goto Ldtor; |
| } |
| if (type->baseElemOf()->ty == Tvoid) |
| { |
| error("%s does not have a default initializer", type->toChars()); |
| } |
| else if (Expression *e = type->defaultInit(loc)) |
| { |
| _init = new ExpInitializer(loc, e); |
| } |
| // Default initializer is always a blit |
| isBlit = true; |
| } |
| |
| if (_init) |
| { |
| sc = sc->push(); |
| sc->stc &= ~(STC_TYPECTOR | STCpure | STCnothrow | STCnogc | STCref | STCdisable); |
| |
| ExpInitializer *ei = _init->isExpInitializer(); |
| if (ei) // Bugzilla 13424: Preset the required type to fail in FuncLiteralDeclaration::semantic3 |
| ei->exp = inferType(ei->exp, type); |
| |
| // If inside function, there is no semantic3() call |
| if (sc->func || sc->intypeof == 1) |
| { |
| // If local variable, use AssignExp to handle all the various |
| // possibilities. |
| if (fd && |
| !(storage_class & (STCmanifest | STCstatic | STCtls | STCgshared | STCextern)) && |
| !_init->isVoidInitializer()) |
| { |
| //printf("fd = '%s', var = '%s'\n", fd->toChars(), toChars()); |
| if (!ei) |
| { |
| ArrayInitializer *ai = _init->isArrayInitializer(); |
| Expression *e; |
| if (ai && tb->ty == Taarray) |
| e = ai->toAssocArrayLiteral(); |
| else |
| e = initializerToExpression(_init); |
| if (!e) |
| { |
| // Run semantic, but don't need to interpret |
| _init = ::semantic(_init, sc, type, INITnointerpret); |
| e = initializerToExpression(_init); |
| if (!e) |
| { |
| error("is not a static and cannot have static initializer"); |
| return; |
| } |
| } |
| ei = new ExpInitializer(_init->loc, e); |
| _init = ei; |
| } |
| |
| Expression *exp = ei->exp; |
| Expression *e1 = new VarExp(loc, this); |
| if (isBlit) |
| exp = new BlitExp(loc, e1, exp); |
| else |
| exp = new ConstructExp(loc, e1, exp); |
| canassign++; |
| exp = ::semantic(exp, sc); |
| canassign--; |
| exp = exp->optimize(WANTvalue); |
| |
| if (exp->op == TOKerror) |
| { |
| _init = new ErrorInitializer(); |
| ei = NULL; |
| } |
| else |
| ei->exp = exp; |
| |
| if (ei && isScope()) |
| { |
| Expression *ex = ei->exp; |
| while (ex->op == TOKcomma) |
| ex = ((CommaExp *)ex)->e2; |
| if (ex->op == TOKblit || ex->op == TOKconstruct) |
| ex = ((AssignExp *)ex)->e2; |
| if (ex->op == TOKnew) |
| { |
| // See if initializer is a NewExp that can be allocated on the stack |
| NewExp *ne = (NewExp *)ex; |
| if (type->toBasetype()->ty == Tclass) |
| { |
| if (ne->newargs && ne->newargs->dim > 1) |
| { |
| mynew = true; |
| } |
| else |
| { |
| ne->onstack = true; |
| onstack = true; |
| } |
| } |
| } |
| else if (ex->op == TOKfunction) |
| { |
| // or a delegate that doesn't escape a reference to the function |
| FuncDeclaration *f = ((FuncExp *)ex)->fd; |
| f->tookAddressOf--; |
| } |
| } |
| } |
| else |
| { |
| // Bugzilla 14166: Don't run CTFE for the temporary variables inside typeof |
| _init = ::semantic(_init, sc, type, sc->intypeof == 1 ? INITnointerpret : INITinterpret); |
| } |
| } |
| else if (parent->isAggregateDeclaration()) |
| { |
| _scope = scx ? scx : sc->copy(); |
| _scope->setNoFree(); |
| } |
| else if (storage_class & (STCconst | STCimmutable | STCmanifest) || |
| type->isConst() || type->isImmutable()) |
| { |
| /* Because we may need the results of a const declaration in a |
| * subsequent type, such as an array dimension, before semantic2() |
| * gets ordinarily run, try to run semantic2() now. |
| * Ignore failure. |
| */ |
| |
| if (!inferred) |
| { |
| unsigned errors = global.errors; |
| inuse++; |
| if (ei) |
| { |
| Expression *exp = ei->exp->syntaxCopy(); |
| |
| bool needctfe = isDataseg() || (storage_class & STCmanifest); |
| if (needctfe) sc = sc->startCTFE(); |
| exp = ::semantic(exp, sc); |
| exp = resolveProperties(sc, exp); |
| if (needctfe) sc = sc->endCTFE(); |
| |
| Type *tb2 = type->toBasetype(); |
| Type *ti = exp->type->toBasetype(); |
| |
| /* The problem is the following code: |
| * struct CopyTest { |
| * double x; |
| * this(double a) { x = a * 10.0;} |
| * this(this) { x += 2.0; } |
| * } |
| * const CopyTest z = CopyTest(5.3); // ok |
| * const CopyTest w = z; // not ok, postblit not run |
| * static assert(w.x == 55.0); |
| * because the postblit doesn't get run on the initialization of w. |
| */ |
| if (ti->ty == Tstruct) |
| { |
| StructDeclaration *sd = ((TypeStruct *)ti)->sym; |
| /* Look to see if initializer involves a copy constructor |
| * (which implies a postblit) |
| */ |
| // there is a copy constructor |
| // and exp is the same struct |
| if (sd->postblit && |
| tb2->toDsymbol(NULL) == sd) |
| { |
| // The only allowable initializer is a (non-copy) constructor |
| if (exp->isLvalue()) |
| error("of type struct %s uses this(this), which is not allowed in static initialization", tb2->toChars()); |
| } |
| } |
| ei->exp = exp; |
| } |
| _init = ::semantic(_init, sc, type, INITinterpret); |
| inuse--; |
| if (global.errors > errors) |
| { |
| _init = new ErrorInitializer(); |
| type = Type::terror; |
| } |
| } |
| else |
| { |
| _scope = scx ? scx : sc->copy(); |
| _scope->setNoFree(); |
| } |
| } |
| sc = sc->pop(); |
| } |
| |
| Ldtor: |
| /* Build code to execute destruction, if necessary |
| */ |
| edtor = callScopeDtor(sc); |
| if (edtor) |
| { |
| if (sc->func && storage_class & (STCstatic | STCgshared)) |
| edtor = ::semantic(edtor, sc->_module->_scope); |
| else |
| edtor = ::semantic(edtor, sc); |
| |
| #if 0 // currently disabled because of std.stdio.stdin, stdout and stderr |
| if (isDataseg() && !(storage_class & STCextern)) |
| error("static storage variables cannot have destructors"); |
| #endif |
| } |
| |
| semanticRun = PASSsemanticdone; |
| |
| if (type->toBasetype()->ty == Terror) |
| errors = true; |
| |
| if (sc->scopesym && !sc->scopesym->isAggregateDeclaration()) |
| { |
| for (ScopeDsymbol *sym = sc->scopesym; sym && endlinnum == 0; |
| sym = sym->parent ? sym->parent->isScopeDsymbol() : NULL) |
| endlinnum = sym->endlinnum; |
| } |
| } |
| |
| void VarDeclaration::semantic2(Scope *sc) |
| { |
| if (semanticRun < PASSsemanticdone && inuse) |
| return; |
| |
| //printf("VarDeclaration::semantic2('%s')\n", toChars()); |
| |
| if (_init && !toParent()->isFuncDeclaration()) |
| { |
| inuse++; |
| // Bugzilla 14166: Don't run CTFE for the temporary variables inside typeof |
| _init = ::semantic(_init, sc, type, sc->intypeof == 1 ? INITnointerpret : INITinterpret); |
| inuse--; |
| } |
| if (_init && storage_class & STCmanifest) |
| { |
| /* Cannot initializer enums with CTFE classreferences and addresses of struct literals. |
| * Scan initializer looking for them. Issue error if found. |
| */ |
| if (ExpInitializer *ei = _init->isExpInitializer()) |
| { |
| struct EnumInitializer |
| { |
| static bool arrayHasInvalidEnumInitializer(Expressions *elems) |
| { |
| for (size_t i = 0; i < elems->dim; i++) |
| { |
| Expression *e = (*elems)[i]; |
| if (e && hasInvalidEnumInitializer(e)) |
| return true; |
| } |
| return false; |
| } |
| |
| static bool hasInvalidEnumInitializer(Expression *e) |
| { |
| if (e->op == TOKclassreference) |
| return true; |
| if (e->op == TOKaddress && ((AddrExp *)e)->e1->op == TOKstructliteral) |
| return true; |
| if (e->op == TOKarrayliteral) |
| return arrayHasInvalidEnumInitializer(((ArrayLiteralExp *)e)->elements); |
| if (e->op == TOKstructliteral) |
| return arrayHasInvalidEnumInitializer(((StructLiteralExp *)e)->elements); |
| if (e->op == TOKassocarrayliteral) |
| { |
| AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)e; |
| return arrayHasInvalidEnumInitializer(ae->values) || |
| arrayHasInvalidEnumInitializer(ae->keys); |
| } |
| return false; |
| } |
| }; |
| if (EnumInitializer::hasInvalidEnumInitializer(ei->exp)) |
| error(": Unable to initialize enum with class or pointer to struct. Use static const variable instead."); |
| } |
| } |
| else if (_init && isThreadlocal()) |
| { |
| if ((type->ty == Tclass) && type->isMutable() && !type->isShared()) |
| { |
| ExpInitializer *ei = _init->isExpInitializer(); |
| if (ei && ei->exp->op == TOKclassreference) |
| error("is mutable. Only const or immutable class thread local variable are allowed, not %s", type->toChars()); |
| } |
| else if (type->ty == Tpointer && type->nextOf()->ty == Tstruct && type->nextOf()->isMutable() &&!type->nextOf()->isShared()) |
| { |
| ExpInitializer *ei = _init->isExpInitializer(); |
| if (ei && ei->exp->op == TOKaddress && ((AddrExp *)ei->exp)->e1->op == TOKstructliteral) |
| { |
| error("is a pointer to mutable struct. Only pointers to const, immutable or shared struct thread local variable are allowed, not %s", type->toChars()); |
| } |
| } |
| } |
| semanticRun = PASSsemantic2done; |
| } |
| |
| void VarDeclaration::setFieldOffset(AggregateDeclaration *ad, unsigned *poffset, bool isunion) |
| { |
| //printf("VarDeclaration::setFieldOffset(ad = %s) %s\n", ad->toChars(), toChars()); |
| |
| if (aliassym) |
| { |
| // If this variable was really a tuple, set the offsets for the tuple fields |
| TupleDeclaration *v2 = aliassym->isTupleDeclaration(); |
| assert(v2); |
| for (size_t i = 0; i < v2->objects->dim; i++) |
| { |
| RootObject *o = (*v2->objects)[i]; |
| assert(o->dyncast() == DYNCAST_EXPRESSION); |
| Expression *e = (Expression *)o; |
| assert(e->op == TOKdsymbol); |
| DsymbolExp *se = (DsymbolExp *)e; |
| se->s->setFieldOffset(ad, poffset, isunion); |
| } |
| return; |
| } |
| |
| if (!isField()) |
| return; |
| assert(!(storage_class & (STCstatic | STCextern | STCparameter | STCtls))); |
| |
| //printf("+VarDeclaration::setFieldOffset(ad = %s) %s\n", ad->toChars(), toChars()); |
| |
| /* Fields that are tuples appear both as part of TupleDeclarations and |
| * as members. That means ignore them if they are already a field. |
| */ |
| if (offset) |
| { |
| // already a field |
| *poffset = ad->structsize; // Bugzilla 13613 |
| return; |
| } |
| for (size_t i = 0; i < ad->fields.dim; i++) |
| { |
| if (ad->fields[i] == this) |
| { |
| // already a field |
| *poffset = ad->structsize; // Bugzilla 13613 |
| return; |
| } |
| } |
| |
| // Check for forward referenced types which will fail the size() call |
| Type *t = type->toBasetype(); |
| if (storage_class & STCref) |
| { |
| // References are the size of a pointer |
| t = Type::tvoidptr; |
| } |
| Type *tv = t->baseElemOf(); |
| if (tv->ty == Tstruct) |
| { |
| TypeStruct *ts = (TypeStruct *)tv; |
| assert(ts->sym != ad); // already checked in ad->determineFields() |
| if (!ts->sym->determineSize(loc)) |
| { |
| type = Type::terror; |
| errors = true; |
| return; |
| } |
| } |
| |
| // List in ad->fields. Even if the type is error, it's necessary to avoid |
| // pointless error diagnostic "more initializers than fields" on struct literal. |
| ad->fields.push(this); |
| |
| if (t->ty == Terror) |
| return; |
| |
| const d_uns64 sz = t->size(loc); |
| assert(sz != SIZE_INVALID && sz < UINT32_MAX); |
| unsigned memsize = (unsigned)sz; // size of member |
| unsigned memalignsize = Target::fieldalign(t); // size of member for alignment purposes |
| |
| offset = AggregateDeclaration::placeField(poffset, memsize, memalignsize, alignment, |
| &ad->structsize, &ad->alignsize, isunion); |
| |
| //printf("\t%s: memalignsize = %d\n", toChars(), memalignsize); |
| |
| //printf(" addField '%s' to '%s' at offset %d, size = %d\n", toChars(), ad->toChars(), offset, memsize); |
| } |
| |
| const char *VarDeclaration::kind() const |
| { |
| return "variable"; |
| } |
| |
| Dsymbol *VarDeclaration::toAlias() |
| { |
| //printf("VarDeclaration::toAlias('%s', this = %p, aliassym = %p)\n", toChars(), this, aliassym); |
| if ((!type || !type->deco) && _scope) |
| semantic(_scope); |
| |
| assert(this != aliassym); |
| Dsymbol *s = aliassym ? aliassym->toAlias() : this; |
| return s; |
| } |
| |
| AggregateDeclaration *VarDeclaration::isThis() |
| { |
| AggregateDeclaration *ad = NULL; |
| |
| if (!(storage_class & (STCstatic | STCextern | STCmanifest | STCtemplateparameter | |
| STCtls | STCgshared | STCctfe))) |
| { |
| for (Dsymbol *s = this; s; s = s->parent) |
| { |
| ad = s->isMember(); |
| if (ad) |
| break; |
| if (!s->parent || !s->parent->isTemplateMixin()) break; |
| } |
| } |
| return ad; |
| } |
| |
| bool VarDeclaration::needThis() |
| { |
| //printf("VarDeclaration::needThis(%s, x%x)\n", toChars(), storage_class); |
| return isField(); |
| } |
| |
| bool VarDeclaration::isExport() const |
| { |
| return protection.kind == PROTexport; |
| } |
| |
| bool VarDeclaration::isImportedSymbol() const |
| { |
| if (protection.kind == PROTexport && !_init && |
| (storage_class & STCstatic || parent->isModule())) |
| return true; |
| return false; |
| } |
| |
| /******************************************* |
| * Helper function for the expansion of manifest constant. |
| */ |
| Expression *VarDeclaration::expandInitializer(Loc loc) |
| { |
| assert((storage_class & STCmanifest) && _init); |
| |
| Expression *e = getConstInitializer(); |
| if (!e) |
| { |
| ::error(loc, "cannot make expression out of initializer for %s", toChars()); |
| return new ErrorExp(); |
| } |
| |
| e = e->copy(); |
| e->loc = loc; // for better error message |
| return e; |
| } |
| |
| void VarDeclaration::checkCtorConstInit() |
| { |
| #if 0 /* doesn't work if more than one static ctor */ |
| if (ctorinit == 0 && isCtorinit() && !isField()) |
| error("missing initializer in static constructor for const variable"); |
| #endif |
| } |
| |
| bool lambdaCheckForNestedRef(Expression *e, Scope *sc); |
| |
| /************************************ |
| * Check to see if this variable is actually in an enclosing function |
| * rather than the current one. |
| * Returns true if error occurs. |
| */ |
| bool VarDeclaration::checkNestedReference(Scope *sc, Loc loc) |
| { |
| //printf("VarDeclaration::checkNestedReference() %s\n", toChars()); |
| if (sc->intypeof == 1 || (sc->flags & SCOPEctfe)) |
| return false; |
| if (!parent || parent == sc->parent) |
| return false; |
| if (isDataseg() || (storage_class & STCmanifest)) |
| return false; |
| |
| // The current function |
| FuncDeclaration *fdthis = sc->parent->isFuncDeclaration(); |
| if (!fdthis) |
| return false; // out of function scope |
| |
| Dsymbol *p = toParent2(); |
| |
| // Function literals from fdthis to p must be delegates |
| checkNestedRef(fdthis, p); |
| |
| // The function that this variable is in |
| FuncDeclaration *fdv = p->isFuncDeclaration(); |
| if (!fdv || fdv == fdthis) |
| return false; |
| |
| // Add fdthis to nestedrefs[] if not already there |
| for (size_t i = 0; 1; i++) |
| { |
| if (i == nestedrefs.dim) |
| { |
| nestedrefs.push(fdthis); |
| break; |
| } |
| if (nestedrefs[i] == fdthis) |
| break; |
| } |
| |
| /* __require and __ensure will always get called directly, |
| * so they never make outer functions closure. |
| */ |
| if (fdthis->ident == Id::require || fdthis->ident == Id::ensure) |
| return false; |
| |
| //printf("\tfdv = %s\n", fdv->toChars()); |
| //printf("\tfdthis = %s\n", fdthis->toChars()); |
| if (loc.filename) |
| { |
| int lv = fdthis->getLevel(loc, sc, fdv); |
| if (lv == -2) // error |
| return true; |
| } |
| |
| // Add this to fdv->closureVars[] if not already there |
| for (size_t i = 0; 1; i++) |
| { |
| if (i == fdv->closureVars.dim) |
| { |
| if (!sc->intypeof && !(sc->flags & SCOPEcompile)) |
| fdv->closureVars.push(this); |
| break; |
| } |
| if (fdv->closureVars[i] == this) |
| break; |
| } |
| |
| //printf("fdthis is %s\n", fdthis->toChars()); |
| //printf("var %s in function %s is nested ref\n", toChars(), fdv->toChars()); |
| // __dollar creates problems because it isn't a real variable Bugzilla 3326 |
| if (ident == Id::dollar) |
| { |
| ::error(loc, "cannnot use $ inside a function literal"); |
| return true; |
| } |
| |
| if (ident == Id::withSym) // Bugzilla 1759 |
| { |
| ExpInitializer *ez = _init->isExpInitializer(); |
| assert(ez); |
| Expression *e = ez->exp; |
| if (e->op == TOKconstruct || e->op == TOKblit) |
| e = ((AssignExp *)e)->e2; |
| return lambdaCheckForNestedRef(e, sc); |
| } |
| |
| return false; |
| } |
| |
| /******************************************* |
| * If variable has a constant expression initializer, get it. |
| * Otherwise, return NULL. |
| */ |
| |
| Expression *VarDeclaration::getConstInitializer(bool needFullType) |
| { |
| assert(type && _init); |
| |
| // Ungag errors when not speculative |
| unsigned oldgag = global.gag; |
| if (global.gag) |
| { |
| Dsymbol *sym = toParent()->isAggregateDeclaration(); |
| if (sym && !sym->isSpeculative()) |
| global.gag = 0; |
| } |
| |
| if (_scope) |
| { |
| inuse++; |
| _init = ::semantic(_init, _scope, type, INITinterpret); |
| _scope = NULL; |
| inuse--; |
| } |
| Expression *e = initializerToExpression(_init, needFullType ? type : NULL); |
| |
| global.gag = oldgag; |
| return e; |
| } |
| |
| /************************************* |
| * Return true if we can take the address of this variable. |
| */ |
| |
| bool VarDeclaration::canTakeAddressOf() |
| { |
| return !(storage_class & STCmanifest); |
| } |
| |
| |
| /******************************* |
| * Does symbol go into data segment? |
| * Includes extern variables. |
| */ |
| |
| bool VarDeclaration::isDataseg() |
| { |
| if (isdataseg == 0) // the value is not cached |
| { |
| isdataseg = 2; // The Variables does not go into the datasegment |
| |
| if (!canTakeAddressOf()) |
| { |
| return false; |
| } |
| |
| Dsymbol *parent = toParent(); |
| if (!parent && !(storage_class & STCstatic)) |
| { |
| error("forward referenced"); |
| type = Type::terror; |
| } |
| else if (storage_class & (STCstatic | STCextern | STCtls | STCgshared) || |
| parent->isModule() || parent->isTemplateInstance() || parent->isNspace()) |
| { |
| assert(!isParameter() && !isResult()); |
| isdataseg = 1; // It is in the DataSegment |
| } |
| } |
| |
| return (isdataseg == 1); |
| } |
| |
| /************************************ |
| * Does symbol go into thread local storage? |
| */ |
| |
| bool VarDeclaration::isThreadlocal() |
| { |
| //printf("VarDeclaration::isThreadlocal(%p, '%s')\n", this, toChars()); |
| /* Data defaults to being thread-local. It is not thread-local |
| * if it is immutable, const or shared. |
| */ |
| bool i = isDataseg() && |
| !(storage_class & (STCimmutable | STCconst | STCshared | STCgshared)); |
| //printf("\treturn %d\n", i); |
| return i; |
| } |
| |
| /******************************************** |
| * Can variable be read and written by CTFE? |
| */ |
| |
| bool VarDeclaration::isCTFE() |
| { |
| return (storage_class & STCctfe) != 0; // || !isDataseg(); |
| } |
| |
| bool VarDeclaration::isOverlappedWith(VarDeclaration *v) |
| { |
| const d_uns64 vsz = v->type->size(); |
| const d_uns64 tsz = type->size(); |
| assert(vsz != SIZE_INVALID && tsz != SIZE_INVALID); |
| return offset < v->offset + vsz && |
| v->offset < offset + tsz; |
| } |
| |
| bool VarDeclaration::hasPointers() |
| { |
| //printf("VarDeclaration::hasPointers() %s, ty = %d\n", toChars(), type->ty); |
| return (!isDataseg() && type->hasPointers()); |
| } |
| |
| /****************************************** |
| * Return true if variable needs to call the destructor. |
| */ |
| |
| bool VarDeclaration::needsScopeDtor() |
| { |
| //printf("VarDeclaration::needsScopeDtor() %s\n", toChars()); |
| return edtor && !(storage_class & STCnodtor); |
| } |
| |
| |
| /****************************************** |
| * If a variable has a scope destructor call, return call for it. |
| * Otherwise, return NULL. |
| */ |
| |
| Expression *VarDeclaration::callScopeDtor(Scope *) |
| { |
| //printf("VarDeclaration::callScopeDtor() %s\n", toChars()); |
| |
| // Destruction of STCfield's is handled by buildDtor() |
| if (storage_class & (STCnodtor | STCref | STCout | STCfield)) |
| { |
| return NULL; |
| } |
| |
| Expression *e = NULL; |
| |
| // Destructors for structs and arrays of structs |
| Type *tv = type->baseElemOf(); |
| if (tv->ty == Tstruct) |
| { |
| StructDeclaration *sd = ((TypeStruct *)tv)->sym; |
| if (!sd->dtor || sd->errors) |
| return NULL; |
| |
| const d_uns64 sz = type->size(); |
| assert(sz != SIZE_INVALID); |
| if (!sz) |
| return NULL; |
| |
| if (type->toBasetype()->ty == Tstruct) |
| { |
| // v.__xdtor() |
| e = new VarExp(loc, this); |
| |
| /* This is a hack so we can call destructors on const/immutable objects. |
| * Need to add things like "const ~this()" and "immutable ~this()" to |
| * fix properly. |
| */ |
| e->type = e->type->mutableOf(); |
| |
| // Enable calling destructors on shared objects. |
| // The destructor is always a single, non-overloaded function, |
| // and must serve both shared and non-shared objects. |
| e->type = e->type->unSharedOf(); |
| |
| e = new DotVarExp(loc, e, sd->dtor, false); |
| e = new CallExp(loc, e); |
| } |
| else |
| { |
| // __ArrayDtor(v[0 .. n]) |
| e = new VarExp(loc, this); |
| |
| const d_uns64 sdsz = sd->type->size(); |
| assert(sdsz != SIZE_INVALID && sdsz != 0); |
| const d_uns64 n = sz / sdsz; |
| e = new SliceExp(loc, e, new IntegerExp(loc, 0, Type::tsize_t), |
| new IntegerExp(loc, n, Type::tsize_t)); |
| // Prevent redundant bounds check |
| ((SliceExp *)e)->upperIsInBounds = true; |
| ((SliceExp *)e)->lowerIsLessThanUpper = true; |
| |
| // This is a hack so we can call destructors on const/immutable objects. |
| e->type = sd->type->arrayOf(); |
| |
| e = new CallExp(loc, new IdentifierExp(loc, Id::__ArrayDtor), e); |
| } |
| return e; |
| } |
| |
| // Destructors for classes |
| if (storage_class & (STCauto | STCscope) && !(storage_class & STCparameter)) |
| { |
| for (ClassDeclaration *cd = type->isClassHandle(); |
| cd; |
| cd = cd->baseClass) |
| { |
| /* We can do better if there's a way with onstack |
| * classes to determine if there's no way the monitor |
| * could be set. |
| */ |
| //if (cd->isInterfaceDeclaration()) |
| //error("interface %s cannot be scope", cd->toChars()); |
| |
| // Destroying C++ scope classes crashes currently. Since C++ class dtors are not currently supported, simply do not run dtors for them. |
| // See https://issues.dlang.org/show_bug.cgi?id=13182 |
| if (cd->cpp) |
| { |
| break; |
| } |
| if (mynew || onstack) // if any destructors |
| { |
| // delete this; |
| Expression *ec; |
| |
| ec = new VarExp(loc, this); |
| e = new DeleteExp(loc, ec, true); |
| e->type = Type::tvoid; |
| break; |
| } |
| } |
| } |
| return e; |
| } |
| |
| /********************************** |
| * Determine if `this` has a lifetime that lasts past |
| * the destruction of `v` |
| * Params: |
| * v = variable to test against |
| * Returns: |
| * true if it does |
| */ |
| bool VarDeclaration::enclosesLifetimeOf(VarDeclaration *v) const |
| { |
| return sequenceNumber < v->sequenceNumber; |
| } |
| |
| /****************************************** |
| */ |
| |
| void ObjectNotFound(Identifier *id) |
| { |
| Type::error(Loc(), "%s not found. object.d may be incorrectly installed or corrupt.", id->toChars()); |
| fatal(); |
| } |
| |
| /******************************** SymbolDeclaration ********************************/ |
| |
| SymbolDeclaration::SymbolDeclaration(Loc loc, StructDeclaration *dsym) |
| : Declaration(dsym->ident) |
| { |
| this->loc = loc; |
| this->dsym = dsym; |
| storage_class |= STCconst; |
| } |
| |
| /********************************* TypeInfoDeclaration ****************************/ |
| |
| TypeInfoDeclaration::TypeInfoDeclaration(Type *tinfo) |
| : VarDeclaration(Loc(), Type::dtypeinfo->type, tinfo->getTypeInfoIdent(), NULL) |
| { |
| this->tinfo = tinfo; |
| storage_class = STCstatic | STCgshared; |
| protection = Prot(PROTpublic); |
| linkage = LINKc; |
| alignment = Target::ptrsize; |
| } |
| |
| TypeInfoDeclaration *TypeInfoDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoDeclaration(tinfo); |
| } |
| |
| Dsymbol *TypeInfoDeclaration::syntaxCopy(Dsymbol *) |
| { |
| assert(0); // should never be produced by syntax |
| return NULL; |
| } |
| |
| void TypeInfoDeclaration::semantic(Scope *) |
| { |
| assert(linkage == LINKc); |
| } |
| |
| const char *TypeInfoDeclaration::toChars() |
| { |
| //printf("TypeInfoDeclaration::toChars() tinfo = %s\n", tinfo->toChars()); |
| OutBuffer buf; |
| buf.writestring("typeid("); |
| buf.writestring(tinfo->toChars()); |
| buf.writeByte(')'); |
| return buf.extractString(); |
| } |
| |
| /***************************** TypeInfoConstDeclaration **********************/ |
| |
| TypeInfoConstDeclaration::TypeInfoConstDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfoconst) |
| { |
| ObjectNotFound(Id::TypeInfo_Const); |
| } |
| type = Type::typeinfoconst->type; |
| } |
| |
| TypeInfoConstDeclaration *TypeInfoConstDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoConstDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoInvariantDeclaration **********************/ |
| |
| TypeInfoInvariantDeclaration::TypeInfoInvariantDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfoinvariant) |
| { |
| ObjectNotFound(Id::TypeInfo_Invariant); |
| } |
| type = Type::typeinfoinvariant->type; |
| } |
| |
| TypeInfoInvariantDeclaration *TypeInfoInvariantDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoInvariantDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoSharedDeclaration **********************/ |
| |
| TypeInfoSharedDeclaration::TypeInfoSharedDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfoshared) |
| { |
| ObjectNotFound(Id::TypeInfo_Shared); |
| } |
| type = Type::typeinfoshared->type; |
| } |
| |
| TypeInfoSharedDeclaration *TypeInfoSharedDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoSharedDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoWildDeclaration **********************/ |
| |
| TypeInfoWildDeclaration::TypeInfoWildDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfowild) |
| { |
| ObjectNotFound(Id::TypeInfo_Wild); |
| } |
| type = Type::typeinfowild->type; |
| } |
| |
| TypeInfoWildDeclaration *TypeInfoWildDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoWildDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoStructDeclaration **********************/ |
| |
| TypeInfoStructDeclaration::TypeInfoStructDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfostruct) |
| { |
| ObjectNotFound(Id::TypeInfo_Struct); |
| } |
| type = Type::typeinfostruct->type; |
| } |
| |
| TypeInfoStructDeclaration *TypeInfoStructDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoStructDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoClassDeclaration ***********************/ |
| |
| TypeInfoClassDeclaration::TypeInfoClassDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfoclass) |
| { |
| ObjectNotFound(Id::TypeInfo_Class); |
| } |
| type = Type::typeinfoclass->type; |
| } |
| |
| TypeInfoClassDeclaration *TypeInfoClassDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoClassDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoInterfaceDeclaration *******************/ |
| |
| TypeInfoInterfaceDeclaration::TypeInfoInterfaceDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfointerface) |
| { |
| ObjectNotFound(Id::TypeInfo_Interface); |
| } |
| type = Type::typeinfointerface->type; |
| } |
| |
| TypeInfoInterfaceDeclaration *TypeInfoInterfaceDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoInterfaceDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoPointerDeclaration *********************/ |
| |
| TypeInfoPointerDeclaration::TypeInfoPointerDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfopointer) |
| { |
| ObjectNotFound(Id::TypeInfo_Pointer); |
| } |
| type = Type::typeinfopointer->type; |
| } |
| |
| TypeInfoPointerDeclaration *TypeInfoPointerDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoPointerDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoArrayDeclaration ***********************/ |
| |
| TypeInfoArrayDeclaration::TypeInfoArrayDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfoarray) |
| { |
| ObjectNotFound(Id::TypeInfo_Array); |
| } |
| type = Type::typeinfoarray->type; |
| } |
| |
| TypeInfoArrayDeclaration *TypeInfoArrayDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoArrayDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoStaticArrayDeclaration *****************/ |
| |
| TypeInfoStaticArrayDeclaration::TypeInfoStaticArrayDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfostaticarray) |
| { |
| ObjectNotFound(Id::TypeInfo_StaticArray); |
| } |
| type = Type::typeinfostaticarray->type; |
| } |
| |
| TypeInfoStaticArrayDeclaration *TypeInfoStaticArrayDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoStaticArrayDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoAssociativeArrayDeclaration ************/ |
| |
| TypeInfoAssociativeArrayDeclaration::TypeInfoAssociativeArrayDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfoassociativearray) |
| { |
| ObjectNotFound(Id::TypeInfo_AssociativeArray); |
| } |
| type = Type::typeinfoassociativearray->type; |
| } |
| |
| TypeInfoAssociativeArrayDeclaration *TypeInfoAssociativeArrayDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoAssociativeArrayDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoVectorDeclaration ***********************/ |
| |
| TypeInfoVectorDeclaration::TypeInfoVectorDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfovector) |
| { |
| ObjectNotFound(Id::TypeInfo_Vector); |
| } |
| type = Type::typeinfovector->type; |
| } |
| |
| TypeInfoVectorDeclaration *TypeInfoVectorDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoVectorDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoEnumDeclaration ***********************/ |
| |
| TypeInfoEnumDeclaration::TypeInfoEnumDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfoenum) |
| { |
| ObjectNotFound(Id::TypeInfo_Enum); |
| } |
| type = Type::typeinfoenum->type; |
| } |
| |
| TypeInfoEnumDeclaration *TypeInfoEnumDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoEnumDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoFunctionDeclaration ********************/ |
| |
| TypeInfoFunctionDeclaration::TypeInfoFunctionDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfofunction) |
| { |
| ObjectNotFound(Id::TypeInfo_Function); |
| } |
| type = Type::typeinfofunction->type; |
| } |
| |
| TypeInfoFunctionDeclaration *TypeInfoFunctionDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoFunctionDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoDelegateDeclaration ********************/ |
| |
| TypeInfoDelegateDeclaration::TypeInfoDelegateDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfodelegate) |
| { |
| ObjectNotFound(Id::TypeInfo_Delegate); |
| } |
| type = Type::typeinfodelegate->type; |
| } |
| |
| TypeInfoDelegateDeclaration *TypeInfoDelegateDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoDelegateDeclaration(tinfo); |
| } |
| |
| /***************************** TypeInfoTupleDeclaration **********************/ |
| |
| TypeInfoTupleDeclaration::TypeInfoTupleDeclaration(Type *tinfo) |
| : TypeInfoDeclaration(tinfo) |
| { |
| if (!Type::typeinfotypelist) |
| { |
| ObjectNotFound(Id::TypeInfo_Tuple); |
| } |
| type = Type::typeinfotypelist->type; |
| } |
| |
| TypeInfoTupleDeclaration *TypeInfoTupleDeclaration::create(Type *tinfo) |
| { |
| return new TypeInfoTupleDeclaration(tinfo); |
| } |
| |
| /********************************* ThisDeclaration ****************************/ |
| |
| // For the "this" parameter to member functions |
| |
| ThisDeclaration::ThisDeclaration(Loc loc, Type *t) |
| : VarDeclaration(loc, t, Id::This, NULL) |
| { |
| storage_class |= STCnodtor; |
| } |
| |
| Dsymbol *ThisDeclaration::syntaxCopy(Dsymbol *) |
| { |
| assert(0); // should never be produced by syntax |
| return NULL; |
| } |
| |
