summaryrefslogtreecommitdiff
path: root/gcc/d/dmd/dsymbolsem.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/d/dmd/dsymbolsem.c')
-rw-r--r--gcc/d/dmd/dsymbolsem.c5620
1 files changed, 0 insertions, 5620 deletions
diff --git a/gcc/d/dmd/dsymbolsem.c b/gcc/d/dmd/dsymbolsem.c
deleted file mode 100644
index 7a44ed2c41d..00000000000
--- a/gcc/d/dmd/dsymbolsem.c
+++ /dev/null
@@ -1,5620 +0,0 @@
-
-/* Compiler implementation of the D programming language
- * Copyright (C) 1999-2021 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
- */
-
-#include "root/dsystem.h"
-#include "root/aav.h"
-
-#include "dsymbol.h"
-#include "aggregate.h"
-#include "aliasthis.h"
-#include "attrib.h"
-#include "cond.h"
-#include "declaration.h"
-#include "enum.h"
-#include "errors.h"
-#include "hdrgen.h"
-#include "id.h"
-#include "import.h"
-#include "init.h"
-#include "mars.h"
-#include "module.h"
-#include "nspace.h"
-#include "objc.h"
-#include "parse.h"
-#include "scope.h"
-#include "statement.h"
-#include "staticassert.h"
-#include "target.h"
-#include "template.h"
-#include "utf.h"
-#include "version.h"
-#include "visitor.h"
-
-bool allowsContractWithoutBody(FuncDeclaration *funcdecl);
-bool checkFrameAccess(Loc loc, Scope *sc, AggregateDeclaration *ad, size_t istart = 0);
-VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e);
-Initializer *inferType(Initializer *init, Scope *sc);
-void MODtoBuffer(OutBuffer *buf, MOD mod);
-bool reliesOnTident(Type *t, TemplateParameters *tparams = NULL, size_t iStart = 0);
-bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps);
-bool symbolIsVisible(Scope *sc, Dsymbol *s);
-Objc *objc();
-
-static unsigned setMangleOverride(Dsymbol *s, char *sym)
-{
- AttribDeclaration *ad = s->isAttribDeclaration();
-
- if (ad)
- {
- Dsymbols *decls = ad->include(NULL);
- unsigned nestedCount = 0;
-
- if (decls && decls->length)
- for (size_t i = 0; i < decls->length; ++i)
- nestedCount += setMangleOverride((*decls)[i], sym);
-
- return nestedCount;
- }
- else if (s->isFuncDeclaration() || s->isVarDeclaration())
- {
- s->isDeclaration()->mangleOverride = sym;
- return 1;
- }
- else
- return 0;
-}
-
-/**********************************
- * Decide if attributes for this function can be inferred from examining
- * the function body.
- * Returns:
- * true if can
- */
-static bool canInferAttributes(FuncDeclaration *fd, Scope *sc)
-{
- if (!fd->fbody)
- return false;
-
- if (fd->isVirtualMethod())
- return false; // since they may be overridden
-
- if (sc->func &&
- /********** this is for backwards compatibility for the moment ********/
- (!fd->isMember() || (sc->func->isSafeBypassingInference() && !fd->isInstantiated())))
- return true;
-
- if (fd->isFuncLiteralDeclaration() || // externs are not possible with literals
- (fd->storage_class & STCinference) || // do attribute inference
- (fd->inferRetType && !fd->isCtorDeclaration()))
- return true;
-
- if (fd->isInstantiated())
- {
- TemplateInstance *ti = fd->parent->isTemplateInstance();
- if (ti == NULL || ti->isTemplateMixin() || ti->tempdecl->ident == fd->ident)
- return true;
- }
-
- return false;
-}
-
-/*****************************************
- * Initialize for inferring the attributes of this function.
- */
-static void initInferAttributes(FuncDeclaration *fd)
-{
- //printf("initInferAttributes() for %s\n", toPrettyChars());
- TypeFunction *tf = fd->type->toTypeFunction();
- if (tf->purity == PUREimpure) // purity not specified
- fd->flags |= FUNCFLAGpurityInprocess;
-
- if (tf->trust == TRUSTdefault)
- fd->flags |= FUNCFLAGsafetyInprocess;
-
- if (!tf->isnothrow)
- fd->flags |= FUNCFLAGnothrowInprocess;
-
- if (!tf->isnogc)
- fd->flags |= FUNCFLAGnogcInprocess;
-
- if (!fd->isVirtual() || fd->introducing)
- fd->flags |= FUNCFLAGreturnInprocess;
-
- // Initialize for inferring STCscope
- if (global.params.vsafe)
- fd->flags |= FUNCFLAGinferScope;
-}
-
-static void badObjectDotD(ClassDeclaration *cd)
-{
- cd->error("missing or corrupt object.d");
- fatal();
-}
-
-/* Bugzilla 12078, 12143 and 15733:
- * While resolving base classes and interfaces, a base may refer
- * the member of this derived class. In that time, if all bases of
- * this class can be determined, we can go forward the semantc process
- * beyond the Lancestorsdone. To do the recursive semantic analysis,
- * temporarily set and unset `_scope` around exp().
- */
-static Type *resolveBase(ClassDeclaration *cd, Scope *sc, Scope *&scx, Type *type)
-{
- if (!scx)
- {
- scx = sc->copy();
- scx->setNoFree();
- }
- cd->_scope = scx;
- Type *t = typeSemantic(type, cd->loc, sc);
- cd->_scope = NULL;
- return t;
-}
-
-static void resolveBase(ClassDeclaration *cd, Scope *sc, Scope *&scx, ClassDeclaration *sym)
-{
- if (!scx)
- {
- scx = sc->copy();
- scx->setNoFree();
- }
- cd->_scope = scx;
- dsymbolSemantic(sym, NULL);
- cd->_scope = NULL;
-}
-
-class DsymbolSemanticVisitor : public Visitor
-{
-public:
- Scope *sc;
-
- DsymbolSemanticVisitor(Scope *sc)
- {
- this->sc = sc;
- }
-
- void visit(Dsymbol *dsym)
- {
- dsym->error("%p has no semantic routine", dsym);
- }
-
- void visit(ScopeDsymbol *) { }
- void visit(Declaration *) { }
-
- void visit(AliasThis *dsym)
- {
- if (dsym->semanticRun != PASSinit)
- return;
-
- if (dsym->_scope)
- {
- sc = dsym->_scope;
- dsym->_scope = NULL;
- }
-
- if (!sc)
- return;
-
- dsym->semanticRun = PASSsemantic;
-
- Dsymbol *p = sc->parent->pastMixin();
- AggregateDeclaration *ad = p->isAggregateDeclaration();
- if (!ad)
- {
- error(dsym->loc, "alias this can only be a member of aggregate, not %s %s",
- p->kind(), p->toChars());
- return;
- }
-
- assert(ad->members);
- Dsymbol *s = ad->search(dsym->loc, dsym->ident);
- if (!s)
- {
- s = sc->search(dsym->loc, dsym->ident, NULL);
- if (s)
- error(dsym->loc, "%s is not a member of %s", s->toChars(), ad->toChars());
- else
- error(dsym->loc, "undefined identifier %s", dsym->ident->toChars());
- return;
- }
- else if (ad->aliasthis && s != ad->aliasthis)
- {
- error(dsym->loc, "there can be only one alias this");
- return;
- }
-
- if (ad->type->ty == Tstruct && ((TypeStruct *)ad->type)->sym != ad)
- {
- AggregateDeclaration *ad2 = ((TypeStruct *)ad->type)->sym;
- assert(ad2->type == Type::terror);
- ad->aliasthis = ad2->aliasthis;
- return;
- }
-
- /* disable the alias this conversion so the implicit conversion check
- * doesn't use it.
- */
- ad->aliasthis = NULL;
-
- Dsymbol *sx = s;
- if (sx->isAliasDeclaration())
- sx = sx->toAlias();
- Declaration *d = sx->isDeclaration();
- if (d && !d->isTupleDeclaration())
- {
- Type *t = d->type;
- assert(t);
- if (ad->type->implicitConvTo(t) > MATCHnomatch)
- {
- error(dsym->loc, "alias this is not reachable as %s already converts to %s", ad->toChars(), t->toChars());
- }
- }
-
- ad->aliasthis = s;
- dsym->semanticRun = PASSsemanticdone;
- }
-
- void visit(AliasDeclaration *dsym)
- {
- if (dsym->semanticRun >= PASSsemanticdone)
- return;
- assert(dsym->semanticRun <= PASSsemantic);
-
- dsym->storage_class |= sc->stc & STCdeprecated;
- dsym->protection = sc->protection;
- dsym->userAttribDecl = sc->userAttribDecl;
-
- if (!sc->func && dsym->inNonRoot())
- return;
-
- aliasSemantic(dsym, sc);
- }
-
- void visit(VarDeclaration *dsym)
- {
- //if (dsym->semanticRun > PASSinit)
- // return;
- //dsym->semanticRun = PASSsemantic;
-
- if (dsym->semanticRun >= PASSsemanticdone)
- return;
-
- Scope *scx = NULL;
- if (dsym->_scope)
- {
- sc = dsym->_scope;
- scx = sc;
- dsym->_scope = NULL;
- }
-
- if (!sc)
- return;
-
- dsym->semanticRun = PASSsemantic;
-
- /* Pick up storage classes from context, but except synchronized,
- * override, abstract, and final.
- */
- dsym->storage_class |= (sc->stc & ~(STCsynchronized | STCoverride | STCabstract | STCfinal));
- if (dsym->storage_class & STCextern && dsym->_init)
- dsym->error("extern symbols cannot have initializers");
-
- dsym->userAttribDecl = sc->userAttribDecl;
-
- AggregateDeclaration *ad = dsym->isThis();
- if (ad)
- dsym->storage_class |= ad->storage_class & STC_TYPECTOR;
-
- /* If auto type inference, do the inference
- */
- int inferred = 0;
- if (!dsym->type)
- {
- dsym->inuse++;
-
- // Infering the type requires running semantic,
- // so mark the scope as ctfe if required
- bool needctfe = (dsym->storage_class & (STCmanifest | STCstatic)) != 0;
- if (needctfe) sc = sc->startCTFE();
-
- //printf("inferring type for %s with init %s\n", dsym->toChars(), dsym->_init->toChars());
- dsym->_init = inferType(dsym->_init, sc);
- dsym->type = initializerToExpression(dsym->_init)->type;
-
- if (needctfe) sc = sc->endCTFE();
-
- dsym->inuse--;
- inferred = 1;
-
- /* This is a kludge to support the existing syntax for RAII
- * declarations.
- */
- dsym->storage_class &= ~STCauto;
- dsym->originalType = dsym->type->syntaxCopy();
- }
- else
- {
- if (!dsym->originalType)
- dsym->originalType = dsym->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 |= (dsym->storage_class & STC_FUNCATTR);
- dsym->inuse++;
- dsym->type = typeSemantic(dsym->type, dsym->loc, sc2);
- dsym->inuse--;
- sc2->pop();
- }
- //printf(" semantic type = %s\n", dsym->type ? dsym->type->toChars() : "null");
- if (dsym->type->ty == Terror)
- dsym->errors = true;
-
- dsym->type->checkDeprecated(dsym->loc, sc);
- dsym->linkage = sc->linkage;
- dsym->parent = sc->parent;
- //printf("this = %p, parent = %p, '%s'\n", dsym, dsym->parent, dsym->parent->toChars());
- dsym->protection = sc->protection;
-
- /* If scope's alignment is the default, use the type's alignment,
- * otherwise the scope overrrides.
- */
- dsym->alignment = sc->alignment();
- if (dsym->alignment == STRUCTALIGN_DEFAULT)
- dsym->alignment = dsym->type->alignment(); // use type's alignment
-
- //printf("sc->stc = %x\n", sc->stc);
- //printf("storage_class = x%x\n", dsym->storage_class);
-
- if (global.params.vcomplex)
- dsym->type->checkComplexTransition(dsym->loc);
-
- // Calculate type size + safety checks
- if (sc->func && !sc->intypeof)
- {
- if ((dsym->storage_class & STCgshared) && !dsym->isMember())
- {
- if (sc->func->setUnsafe())
- dsym->error("__gshared not allowed in safe functions; use shared");
- }
- }
-
- Dsymbol *parent = dsym->toParent();
-
- Type *tb = dsym->type->toBasetype();
- Type *tbn = tb->baseElemOf();
- if (tb->ty == Tvoid && !(dsym->storage_class & STClazy))
- {
- if (inferred)
- {
- dsym->error("type %s is inferred from initializer %s, and variables cannot be of type void",
- dsym->type->toChars(), dsym->_init->toChars());
- }
- else
- dsym->error("variables cannot be of type void");
- dsym->type = Type::terror;
- tb = dsym->type;
- }
- if (tb->ty == Tfunction)
- {
- dsym->error("cannot be declared to be a function");
- dsym->type = Type::terror;
- tb = dsym->type;
- }
- if (tb->ty == Tstruct)
- {
- TypeStruct *ts = (TypeStruct *)tb;
- if (!ts->sym->members)
- {
- dsym->error("no definition of struct `%s`", ts->toChars());
-
- // Explain why the definition is required when it's part of another type
- if (!dsym->type->isTypeStruct())
- {
- // Prefer Loc of the dependant type
- Dsymbol *s = dsym->type->toDsymbol(sc);
- Loc loc = s ? s->loc : dsym->loc;
- errorSupplemental(loc, "required by type `%s`", dsym->type->toChars());
- }
-
- // Flag variable as error to avoid invalid error messages due to unknown size
- dsym->type = Type::terror;
- }
- }
- if ((dsym->storage_class & STCauto) && !inferred)
- dsym->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 = (dsym->_init && !dsym->_init->isVoidInitializer()) ? initializerToExpression(dsym->_init) : NULL;
- if (ie)
- ie = expressionSemantic(ie, sc);
-
- if (nelems > 0 && ie)
- {
- Expressions *iexps = new Expressions();
- iexps->push(ie);
-
- Expressions *exps = new Expressions();
-
- for (size_t pos = 0; pos < iexps->length; pos++)
- {
- Lexpand1:
- Expression *e = (*iexps)[pos];
- Parameter *arg = Parameter::getNth(tt->arguments, pos);
- arg->type = typeSemantic(arg->type, dsym->loc, sc);
- //printf("[%d] iexps->length = %d, ", pos, iexps->length);
- //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->length > nelems)
- goto Lnomatch;
- if (e->type->implicitConvTo(arg->type))
- continue;
- }
-
- if (e->op == TOKtuple)
- {
- TupleExp *te = (TupleExp *)e;
- if (iexps->length - 1 + te->exps->length > 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);
- dsymbolSemantic(v, sc);
- VarExp *ve = new VarExp(dsym->loc, v);
- ve->type = e->type;
-
- exps->setDim(1);
- (*exps)[0] = ve;
- expandAliasThisTuples(exps, 0);
-
- for (size_t u = 0; u < exps->length ; u++)
- {
- Lexpand2:
- Expression *ee = (*exps)[u];
- arg = Parameter::getNth(tt->arguments, pos + u);
- arg->type = typeSemantic(arg->type, dsym->loc, sc);
- //printf("[%d+%d] exps->length = %d, ", pos, u, exps->length);
- //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->length - 1 + exps->length;
- 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(dsym->loc, new DeclarationExp(dsym->loc, v), e0);
- (*exps)[0]->type = e0->type;
-
- iexps->remove(pos);
- iexps->insert(pos, exps);
- goto Lexpand1;
- }
- }
- }
- if (iexps->length < nelems)
- goto Lnomatch;
-
- ie = new TupleExp(dsym->_init->loc, iexps);
- }
- Lnomatch:
-
- if (ie && ie->op == TOKtuple)
- {
- TupleExp *te = (TupleExp *)ie;
- size_t tedim = te->exps->length;
- if (tedim != nelems)
- {
- error(dsym->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", dsym->ident->toChars(), (ulonglong)i);
- const char *name = buf.extractChars();
- 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 = dsym->_init ? dsym->_init->syntaxCopy() : NULL;
-
- VarDeclaration *v = new VarDeclaration(dsym->loc, arg->type, id, ti);
- v->storage_class |= STCtemp | STClocal | dsym->storage_class;
- if (arg->storageClass & STCparameter)
- v->storage_class |= arg->storageClass;
- //printf("declaring field %s of type %s\n", v->toChars(), v->type->toChars());
- dsymbolSemantic(v, 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(dsym->loc, v);
- (*exps)[i] = e;
- }
- TupleDeclaration *v2 = new TupleDeclaration(dsym->loc, dsym->ident, exps);
- v2->parent = dsym->parent;
- v2->isexp = true;
- dsym->aliassym = v2;
- dsym->semanticRun = PASSsemanticdone;
- return;
- }
-
- /* Storage class can modify the type
- */
- dsym->type = dsym->type->addStorageClass(dsym->storage_class);
-
- /* Adjust storage class to reflect type
- */
- if (dsym->type->isConst())
- {
- dsym->storage_class |= STCconst;
- if (dsym->type->isShared())
- dsym->storage_class |= STCshared;
- }
- else if (dsym->type->isImmutable())
- dsym->storage_class |= STCimmutable;
- else if (dsym->type->isShared())
- dsym->storage_class |= STCshared;
- else if (dsym->type->isWild())
- dsym->storage_class |= STCwild;
-
- if (StorageClass stc = dsym->storage_class & (STCsynchronized | STCoverride | STCabstract | STCfinal))
- {
- if (stc == STCfinal)
- dsym->error("cannot be final, perhaps you meant const?");
- else
- {
- OutBuffer buf;
- stcToBuffer(&buf, stc);
- dsym->error("cannot be %s", buf.peekChars());
- }
- dsym->storage_class &= ~stc; // strip off
- }
-
- if (dsym->storage_class & STCscope)
- {
- StorageClass stc = dsym->storage_class & (STCstatic | STCextern | STCmanifest | STCtls | STCgshared);
- if (stc)
- {
- OutBuffer buf;
- stcToBuffer(&buf, stc);
- dsym->error("cannot be `scope` and `%s`", buf.peekChars());
- }
- else if (dsym->isMember())
- {
- dsym->error("field cannot be `scope`");
- }
- else if (!dsym->type->hasPointers())
- {
- dsym->storage_class &= ~STCscope; // silently ignore; may occur in generic code
- }
- }
-
- if (dsym->storage_class & (STCstatic | STCextern | STCmanifest | STCtemplateparameter | STCtls | STCgshared | STCctfe))
- {
- }
- else
- {
- AggregateDeclaration *aad = parent->isAggregateDeclaration();
- if (aad)
- {
- if (global.params.vfield &&
- dsym->storage_class & (STCconst | STCimmutable) && dsym->_init && !dsym->_init->isVoidInitializer())
- {
- const char *s = (dsym->storage_class & STCimmutable) ? "immutable" : "const";
- message(dsym->loc, "`%s.%s` is `%s` field", ad->toPrettyChars(), dsym->toChars(), s);
- }
- dsym->storage_class |= STCfield;
- if (tbn->ty == Tstruct && ((TypeStruct *)tbn)->sym->noDefaultCtor)
- {
- if (!dsym->isThisDeclaration() && !dsym->_init)
- aad->noDefaultCtor = true;
- }
- }
-
- InterfaceDeclaration *id = parent->isInterfaceDeclaration();
- if (id)
- {
- dsym->error("field not allowed in interface");
- }
- else if (aad && aad->sizeok == SIZEOKdone)
- {
- dsym->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 && dsym->storage_class != STCundefined)
- {
- dsym->error("cannot use template to add field to aggregate `%s`", ad2->toChars());
- }
- }
- }
-
- if ((dsym->storage_class & (STCref | STCparameter | STCforeach | STCtemp | STCresult)) == STCref && dsym->ident != Id::This)
- {
- dsym->error("only parameters or foreach declarations can be ref");
- }
-
- if (dsym->type->hasWild())
- {
- if (dsym->storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCfield) ||
- dsym->isDataseg()
- )
- {
- dsym->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)
- {
- dsym->error("inout variables can only be declared inside inout functions");
- }
- }
- }
-
- if (!(dsym->storage_class & (STCctfe | STCref | STCresult)) && tbn->ty == Tstruct &&
- ((TypeStruct *)tbn)->sym->noDefaultCtor)
- {
- if (!dsym->_init)
- {
- if (dsym->isField())
- {
- /* For fields, we'll check the constructor later to make sure it is initialized
- */
- dsym->storage_class |= STCnodefaultctor;
- }
- else if (dsym->storage_class & STCparameter)
- ;
- else
- dsym->error("default construction is disabled for type %s", dsym->type->toChars());
- }
- }
-
- FuncDeclaration *fd = parent->isFuncDeclaration();
- if (dsym->type->isscope() && !(dsym->storage_class & STCnodtor))
- {
- if (dsym->storage_class & (STCfield | STCout | STCref | STCstatic | STCmanifest | STCtls | STCgshared) || !fd)
- {
- dsym->error("globals, statics, fields, manifest constants, ref and out parameters cannot be scope");
- }
-
- if (!(dsym->storage_class & STCscope))
- {
- if (!(dsym->storage_class & STCparameter) && dsym->ident != Id::withSym)
- dsym->error("reference to scope class must be scope");
- }
- }
-
- // Calculate type size + safety checks
- if (sc->func && !sc->intypeof)
- {
- if (dsym->_init && dsym->_init->isVoidInitializer() && dsym->type->hasPointers()) // get type size
- {
- if (sc->func->setUnsafe())
- dsym->error("void initializers for pointers not allowed in safe functions");
- }
- else if (!dsym->_init &&
- !(dsym->storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCfield | STCparameter)) &&
- dsym->type->hasVoidInitPointers())
- {
- if (sc->func->setUnsafe())
- dsym->error("void initializers for pointers not allowed in safe functions");
- }
- }
-
- if (!dsym->_init && !fd)
- {
- // If not mutable, initializable by constructor only
- dsym->storage_class |= STCctorinit;
- }
-
- if (dsym->_init)
- dsym->storage_class |= STCinit; // remember we had an explicit initializer
- else if (dsym->storage_class & STCmanifest)
- dsym->error("manifest constants must have initializers");
-
- bool isBlit = false;
- d_uns64 sz = 0;
- if (!dsym->_init && !sc->inunion && !(dsym->storage_class & (STCstatic | STCgshared | STCextern)) && fd &&
- (!(dsym->storage_class & (STCfield | STCin | STCforeach | STCparameter | STCresult))
- || (dsym->storage_class & STCout)) &&
- (sz = dsym->type->size()) != 0)
- {
- // Provide a default initializer
- //printf("Providing default initializer for '%s'\n", dsym->toChars());
- if (sz == SIZE_INVALID && dsym->type->ty != Terror)
- dsym->error("size of type %s is invalid", dsym->type->toChars());
-
- Type *tv = dsym->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(dsym->loc, sc, ((TypeStruct *)tbn)->sym);
-
- Expression *e = tv->defaultInitLiteral(dsym->loc);
- e = new BlitExp(dsym->loc, new VarExp(dsym->loc, dsym), e);
- e = expressionSemantic(e, sc);
- dsym->_init = new ExpInitializer(dsym->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(dsym->loc, 0, Type::tint32);
- e = new BlitExp(dsym->loc, new VarExp(dsym->loc, dsym), e);
- e->type = dsym->type; // don't type check this, it would fail
- dsym->_init = new ExpInitializer(dsym->loc, e);
- goto Ldtor;
- }
- if (dsym->type->baseElemOf()->ty == Tvoid)
- {
- dsym->error("%s does not have a default initializer", dsym->type->toChars());
- }
- else if (Expression *e = dsym->type->defaultInit(dsym->loc))
- {
- dsym->_init = new ExpInitializer(dsym->loc, e);
- }
- // Default initializer is always a blit
- isBlit = true;
- }
-
- if (dsym->_init)
- {
- sc = sc->push();
- sc->stc &= ~(STC_TYPECTOR | STCpure | STCnothrow | STCnogc | STCref | STCdisable);
-
- ExpInitializer *ei = dsym->_init->isExpInitializer();
- if (ei) // Bugzilla 13424: Preset the required type to fail in FuncLiteralDeclaration::semantic3
- ei->exp = inferType(ei->exp, dsym->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 &&
- !(dsym->storage_class & (STCmanifest | STCstatic | STCtls | STCgshared | STCextern)) &&
- !dsym->_init->isVoidInitializer())
- {
- //printf("fd = '%s', var = '%s'\n", fd->toChars(), dsym->toChars());
- if (!ei)
- {
- ArrayInitializer *ai = dsym->_init->isArrayInitializer();
- Expression *e;
- if (ai && tb->ty == Taarray)
- e = ai->toAssocArrayLiteral();
- else
- e = initializerToExpression(dsym->_init);
- if (!e)
- {
- // Run semantic, but don't need to interpret
- dsym->_init = initializerSemantic(dsym->_init, sc, dsym->type, INITnointerpret);
- e = initializerToExpression(dsym->_init);
- if (!e)
- {
- dsym->error("is not a static and cannot have static initializer");
- e = new ErrorExp();
- }
- }
- ei = new ExpInitializer(dsym->_init->loc, e);
- dsym->_init = ei;
- }
-
- Expression *exp = ei->exp;
- Expression *e1 = new VarExp(dsym->loc, dsym);
- if (isBlit)
- exp = new BlitExp(dsym->loc, e1, exp);
- else
- exp = new ConstructExp(dsym->loc, e1, exp);
- dsym->canassign++;
- exp = expressionSemantic(exp, sc);
- dsym->canassign--;
- exp = exp->optimize(WANTvalue);
-
- if (exp->op == TOKerror)
- {
- dsym->_init = new ErrorInitializer();
- ei = NULL;
- }
- else
- ei->exp = exp;
-
- if (ei && dsym->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 (dsym->type->toBasetype()->ty == Tclass)
- {
- if (ne->newargs && ne->newargs->length > 1)
- {
- dsym->mynew = true;
- }
- else
- {
- ne->onstack = true;
- dsym->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
- dsym->_init = initializerSemantic(dsym->_init, sc, dsym->type, sc->intypeof == 1 ? INITnointerpret : INITinterpret);
- }
- }
- else if (parent->isAggregateDeclaration())
- {
- dsym->_scope = scx ? scx : sc->copy();
- dsym->_scope->setNoFree();
- }
- else if (dsym->storage_class & (STCconst | STCimmutable | STCmanifest) ||
- dsym->type->isConst() || dsym->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;
- dsym->inuse++;
- if (ei)
- {
- Expression *exp = ei->exp->syntaxCopy();
-
- bool needctfe = dsym->isDataseg() || (dsym->storage_class & STCmanifest);
- if (needctfe) sc = sc->startCTFE();
- exp = expressionSemantic(exp, sc);
- exp = resolveProperties(sc, exp);
- if (needctfe) sc = sc->endCTFE();
-
- Type *tb2 = dsym->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())
- dsym->error("of type struct %s uses this(this), which is not allowed in static initialization", tb2->toChars());
- }
- }
- ei->exp = exp;
- }
- dsym->_init = initializerSemantic(dsym->_init, sc, dsym->type, INITinterpret);
- dsym->inuse--;
- if (global.errors > errors)
- {
- dsym->_init = new ErrorInitializer();
- dsym->type = Type::terror;
- }
- }
- else
- {
- dsym->_scope = scx ? scx : sc->copy();
- dsym->_scope->setNoFree();
- }
- }
- sc = sc->pop();
- }
-
- Ldtor:
- /* Build code to execute destruction, if necessary
- */
- dsym->edtor = dsym->callScopeDtor(sc);
- if (dsym->edtor)
- {
- if (sc->func && dsym->storage_class & (STCstatic | STCgshared))
- dsym->edtor = expressionSemantic(dsym->edtor, sc->_module->_scope);
- else
- dsym->edtor = expressionSemantic(dsym->edtor, sc);
-
- #if 0 // currently disabled because of std.stdio.stdin, stdout and stderr
- if (dsym->isDataseg() && !(dsym->storage_class & STCextern))
- dsym->error("static storage variables cannot have destructors");
- #endif
- }
-
- dsym->semanticRun = PASSsemanticdone;
-
- if (dsym->type->toBasetype()->ty == Terror)
- dsym->errors = true;
-
- if (sc->scopesym && !sc->scopesym->isAggregateDeclaration())
- {
- for (ScopeDsymbol *sym = sc->scopesym; sym && dsym->endlinnum == 0;
- sym = sym->parent ? sym->parent->isScopeDsymbol() : NULL)
- dsym->endlinnum = sym->endlinnum;
- }
- }
-
- void visit(TypeInfoDeclaration *dsym)
- {
- assert(dsym->linkage == LINKc);
- }
-
- void visit(Import *imp)
- {
- //printf("Import::semantic('%s') %s\n", toPrettyChars(), imp->id->toChars());
- if (imp->semanticRun > PASSinit)
- return;
-
- if (imp->_scope)
- {
- sc = imp->_scope;
- imp->_scope = NULL;
- }
- if (!sc)
- return;
-
- imp->semanticRun = PASSsemantic;
-
- // Load if not already done so
- if (!imp->mod)
- {
- imp->load(sc);
- if (imp->mod)
- imp->mod->importAll(NULL);
- }
-
- if (imp->mod)
- {
- // Modules need a list of each imported module
- //printf("%s imports %s\n", sc->_module->toChars(), imp->mod->toChars());
- sc->_module->aimports.push(imp->mod);
-
- if (sc->explicitProtection)
- imp->protection = sc->protection;
-
- if (!imp->aliasId && !imp->names.length) // neither a selective nor a renamed import
- {
- ScopeDsymbol *scopesym = NULL;
- if (sc->explicitProtection)
- imp->protection = sc->protection.kind;
- for (Scope *scd = sc; scd; scd = scd->enclosing)
- {
- if (!scd->scopesym)
- continue;
- scopesym = scd->scopesym;
- break;
- }
-
- if (!imp->isstatic)
- {
- scopesym->importScope(imp->mod, imp->protection);
- }
-
- imp->addPackageAccess(scopesym);
- }
-
- dsymbolSemantic(imp->mod, NULL);
-
- if (imp->mod->needmoduleinfo)
- {
- //printf("module4 %s because of %s\n", sc->_module->toChars(), imp->mod->toChars());
- sc->_module->needmoduleinfo = 1;
- }
-
- sc = sc->push(imp->mod);
- sc->protection = imp->protection;
- for (size_t i = 0; i < imp->aliasdecls.length; i++)
- {
- AliasDeclaration *ad = imp->aliasdecls[i];
- //printf("\tImport %s alias %s = %s, scope = %p\n", toPrettyChars(), imp->aliases[i]->toChars(), imp->names[i]->toChars(), ad->_scope);
- Dsymbol *sym = imp->mod->search(imp->loc, imp->names[i], IgnorePrivateImports);
- if (sym)
- {
- if (!symbolIsVisible(sc, sym))
- imp->mod->error(imp->loc, "member `%s` is not visible from module `%s`",
- imp->names[i]->toChars(), sc->_module->toChars());
- dsymbolSemantic(ad, sc);
- // If the import declaration is in non-root module,
- // analysis of the aliased symbol is deferred.
- // Therefore, don't see the ad->aliassym or ad->type here.
- }
- else
- {
- Dsymbol *s = imp->mod->search_correct(imp->names[i]);
- if (s)
- imp->mod->error(imp->loc, "import `%s` not found, did you mean %s `%s`?", imp->names[i]->toChars(), s->kind(), s->toPrettyChars());
- else
- imp->mod->error(imp->loc, "import `%s` not found", imp->names[i]->toChars());
- ad->type = Type::terror;
- }
- }
- sc = sc->pop();
- }
-
- imp->semanticRun = PASSsemanticdone;
-
- // object self-imports itself, so skip that (Bugzilla 7547)
- // don't list pseudo modules __entrypoint.d, __main.d (Bugzilla 11117, 11164)
- if (global.params.moduleDeps != NULL &&
- !(imp->id == Id::object && sc->_module->ident == Id::object) &&
- sc->_module->ident != Id::entrypoint &&
- strcmp(sc->_module->ident->toChars(), "__main") != 0)
- {
- /* The grammar of the file is:
- * ImportDeclaration
- * ::= BasicImportDeclaration [ " : " ImportBindList ] [ " -> "
- * ModuleAliasIdentifier ] "\n"
- *
- * BasicImportDeclaration
- * ::= ModuleFullyQualifiedName " (" FilePath ") : " Protection|"string"
- * " [ " static" ] : " ModuleFullyQualifiedName " (" FilePath ")"
- *
- * FilePath
- * - any string with '(', ')' and '\' escaped with the '\' character
- */
-
- OutBuffer *ob = global.params.moduleDeps;
- Module* imod = sc->instantiatingModule();
- if (!global.params.moduleDepsFile.length)
- ob->writestring("depsImport ");
- ob->writestring(imod->toPrettyChars());
- ob->writestring(" (");
- escapePath(ob, imod->srcfile->toChars());
- ob->writestring(") : ");
-
- // use protection instead of sc->protection because it couldn't be
- // resolved yet, see the comment above
- protectionToBuffer(ob, imp->protection);
- ob->writeByte(' ');
- if (imp->isstatic)
- {
- stcToBuffer(ob, STCstatic);
- ob->writeByte(' ');
- }
- ob->writestring(": ");
-
- if (imp->packages)
- {
- for (size_t i = 0; i < imp->packages->length; i++)
- {
- Identifier *pid = (*imp->packages)[i];
- ob->printf("%s.", pid->toChars());
- }
- }
-
- ob->writestring(imp->id->toChars());
- ob->writestring(" (");
- if (imp->mod)
- escapePath(ob, imp->mod->srcfile->toChars());
- else
- ob->writestring("???");
- ob->writeByte(')');
-
- for (size_t i = 0; i < imp->names.length; i++)
- {
- if (i == 0)
- ob->writeByte(':');
- else
- ob->writeByte(',');
-
- Identifier *name = imp->names[i];
- Identifier *alias = imp->aliases[i];
-
- if (!alias)
- {
- ob->printf("%s", name->toChars());
- alias = name;
- }
- else
- ob->printf("%s=%s", alias->toChars(), name->toChars());
- }
-
- if (imp->aliasId)
- ob->printf(" -> %s", imp->aliasId->toChars());
-
- ob->writenl();
- }
-
- //printf("-Import::semantic('%s'), pkg = %p\n", imp->toChars(), imp->pkg);
- }
-
- void attribSemantic(AttribDeclaration *ad)
- {
- if (ad->semanticRun != PASSinit)
- return;
- ad->semanticRun = PASSsemantic;
- Dsymbols *d = ad->include(sc);
- //printf("\tAttribDeclaration::semantic '%s', d = %p\n",toChars(), d);
- if (d)
- {
- Scope *sc2 = ad->newScope(sc);
- bool errors = false;
- for (size_t i = 0; i < d->length; i++)
- {
- Dsymbol *s = (*d)[i];
- dsymbolSemantic(s, sc2);
- errors |= s->errors;
- }
- ad->errors |= errors;
- if (sc2 != sc)
- sc2->pop();
- }
- ad->semanticRun = PASSsemanticdone;
- }
-
- void visit(AttribDeclaration *atd)
- {
- attribSemantic(atd);
- }
-
- void visit(AnonDeclaration *scd)
- {
- //printf("\tAnonDeclaration::semantic %s %p\n", isunion ? "union" : "struct", scd);
- assert(sc->parent);
- Dsymbol *p = sc->parent->pastMixin();
- AggregateDeclaration *ad = p->isAggregateDeclaration();
- if (!ad)
- {
- error(scd->loc, "%s can only be a part of an aggregate, not %s %s",
- scd->kind(), p->kind(), p->toChars());
- scd->errors = true;
- return;
- }
-
- if (scd->decl)
- {
- sc = sc->push();
- sc->stc &= ~(STCauto | STCscope | STCstatic | STCtls | STCgshared);
- sc->inunion = scd->isunion;
- sc->flags = 0;
-
- for (size_t i = 0; i < scd->decl->length; i++)
- {
- Dsymbol *s = (*scd->decl)[i];
- dsymbolSemantic(s, sc);
- }
- sc = sc->pop();
- }
- }
-
- void visit(PragmaDeclaration *pd)
- {
- // Should be merged with PragmaStatement
- //printf("\tPragmaDeclaration::semantic '%s'\n",toChars());
- if (pd->ident == Id::msg)
- {
- if (pd->args)
- {
- for (size_t i = 0; i < pd->args->length; i++)
- {
- Expression *e = (*pd->args)[i];
-
- sc = sc->startCTFE();
- e = expressionSemantic(e, sc);
- e = resolveProperties(sc, e);
- sc = sc->endCTFE();
- e = ctfeInterpretForPragmaMsg(e);
- if (e->op == TOKerror)
- {
- errorSupplemental(pd->loc, "while evaluating pragma(msg, %s)", (*pd->args)[i]->toChars());
- return;
- }
- StringExp *se = e->toStringExp();
- if (se)
- {
- se = se->toUTF8(sc);
- fprintf(stderr, "%.*s", (int)se->len, (char *)se->string);
- }
- else
- fprintf(stderr, "%s", e->toChars());
- }
- fprintf(stderr, "\n");
- }
- goto Lnodecl;
- }
- else if (pd->ident == Id::lib)
- {
- if (!pd->args || pd->args->length != 1)
- pd->error("string expected for library name");
- else
- {
- StringExp *se = semanticString(sc, (*pd->args)[0], "library name");
- if (!se)
- goto Lnodecl;
- (*pd->args)[0] = se;
-
- char *name = (char *)mem.xmalloc(se->len + 1);
- memcpy(name, se->string, se->len);
- name[se->len] = 0;
- if (global.params.verbose)
- message("library %s", name);
- if (global.params.moduleDeps && !global.params.moduleDepsFile.length)
- {
- OutBuffer *ob = global.params.moduleDeps;
- Module *imod = sc->instantiatingModule();
- ob->writestring("depsLib ");
- ob->writestring(imod->toPrettyChars());
- ob->writestring(" (");
- escapePath(ob, imod->srcfile->toChars());
- ob->writestring(") : ");
- ob->writestring((char *) name);
- ob->writenl();
- }
- mem.xfree(name);
- }
- goto Lnodecl;
- }
- else if (pd->ident == Id::startaddress)
- {
- if (!pd->args || pd->args->length != 1)
- pd->error("function name expected for start address");
- else
- {
- /* Bugzilla 11980:
- * resolveProperties and ctfeInterpret call are not necessary.
- */
- Expression *e = (*pd->args)[0];
-
- sc = sc->startCTFE();
- e = expressionSemantic(e, sc);
- sc = sc->endCTFE();
-
- (*pd->args)[0] = e;
- Dsymbol *sa = getDsymbol(e);
- if (!sa || !sa->isFuncDeclaration())
- pd->error("function name expected for start address, not `%s`", e->toChars());
- }
- goto Lnodecl;
- }
- else if (pd->ident == Id::Pinline)
- {
- goto Ldecl;
- }
- else if (pd->ident == Id::mangle)
- {
- if (!pd->args)
- pd->args = new Expressions();
- if (pd->args->length != 1)
- {
- pd->error("string expected for mangled name");
- pd->args->setDim(1);
- (*pd->args)[0] = new ErrorExp(); // error recovery
- goto Ldecl;
- }
-
- StringExp *se = semanticString(sc, (*pd->args)[0], "mangled name");
- if (!se)
- goto Ldecl;
- (*pd->args)[0] = se; // Will be used for later
-
- if (!se->len)
- {
- pd->error("zero-length string not allowed for mangled name");
- goto Ldecl;
- }
- if (se->sz != 1)
- {
- pd->error("mangled name characters can only be of type char");
- goto Ldecl;
- }
-
- /* Note: D language specification should not have any assumption about backend
- * implementation. Ideally pragma(mangle) can accept a string of any content.
- *
- * Therefore, this validation is compiler implementation specific.
- */
- for (size_t i = 0; i < se->len; )
- {
- utf8_t *p = (utf8_t *)se->string;
- dchar_t c = p[i];
- if (c < 0x80)
- {
- if ((c >= 'A' && c <= 'Z') ||
- (c >= 'a' && c <= 'z') ||
- (c >= '0' && c <= '9') ||
- (c != 0 && strchr("$%().:?@[]_", c)))
- {
- ++i;
- continue;
- }
- else
- {
- pd->error("char 0x%02x not allowed in mangled name", c);
- break;
- }
- }
-
- if (const char* msg = utf_decodeChar((utf8_t *)se->string, se->len, &i, &c))
- {
- pd->error("%s", msg);
- break;
- }
-
- if (!isUniAlpha(c))
- {
- pd->error("char 0x%04x not allowed in mangled name", c);
- break;
- }
- }
- }
- else if (pd->ident == Id::printf || pd->ident == Id::scanf)
- {
- if (pd->args && pd->args->length != 0)
- pd->error("takes no argument");
- goto Ldecl;
- }
- else if (global.params.ignoreUnsupportedPragmas)
- {
- if (global.params.verbose)
- {
- /* Print unrecognized pragmas
- */
- OutBuffer buf;
- buf.writestring(pd->ident->toChars());
- if (pd->args)
- {
- for (size_t i = 0; i < pd->args->length; i++)
- {
- Expression *e = (*pd->args)[i];
-
- sc = sc->startCTFE();
- e = expressionSemantic(e, sc);
- e = resolveProperties(sc, e);
- sc = sc->endCTFE();
-
- e = e->ctfeInterpret();
- if (i == 0)
- buf.writestring(" (");
- else
- buf.writeByte(',');
- buf.writestring(e->toChars());
- }
- if (pd->args->length)
- buf.writeByte(')');
- }
- message("pragma %s", buf.peekChars());
- }
- goto Lnodecl;
- }
- else
- error(pd->loc, "unrecognized pragma(%s)", pd->ident->toChars());
-
- Ldecl:
- if (pd->decl)
- {
- Scope *sc2 = pd->newScope(sc);
-
- for (size_t i = 0; i < pd->decl->length; i++)
- {
- Dsymbol *s = (*pd->decl)[i];
-
- dsymbolSemantic(s, sc2);
-
- if (pd->ident == Id::mangle)
- {
- assert(pd->args && pd->args->length == 1);
- if (StringExp *se = (*pd->args)[0]->toStringExp())
- {
- char *name = (char *)mem.xmalloc(se->len + 1);
- memcpy(name, se->string, se->len);
- name[se->len] = 0;
-
- unsigned cnt = setMangleOverride(s, name);
- if (cnt > 1)
- pd->error("can only apply to a single declaration");
- }
- }
- }
-
- if (sc2 != sc)
- sc2->pop();
- }
- return;
-
- Lnodecl:
- if (pd->decl)
- {
- pd->error("pragma is missing closing `;`");
- goto Ldecl; // do them anyway, to avoid segfaults.
- }
- }
-
- void visit(StaticIfDeclaration *sid)
- {
- attribSemantic(sid);
- }
-
- void visit(StaticForeachDeclaration *sfd)
- {
- attribSemantic(sfd);
- }
-
- Dsymbols *compileIt(CompileDeclaration *cd)
- {
- //printf("CompileDeclaration::compileIt(loc = %d) %s\n", cd->loc.linnum, cd->exp->toChars());
- OutBuffer buf;
- if (expressionsToString(buf, sc, cd->exps))
- return NULL;
-
- unsigned errors = global.errors;
- const size_t len = buf.length();
- const char *str = buf.extractChars();
- Parser p(cd->loc, sc->_module, (const utf8_t *)str, len, false);
- p.nextToken();
-
- Dsymbols *d = p.parseDeclDefs(0);
- if (global.errors != errors)
- return NULL;
-
- if (p.token.value != TOKeof)
- {
- cd->error("incomplete mixin declaration (%s)", str);
- return NULL;
- }
- return d;
- }
-
- void visit(CompileDeclaration *cd)
- {
- //printf("CompileDeclaration::semantic()\n");
- if (!cd->compiled)
- {
- cd->decl = compileIt(cd);
- cd->AttribDeclaration::addMember(sc, cd->scopesym);
- cd->compiled = true;
-
- if (cd->_scope && cd->decl)
- {
- for (size_t i = 0; i < cd->decl->length; i++)
- {
- Dsymbol *s = (*cd->decl)[i];
- s->setScope(cd->_scope);
- }
- }
- }
- attribSemantic(cd);
- }
-
- void visit(UserAttributeDeclaration *uad)
- {
- //printf("UserAttributeDeclaration::semantic() %p\n", this);
- if (uad->decl && !uad->_scope)
- uad->Dsymbol::setScope(sc); // for function local symbols
-
- attribSemantic(uad);
- }
-
- void visit(StaticAssert *sa)
- {
- if (sa->semanticRun < PASSsemanticdone)
- sa->semanticRun = PASSsemanticdone;
- }
-
- void visit(DebugSymbol *ds)
- {
- //printf("DebugSymbol::semantic() %s\n", ds->toChars());
- if (ds->semanticRun < PASSsemanticdone)
- ds->semanticRun = PASSsemanticdone;
- }
-
- void visit(VersionSymbol *vs)
- {
- if (vs->semanticRun < PASSsemanticdone)
- vs->semanticRun = PASSsemanticdone;
- }
-
- void visit(Package *pkg)
- {
- if (pkg->semanticRun < PASSsemanticdone)
- pkg->semanticRun = PASSsemanticdone;
- }
-
- void visit(Module *m)
- {
- if (m->semanticRun != PASSinit)
- return;
-
- //printf("+Module::semantic(this = %p, '%s'): parent = %p\n", this, m->toChars(), parent);
- m->semanticRun = PASSsemantic;
-
- // Note that modules get their own scope, from scratch.
- // This is so regardless of where in the syntax a module
- // gets imported, it is unaffected by context.
- Scope *sc = m->_scope; // see if already got one from importAll()
- if (!sc)
- {
- sc = Scope::createGlobal(m); // create root scope
- }
-
- //printf("Module = %p, linkage = %d\n", sc->scopesym, sc->linkage);
-
- // Pass 1 semantic routines: do public side of the definition
- for (size_t i = 0; i < m->members->length; i++)
- {
- Dsymbol *s = (*m->members)[i];
-
- //printf("\tModule('%s'): '%s'.semantic()\n", m->toChars(), s->toChars());
- dsymbolSemantic(s, sc);
- m->runDeferredSemantic();
- }
-
- if (m->userAttribDecl)
- {
- dsymbolSemantic(m->userAttribDecl, sc);
- }
-
- if (!m->_scope)
- {
- sc = sc->pop();
- sc->pop(); // 2 pops because Scope::createGlobal() created 2
- }
- m->semanticRun = PASSsemanticdone;
- //printf("-Module::semantic(this = %p, '%s'): parent = %p\n", m, m->toChars(), parent);
- }
-
- void visit(EnumDeclaration *ed)
- {
- //printf("EnumDeclaration::semantic(sd = %p, '%s') %s\n", sc->scopesym, sc->scopesym->toChars(), ed->toChars());
- //printf("EnumDeclaration::semantic() %p %s\n", ed, ed->toChars());
- if (ed->semanticRun >= PASSsemanticdone)
- return; // semantic() already completed
- if (ed->semanticRun == PASSsemantic)
- {
- assert(ed->memtype);
- error(ed->loc, "circular reference to enum base type %s", ed->memtype->toChars());
- ed->errors = true;
- ed->semanticRun = PASSsemanticdone;
- return;
- }
- unsigned dprogress_save = Module::dprogress;
-
- Scope *scx = NULL;
- if (ed->_scope)
- {
- sc = ed->_scope;
- scx = ed->_scope; // save so we don't make redundant copies
- ed->_scope = NULL;
- }
-
- if (!sc)
- return;
-
- ed->parent = sc->parent;
- ed->type = typeSemantic(ed->type, ed->loc, sc);
-
- ed->protection = sc->protection;
- if (sc->stc & STCdeprecated)
- ed->isdeprecated = true;
- ed->userAttribDecl = sc->userAttribDecl;
-
- ed->semanticRun = PASSsemantic;
-
- if (!ed->members && !ed->memtype) // enum ident;
- {
- ed->semanticRun = PASSsemanticdone;
- return;
- }
-
- if (!ed->symtab)
- ed->symtab = new DsymbolTable();
-
- /* The separate, and distinct, cases are:
- * 1. enum { ... }
- * 2. enum : memtype { ... }
- * 3. enum ident { ... }
- * 4. enum ident : memtype { ... }
- * 5. enum ident : memtype;
- * 6. enum ident;
- */
-
- if (ed->memtype)
- {
- ed->memtype = typeSemantic(ed->memtype, ed->loc, sc);
-
- /* Check to see if memtype is forward referenced
- */
- if (ed->memtype->ty == Tenum)
- {
- EnumDeclaration *sym = (EnumDeclaration *)ed->memtype->toDsymbol(sc);
- if (!sym->memtype || !sym->members || !sym->symtab || sym->_scope)
- {
- // memtype is forward referenced, so try again later
- ed->_scope = scx ? scx : sc->copy();
- ed->_scope->setNoFree();
- Module::addDeferredSemantic(ed);
- Module::dprogress = dprogress_save;
- //printf("\tdeferring %s\n", ed->toChars());
- ed->semanticRun = PASSinit;
- return;
- }
- else
- // Ensure that semantic is run to detect. e.g. invalid forward references
- dsymbolSemantic(sym, sc);
- }
- if (ed->memtype->ty == Tvoid)
- {
- ed->error("base type must not be void");
- ed->memtype = Type::terror;
- }
- if (ed->memtype->ty == Terror)
- {
- ed->errors = true;
- if (ed->members)
- {
- for (size_t i = 0; i < ed->members->length; i++)
- {
- Dsymbol *s = (*ed->members)[i];
- s->errors = true; // poison all the members
- }
- }
- ed->semanticRun = PASSsemanticdone;
- return;
- }
- }
-
- ed->semanticRun = PASSsemanticdone;
-
- if (!ed->members) // enum ident : memtype;
- return;
-
- if (ed->members->length == 0)
- {
- ed->error("enum %s must have at least one member", ed->toChars());
- ed->errors = true;
- return;
- }
-
- Module::dprogress++;
-
- Scope *sce;
- if (ed->isAnonymous())
- sce = sc;
- else
- {
- sce = sc->push(ed);
- sce->parent = ed;
- }
- sce = sce->startCTFE();
- sce->setNoFree(); // needed for getMaxMinValue()
-
- /* Each enum member gets the sce scope
- */
- for (size_t i = 0; i < ed->members->length; i++)
- {
- EnumMember *em = (*ed->members)[i]->isEnumMember();
- if (em)
- em->_scope = sce;
- }
-
- if (!ed->added)
- {
- /* addMember() is not called when the EnumDeclaration appears as a function statement,
- * so we have to do what addMember() does and install the enum members in the right symbol
- * table
- */
- ScopeDsymbol *scopesym = NULL;
- if (ed->isAnonymous())
- {
- /* Anonymous enum members get added to enclosing scope.
- */
- for (Scope *sct = sce; 1; sct = sct->enclosing)
- {
- assert(sct);
- if (sct->scopesym)
- {
- scopesym = sct->scopesym;
- if (!sct->scopesym->symtab)
- sct->scopesym->symtab = new DsymbolTable();
- break;
- }
- }
- }
- else
- {
- // Otherwise enum members are in the EnumDeclaration's symbol table
- scopesym = ed;
- }
-
- for (size_t i = 0; i < ed->members->length; i++)
- {
- EnumMember *em = (*ed->members)[i]->isEnumMember();
- if (em)
- {
- em->ed = ed;
- em->addMember(sc, scopesym);
- }
- }
- }
-
- for (size_t i = 0; i < ed->members->length; i++)
- {
- EnumMember *em = (*ed->members)[i]->isEnumMember();
- if (em)
- dsymbolSemantic(em, em->_scope);
- }
- //printf("defaultval = %lld\n", defaultval);
-
- //if (defaultval) printf("defaultval: %s %s\n", defaultval->toChars(), defaultval->type->toChars());
- //printf("members = %s\n", ed->members->toChars());
- }
-
- void visit(EnumMember *em)
- {
- //printf("EnumMember::semantic() %s\n", em->toChars());
- if (em->errors || em->semanticRun >= PASSsemanticdone)
- return;
- if (em->semanticRun == PASSsemantic)
- {
- em->error("circular reference to enum member");
- Lerrors:
- em->errors = true;
- em->semanticRun = PASSsemanticdone;
- return;
- }
- assert(em->ed);
-
- dsymbolSemantic(em->ed, sc);
- if (em->ed->errors)
- goto Lerrors;
-
- if (em->errors || em->semanticRun >= PASSsemanticdone)
- return;
-
- if (em->_scope)
- sc = em->_scope;
- if (!sc)
- return;
-
- em->semanticRun = PASSsemantic;
-
- em->protection = em->ed->isAnonymous() ? em->ed->protection : Prot(Prot::public_);
- em->linkage = LINKd;
- em->storage_class |= STCmanifest;
-
- // https://issues.dlang.org/show_bug.cgi?id=9701
- if (em->ed->isAnonymous())
- {
- if (em->userAttribDecl)
- em->userAttribDecl->userAttribDecl = em->ed->userAttribDecl;
- else
- em->userAttribDecl = em->ed->userAttribDecl;
- }
-
- // The first enum member is special
- bool first = (em == (*em->ed->members)[0]);
-
- if (em->origType)
- {
- em->origType = typeSemantic(em->origType, em->loc, sc);
- em->type = em->origType;
- assert(em->value()); // "type id;" is not a valid enum member declaration
- }
-
- if (em->value())
- {
- Expression *e = em->value();
- assert(e->dyncast() == DYNCAST_EXPRESSION);
- e = expressionSemantic(e, sc);
- e = resolveProperties(sc, e);
- e = e->ctfeInterpret();
- if (e->op == TOKerror)
- goto Lerrors;
- if (first && !em->ed->memtype && !em->ed->isAnonymous())
- {
- em->ed->memtype = e->type;
- if (em->ed->memtype->ty == Terror)
- {
- em->ed->errors = true;
- goto Lerrors;
- }
- if (em->ed->memtype->ty != Terror)
- {
- /* Bugzilla 11746: All of named enum members should have same type
- * with the first member. If the following members were referenced
- * during the first member semantic, their types should be unified.
- */
- for (size_t i = 0; i < em->ed->members->length; i++)
- {
- EnumMember *enm = (*em->ed->members)[i]->isEnumMember();
- if (!enm || enm == em || enm->semanticRun < PASSsemanticdone || enm->origType)
- continue;
-
- //printf("[%d] enm = %s, enm->semanticRun = %d\n", i, enm->toChars(), enm->semanticRun);
- Expression *ev = enm->value();
- ev = ev->implicitCastTo(sc, em->ed->memtype);
- ev = ev->ctfeInterpret();
- ev = ev->castTo(sc, em->ed->type);
- if (ev->op == TOKerror)
- em->ed->errors = true;
- enm->value() = ev;
- }
- if (em->ed->errors)
- {
- em->ed->memtype = Type::terror;
- goto Lerrors;
- }
- }
- }
-
- if (em->ed->memtype && !em->origType)
- {
- e = e->implicitCastTo(sc, em->ed->memtype);
- e = e->ctfeInterpret();
-
- // save origValue for better json output
- em->origValue = e;
-
- if (!em->ed->isAnonymous())
- {
- e = e->castTo(sc, em->ed->type);
- e = e->ctfeInterpret();
- }
- }
- else if (em->origType)
- {
- e = e->implicitCastTo(sc, em->origType);
- e = e->ctfeInterpret();
- assert(em->ed->isAnonymous());
-
- // save origValue for better json output
- em->origValue = e;
- }
- em->value() = e;
- }
- else if (first)
- {
- Type *t;
- if (em->ed->memtype)
- t = em->ed->memtype;
- else
- {
- t = Type::tint32;
- if (!em->ed->isAnonymous())
- em->ed->memtype = t;
- }
- Expression *e = new IntegerExp(em->loc, 0, Type::tint32);
- e = e->implicitCastTo(sc, t);
- e = e->ctfeInterpret();
-
- // save origValue for better json output
- em->origValue = e;
-
- if (!em->ed->isAnonymous())
- {
- e = e->castTo(sc, em->ed->type);
- e = e->ctfeInterpret();
- }
- em->value() = e;
- }
- else
- {
- /* Find the previous enum member,
- * and set this to be the previous value + 1
- */
- EnumMember *emprev = NULL;
- for (size_t i = 0; i < em->ed->members->length; i++)
- {
- EnumMember *enm = (*em->ed->members)[i]->isEnumMember();
- if (enm)
- {
- if (enm == em)
- break;
- emprev = enm;
- }
- }
- assert(emprev);
- if (emprev->semanticRun < PASSsemanticdone) // if forward reference
- dsymbolSemantic(emprev, emprev->_scope); // resolve it
- if (emprev->errors)
- goto Lerrors;
-
- Expression *eprev = emprev->value();
- Type *tprev = eprev->type->equals(em->ed->type) ? em->ed->memtype : eprev->type;
-
- Expression *emax = tprev->getProperty(em->ed->loc, Id::max, 0);
- emax = expressionSemantic(emax, sc);
- emax = emax->ctfeInterpret();
-
- // Set value to (eprev + 1).
- // But first check that (eprev != emax)
- assert(eprev);
- Expression *e = new EqualExp(TOKequal, em->loc, eprev, emax);
- e = expressionSemantic(e, sc);
- e = e->ctfeInterpret();
- if (e->toInteger())
- {
- em->error("initialization with (%s.%s + 1) causes overflow for type `%s`", emprev->ed->toChars(), emprev->toChars(), em->ed->type->toBasetype()->toChars());
- goto Lerrors;
- }
-
- // Now set e to (eprev + 1)
- e = new AddExp(em->loc, eprev, new IntegerExp(em->loc, 1, Type::tint32));
- e = expressionSemantic(e, sc);
- e = e->castTo(sc, eprev->type);
- e = e->ctfeInterpret();
-
- // save origValue (without cast) for better json output
- if (e->op != TOKerror) // avoid duplicate diagnostics
- {
- assert(emprev->origValue);
- em->origValue = new AddExp(em->loc, emprev->origValue, new IntegerExp(em->loc, 1, Type::tint32));
- em->origValue = expressionSemantic(em->origValue, sc);
- em->origValue = em->origValue->ctfeInterpret();
- }
-
- if (e->op == TOKerror)
- goto Lerrors;
- if (e->type->isfloating())
- {
- // Check that e != eprev (not always true for floats)
- Expression *etest = new EqualExp(TOKequal, em->loc, e, eprev);
- etest = expressionSemantic(etest, sc);
- etest = etest->ctfeInterpret();
- if (etest->toInteger())
- {
- em->error("has inexact value, due to loss of precision");
- goto Lerrors;
- }
- }
- em->value() = e;
- }
- if (!em->origType)
- em->type = em->value()->type;
-
- assert(em->origValue);
- em->semanticRun = PASSsemanticdone;
- }
-
- void visit(TemplateDeclaration *tempdecl)
- {
- if (tempdecl->semanticRun != PASSinit)
- return; // semantic() already run
-
- // Remember templates defined in module object that we need to know about
- if (sc->_module && sc->_module->ident == Id::object)
- {
- if (tempdecl->ident == Id::RTInfo)
- Type::rtinfo = tempdecl;
- }
-
- /* Remember Scope for later instantiations, but make
- * a copy since attributes can change.
- */
- if (!tempdecl->_scope)
- {
- tempdecl->_scope = sc->copy();
- tempdecl->_scope->setNoFree();
- }
-
- tempdecl->semanticRun = PASSsemantic;
-
- tempdecl->parent = sc->parent;
- tempdecl->protection = sc->protection;
- tempdecl->isstatic = tempdecl->toParent()->isModule() || (tempdecl->_scope->stc & STCstatic);
-
- if (!tempdecl->isstatic)
- {
- if (AggregateDeclaration *ad = tempdecl->parent->pastMixin()->isAggregateDeclaration())
- ad->makeNested();
- }
-
- // Set up scope for parameters
- ScopeDsymbol *paramsym = new ScopeDsymbol();
- paramsym->parent = tempdecl->parent;
- Scope *paramscope = sc->push(paramsym);
- paramscope->stc = 0;
-
- if (global.params.doDocComments)
- {
- tempdecl->origParameters = new TemplateParameters();
- tempdecl->origParameters->setDim(tempdecl->parameters->length);
- for (size_t i = 0; i < tempdecl->parameters->length; i++)
- {
- TemplateParameter *tp = (*tempdecl->parameters)[i];
- (*tempdecl->origParameters)[i] = tp->syntaxCopy();
- }
- }
-
- for (size_t i = 0; i < tempdecl->parameters->length; i++)
- {
- TemplateParameter *tp = (*tempdecl->parameters)[i];
-
- if (!tp->declareParameter(paramscope))
- {
- error(tp->loc, "parameter `%s` multiply defined", tp->ident->toChars());
- tempdecl->errors = true;
- }
- if (!tpsemantic(tp, paramscope, tempdecl->parameters))
- {
- tempdecl->errors = true;
- }
- if (i + 1 != tempdecl->parameters->length && tp->isTemplateTupleParameter())
- {
- tempdecl->error("template tuple parameter must be last one");
- tempdecl->errors = true;
- }
- }
-
- /* Calculate TemplateParameter::dependent
- */
- TemplateParameters tparams;
- tparams.setDim(1);
- for (size_t i = 0; i < tempdecl->parameters->length; i++)
- {
- TemplateParameter *tp = (*tempdecl->parameters)[i];
- tparams[0] = tp;
-
- for (size_t j = 0; j < tempdecl->parameters->length; j++)
- {
- // Skip cases like: X(T : T)
- if (i == j)
- continue;
-
- if (TemplateTypeParameter *ttp = (*tempdecl->parameters)[j]->isTemplateTypeParameter())
- {
- if (reliesOnTident(ttp->specType, &tparams))
- tp->dependent = true;
- }
- else if (TemplateAliasParameter *tap = (*tempdecl->parameters)[j]->isTemplateAliasParameter())
- {
- if (reliesOnTident(tap->specType, &tparams) ||
- reliesOnTident(isType(tap->specAlias), &tparams))
- {
- tp->dependent = true;
- }
- }
- }
- }
-
- paramscope->pop();
-
- // Compute again
- tempdecl->onemember = NULL;
- if (tempdecl->members)
- {
- Dsymbol *s;
- if (Dsymbol::oneMembers(tempdecl->members, &s, tempdecl->ident) && s)
- {
- tempdecl->onemember = s;
- s->parent = tempdecl;
- }
- }
-
- /* BUG: should check:
- * o no virtual functions or non-static data members of classes
- */
- tempdecl->semanticRun = PASSsemanticdone;
- }
-
- void visit(TemplateInstance *ti)
- {
- templateInstanceSemantic(ti, sc, NULL);
- }
-
- void visit(TemplateMixin *tm)
- {
- if (tm->semanticRun != PASSinit)
- {
- // When a class/struct contains mixin members, and is done over
- // because of forward references, never reach here so semanticRun
- // has been reset to PASSinit.
- return;
- }
- tm->semanticRun = PASSsemantic;
-
- Scope *scx = NULL;
- if (tm->_scope)
- {
- sc = tm->_scope;
- scx = tm->_scope; // save so we don't make redundant copies
- tm->_scope = NULL;
- }
-
- /* Run semantic on each argument, place results in tiargs[],
- * then find best match template with tiargs
- */
- if (!tm->findTempDecl(sc) ||
- !tm->semanticTiargs(sc) ||
- !tm->findBestMatch(sc, NULL))
- {
- if (tm->semanticRun == PASSinit) // forward reference had occured
- {
- //printf("forward reference - deferring\n");
- tm->_scope = scx ? scx : sc->copy();
- tm->_scope->setNoFree();
- Module::addDeferredSemantic(tm);
- return;
- }
-
- tm->inst = tm;
- tm->errors = true;
- return; // error recovery
- }
- TemplateDeclaration *tempdecl = tm->tempdecl->isTemplateDeclaration();
- assert(tempdecl);
-
- if (!tm->ident)
- {
- /* Assign scope local unique identifier, as same as lambdas.
- */
- const char *s = "__mixin";
-
- if (FuncDeclaration *func = sc->parent->isFuncDeclaration())
- {
- tm->symtab = func->localsymtab;
- if (tm->symtab)
- {
- // Inside template constraint, symtab is not set yet.
- goto L1;
- }
- }
- else
- {
- tm->symtab = sc->parent->isScopeDsymbol()->symtab;
- L1:
- assert(tm->symtab);
- int num = (int)dmd_aaLen(tm->symtab->tab) + 1;
- tm->ident = Identifier::generateId(s, num);
- tm->symtab->insert(tm);
- }
- }
-
- tm->inst = tm;
- tm->parent = sc->parent;
-
- /* Detect recursive mixin instantiations.
- */
- for (Dsymbol *s = tm->parent; s; s = s->parent)
- {
- //printf("\ts = '%s'\n", s->toChars());
- TemplateMixin *tmix = s->isTemplateMixin();
- if (!tmix || tempdecl != tmix->tempdecl)
- continue;
-
- /* Different argument list lengths happen with variadic args
- */
- if (tm->tiargs->length != tmix->tiargs->length)
- continue;
-
- for (size_t i = 0; i < tm->tiargs->length; i++)
- {
- RootObject *o = (*tm->tiargs)[i];
- Type *ta = isType(o);
- Expression *ea = isExpression(o);
- Dsymbol *sa = isDsymbol(o);
- RootObject *tmo = (*tmix->tiargs)[i];
- if (ta)
- {
- Type *tmta = isType(tmo);
- if (!tmta)
- goto Lcontinue;
- if (!ta->equals(tmta))
- goto Lcontinue;
- }
- else if (ea)
- {
- Expression *tme = isExpression(tmo);
- if (!tme || !ea->equals(tme))
- goto Lcontinue;
- }
- else if (sa)
- {
- Dsymbol *tmsa = isDsymbol(tmo);
- if (sa != tmsa)
- goto Lcontinue;
- }
- else
- assert(0);
- }
- tm->error("recursive mixin instantiation");
- return;
-
- Lcontinue:
- continue;
- }
-
- // Copy the syntax trees from the TemplateDeclaration
- tm->members = Dsymbol::arraySyntaxCopy(tempdecl->members);
- if (!tm->members)
- return;
-
- tm->symtab = new DsymbolTable();
-
- for (Scope *sce = sc; 1; sce = sce->enclosing)
- {
- ScopeDsymbol *sds = (ScopeDsymbol *)sce->scopesym;
- if (sds)
- {
- sds->importScope(tm, Prot(Prot::public_));
- break;
- }
- }
-
- Scope *scy = sc->push(tm);
- scy->parent = tm;
-
- tm->argsym = new ScopeDsymbol();
- tm->argsym->parent = scy->parent;
- Scope *argscope = scy->push(tm->argsym);
-
- unsigned errorsave = global.errors;
-
- // Declare each template parameter as an alias for the argument type
- tm->declareParameters(argscope);
-
- // Add members to enclosing scope, as well as this scope
- for (size_t i = 0; i < tm->members->length; i++)
- {
- Dsymbol *s = (*tm->members)[i];
- s->addMember(argscope, tm);
- //printf("sc->parent = %p, sc->scopesym = %p\n", sc->parent, sc->scopesym);
- //printf("s->parent = %s\n", s->parent->toChars());
- }
-
- // Do semantic() analysis on template instance members
- Scope *sc2 = argscope->push(tm);
- //size_t deferred_dim = Module::deferred.length;
-
- static int nest;
- //printf("%d\n", nest);
- if (++nest > global.recursionLimit)
- {
- global.gag = 0; // ensure error message gets printed
- tm->error("recursive expansion");
- fatal();
- }
-
- for (size_t i = 0; i < tm->members->length; i++)
- {
- Dsymbol *s = (*tm->members)[i];
- s->setScope(sc2);
- }
-
- for (size_t i = 0; i < tm->members->length; i++)
- {
- Dsymbol *s = (*tm->members)[i];
- s->importAll(sc2);
- }
-
- for (size_t i = 0; i < tm->members->length; i++)
- {
- Dsymbol *s = (*tm->members)[i];
- dsymbolSemantic(s, sc2);
- }
-
- nest--;
-
- /* In DeclDefs scope, TemplateMixin does not have to handle deferred symbols.
- * Because the members would already call Module::addDeferredSemantic() for themselves.
- * See Struct, Class, Interface, and EnumDeclaration::semantic().
- */
- //if (!sc->func && Module::deferred.length > deferred_dim) {}
-
- AggregateDeclaration *ad = tm->toParent()->isAggregateDeclaration();
- if (sc->func && !ad)
- {
- semantic2(tm, sc2);
- semantic3(tm, sc2);
- }
-
- // Give additional context info if error occurred during instantiation
- if (global.errors != errorsave)
- {
- tm->error("error instantiating");
- tm->errors = true;
- }
-
- sc2->pop();
- argscope->pop();
- scy->pop();
- }
-
- void visit(Nspace *ns)
- {
- if (ns->semanticRun != PASSinit)
- return;
- if (ns->_scope)
- {
- sc = ns->_scope;
- ns->_scope = NULL;
- }
- if (!sc)
- return;
-
- ns->semanticRun = PASSsemantic;
- ns->parent = sc->parent;
- if (ns->members)
- {
- assert(sc);
- sc = sc->push(ns);
- sc->linkage = LINKcpp; // note that namespaces imply C++ linkage
- sc->parent = ns;
-
- for (size_t i = 0; i < ns->members->length; i++)
- {
- Dsymbol *s = (*ns->members)[i];
- s->importAll(sc);
- }
-
- for (size_t i = 0; i < ns->members->length; i++)
- {
- Dsymbol *s = (*ns->members)[i];
- dsymbolSemantic(s, sc);
- }
- sc->pop();
- }
- ns->semanticRun = PASSsemanticdone;
- }
-
-
-private:
- static bool isPointerToChar(Parameter *p)
- {
- if (TypePointer *tptr = p->type->isTypePointer())
- {
- return tptr->next->ty == Tchar;
- }
- return false;
- }
-
- static bool isVa_list(Parameter *p, FuncDeclaration *funcdecl, Scope *sc)
- {
- return p->type->equals(target.va_listType(funcdecl->loc, sc));
- }
-
-public:
- void funcDeclarationSemantic(FuncDeclaration *funcdecl)
- {
- TypeFunction *f;
- AggregateDeclaration *ad;
- InterfaceDeclaration *id;
-
- if (funcdecl->semanticRun != PASSinit && funcdecl->isFuncLiteralDeclaration())
- {
- /* Member functions that have return types that are
- * forward references can have semantic() run more than
- * once on them.
- * See test\interface2.d, test20
- */
- return;
- }
-
- if (funcdecl->semanticRun >= PASSsemanticdone)
- return;
- assert(funcdecl->semanticRun <= PASSsemantic);
- funcdecl->semanticRun = PASSsemantic;
-
- if (funcdecl->_scope)
- {
- sc = funcdecl->_scope;
- funcdecl->_scope = NULL;
- }
-
- if (!sc || funcdecl->errors)
- return;
-
- funcdecl->parent = sc->parent;
- Dsymbol *parent = funcdecl->toParent();
-
- funcdecl->foverrides.setDim(0); // reset in case semantic() is being retried for this function
-
- funcdecl->storage_class |= sc->stc & ~STCref;
- ad = funcdecl->isThis();
- // Don't nest structs b/c of generated methods which should not access the outer scopes.
- // https://issues.dlang.org/show_bug.cgi?id=16627
- if (ad && !funcdecl->generated)
- {
- funcdecl->storage_class |= ad->storage_class & (STC_TYPECTOR | STCsynchronized);
- ad->makeNested();
- }
- if (sc->func)
- funcdecl->storage_class |= sc->func->storage_class & STCdisable;
- // Remove prefix storage classes silently.
- if ((funcdecl->storage_class & STC_TYPECTOR) && !(ad || funcdecl->isNested()))
- funcdecl->storage_class &= ~STC_TYPECTOR;
-
- //printf("function storage_class = x%llx, sc->stc = x%llx, %x\n", funcdecl->storage_class, sc->stc, Declaration::isFinal());
-
- FuncLiteralDeclaration *fld = funcdecl->isFuncLiteralDeclaration();
- if (fld && fld->treq)
- {
- Type *treq = fld->treq;
- assert(treq->nextOf()->ty == Tfunction);
- if (treq->ty == Tdelegate)
- fld->tok = TOKdelegate;
- else if (treq->ty == Tpointer && treq->nextOf()->ty == Tfunction)
- fld->tok = TOKfunction;
- else
- assert(0);
- funcdecl->linkage = treq->nextOf()->toTypeFunction()->linkage;
- }
- else
- funcdecl->linkage = sc->linkage;
- funcdecl->inlining = sc->inlining;
- funcdecl->protection = sc->protection;
- funcdecl->userAttribDecl = sc->userAttribDecl;
-
- if (!funcdecl->originalType)
- funcdecl->originalType = funcdecl->type->syntaxCopy();
- if (funcdecl->type->ty != Tfunction)
- {
- if (funcdecl->type->ty != Terror)
- {
- funcdecl->error("%s must be a function instead of %s", funcdecl->toChars(), funcdecl->type->toChars());
- funcdecl->type = Type::terror;
- }
- funcdecl->errors = true;
- return;
- }
- if (!funcdecl->type->deco)
- {
- sc = sc->push();
- sc->stc |= funcdecl->storage_class & (STCdisable | STCdeprecated); // forward to function type
- TypeFunction *tf = funcdecl->type->toTypeFunction();
-
- if (sc->func)
- {
- /* If the nesting parent is pure without inference,
- * then this function defaults to pure too.
- *
- * auto foo() pure {
- * auto bar() {} // become a weak purity funciton
- * class C { // nested class
- * auto baz() {} // become a weak purity funciton
- * }
- *
- * static auto boo() {} // typed as impure
- * // Even though, boo cannot call any impure functions.
- * // See also Expression::checkPurity().
- * }
- */
- if (tf->purity == PUREimpure && (funcdecl->isNested() || funcdecl->isThis()))
- {
- FuncDeclaration *fd = NULL;
- for (Dsymbol *p = funcdecl->toParent2(); p; p = p->toParent2())
- {
- if (AggregateDeclaration *adx = p->isAggregateDeclaration())
- {
- if (adx->isNested())
- continue;
- break;
- }
- if ((fd = p->isFuncDeclaration()) != NULL)
- break;
- }
-
- /* If the parent's purity is inferred, then this function's purity needs
- * to be inferred first.
- */
- if (fd && fd->isPureBypassingInference() >= PUREweak &&
- !funcdecl->isInstantiated())
- {
- tf->purity = PUREfwdref; // default to pure
- }
- }
- }
-
- if (tf->isref) sc->stc |= STCref;
- if (tf->isscope) sc->stc |= STCscope;
- if (tf->isnothrow) sc->stc |= STCnothrow;
- if (tf->isnogc) sc->stc |= STCnogc;
- if (tf->isproperty) sc->stc |= STCproperty;
- if (tf->purity == PUREfwdref) sc->stc |= STCpure;
- if (tf->trust != TRUSTdefault)
- sc->stc &= ~(STCsafe | STCsystem | STCtrusted);
- if (tf->trust == TRUSTsafe) sc->stc |= STCsafe;
- if (tf->trust == TRUSTsystem) sc->stc |= STCsystem;
- if (tf->trust == TRUSTtrusted) sc->stc |= STCtrusted;
-
- if (funcdecl->isCtorDeclaration())
- {
- sc->flags |= SCOPEctor;
-
- Type *tret = ad->handleType();
- assert(tret);
- tret = tret->addStorageClass(funcdecl->storage_class | sc->stc);
- tret = tret->addMod(funcdecl->type->mod);
- tf->next = tret;
-
- if (ad->isStructDeclaration())
- sc->stc |= STCref;
- }
-
- // 'return' on a non-static class member function implies 'scope' as well
- if (ad && ad->isClassDeclaration() && (tf->isreturn || sc->stc & STCreturn) && !(sc->stc & STCstatic))
- sc->stc |= STCscope;
-
- // If 'this' has no pointers, remove 'scope' as it has no meaning
- if (sc->stc & STCscope && ad && ad->isStructDeclaration() && !ad->type->hasPointers())
- {
- sc->stc &= ~STCscope;
- tf->isscope = false;
- }
-
- sc->linkage = funcdecl->linkage;
-
- if (!tf->isNaked() && !(funcdecl->isThis() || funcdecl->isNested()))
- {
- OutBuffer buf;
- MODtoBuffer(&buf, tf->mod);
- funcdecl->error("without `this` cannot be %s", buf.peekChars());
- tf->mod = 0; // remove qualifiers
- }
-
- /* Apply const, immutable, wild and shared storage class
- * to the function type. Do this before type semantic.
- */
- StorageClass stc = funcdecl->storage_class;
- if (funcdecl->type->isImmutable())
- stc |= STCimmutable;
- if (funcdecl->type->isConst())
- stc |= STCconst;
- if (funcdecl->type->isShared() || funcdecl->storage_class & STCsynchronized)
- stc |= STCshared;
- if (funcdecl->type->isWild())
- stc |= STCwild;
- switch (stc & STC_TYPECTOR)
- {
- case STCimmutable:
- case STCimmutable | STCconst:
- case STCimmutable | STCwild:
- case STCimmutable | STCwild | STCconst:
- case STCimmutable | STCshared:
- case STCimmutable | STCshared | STCconst:
- case STCimmutable | STCshared | STCwild:
- case STCimmutable | STCshared | STCwild | STCconst:
- // Don't use immutableOf(), as that will do a merge()
- funcdecl->type = funcdecl->type->makeImmutable();
- break;
-
- case STCconst:
- funcdecl->type = funcdecl->type->makeConst();
- break;
-
- case STCwild:
- funcdecl->type = funcdecl->type->makeWild();
- break;
-
- case STCwild | STCconst:
- funcdecl->type = funcdecl->type->makeWildConst();
- break;
-
- case STCshared:
- funcdecl->type = funcdecl->type->makeShared();
- break;
-
- case STCshared | STCconst:
- funcdecl->type = funcdecl->type->makeSharedConst();
- break;
-
- case STCshared | STCwild:
- funcdecl->type = funcdecl->type->makeSharedWild();
- break;
-
- case STCshared | STCwild | STCconst:
- funcdecl->type = funcdecl->type->makeSharedWildConst();
- break;
-
- case 0:
- break;
-
- default:
- assert(0);
- }
-
- funcdecl->type = typeSemantic(funcdecl->type, funcdecl->loc, sc);
- sc = sc->pop();
- }
- if (funcdecl->type->ty != Tfunction)
- {
- if (funcdecl->type->ty != Terror)
- {
- funcdecl->error("%s must be a function instead of %s", funcdecl->toChars(), funcdecl->type->toChars());
- funcdecl->type = Type::terror;
- }
- funcdecl->errors = true;
- return;
- }
- else
- {
- // Merge back function attributes into 'originalType'.
- // It's used for mangling, ddoc, and json output.
- TypeFunction *tfo = funcdecl->originalType->toTypeFunction();
- TypeFunction *tfx = funcdecl->type->toTypeFunction();
- tfo->mod = tfx->mod;
- tfo->isscope = tfx->isscope;
- tfo->isscopeinferred = tfx->isscopeinferred;
- tfo->isref = tfx->isref;
- tfo->isnothrow = tfx->isnothrow;
- tfo->isnogc = tfx->isnogc;
- tfo->isproperty = tfx->isproperty;
- tfo->purity = tfx->purity;
- tfo->trust = tfx->trust;
-
- funcdecl->storage_class &= ~(STC_TYPECTOR | STC_FUNCATTR);
- }
-
- f = (TypeFunction *)funcdecl->type;
-
- if ((funcdecl->storage_class & STCauto) && !f->isref && !funcdecl->inferRetType)
- funcdecl->error("storage class `auto` has no effect if return type is not inferred");
- /* Functions can only be 'scope' if they have a 'this'
- */
- if (f->isscope && !funcdecl->isNested() && !ad)
- {
- funcdecl->error("functions cannot be scope");
- }
-
- if (f->isreturn && !funcdecl->needThis() && !funcdecl->isNested())
- {
- /* Non-static nested functions have a hidden 'this' pointer to which
- * the 'return' applies
- */
- funcdecl->error("static member has no `this` to which `return` can apply");
- }
-
- if (funcdecl->isAbstract() && !funcdecl->isVirtual())
- {
- const char *sfunc;
- if (funcdecl->isStatic())
- sfunc = "static";
- else if (funcdecl->protection.kind == Prot::private_ || funcdecl->protection.kind == Prot::package_)
- sfunc = protectionToChars(funcdecl->protection.kind);
- else
- sfunc = "non-virtual";
- funcdecl->error("%s functions cannot be abstract", sfunc);
- }
-
- if (funcdecl->isOverride() && !funcdecl->isVirtual())
- {
- Prot::Kind kind = funcdecl->prot().kind;
- if ((kind == Prot::private_ || kind == Prot::package_) && funcdecl->isMember())
- funcdecl->error("%s method is not virtual and cannot override", protectionToChars(kind));
- else
- funcdecl->error("cannot override a non-virtual function");
- }
-
- if (funcdecl->isAbstract() && funcdecl->isFinalFunc())
- funcdecl->error("cannot be both final and abstract");
-
- if (const unsigned pors = sc->flags & (SCOPEprintf | SCOPEscanf))
- {
- /* printf/scanf-like functions must be of the form:
- * extern (C/C++) T printf([parameters...], const(char)* format, ...);
- * or:
- * extern (C/C++) T vprintf([parameters...], const(char)* format, va_list);
- */
- const size_t nparams = f->parameterList.length();
- if ((f->linkage == LINKc || f->linkage == LINKcpp) &&
-
- ((f->parameterList.varargs == VARARGvariadic &&
- nparams >= 1 &&
- isPointerToChar(f->parameterList[nparams - 1])) ||
- (f->parameterList.varargs == VARARGnone &&
- nparams >= 2 &&
- isPointerToChar(f->parameterList[nparams - 2]) &&
- isVa_list(f->parameterList[nparams - 1], funcdecl, sc))
- )
- )
- {
- funcdecl->flags |= (pors == SCOPEprintf) ? FUNCFLAGprintf : FUNCFLAGscanf;
- }
- else
- {
- const char *p = (pors == SCOPEprintf ? Id::printf : Id::scanf)->toChars();
- if (f->parameterList.varargs == VARARGvariadic)
- {
- funcdecl->error("`pragma(%s)` functions must be `extern(C) %s %s([parameters...], const(char)*, ...)`"
- " not `%s`",
- p, f->next->toChars(), funcdecl->toChars(), funcdecl->type->toChars());
- }
- else
- {
- funcdecl->error("`pragma(%s)` functions must be `extern(C) %s %s([parameters...], const(char)*, va_list)`",
- p, f->next->toChars(), funcdecl->toChars());
- }
- }
- }
-
- id = parent->isInterfaceDeclaration();
- if (id)
- {
- funcdecl->storage_class |= STCabstract;
-
- if (funcdecl->isCtorDeclaration() ||
- funcdecl->isPostBlitDeclaration() ||
- funcdecl->isDtorDeclaration() ||
- funcdecl->isInvariantDeclaration() ||
- funcdecl->isNewDeclaration() || funcdecl->isDelete())
- funcdecl->error("constructors, destructors, postblits, invariants, new and delete functions are not allowed in interface %s", id->toChars());
- if (funcdecl->fbody && funcdecl->isVirtual())
- funcdecl->error("function body only allowed in final functions in interface %s", id->toChars());
- }
-
- if (UnionDeclaration *ud = parent->isUnionDeclaration())
- {
- if (funcdecl->isPostBlitDeclaration() ||
- funcdecl->isDtorDeclaration() ||
- funcdecl->isInvariantDeclaration())
- funcdecl->error("destructors, postblits and invariants are not allowed in union %s", ud->toChars());
- }
-
- if (parent->isStructDeclaration())
- {
- if (funcdecl->isCtorDeclaration())
- {
- goto Ldone;
- }
- }
-
- if (ClassDeclaration *cd = parent->isClassDeclaration())
- {
- if (funcdecl->isCtorDeclaration())
- {
- goto Ldone;
- }
-
- if (funcdecl->storage_class & STCabstract)
- cd->isabstract = ABSyes;
-
- // if static function, do not put in vtbl[]
- if (!funcdecl->isVirtual())
- {
- //printf("\tnot virtual\n");
- goto Ldone;
- }
- // Suppress further errors if the return type is an error
- if (funcdecl->type->nextOf() == Type::terror)
- goto Ldone;
-
- bool may_override = false;
- for (size_t i = 0; i < cd->baseclasses->length; i++)
- {
- BaseClass *b = (*cd->baseclasses)[i];
- ClassDeclaration *cbd = b->type->toBasetype()->isClassHandle();
- if (!cbd)
- continue;
- for (size_t j = 0; j < cbd->vtbl.length; j++)
- {
- FuncDeclaration *f2 = cbd->vtbl[j]->isFuncDeclaration();
- if (!f2 || f2->ident != funcdecl->ident)
- continue;
- if (cbd->parent && cbd->parent->isTemplateInstance())
- {
- if (!f2->functionSemantic())
- goto Ldone;
- }
- may_override = true;
- }
- }
- if (may_override && funcdecl->type->nextOf() == NULL)
- {
- /* If same name function exists in base class but 'this' is auto return,
- * cannot find index of base class's vtbl[] to override.
- */
- funcdecl->error("return type inference is not supported if may override base class function");
- }
-
- /* Find index of existing function in base class's vtbl[] to override
- * (the index will be the same as in cd's current vtbl[])
- */
- int vi = cd->baseClass ? funcdecl->findVtblIndex((Dsymbols*)&cd->baseClass->vtbl, (int)cd->baseClass->vtbl.length)
- : -1;
-
- bool doesoverride = false;
- switch (vi)
- {
- case -1:
- Lintro:
- /* Didn't find one, so
- * This is an 'introducing' function which gets a new
- * slot in the vtbl[].
- */
-
- // Verify this doesn't override previous final function
- if (cd->baseClass)
- {
- Dsymbol *s = cd->baseClass->search(funcdecl->loc, funcdecl->ident);
- if (s)
- {
- FuncDeclaration *f2 = s->isFuncDeclaration();
- if (f2)
- {
- f2 = f2->overloadExactMatch(funcdecl->type);
- if (f2 && f2->isFinalFunc() && f2->prot().kind != Prot::private_)
- funcdecl->error("cannot override final function %s", f2->toPrettyChars());
- }
- }
- }
-
- /* These quirky conditions mimic what VC++ appears to do
- */
- if (global.params.mscoff && cd->isCPPclass() &&
- cd->baseClass && cd->baseClass->vtbl.length)
- {
- /* if overriding an interface function, then this is not
- * introducing and don't put it in the class vtbl[]
- */
- funcdecl->interfaceVirtual = funcdecl->overrideInterface();
- if (funcdecl->interfaceVirtual)
- {
- //printf("\tinterface function %s\n", funcdecl->toChars());
- cd->vtblFinal.push(funcdecl);
- goto Linterfaces;
- }
- }
-
- if (funcdecl->isFinalFunc())
- {
- // Don't check here, as it may override an interface function
- //if (funcdecl->isOverride())
- //funcdecl->error("is marked as override, but does not override any function");
- cd->vtblFinal.push(funcdecl);
- }
- else
- {
- //printf("\tintroducing function %s\n", funcdecl->toChars());
- funcdecl->introducing = 1;
- if (cd->isCPPclass() && target.cpp.reverseOverloads)
- {
- // with dmc, overloaded functions are grouped and in reverse order
- funcdecl->vtblIndex = (int)cd->vtbl.length;
- for (int i = 0; i < (int)cd->vtbl.length; i++)
- {
- if (cd->vtbl[i]->ident == funcdecl->ident && cd->vtbl[i]->parent == parent)
- {
- funcdecl->vtblIndex = (int)i;
- break;
- }
- }
- // shift all existing functions back
- for (int i = (int)cd->vtbl.length; i > funcdecl->vtblIndex; i--)
- {
- FuncDeclaration *fd = cd->vtbl[i-1]->isFuncDeclaration();
- assert(fd);
- fd->vtblIndex++;
- }
- cd->vtbl.insert(funcdecl->vtblIndex, funcdecl);
- }
- else
- {
- // Append to end of vtbl[]
- vi = (int)cd->vtbl.length;
- cd->vtbl.push(funcdecl);
- funcdecl->vtblIndex = vi;
- }
- }
- break;
-
- case -2:
- // can't determine because of forward references
- funcdecl->errors = true;
- return;
-
- default:
- {
- FuncDeclaration *fdv = cd->baseClass->vtbl[vi]->isFuncDeclaration();
- FuncDeclaration *fdc = cd->vtbl[vi]->isFuncDeclaration();
- // This function is covariant with fdv
-
- if (fdc == funcdecl)
- {
- doesoverride = true;
- break;
- }
-
- if (fdc->toParent() == parent)
- {
- //printf("vi = %d,\tthis = %p %s %s @ [%s]\n\tfdc = %p %s %s @ [%s]\n\tfdv = %p %s %s @ [%s]\n",
- // vi, funcdecl, funcdecl->toChars(), funcdecl->type->toChars(), funcdecl->loc.toChars(),
- // fdc, fdc ->toChars(), fdc ->type->toChars(), fdc ->loc.toChars(),
- // fdv, fdv ->toChars(), fdv ->type->toChars(), fdv ->loc.toChars());
-
- // fdc overrides fdv exactly, then this introduces new function.
- if (fdc->type->mod == fdv->type->mod && funcdecl->type->mod != fdv->type->mod)
- goto Lintro;
- }
-
- // This function overrides fdv
- if (fdv->isFinalFunc())
- funcdecl->error("cannot override final function %s", fdv->toPrettyChars());
-
- if (!funcdecl->isOverride())
- {
- if (fdv->isFuture())
- {
- ::deprecation(funcdecl->loc, "@__future base class method %s is being overridden by %s; rename the latter",
- fdv->toPrettyChars(), funcdecl->toPrettyChars());
- // Treat 'this' as an introducing function, giving it a separate hierarchy in the vtbl[]
- goto Lintro;
- }
- else
- {
- int vi2 = funcdecl->findVtblIndex(&cd->baseClass->vtbl, (int)cd->baseClass->vtbl.length, false);
- if (vi2 < 0)
- // https://issues.dlang.org/show_bug.cgi?id=17349
- ::deprecation(funcdecl->loc, "cannot implicitly override base class method `%s` with `%s`; add `override` attribute",
- fdv->toPrettyChars(), funcdecl->toPrettyChars());
- else
- error(funcdecl->loc, "implicitly overriding base class method %s with %s deprecated; add `override` attribute",
- fdv->toPrettyChars(), funcdecl->toPrettyChars());
- }
- }
-
- doesoverride = true;
- if (fdc->toParent() == parent)
- {
- // If both are mixins, or both are not, then error.
- // If either is not, the one that is not overrides the other.
- bool thismixin = funcdecl->parent->isClassDeclaration() != NULL;
- bool fdcmixin = fdc->parent->isClassDeclaration() != NULL;
- if (thismixin == fdcmixin)
- {
- funcdecl->error("multiple overrides of same function");
- }
- else if (!thismixin) // fdc overrides fdv
- {
- // this doesn't override any function
- break;
- }
- }
- cd->vtbl[vi] = funcdecl;
- funcdecl->vtblIndex = vi;
-
- /* Remember which functions this overrides
- */
- funcdecl->foverrides.push(fdv);
-
- /* This works by whenever this function is called,
- * it actually returns tintro, which gets dynamically
- * cast to type. But we know that tintro is a base
- * of type, so we could optimize it by not doing a
- * dynamic cast, but just subtracting the isBaseOf()
- * offset if the value is != null.
- */
-
- if (fdv->tintro)
- funcdecl->tintro = fdv->tintro;
- else if (!funcdecl->type->equals(fdv->type))
- {
- /* Only need to have a tintro if the vptr
- * offsets differ
- */
- int offset;
- if (fdv->type->nextOf()->isBaseOf(funcdecl->type->nextOf(), &offset))
- {
- funcdecl->tintro = fdv->type;
- }
- }
- break;
- }
- }
-
- /* Go through all the interface bases.
- * If this function is covariant with any members of those interface
- * functions, set the tintro.
- */
- Linterfaces:
- for (size_t i = 0; i < cd->interfaces.length; i++)
- {
- BaseClass *b = cd->interfaces.ptr[i];
- vi = funcdecl->findVtblIndex((Dsymbols *)&b->sym->vtbl, (int)b->sym->vtbl.length);
- switch (vi)
- {
- case -1:
- break;
-
- case -2:
- // can't determine because of forward references
- funcdecl->errors = true;
- return;
-
- default:
- {
- FuncDeclaration *fdv = (FuncDeclaration *)b->sym->vtbl[vi];
- Type *ti = NULL;
-
- /* Remember which functions this overrides
- */
- funcdecl->foverrides.push(fdv);
-
- /* Should we really require 'override' when implementing
- * an interface function?
- */
- //if (!funcdecl->isOverride())
- //warning(funcdecl->loc, "overrides base class function %s, but is not marked with `override`", fdv->toPrettyChars());
-
- if (fdv->tintro)
- ti = fdv->tintro;
- else if (!funcdecl->type->equals(fdv->type))
- {
- /* Only need to have a tintro if the vptr
- * offsets differ
- */
- int offset;
- if (fdv->type->nextOf()->isBaseOf(funcdecl->type->nextOf(), &offset))
- {
- ti = fdv->type;
- }
- }
- if (ti)
- {
- if (funcdecl->tintro)
- {
- if (!funcdecl->tintro->nextOf()->equals(ti->nextOf()) &&
- !funcdecl->tintro->nextOf()->isBaseOf(ti->nextOf(), NULL) &&
- !ti->nextOf()->isBaseOf(funcdecl->tintro->nextOf(), NULL))
- {
- funcdecl->error("incompatible covariant types %s and %s", funcdecl->tintro->toChars(), ti->toChars());
- }
- }
- funcdecl->tintro = ti;
- }
- goto L2;
- }
- }
- }
-
- if (!doesoverride && funcdecl->isOverride() && (funcdecl->type->nextOf() || !may_override))
- {
- BaseClass *bc = NULL;
- Dsymbol *s = NULL;
- for (size_t i = 0; i < cd->baseclasses->length; i++)
- {
- bc = (*cd->baseclasses)[i];
- s = bc->sym->search_correct(funcdecl->ident);
- if (s) break;
- }
-
- if (s)
- funcdecl->error("does not override any function, did you mean to override `%s%s`?",
- bc->sym->isCPPclass() ? "extern (C++) " : "", s->toPrettyChars());
- else
- funcdecl->error("does not override any function");
- }
-
- L2: ;
-
- /* Go through all the interface bases.
- * Disallow overriding any final functions in the interface(s).
- */
- for (size_t i = 0; i < cd->interfaces.length; i++)
- {
- BaseClass *b = cd->interfaces.ptr[i];
- if (b->sym)
- {
- Dsymbol *s = search_function(b->sym, funcdecl->ident);
- if (s)
- {
- FuncDeclaration *f2 = s->isFuncDeclaration();
- if (f2)
- {
- f2 = f2->overloadExactMatch(funcdecl->type);
- if (f2 && f2->isFinalFunc() && f2->prot().kind != Prot::private_)
- funcdecl->error("cannot override final function %s.%s", b->sym->toChars(), f2->toPrettyChars());
- }
- }
- }
- }
-
- if (funcdecl->isOverride())
- {
- if (funcdecl->storage_class & STCdisable)
- funcdecl->deprecation("overridden functions cannot be annotated @disable");
- if (funcdecl->isDeprecated())
- funcdecl->deprecation("deprecated functions cannot be annotated @disable");
- }
- }
- else if (funcdecl->isOverride() && !parent->isTemplateInstance())
- funcdecl->error("override only applies to class member functions");
-
- // Reflect this->type to f because it could be changed by findVtblIndex
- f = funcdecl->type->toTypeFunction();
-
- Ldone:
- /* Contracts can only appear without a body when they are virtual interface functions
- */
- if (!funcdecl->fbody && !allowsContractWithoutBody(funcdecl))
- funcdecl->error("in and out contracts can only appear without a body when they are virtual interface functions or abstract");
-
- /* Do not allow template instances to add virtual functions
- * to a class.
- */
- if (funcdecl->isVirtual())
- {
- 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
- ClassDeclaration *cd = ti->tempdecl->isClassMember();
- if (cd)
- {
- funcdecl->error("cannot use template to add virtual function to class `%s`", cd->toChars());
- }
- }
- }
-
- if (funcdecl->isMain())
- funcdecl->checkDmain(); // Check main() parameters and return type
-
- /* Purity and safety can be inferred for some functions by examining
- * the function body.
- */
- if (canInferAttributes(funcdecl, sc))
- initInferAttributes(funcdecl);
-
- Module::dprogress++;
- funcdecl->semanticRun = PASSsemanticdone;
-
- /* Save scope for possible later use (if we need the
- * function internals)
- */
- funcdecl->_scope = sc->copy();
- funcdecl->_scope->setNoFree();
-
- static bool printedMain = false; // semantic might run more than once
- if (global.params.verbose && !printedMain)
- {
- const char *type = funcdecl->isMain() ? "main" : funcdecl->isWinMain() ? "winmain" : funcdecl->isDllMain() ? "dllmain" : (const char *)NULL;
- Module *mod = sc->_module;
-
- if (type && mod)
- {
- printedMain = true;
- const char *name = mod->srcfile->toChars();
- const char *path = FileName::searchPath(global.path, name, true);
- message("entry %-10s\t%s", type, path ? path : name);
- }
- }
-
- if (funcdecl->fbody && funcdecl->isMain() && sc->_module->isRoot())
- Compiler::genCmain(sc);
-
- assert(funcdecl->type->ty != Terror || funcdecl->errors);
-
- // semantic for parameters' UDAs
- const size_t nparams = f->parameterList.length();
- for (size_t i = 0; i < nparams; i++)
- {
- Parameter *param = f->parameterList[i];
- if (param && param->userAttribDecl)
- dsymbolSemantic(param->userAttribDecl, sc);
- }
- }
-
- // Do the semantic analysis on the external interface to the function.
- void visit(FuncDeclaration *funcdecl)
- {
- funcDeclarationSemantic(funcdecl);
- }
-
- void visit(CtorDeclaration *ctd)
- {
- //printf("CtorDeclaration::semantic() %s\n", ctd->toChars());
- if (ctd->semanticRun >= PASSsemanticdone)
- return;
- if (ctd->_scope)
- {
- sc = ctd->_scope;
- ctd->_scope = NULL;
- }
-
- ctd->parent = sc->parent;
- Dsymbol *p = ctd->toParent2();
- AggregateDeclaration *ad = p->isAggregateDeclaration();
- if (!ad)
- {
- error(ctd->loc, "constructor can only be a member of aggregate, not %s %s",
- p->kind(), p->toChars());
- ctd->type = Type::terror;
- ctd->errors = true;
- return;
- }
-
- sc = sc->push();
- sc->stc &= ~STCstatic; // not a static constructor
- sc->flags |= SCOPEctor;
-
- funcDeclarationSemantic(ctd);
-
- sc->pop();
-
- if (ctd->errors)
- return;
-
- TypeFunction *tf = ctd->type->toTypeFunction();
-
- /* See if it's the default constructor
- * But, template constructor should not become a default constructor.
- */
- if (ad && (!ctd->parent->isTemplateInstance() || ctd->parent->isTemplateMixin()))
- {
- const size_t dim = tf->parameterList.length();
-
- if (StructDeclaration *sd = ad->isStructDeclaration())
- {
- if (dim == 0 && tf->parameterList.varargs == VARARGnone) // empty default ctor w/o any varargs
- {
- if (ctd->fbody || !(ctd->storage_class & STCdisable) || dim)
- {
- ctd->error("default constructor for structs only allowed "
- "with @disable, no body, and no parameters");
- ctd->storage_class |= STCdisable;
- ctd->fbody = NULL;
- }
- sd->noDefaultCtor = true;
- }
- else if (dim == 0 && tf->parameterList.varargs) // allow varargs only ctor
- {
- }
- else if (dim && tf->parameterList[0]->defaultArg)
- {
- // if the first parameter has a default argument, then the rest does as well
- if (ctd->storage_class & STCdisable)
- {
- ctd->deprecation("@disable'd constructor cannot have default "
- "arguments for all parameters.");
- deprecationSupplemental(ctd->loc, "Use @disable this(); if you want to disable default initialization.");
- }
- else
- ctd->deprecation("all parameters have default arguments, "
- "but structs cannot have default constructors.");
- }
-
- }
- else if (dim == 0 && tf->parameterList.varargs == VARARGnone)
- {
- ad->defaultCtor = ctd;
- }
- }
- }
-
- void visit(PostBlitDeclaration *pbd)
- {
- //printf("PostBlitDeclaration::semantic() %s\n", pbd->toChars());
- //printf("ident: %s, %s, %p, %p\n", pbd->ident->toChars(), Id::dtor->toChars(), pbd->ident, Id::dtor);
- //printf("stc = x%llx\n", sc->stc);
- if (pbd->semanticRun >= PASSsemanticdone)
- return;
- if (pbd->_scope)
- {
- sc = pbd->_scope;
- pbd->_scope = NULL;
- }
-
- pbd->parent = sc->parent;
- Dsymbol *p = pbd->toParent2();
- StructDeclaration *ad = p->isStructDeclaration();
- if (!ad)
- {
- error(pbd->loc, "postblit can only be a member of struct/union, not %s %s",
- p->kind(), p->toChars());
- pbd->type = Type::terror;
- pbd->errors = true;
- return;
- }
- if (pbd->ident == Id::postblit && pbd->semanticRun < PASSsemantic)
- ad->postblits.push(pbd);
- if (!pbd->type)
- pbd->type = new TypeFunction(ParameterList(), Type::tvoid, LINKd, pbd->storage_class);
-
- sc = sc->push();
- sc->stc &= ~STCstatic; // not static
- sc->linkage = LINKd;
-
- funcDeclarationSemantic(pbd);
-
- sc->pop();
- }
-
- void visit(DtorDeclaration *dd)
- {
- //printf("DtorDeclaration::semantic() %s\n", dd->toChars());
- //printf("ident: %s, %s, %p, %p\n", dd->ident->toChars(), Id::dtor->toChars(), dd->ident, Id::dtor);
- if (dd->semanticRun >= PASSsemanticdone)
- return;
- if (dd->_scope)
- {
- sc = dd->_scope;
- dd->_scope = NULL;
- }
-
- dd->parent = sc->parent;
- Dsymbol *p = dd->toParent2();
- AggregateDeclaration *ad = p->isAggregateDeclaration();
- if (!ad)
- {
- error(dd->loc, "destructor can only be a member of aggregate, not %s %s",
- p->kind(), p->toChars());
- dd->type = Type::terror;
- dd->errors = true;
- return;
- }
- if (dd->ident == Id::dtor && dd->semanticRun < PASSsemantic)
- ad->dtors.push(dd);
- if (!dd->type)
- dd->type = new TypeFunction(ParameterList(), Type::tvoid, LINKd, dd->storage_class);
-
- sc = sc->push();
- sc->stc &= ~STCstatic; // not a static destructor
- if (sc->linkage != LINKcpp)
- sc->linkage = LINKd;
-
- funcDeclarationSemantic(dd);
-
- sc->pop();
- }
-
- void visit(StaticCtorDeclaration *scd)
- {
- //printf("StaticCtorDeclaration::semantic()\n");
- if (scd->semanticRun >= PASSsemanticdone)
- return;
- if (scd->_scope)
- {
- sc = scd->_scope;
- scd->_scope = NULL;
- }
-
- scd->parent = sc->parent;
- Dsymbol *p = scd->parent->pastMixin();
- if (!p->isScopeDsymbol())
- {
- const char *s = (scd->isSharedStaticCtorDeclaration() ? "shared " : "");
- error(scd->loc, "%sstatic constructor can only be member of module/aggregate/template, not %s %s",
- s, p->kind(), p->toChars());
- scd->type = Type::terror;
- scd->errors = true;
- return;
- }
- if (!scd->type)
- scd->type = new TypeFunction(ParameterList(), Type::tvoid, LINKd, scd->storage_class);
-
- /* If the static ctor appears within a template instantiation,
- * it could get called multiple times by the module constructors
- * for different modules. Thus, protect it with a gate.
- */
- if (scd->isInstantiated() && scd->semanticRun < PASSsemantic)
- {
- /* Add this prefix to the function:
- * static int gate;
- * if (++gate != 1) return;
- * Note that this is not thread safe; should not have threads
- * during static construction.
- */
- VarDeclaration *v = new VarDeclaration(Loc(), Type::tint32, Id::gate, NULL);
- v->storage_class = STCtemp | (scd->isSharedStaticCtorDeclaration() ? STCstatic : STCtls);
- Statements *sa = new Statements();
- Statement *s = new ExpStatement(Loc(), v);
- sa->push(s);
- Expression *e = new IdentifierExp(Loc(), v->ident);
- e = new AddAssignExp(Loc(), e, new IntegerExp(1));
- e = new EqualExp(TOKnotequal, Loc(), e, new IntegerExp(1));
- s = new IfStatement(Loc(), NULL, e, new ReturnStatement(Loc(), NULL), NULL, Loc());
- sa->push(s);
- if (scd->fbody)
- sa->push(scd->fbody);
- scd->fbody = new CompoundStatement(Loc(), sa);
- }
-
- funcDeclarationSemantic(scd);
-
- // We're going to need ModuleInfo
- Module *m = scd->getModule();
- if (!m)
- m = sc->_module;
- if (m)
- {
- m->needmoduleinfo = 1;
- //printf("module1 %s needs moduleinfo\n", m->toChars());
- }
- }
-
- void visit(StaticDtorDeclaration *sdd)
- {
- if (sdd->semanticRun >= PASSsemanticdone)
- return;
- if (sdd->_scope)
- {
- sc = sdd->_scope;
- sdd->_scope = NULL;
- }
-
- sdd->parent = sc->parent;
- Dsymbol *p = sdd->parent->pastMixin();
- if (!p->isScopeDsymbol())
- {
- const char *s = (sdd->isSharedStaticDtorDeclaration() ? "shared " : "");
- error(sdd->loc, "%sstatic destructor can only be member of module/aggregate/template, not %s %s",
- s, p->kind(), p->toChars());
- sdd->type = Type::terror;
- sdd->errors = true;
- return;
- }
- if (!sdd->type)
- sdd->type = new TypeFunction(ParameterList(), Type::tvoid, LINKd, sdd->storage_class);
-
- /* If the static ctor appears within a template instantiation,
- * it could get called multiple times by the module constructors
- * for different modules. Thus, protect it with a gate.
- */
- if (sdd->isInstantiated() && sdd->semanticRun < PASSsemantic)
- {
- /* Add this prefix to the function:
- * static int gate;
- * if (--gate != 0) return;
- * Increment gate during constructor execution.
- * Note that this is not thread safe; should not have threads
- * during static destruction.
- */
- VarDeclaration *v = new VarDeclaration(Loc(), Type::tint32, Id::gate, NULL);
- v->storage_class = STCtemp | (sdd->isSharedStaticDtorDeclaration() ? STCstatic : STCtls);
- Statements *sa = new Statements();
- Statement *s = new ExpStatement(Loc(), v);
- sa->push(s);
- Expression *e = new IdentifierExp(Loc(), v->ident);
- e = new AddAssignExp(Loc(), e, new IntegerExp(-1));
- e = new EqualExp(TOKnotequal, Loc(), e, new IntegerExp(0));
- s = new IfStatement(Loc(), NULL, e, new ReturnStatement(Loc(), NULL), NULL, Loc());
- sa->push(s);
- if (sdd->fbody)
- sa->push(sdd->fbody);
- sdd->fbody = new CompoundStatement(Loc(), sa);
- sdd->vgate = v;
- }
-
- funcDeclarationSemantic(sdd);
-
- // We're going to need ModuleInfo
- Module *m = sdd->getModule();
- if (!m)
- m = sc->_module;
- if (m)
- {
- m->needmoduleinfo = 1;
- //printf("module2 %s needs moduleinfo\n", m->toChars());
- }
- }
-
- void visit(InvariantDeclaration *invd)
- {
- if (invd->semanticRun >= PASSsemanticdone)
- return;
- if (invd->_scope)
- {
- sc = invd->_scope;
- invd->_scope = NULL;
- }
-
- invd->parent = sc->parent;
- Dsymbol *p = invd->parent->pastMixin();
- AggregateDeclaration *ad = p->isAggregateDeclaration();
- if (!ad)
- {
- error(invd->loc, "invariant can only be a member of aggregate, not %s %s",
- p->kind(), p->toChars());
- invd->type = Type::terror;
- invd->errors = true;
- return;
- }
- if (invd->ident != Id::classInvariant &&
- invd->semanticRun < PASSsemantic &&
- !ad->isUnionDeclaration() // users are on their own with union fields
- )
- ad->invs.push(invd);
- if (!invd->type)
- invd->type = new TypeFunction(ParameterList(), Type::tvoid, LINKd, invd->storage_class);
-
- sc = sc->push();
- sc->stc &= ~STCstatic; // not a static invariant
- sc->stc |= STCconst; // invariant() is always const
- sc->flags = (sc->flags & ~SCOPEcontract) | SCOPEinvariant;
- sc->linkage = LINKd;
-
- funcDeclarationSemantic(invd);
-
- sc->pop();
- }
-
- void visit(UnitTestDeclaration *utd)
- {
- if (utd->semanticRun >= PASSsemanticdone)
- return;
- if (utd->_scope)
- {
- sc = utd->_scope;
- utd->_scope = NULL;
- }
-
- utd->protection = sc->protection;
-
- utd->parent = sc->parent;
- Dsymbol *p = utd->parent->pastMixin();
- if (!p->isScopeDsymbol())
- {
- error(utd->loc, "unittest can only be a member of module/aggregate/template, not %s %s",
- p->kind(), p->toChars());
- utd->type = Type::terror;
- utd->errors = true;
- return;
- }
-
- if (global.params.useUnitTests)
- {
- if (!utd->type)
- utd->type = new TypeFunction(ParameterList(), Type::tvoid, LINKd, utd->storage_class);
- Scope *sc2 = sc->push();
- sc2->linkage = LINKd;
- funcDeclarationSemantic(utd);
- sc2->pop();
- }
- }
-
- void visit(NewDeclaration *nd)
- {
- //printf("NewDeclaration::semantic()\n");
- if (nd->semanticRun >= PASSsemanticdone)
- return;
- if (nd->_scope)
- {
- sc = nd->_scope;
- nd->_scope = NULL;
- }
-
- nd->parent = sc->parent;
- Dsymbol *p = nd->parent->pastMixin();
- if (!p->isAggregateDeclaration())
- {
- error(nd->loc, "allocator can only be a member of aggregate, not %s %s",
- p->kind(), p->toChars());
- nd->type = Type::terror;
- nd->errors = true;
- return;
- }
- Type *tret = Type::tvoid->pointerTo();
- if (!nd->type)
- nd->type = new TypeFunction(ParameterList(nd->parameters, nd->varargs), tret, LINKd, nd->storage_class);
-
- nd->type = typeSemantic(nd->type, nd->loc, sc);
-
- // Check that there is at least one argument of type size_t
- TypeFunction *tf = nd->type->toTypeFunction();
- if (tf->parameterList.length() < 1)
- {
- nd->error("at least one argument of type size_t expected");
- }
- else
- {
- Parameter *fparam = tf->parameterList[0];
- if (!fparam->type->equals(Type::tsize_t))
- nd->error("first argument must be type size_t, not %s", fparam->type->toChars());
- }
-
- funcDeclarationSemantic(nd);
- }
-
- void visit(DeleteDeclaration *deld)
- {
- //printf("DeleteDeclaration::semantic()\n");
- if (deld->semanticRun >= PASSsemanticdone)
- return;
- if (deld->_scope)
- {
- sc = deld->_scope;
- deld->_scope = NULL;
- }
-
- deld->parent = sc->parent;
- Dsymbol *p = deld->parent->pastMixin();
- if (!p->isAggregateDeclaration())
- {
- error(deld->loc, "deallocator can only be a member of aggregate, not %s %s",
- p->kind(), p->toChars());
- deld->type = Type::terror;
- deld->errors = true;
- return;
- }
- if (!deld->type)
- deld->type = new TypeFunction(ParameterList(deld->parameters), Type::tvoid, LINKd, deld->storage_class);
-
- deld->type = typeSemantic(deld->type, deld->loc, sc);
-
- // Check that there is only one argument of type void*
- TypeFunction *tf = deld->type->toTypeFunction();
- if (tf->parameterList.length() != 1)
- {
- deld->error("one argument of type void* expected");
- }
- else
- {
- Parameter *fparam = tf->parameterList[0];
- if (!fparam->type->equals(Type::tvoid->pointerTo()))
- deld->error("one argument of type void* expected, not %s", fparam->type->toChars());
- }
-
- funcDeclarationSemantic(deld);
- }
-
- void visit(StructDeclaration *sd)
- {
- //printf("StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", sd, sd->parent->toChars(), sd->toChars(), sizeok);
-
- //static int count; if (++count == 20) halt();
-
- if (sd->semanticRun >= PASSsemanticdone)
- return;
- unsigned errors = global.errors;
-
- //printf("+StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", sd, sd->parent->toChars(), sd->toChars(), sizeok);
- Scope *scx = NULL;
- if (sd->_scope)
- {
- sc = sd->_scope;
- scx = sd->_scope; // save so we don't make redundant copies
- sd->_scope = NULL;
- }
-
- if (!sd->parent)
- {
- assert(sc->parent && sc->func);
- sd->parent = sc->parent;
- }
- assert(sd->parent && !sd->isAnonymous());
-
- if (sd->errors)
- sd->type = Type::terror;
- if (sd->semanticRun == PASSinit)
- sd->type = sd->type->addSTC(sc->stc | sd->storage_class);
- sd->type = typeSemantic(sd->type, sd->loc, sc);
-
- if (sd->type->ty == Tstruct && ((TypeStruct *)sd->type)->sym != sd)
- {
- TemplateInstance *ti = ((TypeStruct *)sd->type)->sym->isInstantiated();
- if (ti && isError(ti))
- ((TypeStruct *)sd->type)->sym = sd;
- }
-
- // Ungag errors when not speculative
- Ungag ungag = sd->ungagSpeculative();
-
- if (sd->semanticRun == PASSinit)
- {
- sd->protection = sc->protection;
-
- sd->alignment = sc->alignment();
-
- sd->storage_class |= sc->stc;
- if (sd->storage_class & STCdeprecated)
- sd->isdeprecated = true;
- if (sd->storage_class & STCabstract)
- sd->error("structs, unions cannot be abstract");
- sd->userAttribDecl = sc->userAttribDecl;
-
- if (sc->linkage == LINKcpp)
- sd->classKind = ClassKind::cpp;
- }
- else if (sd->symtab && !scx)
- {
- return;
- }
- sd->semanticRun = PASSsemantic;
-
- if (!sd->members) // if opaque declaration
- {
- sd->semanticRun = PASSsemanticdone;
- return;
- }
- if (!sd->symtab)
- {
- sd->symtab = new DsymbolTable();
-
- for (size_t i = 0; i < sd->members->length; i++)
- {
- Dsymbol *s = (*sd->members)[i];
- //printf("adding member '%s' to '%s'\n", s->toChars(), sd->toChars());
- s->addMember(sc, sd);
- }
- }
-
- Scope *sc2 = sd->newScope(sc);
-
- /* Set scope so if there are forward references, we still might be able to
- * resolve individual members like enums.
- */
- for (size_t i = 0; i < sd->members->length; i++)
- {
- Dsymbol *s = (*sd->members)[i];
- //printf("struct: setScope %s %s\n", s->kind(), s->toChars());
- s->setScope(sc2);
- }
-
- for (size_t i = 0; i < sd->members->length; i++)
- {
- Dsymbol *s = (*sd->members)[i];
- s->importAll(sc2);
- }
-
- for (size_t i = 0; i < sd->members->length; i++)
- {
- Dsymbol *s = (*sd->members)[i];
- dsymbolSemantic(s, sc2);
- }
-
- if (!sd->determineFields())
- {
- assert(sd->type->ty == Terror);
- sc2->pop();
- sd->semanticRun = PASSsemanticdone;
- return;
- }
-
- /* Following special member functions creation needs semantic analysis
- * completion of sub-structs in each field types. For example, buildDtor
- * needs to check existence of elaborate dtor in type of each fields.
- * See the case in compilable/test14838.d
- */
- for (size_t i = 0; i < sd->fields.length; i++)
- {
- VarDeclaration *v = sd->fields[i];
- Type *tb = v->type->baseElemOf();
- if (tb->ty != Tstruct)
- continue;
- StructDeclaration *sdec = ((TypeStruct *)tb)->sym;
- if (sdec->semanticRun >= PASSsemanticdone)
- continue;
-
- sc2->pop();
-
- sd->_scope = scx ? scx : sc->copy();
- sd->_scope->setNoFree();
- Module::addDeferredSemantic(sd);
-
- //printf("\tdeferring %s\n", sd->toChars());
- return;
- }
-
- /* Look for special member functions.
- */
- sd->aggNew = (NewDeclaration *)sd->search(Loc(), Id::classNew);
- sd->aggDelete = (DeleteDeclaration *)sd->search(Loc(), Id::classDelete);
-
- // Look for the constructor
- sd->ctor = sd->searchCtor();
-
- sd->dtor = buildDtor(sd, sc2);
- sd->postblit = buildPostBlit(sd, sc2);
-
- buildOpAssign(sd, sc2);
- buildOpEquals(sd, sc2);
-
- if (global.params.useTypeInfo && Type::dtypeinfo) // these functions are used for TypeInfo
- {
- sd->xeq = buildXopEquals(sd, sc2);
- sd->xcmp = buildXopCmp(sd, sc2);
- sd->xhash = buildXtoHash(sd, sc2);
- }
-
- sd->inv = buildInv(sd, sc2);
-
- Module::dprogress++;
- sd->semanticRun = PASSsemanticdone;
- //printf("-StructDeclaration::semantic(this=%p, '%s')\n", sd, sd->toChars());
-
- sc2->pop();
-
- if (sd->ctor)
- {
- Dsymbol *scall = sd->search(Loc(), Id::call);
- if (scall)
- {
- unsigned xerrors = global.startGagging();
- sc = sc->push();
- sc->tinst = NULL;
- sc->minst = NULL;
- FuncDeclaration *fcall = resolveFuncCall(sd->loc, sc, scall, NULL, NULL, NULL, 1);
- sc = sc->pop();
- global.endGagging(xerrors);
-
- if (fcall && fcall->isStatic())
- {
- sd->error(fcall->loc, "`static opCall` is hidden by constructors and can never be called");
- errorSupplemental(fcall->loc, "Please use a factory method instead, or replace all constructors with `static opCall`.");
- }
- }
- }
-
- if (sd->type->ty == Tstruct && ((TypeStruct *)sd->type)->sym != sd)
- {
- // https://issues.dlang.org/show_bug.cgi?id=19024
- StructDeclaration *sym = ((TypeStruct *)sd->type)->sym;
- sd->error("already exists at %s. Perhaps in another function with the same name?", sym->loc.toChars());
- }
-
- if (global.errors != errors)
- {
- // The type is no good.
- sd->type = Type::terror;
- sd->errors = true;
- if (sd->deferred)
- sd->deferred->errors = true;
- }
-
- if (sd->deferred && !global.gag)
- {
- semantic2(sd->deferred, sc);
- semantic3(sd->deferred, sc);
- }
- }
-
- void interfaceSemantic(ClassDeclaration *cd)
- {
- cd->vtblInterfaces = new BaseClasses();
- cd->vtblInterfaces->reserve(cd->interfaces.length);
-
- for (size_t i = 0; i < cd->interfaces.length; i++)
- {
- BaseClass *b = cd->interfaces.ptr[i];
- cd->vtblInterfaces->push(b);
- b->copyBaseInterfaces(cd->vtblInterfaces);
- }
- }
-
- void visit(ClassDeclaration *cldec)
- {
- //printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", cldec->toChars(), cldec->type, sizeok, cldec);
- //printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");
- //printf("sc->stc = %x\n", sc->stc);
-
- //{ static int n; if (++n == 20) *(char*)0=0; }
-
- if (cldec->semanticRun >= PASSsemanticdone)
- return;
- unsigned errors = global.errors;
-
- //printf("+ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", cldec->toChars(), cldec->type, sizeok, cldec);
-
- Scope *scx = NULL;
- if (cldec->_scope)
- {
- sc = cldec->_scope;
- scx = cldec->_scope; // save so we don't make redundant copies
- cldec->_scope = NULL;
- }
-
- if (!cldec->parent)
- {
- assert(sc->parent);
- cldec->parent = sc->parent;
- }
-
- if (cldec->errors)
- cldec->type = Type::terror;
- cldec->type = typeSemantic(cldec->type, cldec->loc, sc);
-
- if (cldec->type->ty == Tclass && ((TypeClass *)cldec->type)->sym != cldec)
- {
- TemplateInstance *ti = ((TypeClass *)cldec->type)->sym->isInstantiated();
- if (ti && isError(ti))
- ((TypeClass *)cldec->type)->sym = cldec;
- }
-
- // Ungag errors when not speculative
- Ungag ungag = cldec->ungagSpeculative();
-
- if (cldec->semanticRun == PASSinit)
- {
- cldec->protection = sc->protection;
-
- cldec->storage_class |= sc->stc;
- if (cldec->storage_class & STCdeprecated)
- cldec->isdeprecated = true;
- if (cldec->storage_class & STCauto)
- cldec->error("storage class `auto` is invalid when declaring a class, did you mean to use `scope`?");
- if (cldec->storage_class & STCscope)
- cldec->isscope = true;
- if (cldec->storage_class & STCabstract)
- cldec->isabstract = ABSyes;
-
- cldec->userAttribDecl = sc->userAttribDecl;
-
- if (sc->linkage == LINKcpp)
- cldec->classKind = ClassKind::cpp;
- if (sc->linkage == LINKobjc)
- objc()->setObjc(cldec);
- }
- else if (cldec->symtab && !scx)
- {
- return;
- }
- cldec->semanticRun = PASSsemantic;
-
- if (cldec->baseok < BASEOKdone)
- {
- cldec->baseok = BASEOKin;
-
- // Expand any tuples in baseclasses[]
- for (size_t i = 0; i < cldec->baseclasses->length; )
- {
- BaseClass *b = (*cldec->baseclasses)[i];
- b->type = resolveBase(cldec, sc, scx, b->type);
-
- Type *tb = b->type->toBasetype();
- if (tb->ty == Ttuple)
- {
- TypeTuple *tup = (TypeTuple *)tb;
- cldec->baseclasses->remove(i);
- size_t dim = Parameter::dim(tup->arguments);
- for (size_t j = 0; j < dim; j++)
- {
- Parameter *arg = Parameter::getNth(tup->arguments, j);
- b = new BaseClass(arg->type);
- cldec->baseclasses->insert(i + j, b);
- }
- }
- else
- i++;
- }
-
- if (cldec->baseok >= BASEOKdone)
- {
- //printf("%s already semantic analyzed, semanticRun = %d\n", cldec->toChars(), cldec->semanticRun);
- if (cldec->semanticRun >= PASSsemanticdone)
- return;
- goto Lancestorsdone;
- }
-
- // See if there's a base class as first in baseclasses[]
- if (cldec->baseclasses->length)
- {
- BaseClass *b = (*cldec->baseclasses)[0];
- Type *tb = b->type->toBasetype();
- TypeClass *tc = (tb->ty == Tclass) ? (TypeClass *)tb : NULL;
- if (!tc)
- {
- if (b->type != Type::terror)
- cldec->error("base type must be class or interface, not %s", b->type->toChars());
- cldec->baseclasses->remove(0);
- goto L7;
- }
-
- if (tc->sym->isDeprecated())
- {
- if (!cldec->isDeprecated())
- {
- // Deriving from deprecated class makes this one deprecated too
- cldec->isdeprecated = true;
-
- tc->checkDeprecated(cldec->loc, sc);
- }
- }
-
- if (tc->sym->isInterfaceDeclaration())
- goto L7;
-
- for (ClassDeclaration *cdb = tc->sym; cdb; cdb = cdb->baseClass)
- {
- if (cdb == cldec)
- {
- cldec->error("circular inheritance");
- cldec->baseclasses->remove(0);
- goto L7;
- }
- }
-
- /* Bugzilla 11034: Essentially, class inheritance hierarchy
- * and instance size of each classes are orthogonal information.
- * Therefore, even if tc->sym->sizeof == SIZEOKnone,
- * we need to set baseClass field for class covariance check.
- */
- cldec->baseClass = tc->sym;
- b->sym = cldec->baseClass;
-
- if (tc->sym->baseok < BASEOKdone)
- resolveBase(cldec, sc, scx, tc->sym); // Try to resolve forward reference
- if (tc->sym->baseok < BASEOKdone)
- {
- //printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
- if (tc->sym->_scope)
- Module::addDeferredSemantic(tc->sym);
- cldec->baseok = BASEOKnone;
- }
- L7: ;
- }
-
- // Treat the remaining entries in baseclasses as interfaces
- // Check for errors, handle forward references
- for (size_t i = (cldec->baseClass ? 1 : 0); i < cldec->baseclasses->length; )
- {
- BaseClass *b = (*cldec->baseclasses)[i];
- Type *tb = b->type->toBasetype();
- TypeClass *tc = (tb->ty == Tclass) ? (TypeClass *)tb : NULL;
- if (!tc || !tc->sym->isInterfaceDeclaration())
- {
- if (b->type != Type::terror)
- cldec->error("base type must be interface, not %s", b->type->toChars());
- cldec->baseclasses->remove(i);
- continue;
- }
-
- // Check for duplicate interfaces
- for (size_t j = (cldec->baseClass ? 1 : 0); j < i; j++)
- {
- BaseClass *b2 = (*cldec->baseclasses)[j];
- if (b2->sym == tc->sym)
- {
- cldec->error("inherits from duplicate interface %s", b2->sym->toChars());
- cldec->baseclasses->remove(i);
- continue;
- }
- }
-
- if (tc->sym->isDeprecated())
- {
- if (!cldec->isDeprecated())
- {
- // Deriving from deprecated class makes this one deprecated too
- cldec->isdeprecated = true;
-
- tc->checkDeprecated(cldec->loc, sc);
- }
- }
-
- b->sym = tc->sym;
-
- if (tc->sym->baseok < BASEOKdone)
- resolveBase(cldec, sc, scx, tc->sym); // Try to resolve forward reference
- if (tc->sym->baseok < BASEOKdone)
- {
- //printf("\ttry later, forward reference of base %s\n", tc->sym->toChars());
- if (tc->sym->_scope)
- Module::addDeferredSemantic(tc->sym);
- cldec->baseok = BASEOKnone;
- }
- i++;
- }
- if (cldec->baseok == BASEOKnone)
- {
- // Forward referencee of one or more bases, try again later
- cldec->_scope = scx ? scx : sc->copy();
- cldec->_scope->setNoFree();
- Module::addDeferredSemantic(cldec);
- //printf("\tL%d semantic('%s') failed due to forward references\n", __LINE__, cldec->toChars());
- return;
- }
- cldec->baseok = BASEOKdone;
-
- // If no base class, and this is not an Object, use Object as base class
- if (!cldec->baseClass && cldec->ident != Id::Object && !cldec->isCPPclass())
- {
- if (!ClassDeclaration::object || ClassDeclaration::object->errors)
- badObjectDotD(cldec);
-
- Type *t = ClassDeclaration::object->type;
- t = typeSemantic(t, cldec->loc, sc)->toBasetype();
- if (t->ty == Terror)
- badObjectDotD(cldec);
- assert(t->ty == Tclass);
- TypeClass *tc = (TypeClass *)t;
-
- BaseClass *b = new BaseClass(tc);
- cldec->baseclasses->shift(b);
-
- cldec->baseClass = tc->sym;
- assert(!cldec->baseClass->isInterfaceDeclaration());
- b->sym = cldec->baseClass;
- }
- if (cldec->baseClass)
- {
- if (cldec->baseClass->storage_class & STCfinal)
- cldec->error("cannot inherit from final class %s", cldec->baseClass->toChars());
-
- // Inherit properties from base class
- if (cldec->baseClass->isCOMclass())
- cldec->com = true;
- if (cldec->baseClass->isCPPclass())
- cldec->classKind = ClassKind::cpp;
- if (cldec->baseClass->isscope)
- cldec->isscope = true;
- cldec->enclosing = cldec->baseClass->enclosing;
- cldec->storage_class |= cldec->baseClass->storage_class & STC_TYPECTOR;
- }
-
- cldec->interfaces.length = cldec->baseclasses->length - (cldec->baseClass ? 1 : 0);
- cldec->interfaces.ptr = cldec->baseclasses->tdata() + (cldec->baseClass ? 1 : 0);
-
- for (size_t i = 0; i < cldec->interfaces.length; i++)
- {
- BaseClass *b = cldec->interfaces.ptr[i];
- // If this is an interface, and it derives from a COM interface,
- // then this is a COM interface too.
- if (b->sym->isCOMinterface())
- cldec->com = true;
- if (cldec->isCPPclass() && !b->sym->isCPPinterface())
- {
- error(cldec->loc, "C++ class `%s` cannot implement D interface `%s`",
- cldec->toPrettyChars(), b->sym->toPrettyChars());
- }
- }
-
- interfaceSemantic(cldec);
- }
- Lancestorsdone:
- //printf("\tClassDeclaration::semantic(%s) baseok = %d\n", cldec->toChars(), cldec->baseok);
-
- if (!cldec->members) // if opaque declaration
- {
- cldec->semanticRun = PASSsemanticdone;
- return;
- }
- if (!cldec->symtab)
- {
- cldec->symtab = new DsymbolTable();
-
- /* Bugzilla 12152: The semantic analysis of base classes should be finished
- * before the members semantic analysis of this class, in order to determine
- * vtbl in this class. However if a base class refers the member of this class,
- * it can be resolved as a normal forward reference.
- * Call addMember() and setScope() to make this class members visible from the base classes.
- */
- for (size_t i = 0; i < cldec->members->length; i++)
- {
- Dsymbol *s = (*cldec->members)[i];
- s->addMember(sc, cldec);
- }
-
- Scope *sc2 = cldec->newScope(sc);
-
- /* Set scope so if there are forward references, we still might be able to
- * resolve individual members like enums.
- */
- for (size_t i = 0; i < cldec->members->length; i++)
- {
- Dsymbol *s = (*cldec->members)[i];
- //printf("[%d] setScope %s %s, sc2 = %p\n", i, s->kind(), s->toChars(), sc2);
- s->setScope(sc2);
- }
-
- sc2->pop();
- }
-
- for (size_t i = 0; i < cldec->baseclasses->length; i++)
- {
- BaseClass *b = (*cldec->baseclasses)[i];
- Type *tb = b->type->toBasetype();
- assert(tb->ty == Tclass);
- TypeClass *tc = (TypeClass *)tb;
-
- if (tc->sym->semanticRun < PASSsemanticdone)
- {
- // Forward referencee of one or more bases, try again later
- cldec->_scope = scx ? scx : sc->copy();
- cldec->_scope->setNoFree();
- if (tc->sym->_scope)
- Module::addDeferredSemantic(tc->sym);
- Module::addDeferredSemantic(cldec);
- //printf("\tL%d semantic('%s') failed due to forward references\n", __LINE__, cldec->toChars());
- return;
- }
- }
-
- if (cldec->baseok == BASEOKdone)
- {
- cldec->baseok = BASEOKsemanticdone;
-
- // initialize vtbl
- if (cldec->baseClass)
- {
- if (cldec->isCPPclass() && cldec->baseClass->vtbl.length == 0)
- {
- cldec->error("C++ base class %s needs at least one virtual function", cldec->baseClass->toChars());
- }
-
- // Copy vtbl[] from base class
- cldec->vtbl.setDim(cldec->baseClass->vtbl.length);
- memcpy(cldec->vtbl.tdata(), cldec->baseClass->vtbl.tdata(), sizeof(void *) * cldec->vtbl.length);
-
- cldec->vthis = cldec->baseClass->vthis;
- }
- else
- {
- // No base class, so this is the root of the class hierarchy
- cldec->vtbl.setDim(0);
- if (cldec->vtblOffset())
- cldec->vtbl.push(cldec); // leave room for classinfo as first member
- }
-
- /* If this is a nested class, add the hidden 'this'
- * member which is a pointer to the enclosing scope.
- */
- if (cldec->vthis) // if inheriting from nested class
- {
- // Use the base class's 'this' member
- if (cldec->storage_class & STCstatic)
- cldec->error("static class cannot inherit from nested class %s", cldec->baseClass->toChars());
- if (cldec->toParent2() != cldec->baseClass->toParent2() &&
- (!cldec->toParent2() ||
- !cldec->baseClass->toParent2()->getType() ||
- !cldec->baseClass->toParent2()->getType()->isBaseOf(cldec->toParent2()->getType(), NULL)))
- {
- if (cldec->toParent2())
- {
- cldec->error("is nested within %s, but super class %s is nested within %s",
- cldec->toParent2()->toChars(),
- cldec->baseClass->toChars(),
- cldec->baseClass->toParent2()->toChars());
- }
- else
- {
- cldec->error("is not nested, but super class %s is nested within %s",
- cldec->baseClass->toChars(),
- cldec->baseClass->toParent2()->toChars());
- }
- cldec->enclosing = NULL;
- }
- }
- else
- cldec->makeNested();
- }
-
- Scope *sc2 = cldec->newScope(sc);
-
- for (size_t i = 0; i < cldec->members->length; i++)
- {
- Dsymbol *s = (*cldec->members)[i];
- s->importAll(sc2);
- }
-
- // Note that members.length can grow due to tuple expansion during semantic()
- for (size_t i = 0; i < cldec->members->length; i++)
- {
- Dsymbol *s = (*cldec->members)[i];
- dsymbolSemantic(s, sc2);
- }
-
- if (!cldec->determineFields())
- {
- assert(cldec->type == Type::terror);
- sc2->pop();
- return;
- }
-
- /* Following special member functions creation needs semantic analysis
- * completion of sub-structs in each field types.
- */
- for (size_t i = 0; i < cldec->fields.length; i++)
- {
- VarDeclaration *v = cldec->fields[i];
- Type *tb = v->type->baseElemOf();
- if (tb->ty != Tstruct)
- continue;
- StructDeclaration *sd = ((TypeStruct *)tb)->sym;
- if (sd->semanticRun >= PASSsemanticdone)
- continue;
-
- sc2->pop();
-
- cldec->_scope = scx ? scx : sc->copy();
- cldec->_scope->setNoFree();
- Module::addDeferredSemantic(cldec);
- //printf("\tdeferring %s\n", cldec->toChars());
- return;
- }
-
- /* Look for special member functions.
- * They must be in this class, not in a base class.
- */
-
- // Can be in base class
- cldec->aggNew = (NewDeclaration *)cldec->search(Loc(), Id::classNew);
- cldec->aggDelete = (DeleteDeclaration *)cldec->search(Loc(), Id::classDelete);
-
- // Look for the constructor
- cldec->ctor = cldec->searchCtor();
-
- if (!cldec->ctor && cldec->noDefaultCtor)
- {
- // A class object is always created by constructor, so this check is legitimate.
- for (size_t i = 0; i < cldec->fields.length; i++)
- {
- VarDeclaration *v = cldec->fields[i];
- if (v->storage_class & STCnodefaultctor)
- error(v->loc, "field %s must be initialized in constructor", v->toChars());
- }
- }
-
- // If this class has no constructor, but base class has a default
- // ctor, create a constructor:
- // this() { }
- if (!cldec->ctor && cldec->baseClass && cldec->baseClass->ctor)
- {
- FuncDeclaration *fd = resolveFuncCall(cldec->loc, sc2, cldec->baseClass->ctor, NULL, cldec->type, NULL, 1);
- if (!fd) // try shared base ctor instead
- fd = resolveFuncCall(cldec->loc, sc2, cldec->baseClass->ctor, NULL, cldec->type->sharedOf(), NULL, 1);
- if (fd && !fd->errors)
- {
- //printf("Creating default this(){} for class %s\n", cldec->toChars());
- TypeFunction *btf = fd->type->toTypeFunction();
- TypeFunction *tf = new TypeFunction(ParameterList(), NULL, LINKd, fd->storage_class);
- tf->mod = btf->mod;
- tf->purity = btf->purity;
- tf->isnothrow = btf->isnothrow;
- tf->isnogc = btf->isnogc;
- tf->trust = btf->trust;
-
- CtorDeclaration *ctor = new CtorDeclaration(cldec->loc, Loc(), 0, tf);
- ctor->fbody = new CompoundStatement(Loc(), new Statements());
-
- cldec->members->push(ctor);
- ctor->addMember(sc, cldec);
- dsymbolSemantic(ctor, sc2);
-
- cldec->ctor = ctor;
- cldec->defaultCtor = ctor;
- }
- else
- {
- cldec->error("cannot implicitly generate a default ctor when base class %s is missing a default ctor",
- cldec->baseClass->toPrettyChars());
- }
- }
-
- cldec->dtor = buildDtor(cldec, sc2);
-
- if (FuncDeclaration *f = hasIdentityOpAssign(cldec, sc2))
- {
- if (!(f->storage_class & STCdisable))
- cldec->error(f->loc, "identity assignment operator overload is illegal");
- }
-
- cldec->inv = buildInv(cldec, sc2);
-
- Module::dprogress++;
- cldec->semanticRun = PASSsemanticdone;
- //printf("-ClassDeclaration.semantic(%s), type = %p\n", cldec->toChars(), cldec->type);
- //members.print();
-
- sc2->pop();
-
- if (cldec->type->ty == Tclass && ((TypeClass *)cldec->type)->sym != cldec)
- {
- // https://issues.dlang.org/show_bug.cgi?id=17492
- ClassDeclaration *cd = ((TypeClass *)cldec->type)->sym;
- cldec->error("already exists at %s. Perhaps in another function with the same name?", cd->loc.toChars());
- }
-
- if (global.errors != errors)
- {
- // The type is no good.
- cldec->type = Type::terror;
- cldec->errors = true;
- if (cldec->deferred)
- cldec->deferred->errors = true;
- }
-
- // Verify fields of a synchronized class are not public
- if (cldec->storage_class & STCsynchronized)
- {
- for (size_t i = 0; i < cldec->fields.length; i++)
- {
- VarDeclaration *vd = cldec->fields[i];
- if (!vd->isThisDeclaration() &&
- !vd->prot().isMoreRestrictiveThan(Prot(Prot::public_)))
- {
- vd->error("Field members of a synchronized class cannot be %s",
- protectionToChars(vd->prot().kind));
- }
- }
- }
-
- if (cldec->deferred && !global.gag)
- {
- semantic2(cldec->deferred, sc);
- semantic3(cldec->deferred, sc);
- }
- //printf("-ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", cldec->toChars(), cldec->type, sizeok, cldec);
- }
-
- void visit(InterfaceDeclaration *idec)
- {
- //printf("InterfaceDeclaration::semantic(%s), type = %p\n", idec->toChars(), idec->type);
- if (idec->semanticRun >= PASSsemanticdone)
- return;
- unsigned errors = global.errors;
-
- //printf("+InterfaceDeclaration.semantic(%s), type = %p\n", idec->toChars(), idec->type);
-
- Scope *scx = NULL;
- if (idec->_scope)
- {
- sc = idec->_scope;
- scx = idec->_scope; // save so we don't make redundant copies
- idec->_scope = NULL;
- }
-
- if (!idec->parent)
- {
- assert(sc->parent && sc->func);
- idec->parent = sc->parent;
- }
- assert(idec->parent && !idec->isAnonymous());
-
- if (idec->errors)
- idec->type = Type::terror;
- idec->type = typeSemantic(idec->type, idec->loc, sc);
-
- if (idec->type->ty == Tclass && ((TypeClass *)idec->type)->sym != idec)
- {
- TemplateInstance *ti = ((TypeClass *)idec->type)->sym->isInstantiated();
- if (ti && isError(ti))
- ((TypeClass *)idec->type)->sym = idec;
- }
-
- // Ungag errors when not speculative
- Ungag ungag = idec->ungagSpeculative();
-
- if (idec->semanticRun == PASSinit)
- {
- idec->protection = sc->protection;
-
- idec->storage_class |= sc->stc;
- if (idec->storage_class & STCdeprecated)
- idec->isdeprecated = true;
-
- idec->userAttribDecl = sc->userAttribDecl;
- }
- else if (idec->symtab)
- {
- if (idec->sizeok == SIZEOKdone || !scx)
- {
- idec->semanticRun = PASSsemanticdone;
- return;
- }
- }
- idec->semanticRun = PASSsemantic;
-
- if (idec->baseok < BASEOKdone)
- {
- idec->baseok = BASEOKin;
-
- // Expand any tuples in baseclasses[]
- for (size_t i = 0; i < idec->baseclasses->length; )
- {
- BaseClass *b = (*idec->baseclasses)[i];
- b->type = resolveBase(idec, sc, scx, b->type);
-
- Type *tb = b->type->toBasetype();
- if (tb->ty == Ttuple)
- {
- TypeTuple *tup = (TypeTuple *)tb;
- idec->baseclasses->remove(i);
- size_t dim = Parameter::dim(tup->arguments);
- for (size_t j = 0; j < dim; j++)
- {
- Parameter *arg = Parameter::getNth(tup->arguments, j);
- b = new BaseClass(arg->type);
- idec->baseclasses->insert(i + j, b);
- }
- }
- else
- i++;
- }
-
- if (idec->baseok >= BASEOKdone)
- {
- //printf("%s already semantic analyzed, semanticRun = %d\n", idec->toChars(), idec->semanticRun);
- if (idec->semanticRun >= PASSsemanticdone)
- return;
- goto Lancestorsdone;
- }
-
- if (!idec->baseclasses->length && sc->linkage == LINKcpp)
- idec->classKind = ClassKind::cpp;
- if (sc->linkage == LINKobjc)
- objc()->setObjc(idec);
-
- // Check for errors, handle forward references
- for (size_t i = 0; i < idec->baseclasses->length; )
- {
- BaseClass *b = (*idec->baseclasses)[i];
- Type *tb = b->type->toBasetype();
- TypeClass *tc = (tb->ty == Tclass) ? (TypeClass *)tb : NULL;
- if (!tc || !tc->sym->isInterfaceDeclaration())
- {
- if (b->type != Type::terror)
- idec->error("base type must be interface, not %s", b->type->toChars());
- idec->baseclasses->remove(i);
- continue;
- }
-
- // Check for duplicate interfaces
- for (size_t j = 0; j < i; j++)
- {
- BaseClass *b2 = (*idec->baseclasses)[j];
- if (b2->sym == tc->sym)
- {
- idec->error("inherits from duplicate interface %s", b2->sym->toChars());
- idec->baseclasses->remove(i);
- continue;
- }
- }
-
- if (tc->sym == idec || idec->isBaseOf2(tc->sym))
- {
- idec->error("circular inheritance of interface");
- idec->baseclasses->remove(i);
- continue;
- }
-
- if (tc->sym->isDeprecated())
- {
- if (!idec->isDeprecated())
- {
- // Deriving from deprecated class makes this one deprecated too
- idec->isdeprecated = true;
-
- tc->checkDeprecated(idec->loc, sc);
- }
- }
-
- b->sym = tc->sym;
-
- if (tc->sym->baseok < BASEOKdone)
- resolveBase(idec, sc, scx, tc->sym); // Try to resolve forward reference
- if (tc->sym->baseok < BASEOKdone)
- {
- //printf("\ttry later, forward reference of base %s\n", tc->sym->toChars());
- if (tc->sym->_scope)
- Module::addDeferredSemantic(tc->sym);
- idec->baseok = BASEOKnone;
- }
- i++;
- }
- if (idec->baseok == BASEOKnone)
- {
- // Forward referencee of one or more bases, try again later
- idec->_scope = scx ? scx : sc->copy();
- idec->_scope->setNoFree();
- Module::addDeferredSemantic(idec);
- return;
- }
- idec->baseok = BASEOKdone;
-
- idec->interfaces.length = idec->baseclasses->length;
- idec->interfaces.ptr = idec->baseclasses->tdata();
-
- for (size_t i = 0; i < idec->interfaces.length; i++)
- {
- BaseClass *b = idec->interfaces.ptr[i];
- // If this is an interface, and it derives from a COM interface,
- // then this is a COM interface too.
- if (b->sym->isCOMinterface())
- idec->com = true;
- if (b->sym->isCPPinterface())
- idec->classKind = ClassKind::cpp;
- }
-
- interfaceSemantic(idec);
- }
- Lancestorsdone:
-
- if (!idec->members) // if opaque declaration
- {
- idec->semanticRun = PASSsemanticdone;
- return;
- }
- if (!idec->symtab)
- idec->symtab = new DsymbolTable();
-
- for (size_t i = 0; i < idec->baseclasses->length; i++)
- {
- BaseClass *b = (*idec->baseclasses)[i];
- Type *tb = b->type->toBasetype();
- assert(tb->ty == Tclass);
- TypeClass *tc = (TypeClass *)tb;
-
- if (tc->sym->semanticRun < PASSsemanticdone)
- {
- // Forward referencee of one or more bases, try again later
- idec->_scope = scx ? scx : sc->copy();
- idec->_scope->setNoFree();
- if (tc->sym->_scope)
- Module::addDeferredSemantic(tc->sym);
- Module::addDeferredSemantic(idec);
- return;
- }
- }
-
- if (idec->baseok == BASEOKdone)
- {
- idec->baseok = BASEOKsemanticdone;
-
- // initialize vtbl
- if (idec->vtblOffset())
- idec->vtbl.push(idec); // leave room at vtbl[0] for classinfo
-
- // Cat together the vtbl[]'s from base cldec->interfaces
- for (size_t i = 0; i < idec->interfaces.length; i++)
- {
- BaseClass *b = idec->interfaces.ptr[i];
-
- // Skip if b has already appeared
- for (size_t k = 0; k < i; k++)
- {
- if (b == idec->interfaces.ptr[k])
- goto Lcontinue;
- }
-
- // Copy vtbl[] from base class
- if (b->sym->vtblOffset())
- {
- size_t d = b->sym->vtbl.length;
- if (d > 1)
- {
- idec->vtbl.reserve(d - 1);
- for (size_t j = 1; j < d; j++)
- idec->vtbl.push(b->sym->vtbl[j]);
- }
- }
- else
- {
- idec->vtbl.append(&b->sym->vtbl);
- }
-
- Lcontinue:
- ;
- }
- }
-
- for (size_t i = 0; i < idec->members->length; i++)
- {
- Dsymbol *s = (*idec->members)[i];
- s->addMember(sc, idec);
- }
-
- Scope *sc2 = idec->newScope(sc);
-
- /* Set scope so if there are forward references, we still might be able to
- * resolve individual members like enums.
- */
- for (size_t i = 0; i < idec->members->length; i++)
- {
- Dsymbol *s = (*idec->members)[i];
- //printf("setScope %s %s\n", s->kind(), s->toChars());
- s->setScope(sc2);
- }
-
- for (size_t i = 0; i < idec->members->length; i++)
- {
- Dsymbol *s = (*idec->members)[i];
- s->importAll(sc2);
- }
-
- for (size_t i = 0; i < idec->members->length; i++)
- {
- Dsymbol *s = (*idec->members)[i];
- dsymbolSemantic(s, sc2);
- }
-
- Module::dprogress++;
- idec->semanticRun = PASSsemanticdone;
- //printf("-InterfaceDeclaration.semantic(%s), type = %p\n", idec->toChars(), idec->type);
- //members->print();
-
- sc2->pop();
-
- if (global.errors != errors)
- {
- // The type is no good.
- idec->type = Type::terror;
- }
-
- assert(idec->type->ty != Tclass || ((TypeClass *)idec->type)->sym == idec);
- }
-};
-
-/******************************************************
- * Do template instance semantic for isAliasSeq templates.
- * This is a greatly simplified version of TemplateInstance::semantic().
- */
-static void aliasSeqInstanceSemantic(TemplateInstance *tempinst, Scope *sc, TemplateDeclaration *tempdecl)
-{
- //printf("[%s] aliasSeqInstanceSemantic('%s')\n", tempinst->loc.toChars(), tempinst->toChars());
- Scope *paramscope = sc->push();
- paramscope->stc = 0;
- paramscope->protection = Prot(Prot::public_);
-
- TemplateTupleParameter *ttp = (*tempdecl->parameters)[0]->isTemplateTupleParameter();
- Tuple *va = isTuple(tempinst->tdtypes[0]);
- Declaration *d = new TupleDeclaration(tempinst->loc, ttp->ident, &va->objects);
- d->storage_class |= STCtemplateparameter;
- dsymbolSemantic(d, sc);
-
- paramscope->pop();
-
- tempinst->aliasdecl = d;
-
- tempinst->semanticRun = PASSsemanticdone;
-}
-
-/******************************************************
- * Do template instance semantic for isAlias templates.
- * This is a greatly simplified version of TemplateInstance::semantic().
- */
-static void aliasInstanceSemantic(TemplateInstance *tempinst, Scope *sc, TemplateDeclaration *tempdecl)
-{
- //printf("[%s] aliasInstanceSemantic('%s')\n", tempinst->loc.toChars(), tempinst->toChars());
- Scope *paramscope = sc->push();
- paramscope->stc = 0;
- paramscope->protection = Prot(Prot::public_);
-
- TemplateTypeParameter *ttp = (*tempdecl->parameters)[0]->isTemplateTypeParameter();
- Type *ta = isType(tempinst->tdtypes[0]);
- AliasDeclaration *ad = tempdecl->onemember->isAliasDeclaration();
-
- // Note: qualifiers can be in both 'ad.type.mod' and 'ad.storage_class'
- Declaration *d = new AliasDeclaration(tempinst->loc, ttp->ident, ta->addMod(ad->type->mod));
- d->storage_class |= STCtemplateparameter | ad->storage_class;
- dsymbolSemantic(d, sc);
-
- paramscope->pop();
-
- tempinst->aliasdecl = d;
-
- tempinst->semanticRun = PASSsemanticdone;
-}
-
-void templateInstanceSemantic(TemplateInstance *tempinst, Scope *sc, Expressions *fargs)
-{
- //printf("[%s] TemplateInstance::semantic('%s', this=%p, gag = %d, sc = %p)\n", tempinst->loc.toChars(), tempinst->toChars(), tempinst, global.gag, sc);
- if (tempinst->inst) // if semantic() was already run
- {
- return;
- }
- if (tempinst->semanticRun != PASSinit)
- {
- Ungag ungag(global.gag);
- if (!tempinst->gagged)
- global.gag = 0;
- tempinst->error(tempinst->loc, "recursive template expansion");
- if (tempinst->gagged)
- tempinst->semanticRun = PASSinit;
- else
- tempinst->inst = tempinst;
- tempinst->errors = true;
- return;
- }
-
- // Get the enclosing template instance from the scope tinst
- tempinst->tinst = sc->tinst;
-
- // Get the instantiating module from the scope minst
- tempinst->minst = sc->minst;
- // Bugzilla 10920: If the enclosing function is non-root symbol,
- // this instance should be speculative.
- if (!tempinst->tinst && sc->func && sc->func->inNonRoot())
- {
- tempinst->minst = NULL;
- }
-
- tempinst->gagged = (global.gag > 0);
-
- tempinst->semanticRun = PASSsemantic;
-
- /* Find template declaration first,
- * then run semantic on each argument (place results in tiargs[]),
- * last find most specialized template from overload list/set.
- */
- if (!tempinst->findTempDecl(sc, NULL) ||
- !tempinst->semanticTiargs(sc) ||
- !tempinst->findBestMatch(sc, fargs))
- {
-Lerror:
- if (tempinst->gagged)
- {
- // Bugzilla 13220: Rollback status for later semantic re-running.
- tempinst->semanticRun = PASSinit;
- }
- else
- tempinst->inst = tempinst;
- tempinst->errors = true;
- return;
- }
- TemplateDeclaration *tempdecl = tempinst->tempdecl->isTemplateDeclaration();
- assert(tempdecl);
-
- // If tempdecl is a mixin, disallow it
- if (tempdecl->ismixin)
- {
- tempinst->error("mixin templates are not regular templates");
- goto Lerror;
- }
-
- tempinst->hasNestedArgs(tempinst->tiargs, tempdecl->isstatic);
- if (tempinst->errors)
- goto Lerror;
-
- /* Greatly simplified semantic processing for AliasSeq templates
- */
- if (tempdecl->isTrivialAliasSeq)
- {
- tempinst->inst = tempinst;
- return aliasSeqInstanceSemantic(tempinst, sc, tempdecl);
- }
- /* Greatly simplified semantic processing for Alias templates
- */
- else if (tempdecl->isTrivialAlias)
- {
- tempinst->inst = tempinst;
- return aliasInstanceSemantic(tempinst, sc, tempdecl);
- }
-
- /* See if there is an existing TemplateInstantiation that already
- * implements the typeargs. If so, just refer to that one instead.
- */
- tempinst->inst = tempdecl->findExistingInstance(tempinst, fargs);
- TemplateInstance *errinst = NULL;
- if (!tempinst->inst)
- {
- // So, we need to implement 'this' instance.
- }
- else if (tempinst->inst->gagged && !tempinst->gagged && tempinst->inst->errors)
- {
- // If the first instantiation had failed, re-run semantic,
- // so that error messages are shown.
- errinst = tempinst->inst;
- }
- else
- {
- // It's a match
- tempinst->parent = tempinst->inst->parent;
- tempinst->errors = tempinst->inst->errors;
-
- // If both this and the previous instantiation were gagged,
- // use the number of errors that happened last time.
- global.errors += tempinst->errors;
- global.gaggedErrors += tempinst->errors;
-
- // If the first instantiation was gagged, but this is not:
- if (tempinst->inst->gagged)
- {
- // It had succeeded, mark it is a non-gagged instantiation,
- // and reuse it.
- tempinst->inst->gagged = tempinst->gagged;
- }
-
- tempinst->tnext = tempinst->inst->tnext;
- tempinst->inst->tnext = tempinst;
-
- /* A module can have explicit template instance and its alias
- * in module scope (e,g, `alias Base64 = Base64Impl!('+', '/');`).
- * If the first instantiation 'inst' had happened in non-root module,
- * compiler can assume that its instantiated code would be included
- * in the separately compiled obj/lib file (e.g. phobos.lib).
- *
- * However, if 'this' second instantiation happened in root module,
- * compiler might need to invoke its codegen (Bugzilla 2500 & 2644).
- * But whole import graph is not determined until all semantic pass finished,
- * so 'inst' should conservatively finish the semantic3 pass for the codegen.
- */
- if (tempinst->minst && tempinst->minst->isRoot() && !(tempinst->inst->minst && tempinst->inst->minst->isRoot()))
- {
- /* Swap the position of 'inst' and 'this' in the instantiation graph.
- * Then, the primary instance `inst` will be changed to a root instance,
- * along with all members of `inst` having their scopes updated.
- *
- * Before:
- * non-root -> A!() -> B!()[inst] -> C!() { members[non-root] }
- * |
- * root -> D!() -> B!()[this]
- *
- * After:
- * non-root -> A!() -> B!()[this]
- * |
- * root -> D!() -> B!()[inst] -> C!() { members[root] }
- */
- Module *mi = tempinst->minst;
- TemplateInstance *ti = tempinst->tinst;
- tempinst->minst = tempinst->inst->minst;
- tempinst->tinst = tempinst->inst->tinst;
- tempinst->inst->minst = mi;
- tempinst->inst->tinst = ti;
-
- /* https://issues.dlang.org/show_bug.cgi?id=21299
- `minst` has been updated on the primary instance `inst` so it is
- now coming from a root module, however all Dsymbol `inst.members`
- of the instance still have their `_scope.minst` pointing at the
- original non-root module. We must now propagate `minst` to all
- members so that forward referenced dependencies that get
- instantiated will also be appended to the root module, otherwise
- there will be undefined references at link-time. */
- class InstMemberWalker : public Visitor
- {
- public:
- TemplateInstance *inst;
-
- InstMemberWalker(TemplateInstance *inst)
- : inst(inst) { }
-
- void visit(Dsymbol *d)
- {
- if (d->_scope)
- d->_scope->minst = inst->minst;
- }
-
- void visit(ScopeDsymbol *sds)
- {
- if (!sds->members)
- return;
- for (size_t i = 0; i < sds->members->length; i++)
- {
- Dsymbol *s = (*sds->members)[i];
- s->accept(this);
- }
- visit((Dsymbol *)sds);
- }
-
- void visit(AttribDeclaration *ad)
- {
- Dsymbols *d = ad->include(NULL);
- if (!d)
- return;
- for (size_t i = 0; i < d->length; i++)
- {
- Dsymbol *s = (*d)[i];
- s->accept(this);
- }
- visit((Dsymbol *)ad);
- }
-
- void visit(ConditionalDeclaration *cd)
- {
- if (cd->condition->inc)
- visit((AttribDeclaration *)cd);
- else
- visit((Dsymbol *)cd);
- }
- };
- InstMemberWalker v(tempinst->inst);
- tempinst->inst->accept(&v);
-
- if (tempinst->minst) // if inst was not speculative
- {
- /* Add 'inst' once again to the root module members[], then the
- * instance members will get codegen chances.
- */
- tempinst->inst->appendToModuleMember();
- }
- }
-
- return;
- }
- unsigned errorsave = global.errors;
-
- tempinst->inst = tempinst;
- tempinst->parent = tempinst->enclosing ? tempinst->enclosing : tempdecl->parent;
- //printf("parent = '%s'\n", tempinst->parent->kind());
-
- TemplateInstance *tempdecl_instance_idx = tempdecl->addInstance(tempinst);
-
- //getIdent();
-
- // Store the place we added it to in target_symbol_list(_idx) so we can
- // remove it later if we encounter an error.
- Dsymbols *target_symbol_list = tempinst->appendToModuleMember();
- size_t target_symbol_list_idx = target_symbol_list ? target_symbol_list->length - 1 : 0;
-
- // Copy the syntax trees from the TemplateDeclaration
- tempinst->members = Dsymbol::arraySyntaxCopy(tempdecl->members);
-
- // resolve TemplateThisParameter
- for (size_t i = 0; i < tempdecl->parameters->length; i++)
- {
- if ((*tempdecl->parameters)[i]->isTemplateThisParameter() == NULL)
- continue;
- Type *t = isType((*tempinst->tiargs)[i]);
- assert(t);
- if (StorageClass stc = ModToStc(t->mod))
- {
- //printf("t = %s, stc = x%llx\n", t->toChars(), stc);
- Dsymbols *s = new Dsymbols();
- s->push(new StorageClassDeclaration(stc, tempinst->members));
- tempinst->members = s;
- }
- break;
- }
-
- // Create our own scope for the template parameters
- Scope *scope = tempdecl->_scope;
- if (tempdecl->semanticRun == PASSinit)
- {
- tempinst->error("template instantiation %s forward references template declaration %s", tempinst->toChars(), tempdecl->toChars());
- return;
- }
-
- tempinst->argsym = new ScopeDsymbol();
- tempinst->argsym->parent = scope->parent;
- scope = scope->push(tempinst->argsym);
- scope->tinst = tempinst;
- scope->minst = tempinst->minst;
- //scope->stc = 0;
-
- // Declare each template parameter as an alias for the argument type
- Scope *paramscope = scope->push();
- paramscope->stc = 0;
- paramscope->protection = Prot(Prot::public_); // Bugzilla 14169: template parameters should be public
- tempinst->declareParameters(paramscope);
- paramscope->pop();
-
- // Add members of template instance to template instance symbol table
-// tempinst->parent = scope->scopesym;
- tempinst->symtab = new DsymbolTable();
- for (size_t i = 0; i < tempinst->members->length; i++)
- {
- Dsymbol *s = (*tempinst->members)[i];
- s->addMember(scope, tempinst);
- }
-
- /* See if there is only one member of template instance, and that
- * member has the same name as the template instance.
- * If so, this template instance becomes an alias for that member.
- */
- //printf("members->length = %d\n", tempinst->members->length);
- if (tempinst->members->length)
- {
- Dsymbol *s;
- if (Dsymbol::oneMembers(tempinst->members, &s, tempdecl->ident) && s)
- {
- //printf("tempdecl->ident = %s, s = '%s'\n", tempdecl->ident->toChars(), s->kind(), s->toPrettyChars());
- //printf("setting aliasdecl\n");
- tempinst->aliasdecl = s;
- }
- }
-
- /* If function template declaration
- */
- if (fargs && tempinst->aliasdecl)
- {
- FuncDeclaration *fd = tempinst->aliasdecl->isFuncDeclaration();
- if (fd)
- {
- /* Transmit fargs to type so that TypeFunction::semantic() can
- * resolve any "auto ref" storage classes.
- */
- TypeFunction *tf = (TypeFunction *)fd->type;
- if (tf && tf->ty == Tfunction)
- tf->fargs = fargs;
- }
- }
-
- // Do semantic() analysis on template instance members
- Scope *sc2;
- sc2 = scope->push(tempinst);
- //printf("enclosing = %d, sc->parent = %s\n", tempinst->enclosing, sc->parent->toChars());
- sc2->parent = tempinst;
- sc2->tinst = tempinst;
- sc2->minst = tempinst->minst;
-
- tempinst->tryExpandMembers(sc2);
-
- tempinst->semanticRun = PASSsemanticdone;
-
- /* ConditionalDeclaration may introduce eponymous declaration,
- * so we should find it once again after semantic.
- */
- if (tempinst->members->length)
- {
- Dsymbol *s;
- if (Dsymbol::oneMembers(tempinst->members, &s, tempdecl->ident) && s)
- {
- if (!tempinst->aliasdecl || tempinst->aliasdecl != s)
- {
- //printf("tempdecl->ident = %s, s = '%s'\n", tempdecl->ident->toChars(), s->kind(), s->toPrettyChars());
- //printf("setting aliasdecl 2\n");
- tempinst->aliasdecl = s;
- }
- }
- }
-
- if (global.errors != errorsave)
- goto Laftersemantic;
-
- /* If any of the instantiation members didn't get semantic() run
- * on them due to forward references, we cannot run semantic2()
- * or semantic3() yet.
- */
- {
- bool found_deferred_ad = false;
- for (size_t i = 0; i < Module::deferred.length; i++)
- {
- Dsymbol *sd = Module::deferred[i];
- AggregateDeclaration *ad = sd->isAggregateDeclaration();
- if (ad && ad->parent && ad->parent->isTemplateInstance())
- {
- //printf("deferred template aggregate: %s %s\n",
- // sd->parent->toChars(), sd->toChars());
- found_deferred_ad = true;
- if (ad->parent == tempinst)
- {
- ad->deferred = tempinst;
- break;
- }
- }
- }
- if (found_deferred_ad || Module::deferred.length)
- goto Laftersemantic;
- }
-
- /* The problem is when to parse the initializer for a variable.
- * Perhaps VarDeclaration::semantic() should do it like it does
- * for initializers inside a function.
- */
- //if (sc->parent->isFuncDeclaration())
- {
- /* BUG 782: this has problems if the classes this depends on
- * are forward referenced. Find a way to defer semantic()
- * on this template.
- */
- semantic2(tempinst, sc2);
- }
- if (global.errors != errorsave)
- goto Laftersemantic;
-
- if ((sc->func || (sc->flags & SCOPEfullinst)) && !tempinst->tinst)
- {
- /* If a template is instantiated inside function, the whole instantiation
- * should be done at that position. But, immediate running semantic3 of
- * dependent templates may cause unresolved forward reference (Bugzilla 9050).
- * To avoid the issue, don't run semantic3 until semantic and semantic2 done.
- */
- TemplateInstances deferred;
- tempinst->deferred = &deferred;
-
- //printf("Run semantic3 on %s\n", tempinst->toChars());
- tempinst->trySemantic3(sc2);
-
- for (size_t i = 0; i < deferred.length; i++)
- {
- //printf("+ run deferred semantic3 on %s\n", deferred[i]->toChars());
- semantic3(deferred[i], NULL);
- }
-
- tempinst->deferred = NULL;
- }
- else if (tempinst->tinst)
- {
- bool doSemantic3 = false;
- if (sc->func && tempinst->aliasdecl && tempinst->aliasdecl->toAlias()->isFuncDeclaration())
- {
- /* Template function instantiation should run semantic3 immediately
- * for attribute inference.
- */
- tempinst->trySemantic3(sc2);
- }
- else if (sc->func)
- {
- /* A lambda function in template arguments might capture the
- * instantiated scope context. For the correct context inference,
- * all instantiated functions should run the semantic3 immediately.
- * See also compilable/test14973.d
- */
- for (size_t i = 0; i < tempinst->tdtypes.length; i++)
- {
- RootObject *oarg = tempinst->tdtypes[i];
- Dsymbol *s = getDsymbol(oarg);
- if (!s)
- continue;
-
- if (TemplateDeclaration *td = s->isTemplateDeclaration())
- {
- if (!td->literal)
- continue;
- assert(td->members && td->members->length == 1);
- s = (*td->members)[0];
- }
- if (FuncLiteralDeclaration *fld = s->isFuncLiteralDeclaration())
- {
- if (fld->tok == TOKreserved)
- {
- doSemantic3 = true;
- break;
- }
- }
- }
- //printf("[%s] %s doSemantic3 = %d\n", tempinst->loc.toChars(), tempinst->toChars(), doSemantic3);
- }
- if (doSemantic3)
- tempinst->trySemantic3(sc2);
-
- TemplateInstance *ti = tempinst->tinst;
- int nest = 0;
- while (ti && !ti->deferred && ti->tinst)
- {
- ti = ti->tinst;
- if (++nest > global.recursionLimit)
- {
- global.gag = 0; // ensure error message gets printed
- tempinst->error("recursive expansion");
- fatal();
- }
- }
- if (ti && ti->deferred)
- {
- //printf("deferred semantic3 of %p %s, ti = %s, ti->deferred = %p\n", tempinst, tempinst->toChars(), ti->toChars());
- for (size_t i = 0; ; i++)
- {
- if (i == ti->deferred->length)
- {
- ti->deferred->push(tempinst);
- break;
- }
- if ((*ti->deferred)[i] == tempinst)
- break;
- }
- }
- }
-
- if (tempinst->aliasdecl)
- {
- /* Bugzilla 13816: AliasDeclaration tries to resolve forward reference
- * twice (See inuse check in AliasDeclaration::toAlias()). It's
- * necessary to resolve mutual references of instantiated symbols, but
- * it will left a true recursive alias in tuple declaration - an
- * AliasDeclaration A refers TupleDeclaration B, and B contains A
- * in its elements. To correctly make it an error, we strictly need to
- * resolve the alias of eponymous member.
- */
- tempinst->aliasdecl = tempinst->aliasdecl->toAlias2();
- }
-
- Laftersemantic:
- sc2->pop();
-
- scope->pop();
-
- // Give additional context info if error occurred during instantiation
- if (global.errors != errorsave)
- {
- if (!tempinst->errors)
- {
- if (!tempdecl->literal)
- tempinst->error(tempinst->loc, "error instantiating");
- if (tempinst->tinst)
- tempinst->tinst->printInstantiationTrace();
- }
- tempinst->errors = true;
- if (tempinst->gagged)
- {
- // Errors are gagged, so remove the template instance from the
- // instance/symbol lists we added it to and reset our state to
- // finish clean and so we can try to instantiate it again later
- // (see bugzilla 4302 and 6602).
- tempdecl->removeInstance(tempdecl_instance_idx);
- if (target_symbol_list)
- {
- // Because we added 'this' in the last position above, we
- // should be able to remove it without messing other indices up.
- assert((*target_symbol_list)[target_symbol_list_idx] == tempinst);
- target_symbol_list->remove(target_symbol_list_idx);
- tempinst->memberOf = NULL; // no longer a member
- }
- tempinst->semanticRun = PASSinit;
- tempinst->inst = NULL;
- tempinst->symtab = NULL;
- }
- }
- else if (errinst)
- {
- /* Bugzilla 14541: If the previous gagged instance had failed by
- * circular references, currrent "error reproduction instantiation"
- * might succeed, because of the difference of instantiated context.
- * On such case, the cached error instance needs to be overridden by the
- * succeeded instance.
- */
- //printf("replaceInstance()\n");
- TemplateInstances *tinstances = (TemplateInstances *)dmd_aaGetRvalue((AA *)tempdecl->instances, (void *)tempinst->hash);
- assert(tinstances);
- for (size_t i = 0; i < tinstances->length; i++)
- {
- TemplateInstance *ti = (*tinstances)[i];
- if (ti == errinst)
- {
- (*tinstances)[i] = tempinst; // override
- break;
- }
- }
- }
-}
-
-// function used to perform semantic on AliasDeclaration
-void aliasSemantic(AliasDeclaration *ds, Scope *sc)
-{
- //printf("AliasDeclaration::semantic() %s\n", ds->toChars());
-
- // as AliasDeclaration::semantic, in case we're called first.
- // see https://issues.dlang.org/show_bug.cgi?id=21001
- ds->storage_class |= sc->stc & STCdeprecated;
- ds->protection = sc->protection;
- ds->userAttribDecl = sc->userAttribDecl;
-
- // TypeTraits needs to know if it's located in an AliasDeclaration
- const unsigned oldflags = sc->flags;
- sc->flags |= SCOPEalias;
-
- if (ds->aliassym)
- {
- FuncDeclaration *fd = ds->aliassym->isFuncLiteralDeclaration();
- TemplateDeclaration *td = ds->aliassym->isTemplateDeclaration();
- if (fd || (td && td->literal))
- {
- if (fd && fd->semanticRun >= PASSsemanticdone)
- {
- sc->flags = oldflags;
- return;
- }
-
- Expression *e = new FuncExp(ds->loc, ds->aliassym);
- e = expressionSemantic(e, sc);
- if (e->op == TOKfunction)
- {
- FuncExp *fe = (FuncExp *)e;
- ds->aliassym = fe->td ? (Dsymbol *)fe->td : fe->fd;
- }
- else
- {
- ds->aliassym = NULL;
- ds->type = Type::terror;
- }
- sc->flags = oldflags;
- return;
- }
-
- if (ds->aliassym->isTemplateInstance())
- dsymbolSemantic(ds->aliassym, sc);
- sc->flags = oldflags;
- return;
- }
- ds->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 = ds->type;
-
- // Ungag errors when not instantiated DeclDefs scope alias
- Ungag ungag(global.gag);
- //printf("%s parent = %s, gag = %d, instantiated = %d\n", ds->toChars(), ds->parent, global.gag, ds->isInstantiated());
- if (ds->parent && global.gag && !ds->isInstantiated() && !ds->toParent2()->isFuncDeclaration())
- {
- //printf("%s type = %s\n", ds->toPrettyChars(), ds->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 = ds->type->toDsymbol(sc);
- if (errors != global.errors)
- {
- s = NULL;
- ds->type = Type::terror;
- }
- if (s && s == ds)
- {
- ds->error("cannot resolve");
- s = NULL;
- ds->type = Type::terror;
- }
- if (!s || !s->isEnumMember())
- {
- Type *t;
- Expression *e;
- Scope *sc2 = sc;
- if (ds->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 |= ds->storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCshared | STCdisable);
- }
- ds->type = ds->type->addSTC(ds->storage_class);
- ds->type->resolve(ds->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)
- ds->error("cannot alias an expression %s", e->toChars());
- t = Type::terror;
- }
- }
- ds->type = t;
- }
- if (s == ds)
- {
- assert(global.errors);
- ds->type = Type::terror;
- s = NULL;
- }
- if (!s) // it's a type alias
- {
- //printf("alias %s resolved to type %s\n", ds->toChars(), ds->type->toChars());
- ds->type = typeSemantic(ds->type, ds->loc, sc);
- ds->aliassym = NULL;
- }
- else // it's a symbolic alias
- {
- //printf("alias %s resolved to %s %s\n", ds->toChars(), s->kind(), s->toChars());
- ds->type = NULL;
- ds->aliassym = s;
- }
- if (global.gag && errors != global.errors)
- {
- ds->type = oldtype;
- ds->aliassym = NULL;
- }
- ds->inuse = 0;
- ds->semanticRun = PASSsemanticdone;
-
- if (Dsymbol *sx = ds->overnext)
- {
- ds->overnext = NULL;
-
- if (!ds->overloadInsert(sx))
- ScopeDsymbol::multiplyDefined(Loc(), sx, ds);
- }
- sc->flags = oldflags;
-}
-
-
-/*************************************
- * Does semantic analysis on the public face of declarations.
- */
-void dsymbolSemantic(Dsymbol *dsym, Scope *sc)
-{
- DsymbolSemanticVisitor v(sc);
- dsym->accept(&v);
-}
View Lorry Controller Status