| |
| /* 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 "dsymbol.h" |
| #include "aggregate.h" |
| #include "attrib.h" |
| #include "declaration.h" |
| #include "errors.h" |
| #include "id.h" |
| #include "init.h" |
| #include "module.h" |
| #include "nspace.h" |
| #include "scope.h" |
| #include "statement.h" |
| #include "statement_rewrite_walker.h" |
| #include "target.h" |
| #include "template.h" |
| #include "visitor.h" |
| |
| bool allowsContractWithoutBody(FuncDeclaration *funcdecl); |
| int blockExit(Statement *s, FuncDeclaration *func, bool mustNotThrow); |
| bool checkReturnEscape(Scope *sc, Expression *e, bool gag); |
| bool checkReturnEscapeRef(Scope *sc, Expression *e, bool gag); |
| TypeIdentifier *getThrowable(); |
| char *MODtoChars(MOD mod); |
| Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads); |
| void allocFieldinit(Scope *sc, size_t dim); |
| void freeFieldinit(Scope *sc); |
| |
| /* Determine if function should add `return 0;` |
| */ |
| static bool addReturn0(FuncDeclaration *funcdecl) |
| { |
| TypeFunction *f = (TypeFunction *)funcdecl->type; |
| |
| return f->next->ty == Tvoid && |
| (funcdecl->isMain() || (global.params.betterC && funcdecl->isCMain())); |
| } |
| |
| /******************************************************** |
| * Generate Expression to call the invariant. |
| * Input: |
| * ad aggregate with the invariant |
| * vthis variable with 'this' |
| * Returns: |
| * void expression that calls the invariant |
| */ |
| static Expression *addInvariant(AggregateDeclaration *ad, VarDeclaration *vthis) |
| { |
| Expression *e = NULL; |
| |
| // Call invariant directly only if it exists |
| FuncDeclaration *inv = ad->inv; |
| ClassDeclaration *cd = ad->isClassDeclaration(); |
| |
| while (!inv && cd) |
| { |
| cd = cd->baseClass; |
| if (!cd) |
| break; |
| inv = cd->inv; |
| } |
| if (inv) |
| { |
| #if 1 |
| // Workaround for bugzilla 13394: For the correct mangling, |
| // run attribute inference on inv if needed. |
| inv->functionSemantic(); |
| #endif |
| |
| //e = new DsymbolExp(Loc(), inv); |
| //e = new CallExp(Loc(), e); |
| //dsymbolSemantic(e, sc2); |
| |
| /* https://issues.dlang.org/show_bug.cgi?id=13113 |
| * Currently virtual invariant calls completely |
| * bypass attribute enforcement. |
| * Change the behavior of pre-invariant call by following it. |
| */ |
| e = new ThisExp(Loc()); |
| e->type = vthis->type; |
| e = new DotVarExp(Loc(), e, inv, false); |
| e->type = inv->type; |
| e = new CallExp(Loc(), e); |
| e->type = Type::tvoid; |
| } |
| return e; |
| } |
| |
| /* Tweak all return statements and dtor call for nrvo_var, for correct NRVO. |
| */ |
| class NrvoWalker : public StatementRewriteWalker |
| { |
| public: |
| FuncDeclaration *fd; |
| Scope *sc; |
| |
| void visit(ReturnStatement *s) |
| { |
| // See if all returns are instead to be replaced with a goto returnLabel; |
| if (fd->returnLabel) |
| { |
| /* Rewrite: |
| * return exp; |
| * as: |
| * vresult = exp; goto Lresult; |
| */ |
| GotoStatement *gs = new GotoStatement(s->loc, Id::returnLabel); |
| gs->label = fd->returnLabel; |
| |
| Statement *s1 = gs; |
| if (s->exp) |
| s1 = new CompoundStatement(s->loc, new ExpStatement(s->loc, s->exp), gs); |
| |
| replaceCurrent(s1); |
| } |
| } |
| void visit(TryFinallyStatement *s) |
| { |
| DtorExpStatement *des; |
| if (fd->nrvo_can && |
| s->finalbody && (des = s->finalbody->isDtorExpStatement()) != NULL && |
| fd->nrvo_var == des->var) |
| { |
| if (!(global.params.useExceptions && ClassDeclaration::throwable)) |
| { |
| /* Don't need to call destructor at all, since it is nrvo |
| */ |
| replaceCurrent(s->_body); |
| s->_body->accept(this); |
| return; |
| } |
| |
| /* Normally local variable dtors are called regardless exceptions. |
| * But for nrvo_var, its dtor should be called only when exception is thrown. |
| * |
| * Rewrite: |
| * try { s->body; } finally { nrvo_var->edtor; } |
| * // equivalent with: |
| * // s->body; scope(exit) nrvo_var->edtor; |
| * as: |
| * try { s->body; } catch(Throwable __o) { nrvo_var->edtor; throw __o; } |
| * // equivalent with: |
| * // s->body; scope(failure) nrvo_var->edtor; |
| */ |
| Statement *sexception = new DtorExpStatement(Loc(), fd->nrvo_var->edtor, fd->nrvo_var); |
| Identifier *id = Identifier::generateId("__o"); |
| |
| Statement *handler = new PeelStatement(sexception); |
| if (blockExit(sexception, fd, false) & BEfallthru) |
| { |
| ThrowStatement *ts = new ThrowStatement(Loc(), new IdentifierExp(Loc(), id)); |
| ts->internalThrow = true; |
| handler = new CompoundStatement(Loc(), handler, ts); |
| } |
| |
| Catches *catches = new Catches(); |
| Catch *ctch = new Catch(Loc(), getThrowable(), id, handler); |
| ctch->internalCatch = true; |
| catchSemantic(ctch, sc); // Run semantic to resolve identifier '__o' |
| catches->push(ctch); |
| |
| Statement *s2 = new TryCatchStatement(Loc(), s->_body, catches); |
| replaceCurrent(s2); |
| s2->accept(this); |
| } |
| else |
| StatementRewriteWalker::visit(s); |
| } |
| }; |
| |
| class Semantic3Visitor : public Visitor |
| { |
| public: |
| Scope *sc; |
| |
| Semantic3Visitor(Scope *sc) |
| { |
| this->sc = sc; |
| } |
| |
| void visit(Dsymbol *) |
| { |
| // Most Dsymbols have no further semantic analysis needed |
| } |
| |
| void visit(TemplateInstance *tempinst) |
| { |
| //if (tempinst->toChars()[0] == 'D') *(char*)0=0; |
| if (tempinst->semanticRun >= PASSsemantic3) |
| return; |
| tempinst->semanticRun = PASSsemantic3; |
| if (!tempinst->errors && tempinst->members) |
| { |
| TemplateDeclaration *tempdecl = tempinst->tempdecl->isTemplateDeclaration(); |
| assert(tempdecl); |
| |
| sc = tempdecl->_scope; |
| sc = sc->push(tempinst->argsym); |
| sc = sc->push(tempinst); |
| sc->tinst = tempinst; |
| sc->minst = tempinst->minst; |
| |
| int needGagging = (tempinst->gagged && !global.gag); |
| unsigned int olderrors = global.errors; |
| int oldGaggedErrors = -1; // dead-store to prevent spurious warning |
| /* If this is a gagged instantiation, gag errors. |
| * Future optimisation: If the results are actually needed, errors |
| * would already be gagged, so we don't really need to run semantic |
| * on the members. |
| */ |
| if (needGagging) |
| oldGaggedErrors = global.startGagging(); |
| |
| for (size_t i = 0; i < tempinst->members->length; i++) |
| { |
| Dsymbol *s = (*tempinst->members)[i]; |
| semantic3(s, sc); |
| if (tempinst->gagged && global.errors != olderrors) |
| break; |
| } |
| |
| if (global.errors != olderrors) |
| { |
| if (!tempinst->errors) |
| { |
| if (!tempdecl->literal) |
| tempinst->error(tempinst->loc, "error instantiating"); |
| if (tempinst->tinst) |
| tempinst->tinst->printInstantiationTrace(); |
| } |
| tempinst->errors = true; |
| } |
| if (needGagging) |
| global.endGagging(oldGaggedErrors); |
| |
| sc = sc->pop(); |
| sc->pop(); |
| } |
| } |
| |
| void visit(TemplateMixin *tmix) |
| { |
| if (tmix->semanticRun >= PASSsemantic3) |
| return; |
| tmix->semanticRun = PASSsemantic3; |
| if (tmix->members) |
| { |
| sc = sc->push(tmix->argsym); |
| sc = sc->push(tmix); |
| for (size_t i = 0; i < tmix->members->length; i++) |
| { |
| Dsymbol *s = (*tmix->members)[i]; |
| semantic3(s, sc); |
| } |
| sc = sc->pop(); |
| sc->pop(); |
| } |
| } |
| |
| void visit(Module *mod) |
| { |
| //printf("Module::semantic3('%s'): parent = %p\n", mod->toChars(), mod->parent); |
| if (mod->semanticRun != PASSsemantic2done) |
| return; |
| mod->semanticRun = PASSsemantic3; |
| |
| // 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 = Scope::createGlobal(mod); // create root scope |
| //printf("Module = %p\n", sc.scopesym); |
| |
| // Pass 3 semantic routines: do initializers and function bodies |
| for (size_t i = 0; i < mod->members->length; i++) |
| { |
| Dsymbol *s = (*mod->members)[i]; |
| //printf("Module %s: %s.semantic3()\n", mod->toChars(), s->toChars()); |
| semantic3(s, sc); |
| |
| mod->runDeferredSemantic2(); |
| } |
| |
| if (mod->userAttribDecl) |
| { |
| semantic3(mod->userAttribDecl, sc); |
| } |
| |
| sc = sc->pop(); |
| sc->pop(); |
| mod->semanticRun = PASSsemantic3done; |
| } |
| |
| void visit(FuncDeclaration *funcdecl) |
| { |
| VarDeclaration *_arguments = NULL; |
| |
| if (!funcdecl->parent) |
| { |
| if (global.errors) |
| return; |
| //printf("FuncDeclaration::semantic3(%s '%s', sc = %p)\n", funcdecl->kind(), funcdecl->toChars(), sc); |
| assert(0); |
| } |
| if (funcdecl->errors || isError(funcdecl->parent)) |
| { |
| funcdecl->errors = true; |
| return; |
| } |
| //printf("FuncDeclaration::semantic3('%s.%s', %p, sc = %p, loc = %s)\n", funcdecl->parent->toChars(), funcdecl->toChars(), funcdecl, sc, funcdecl->loc.toChars()); |
| //fflush(stdout); |
| //printf("storage class = x%x %x\n", sc->stc, funcdecl->storage_class); |
| //{ static int x; if (++x == 2) *(char*)0=0; } |
| //printf("\tlinkage = %d\n", sc->linkage); |
| |
| if (funcdecl->ident == Id::assign && !funcdecl->inuse) |
| { |
| if (funcdecl->storage_class & STCinference) |
| { |
| /* Bugzilla 15044: For generated opAssign function, any errors |
| * from its body need to be gagged. |
| */ |
| unsigned oldErrors = global.startGagging(); |
| funcdecl->inuse++; |
| semantic3(funcdecl, sc); |
| funcdecl->inuse--; |
| if (global.endGagging(oldErrors)) // if errors happened |
| { |
| // Disable generated opAssign, because some members forbid identity assignment. |
| funcdecl->storage_class |= STCdisable; |
| funcdecl->fbody = NULL; // remove fbody which contains the error |
| funcdecl->semantic3Errors = false; |
| } |
| return; |
| } |
| } |
| |
| //printf(" sc->incontract = %d\n", (sc->flags & SCOPEcontract)); |
| if (funcdecl->semanticRun >= PASSsemantic3) |
| return; |
| funcdecl->semanticRun = PASSsemantic3; |
| funcdecl->semantic3Errors = false; |
| |
| if (!funcdecl->type || funcdecl->type->ty != Tfunction) |
| return; |
| TypeFunction *f = (TypeFunction *)funcdecl->type; |
| if (!funcdecl->inferRetType && f->next->ty == Terror) |
| return; |
| |
| if (!funcdecl->fbody && funcdecl->inferRetType && !f->next) |
| { |
| funcdecl->error("has no function body with return type inference"); |
| return; |
| } |
| |
| unsigned oldErrors = global.errors; |
| |
| if (funcdecl->frequires) |
| { |
| for (size_t i = 0; i < funcdecl->foverrides.length; i++) |
| { |
| FuncDeclaration *fdv = funcdecl->foverrides[i]; |
| |
| if (fdv->fbody && !fdv->frequires) |
| { |
| funcdecl->error("cannot have an in contract when overriden function %s does not have an in contract", fdv->toPrettyChars()); |
| break; |
| } |
| } |
| } |
| |
| // Remember whether we need to generate an 'out' contract. |
| const bool needEnsure = FuncDeclaration::needsFensure(funcdecl); |
| |
| if (funcdecl->fbody || funcdecl->frequires || needEnsure) |
| { |
| /* Symbol table into which we place parameters and nested functions, |
| * solely to diagnose name collisions. |
| */ |
| funcdecl->localsymtab = new DsymbolTable(); |
| |
| // Establish function scope |
| ScopeDsymbol *ss = new ScopeDsymbol(); |
| // find enclosing scope symbol, might skip symbol-less CTFE and/or FuncExp scopes |
| for (Scope *scx = sc; ; scx = scx->enclosing) |
| { |
| if (scx->scopesym) |
| { |
| ss->parent = scx->scopesym; |
| break; |
| } |
| } |
| ss->loc = funcdecl->loc; |
| ss->endlinnum = funcdecl->endloc.linnum; |
| Scope *sc2 = sc->push(ss); |
| sc2->func = funcdecl; |
| sc2->parent = funcdecl; |
| sc2->callSuper = 0; |
| sc2->sbreak = NULL; |
| sc2->scontinue = NULL; |
| sc2->sw = NULL; |
| sc2->fes = funcdecl->fes; |
| sc2->linkage = LINKd; |
| sc2->stc &= ~(STCauto | STCscope | STCstatic | STCextern | STCabstract | |
| STCdeprecated | STCoverride | |
| STC_TYPECTOR | STCfinal | STCtls | STCgshared | STCref | STCreturn | |
| STCproperty | STCnothrow | STCpure | STCsafe | STCtrusted | STCsystem); |
| sc2->protection = Prot(Prot::public_); |
| sc2->explicitProtection = 0; |
| sc2->aligndecl = NULL; |
| if (funcdecl->ident != Id::require && funcdecl->ident != Id::ensure) |
| sc2->flags = sc->flags & ~SCOPEcontract; |
| sc2->flags &= ~SCOPEcompile; |
| sc2->tf = NULL; |
| sc2->os = NULL; |
| sc2->noctor = 0; |
| sc2->userAttribDecl = NULL; |
| if (sc2->intypeof == 1) sc2->intypeof = 2; |
| sc2->fieldinit = NULL; |
| sc2->fieldinit_dim = 0; |
| |
| /* Note: When a lambda is defined immediately under aggregate member |
| * scope, it should be contextless due to prevent interior pointers. |
| * e.g. |
| * // dg points 'this' - it's interior pointer |
| * class C { int x; void delegate() dg = (){ this.x = 1; }; } |
| * |
| * However, lambdas could be used inside typeof, in order to check |
| * some expressions varidity at compile time. For such case the lambda |
| * body can access aggregate instance members. |
| * e.g. |
| * class C { int x; static assert(is(typeof({ this.x = 1; }))); } |
| * |
| * To properly accept it, mark these lambdas as member functions. |
| */ |
| if (FuncLiteralDeclaration *fld = funcdecl->isFuncLiteralDeclaration()) |
| { |
| if (AggregateDeclaration *ad = funcdecl->isMember2()) |
| { |
| if (!sc->intypeof) |
| { |
| if (fld->tok == TOKdelegate) |
| funcdecl->error("cannot be %s members", ad->kind()); |
| else |
| fld->tok = TOKfunction; |
| } |
| else |
| { |
| if (fld->tok != TOKfunction) |
| fld->tok = TOKdelegate; |
| } |
| } |
| } |
| |
| // Declare 'this' |
| AggregateDeclaration *ad = funcdecl->isThis(); |
| funcdecl->vthis = funcdecl->declareThis(sc2, ad); |
| //printf("[%s] ad = %p vthis = %p\n", funcdecl->loc.toChars(), ad, funcdecl->vthis); |
| //if (funcdecl->vthis) printf("\tvthis->type = %s\n", funcdecl->vthis->type->toChars()); |
| |
| // Declare hidden variable _arguments[] and _argptr |
| if (f->parameterList.varargs == VARARGvariadic) |
| { |
| if (f->linkage == LINKd) |
| { |
| // Variadic arguments depend on Typeinfo being defined |
| if (!global.params.useTypeInfo || !Type::dtypeinfo || !Type::typeinfotypelist) |
| { |
| if (!global.params.useTypeInfo) |
| funcdecl->error("D-style variadic functions cannot be used with -betterC"); |
| else if (!Type::typeinfotypelist) |
| funcdecl->error("`object.TypeInfo_Tuple` could not be found, but is implicitly used in D-style variadic functions"); |
| else |
| funcdecl->error("`object.TypeInfo` could not be found, but is implicitly used in D-style variadic functions"); |
| fatal(); |
| } |
| |
| // Declare _arguments[] |
| funcdecl->v_arguments = new VarDeclaration(Loc(), Type::typeinfotypelist->type, Id::_arguments_typeinfo, NULL); |
| funcdecl->v_arguments->storage_class |= STCtemp | STCparameter; |
| dsymbolSemantic(funcdecl->v_arguments, sc2); |
| sc2->insert(funcdecl->v_arguments); |
| funcdecl->v_arguments->parent = funcdecl; |
| |
| //Type *t = Type::typeinfo->type->constOf()->arrayOf(); |
| Type *t = Type::dtypeinfo->type->arrayOf(); |
| _arguments = new VarDeclaration(Loc(), t, Id::_arguments, NULL); |
| _arguments->storage_class |= STCtemp; |
| dsymbolSemantic(_arguments, sc2); |
| sc2->insert(_arguments); |
| _arguments->parent = funcdecl; |
| } |
| if (f->linkage == LINKd || f->parameterList.length()) |
| { |
| // Declare _argptr |
| Type *t = target.va_listType(funcdecl->loc, sc); |
| funcdecl->v_argptr = new VarDeclaration(Loc(), t, Id::_argptr, NULL); |
| funcdecl->v_argptr->storage_class |= STCtemp; |
| dsymbolSemantic(funcdecl->v_argptr, sc2); |
| sc2->insert(funcdecl->v_argptr); |
| funcdecl->v_argptr->parent = funcdecl; |
| } |
| } |
| |
| /* Declare all the function parameters as variables |
| * and install them in parameters[] |
| */ |
| size_t nparams = f->parameterList.length(); |
| if (nparams) |
| { |
| /* parameters[] has all the tuples removed, as the back end |
| * doesn't know about tuples |
| */ |
| funcdecl->parameters = new VarDeclarations(); |
| funcdecl->parameters->reserve(nparams); |
| for (size_t i = 0; i < nparams; i++) |
| { |
| Parameter *fparam = f->parameterList[i]; |
| Identifier *id = fparam->ident; |
| StorageClass stc = 0; |
| if (!id) |
| { |
| /* Generate identifier for un-named parameter, |
| * because we need it later on. |
| */ |
| fparam->ident = id = Identifier::generateId("_param_", i); |
| stc |= STCtemp; |
| } |
| Type *vtype = fparam->type; |
| VarDeclaration *v = new VarDeclaration(funcdecl->loc, vtype, id, NULL); |
| //printf("declaring parameter %s of type %s\n", v->toChars(), v->type->toChars()); |
| stc |= STCparameter; |
| if (f->parameterList.varargs == VARARGtypesafe && i + 1 == nparams) |
| stc |= STCvariadic; |
| if (funcdecl->flags & FUNCFLAGinferScope && !(fparam->storageClass & STCscope)) |
| stc |= STCmaybescope; |
| stc |= fparam->storageClass & (STCin | STCout | STCref | STCreturn | STCscope | STClazy | STCfinal | STC_TYPECTOR | STCnodtor); |
| v->storage_class = stc; |
| dsymbolSemantic(v, sc2); |
| if (!sc2->insert(v)) |
| funcdecl->error("parameter %s.%s is already defined", funcdecl->toChars(), v->toChars()); |
| else |
| funcdecl->parameters->push(v); |
| funcdecl->localsymtab->insert(v); |
| v->parent = funcdecl; |
| if (fparam->userAttribDecl) |
| v->userAttribDecl = fparam->userAttribDecl; |
| } |
| } |
| |
| // Declare the tuple symbols and put them in the symbol table, |
| // but not in parameters[]. |
| if (f->parameterList.parameters) |
| { |
| for (size_t i = 0; i < f->parameterList.parameters->length; i++) |
| { |
| Parameter *fparam = (*f->parameterList.parameters)[i]; |
| |
| if (!fparam->ident) |
| continue; // never used, so ignore |
| if (fparam->type->ty == Ttuple) |
| { |
| TypeTuple *t = (TypeTuple *)fparam->type; |
| size_t dim = Parameter::dim(t->arguments); |
| Objects *exps = new Objects(); |
| exps->setDim(dim); |
| for (size_t j = 0; j < dim; j++) |
| { |
| Parameter *narg = Parameter::getNth(t->arguments, j); |
| assert(narg->ident); |
| VarDeclaration *v = sc2->search(Loc(), narg->ident, NULL)->isVarDeclaration(); |
| assert(v); |
| Expression *e = new VarExp(v->loc, v); |
| (*exps)[j] = e; |
| } |
| assert(fparam->ident); |
| TupleDeclaration *v = new TupleDeclaration(funcdecl->loc, fparam->ident, exps); |
| //printf("declaring tuple %s\n", v->toChars()); |
| v->isexp = true; |
| if (!sc2->insert(v)) |
| funcdecl->error("parameter %s.%s is already defined", funcdecl->toChars(), v->toChars()); |
| funcdecl->localsymtab->insert(v); |
| v->parent = funcdecl; |
| } |
| } |
| } |
| |
| // Precondition invariant |
| Statement *fpreinv = NULL; |
| if (funcdecl->addPreInvariant()) |
| { |
| Expression *e = addInvariant(ad, funcdecl->vthis); |
| if (e) |
| fpreinv = new ExpStatement(Loc(), e); |
| } |
| |
| // Postcondition invariant |
| Statement *fpostinv = NULL; |
| if (funcdecl->addPostInvariant()) |
| { |
| Expression *e = addInvariant(ad, funcdecl->vthis); |
| if (e) |
| fpostinv = new ExpStatement(Loc(), e); |
| } |
| |
| // Pre/Postcondition contract |
| if (!funcdecl->fbody) |
| funcdecl->buildEnsureRequire(); |
| |
| Scope *scout = NULL; |
| if (needEnsure || funcdecl->addPostInvariant()) |
| { |
| if ((needEnsure && global.params.useOut == CHECKENABLEon) || fpostinv) |
| { |
| funcdecl->returnLabel = new LabelDsymbol(Id::returnLabel); |
| } |
| |
| // scope of out contract (need for vresult->semantic) |
| ScopeDsymbol *sym = new ScopeDsymbol(); |
| sym->parent = sc2->scopesym; |
| sym->loc = funcdecl->loc; |
| sym->endlinnum = funcdecl->endloc.linnum; |
| scout = sc2->push(sym); |
| } |
| |
| if (funcdecl->fbody) |
| { |
| ScopeDsymbol *sym = new ScopeDsymbol(); |
| sym->parent = sc2->scopesym; |
| sym->loc = funcdecl->loc; |
| sym->endlinnum = funcdecl->endloc.linnum; |
| sc2 = sc2->push(sym); |
| |
| AggregateDeclaration *ad2 = funcdecl->isMember2(); |
| |
| /* If this is a class constructor |
| */ |
| if (ad2 && funcdecl->isCtorDeclaration()) |
| { |
| allocFieldinit(sc2, ad2->fields.length); |
| for (size_t i = 0; i < ad2->fields.length; i++) |
| { |
| VarDeclaration *v = ad2->fields[i]; |
| v->ctorinit = 0; |
| } |
| } |
| |
| bool inferRef = (f->isref && (funcdecl->storage_class & STCauto)); |
| |
| funcdecl->fbody = statementSemantic(funcdecl->fbody, sc2); |
| if (!funcdecl->fbody) |
| funcdecl->fbody = new CompoundStatement(Loc(), new Statements()); |
| |
| if (funcdecl->naked) |
| { |
| fpreinv = NULL; // can't accommodate with no stack frame |
| fpostinv = NULL; |
| } |
| |
| assert(funcdecl->type == f || |
| (funcdecl->type->ty == Tfunction && |
| f->purity == PUREimpure && |
| ((TypeFunction *)funcdecl->type)->purity >= PUREfwdref)); |
| f = (TypeFunction *)funcdecl->type; |
| |
| if (funcdecl->inferRetType) |
| { |
| // If no return type inferred yet, then infer a void |
| if (!f->next) |
| f->next = Type::tvoid; |
| if (f->checkRetType(funcdecl->loc)) |
| funcdecl->fbody = new ErrorStatement(); |
| } |
| if (global.params.vcomplex && f->next != NULL) |
| f->next->checkComplexTransition(funcdecl->loc); |
| |
| if (funcdecl->returns && !funcdecl->fbody->isErrorStatement()) |
| { |
| for (size_t i = 0; i < funcdecl->returns->length; ) |
| { |
| Expression *exp = (*funcdecl->returns)[i]->exp; |
| if (exp->op == TOKvar && ((VarExp *)exp)->var == funcdecl->vresult) |
| { |
| if (addReturn0(funcdecl)) |
| exp->type = Type::tint32; |
| else |
| exp->type = f->next; |
| // Remove `return vresult;` from returns |
| funcdecl->returns->remove(i); |
| continue; |
| } |
| if (inferRef && f->isref && !exp->type->constConv(f->next)) // Bugzilla 13336 |
| f->isref = false; |
| i++; |
| } |
| } |
| if (f->isref) // Function returns a reference |
| { |
| if (funcdecl->storage_class & STCauto) |
| funcdecl->storage_class &= ~STCauto; |
| } |
| if (!target.isReturnOnStack(f, funcdecl->needThis()) || !funcdecl->checkNRVO()) |
| funcdecl->nrvo_can = 0; |
| |
| if (funcdecl->fbody->isErrorStatement()) |
| ; |
| else if (funcdecl->isStaticCtorDeclaration()) |
| { |
| /* It's a static constructor. Ensure that all |
| * ctor consts were initialized. |
| */ |
| ScopeDsymbol *pd = funcdecl->toParent()->isScopeDsymbol(); |
| for (size_t i = 0; i < pd->members->length; i++) |
| { |
| Dsymbol *s = (*pd->members)[i]; |
| s->checkCtorConstInit(); |
| } |
| } |
| else if (ad2 && funcdecl->isCtorDeclaration()) |
| { |
| ClassDeclaration *cd = ad2->isClassDeclaration(); |
| |
| // Verify that all the ctorinit fields got initialized |
| if (!(sc2->callSuper & CSXthis_ctor)) |
| { |
| for (size_t i = 0; i < ad2->fields.length; i++) |
| { |
| VarDeclaration *v = ad2->fields[i]; |
| if (v->isThisDeclaration()) |
| continue; |
| if (v->ctorinit == 0) |
| { |
| /* Current bugs in the flow analysis: |
| * 1. union members should not produce error messages even if |
| * not assigned to |
| * 2. structs should recognize delegating opAssign calls as well |
| * as delegating calls to other constructors |
| */ |
| if (v->isCtorinit() && !v->type->isMutable() && cd) |
| funcdecl->error("missing initializer for %s field %s", MODtoChars(v->type->mod), v->toChars()); |
| else if (v->storage_class & STCnodefaultctor) |
| error(funcdecl->loc, "field %s must be initialized in constructor", v->toChars()); |
| else if (v->type->needsNested()) |
| error(funcdecl->loc, "field %s must be initialized in constructor, because it is nested struct", v->toChars()); |
| } |
| else |
| { |
| bool mustInit = (v->storage_class & STCnodefaultctor || |
| v->type->needsNested()); |
| if (mustInit && !(sc2->fieldinit[i] & CSXthis_ctor)) |
| { |
| funcdecl->error("field %s must be initialized but skipped", v->toChars()); |
| } |
| } |
| } |
| } |
| freeFieldinit(sc2); |
| |
| if (cd && |
| !(sc2->callSuper & CSXany_ctor) && |
| cd->baseClass && cd->baseClass->ctor) |
| { |
| sc2->callSuper = 0; |
| |
| // Insert implicit super() at start of fbody |
| FuncDeclaration *fd = resolveFuncCall(Loc(), sc2, cd->baseClass->ctor, NULL, funcdecl->vthis->type, NULL, 1); |
| if (!fd) |
| { |
| funcdecl->error("no match for implicit super() call in constructor"); |
| } |
| else if (fd->storage_class & STCdisable) |
| { |
| funcdecl->error("cannot call super() implicitly because it is annotated with @disable"); |
| } |
| else |
| { |
| Expression *e1 = new SuperExp(Loc()); |
| Expression *e = new CallExp(Loc(), e1); |
| e = expressionSemantic(e, sc2); |
| |
| Statement *s = new ExpStatement(Loc(), e); |
| funcdecl->fbody = new CompoundStatement(Loc(), s, funcdecl->fbody); |
| } |
| } |
| //printf("callSuper = x%x\n", sc2->callSuper); |
| } |
| |
| /* https://issues.dlang.org/show_bug.cgi?id=17502 |
| * Wait until after the return type has been inferred before |
| * generating the contracts for this function, and merging contracts |
| * from overrides. |
| * |
| * https://issues.dlang.org/show_bug.cgi?id=17893 |
| * However should take care to generate this before inferered |
| * function attributes are applied, such as 'nothrow'. |
| * |
| * This was originally at the end of the first semantic pass, but |
| * required a fix-up to be done here for the '__result' variable |
| * type of __ensure() inside auto functions, but this didn't work |
| * if the out parameter was implicit. |
| */ |
| funcdecl->buildEnsureRequire(); |
| |
| int blockexit = BEnone; |
| if (!funcdecl->fbody->isErrorStatement()) |
| { |
| // Check for errors related to 'nothrow'. |
| unsigned int nothrowErrors = global.errors; |
| blockexit = blockExit(funcdecl->fbody, funcdecl, f->isnothrow); |
| if (f->isnothrow && (global.errors != nothrowErrors)) |
| error(funcdecl->loc, "nothrow %s `%s` may throw", funcdecl->kind(), funcdecl->toPrettyChars()); |
| if (funcdecl->flags & FUNCFLAGnothrowInprocess) |
| { |
| if (funcdecl->type == f) f = (TypeFunction *)f->copy(); |
| f->isnothrow = !(blockexit & BEthrow); |
| } |
| } |
| |
| if (funcdecl->fbody->isErrorStatement()) |
| ; |
| else if (ad2 && funcdecl->isCtorDeclaration()) |
| { |
| /* Append: |
| * return this; |
| * to function body |
| */ |
| if (blockexit & BEfallthru) |
| { |
| Statement *s = new ReturnStatement(funcdecl->loc, NULL); |
| s = statementSemantic(s, sc2); |
| funcdecl->fbody = new CompoundStatement(funcdecl->loc, funcdecl->fbody, s); |
| funcdecl->hasReturnExp |= (funcdecl->hasReturnExp & 1 ? 16 : 1); |
| } |
| } |
| else if (funcdecl->fes) |
| { |
| // For foreach(){} body, append a return 0; |
| if (blockexit & BEfallthru) |
| { |
| Expression *e = new IntegerExp(0); |
| Statement *s = new ReturnStatement(Loc(), e); |
| funcdecl->fbody = new CompoundStatement(Loc(), funcdecl->fbody, s); |
| funcdecl->hasReturnExp |= (funcdecl->hasReturnExp & 1 ? 16 : 1); |
| } |
| assert(!funcdecl->returnLabel); |
| } |
| else if (f->next->ty == Tnoreturn) |
| { |
| } |
| else |
| { |
| const bool inlineAsm = (funcdecl->hasReturnExp & 8) != 0; |
| if ((blockexit & BEfallthru) && f->next->ty != Tvoid && !inlineAsm) |
| { |
| if (!funcdecl->hasReturnExp) |
| funcdecl->error("has no `return` statement, but is expected to return a value of type `%s`", f->next->toChars()); |
| else |
| funcdecl->error("no `return exp;` or `assert(0);` at end of function"); |
| } |
| } |
| |
| if (funcdecl->returns) |
| { |
| bool implicit0 = addReturn0(funcdecl); |
| Type *tret = implicit0 ? Type::tint32 : f->next; |
| assert(tret->ty != Tvoid); |
| if (funcdecl->vresult || funcdecl->returnLabel) |
| funcdecl->buildResultVar(scout ? scout : sc2, tret); |
| |
| /* Cannot move this loop into NrvoWalker, because |
| * returns[i] may be in the nested delegate for foreach-body. |
| */ |
| for (size_t i = 0; i < funcdecl->returns->length; i++) |
| { |
| ReturnStatement *rs = (*funcdecl->returns)[i]; |
| Expression *exp = rs->exp; |
| if (exp->op == TOKerror) |
| continue; |
| if (tret->ty == Terror) |
| { |
| // Bugzilla 13702 |
| exp = checkGC(sc2, exp); |
| continue; |
| } |
| |
| if (!exp->implicitConvTo(tret) && |
| funcdecl->parametersIntersect(exp->type)) |
| { |
| if (exp->type->immutableOf()->implicitConvTo(tret)) |
| exp = exp->castTo(sc2, exp->type->immutableOf()); |
| else if (exp->type->wildOf()->implicitConvTo(tret)) |
| exp = exp->castTo(sc2, exp->type->wildOf()); |
| } |
| exp = exp->implicitCastTo(sc2, tret); |
| |
| if (f->isref) |
| { |
| // Function returns a reference |
| exp = exp->toLvalue(sc2, exp); |
| checkReturnEscapeRef(sc2, exp, false); |
| } |
| else |
| { |
| exp = exp->optimize(WANTvalue); |
| |
| /* Bugzilla 10789: |
| * If NRVO is not possible, all returned lvalues should call their postblits. |
| */ |
| if (!funcdecl->nrvo_can) |
| exp = doCopyOrMove(sc2, exp); |
| |
| if (tret->hasPointers()) |
| checkReturnEscape(sc2, exp, false); |
| } |
| |
| exp = checkGC(sc2, exp); |
| |
| if (funcdecl->vresult) |
| { |
| // Create: return vresult = exp; |
| exp = new BlitExp(rs->loc, funcdecl->vresult, exp); |
| exp->type = funcdecl->vresult->type; |
| |
| if (rs->caseDim) |
| exp = Expression::combine(exp, new IntegerExp(rs->caseDim)); |
| } |
| else if (funcdecl->tintro && !tret->equals(funcdecl->tintro->nextOf())) |
| { |
| exp = exp->implicitCastTo(sc2, funcdecl->tintro->nextOf()); |
| } |
| rs->exp = exp; |
| } |
| } |
| if (funcdecl->nrvo_var || funcdecl->returnLabel) |
| { |
| NrvoWalker nw; |
| nw.fd = funcdecl; |
| nw.sc = sc2; |
| nw.visitStmt(funcdecl->fbody); |
| } |
| |
| sc2 = sc2->pop(); |
| } |
| |
| funcdecl->frequire = funcdecl->mergeFrequire(funcdecl->frequire); |
| funcdecl->fensure = funcdecl->mergeFensure(funcdecl->fensure, Id::result); |
| |
| Statement *freq = funcdecl->frequire; |
| Statement *fens = funcdecl->fensure; |
| |
| /* Do the semantic analysis on the [in] preconditions and |
| * [out] postconditions. |
| */ |
| if (freq) |
| { |
| /* frequire is composed of the [in] contracts |
| */ |
| ScopeDsymbol *sym = new ScopeDsymbol(); |
| sym->parent = sc2->scopesym; |
| sym->loc = funcdecl->loc; |
| sym->endlinnum = funcdecl->endloc.linnum; |
| sc2 = sc2->push(sym); |
| sc2->flags = (sc2->flags & ~SCOPEcontract) | SCOPErequire; |
| |
| // BUG: need to error if accessing out parameters |
| // BUG: need to disallow returns and throws |
| // BUG: verify that all in and ref parameters are read |
| freq = statementSemantic(freq, sc2); |
| blockExit(freq, funcdecl, false); |
| |
| sc2 = sc2->pop(); |
| |
| if (global.params.useIn == CHECKENABLEoff) |
| freq = NULL; |
| } |
| |
| if (fens) |
| { |
| /* fensure is composed of the [out] contracts |
| */ |
| if (f->next->ty == Tvoid && funcdecl->fensures) |
| { |
| for (size_t i = 0; i < funcdecl->fensures->length; i++) |
| { |
| Ensure e = (*funcdecl->fensures)[i]; |
| if (e.id) |
| { |
| funcdecl->error(e.ensure->loc, "`void` functions have no result"); |
| //fens = NULL; |
| } |
| } |
| } |
| |
| sc2 = scout; //push |
| sc2->flags = (sc2->flags & ~SCOPEcontract) | SCOPEensure; |
| |
| // BUG: need to disallow returns and throws |
| if (funcdecl->fensure && f->next->ty != Tvoid) |
| funcdecl->buildResultVar(scout, f->next); |
| |
| fens = statementSemantic(fens, sc2); |
| blockExit(fens, funcdecl, false); |
| |
| sc2 = sc2->pop(); |
| |
| if (global.params.useOut == CHECKENABLEoff) |
| fens = NULL; |
| } |
| |
| if (funcdecl->fbody && funcdecl->fbody->isErrorStatement()) |
| ; |
| else |
| { |
| Statements *a = new Statements(); |
| |
| // Merge in initialization of 'out' parameters |
| if (funcdecl->parameters) |
| { |
| for (size_t i = 0; i < funcdecl->parameters->length; i++) |
| { |
| VarDeclaration *v = (*funcdecl->parameters)[i]; |
| if (v->storage_class & STCout) |
| { |
| assert(v->_init); |
| ExpInitializer *ie = v->_init->isExpInitializer(); |
| assert(ie); |
| if (ie->exp->op == TOKconstruct) |
| ie->exp->op = TOKassign; // construction occured in parameter processing |
| a->push(new ExpStatement(Loc(), ie->exp)); |
| } |
| } |
| } |
| |
| if (funcdecl->v_argptr) |
| { |
| // Handled in FuncDeclaration::toObjFile |
| funcdecl->v_argptr->_init = new VoidInitializer(funcdecl->loc); |
| } |
| |
| if (_arguments) |
| { |
| /* Advance to elements[] member of TypeInfo_Tuple with: |
| * _arguments = v_arguments.elements; |
| */ |
| Expression *e = new VarExp(Loc(), funcdecl->v_arguments); |
| e = new DotIdExp(Loc(), e, Id::elements); |
| e = new ConstructExp(Loc(), _arguments, e); |
| e = expressionSemantic(e, sc2); |
| |
| _arguments->_init = new ExpInitializer(Loc(), e); |
| DeclarationExp *de = new DeclarationExp(Loc(), _arguments); |
| a->push(new ExpStatement(Loc(), de)); |
| } |
| |
| // Merge contracts together with body into one compound statement |
| |
| if (freq || fpreinv) |
| { |
| if (!freq) |
| freq = fpreinv; |
| else if (fpreinv) |
| freq = new CompoundStatement(Loc(), freq, fpreinv); |
| |
| a->push(freq); |
| } |
| |
| if (funcdecl->fbody) |
| a->push(funcdecl->fbody); |
| |
| if (fens || fpostinv) |
| { |
| if (!fens) |
| fens = fpostinv; |
| else if (fpostinv) |
| fens = new CompoundStatement(Loc(), fpostinv, fens); |
| |
| LabelStatement *ls = new LabelStatement(Loc(), Id::returnLabel, fens); |
| funcdecl->returnLabel->statement = ls; |
| a->push(funcdecl->returnLabel->statement); |
| |
| if (f->next->ty != Tvoid && funcdecl->vresult) |
| { |
| // Create: return vresult; |
| Expression *e = new VarExp(Loc(), funcdecl->vresult); |
| if (funcdecl->tintro) |
| { |
| e = e->implicitCastTo(sc, funcdecl->tintro->nextOf()); |
| e = expressionSemantic(e, sc); |
| } |
| ReturnStatement *s = new ReturnStatement(Loc(), e); |
| a->push(s); |
| } |
| } |
| if (addReturn0(funcdecl)) |
| { |
| // Add a return 0; statement |
| Statement *s = new ReturnStatement(Loc(), new IntegerExp(0)); |
| a->push(s); |
| } |
| |
| Statement *sbody = new CompoundStatement(Loc(), a); |
| /* Append destructor calls for parameters as finally blocks. |
| */ |
| if (funcdecl->parameters) |
| { |
| for (size_t i = 0; i < funcdecl->parameters->length; i++) |
| { |
| VarDeclaration *v = (*funcdecl->parameters)[i]; |
| |
| if (v->storage_class & (STCref | STCout | STClazy)) |
| continue; |
| |
| if (v->needsScopeDtor()) |
| { |
| // same with ExpStatement.scopeCode() |
| Statement *s = new DtorExpStatement(Loc(), v->edtor, v); |
| v->storage_class |= STCnodtor; |
| |
| s = statementSemantic(s, sc2); |
| |
| bool isnothrow = f->isnothrow & !(funcdecl->flags & FUNCFLAGnothrowInprocess); |
| int blockexit = blockExit(s, funcdecl, isnothrow); |
| if (f->isnothrow && isnothrow && blockexit & BEthrow) |
| error(funcdecl->loc, "nothrow %s `%s` may throw", funcdecl->kind(), funcdecl->toPrettyChars()); |
| if (funcdecl->flags & FUNCFLAGnothrowInprocess && blockexit & BEthrow) |
| f->isnothrow = false; |
| if (blockExit(sbody, funcdecl, f->isnothrow) == BEfallthru) |
| sbody = new CompoundStatement(Loc(), sbody, s); |
| else |
| sbody = new TryFinallyStatement(Loc(), sbody, s); |
| } |
| } |
| } |
| // from this point on all possible 'throwers' are checked |
| funcdecl->flags &= ~FUNCFLAGnothrowInprocess; |
| |
| if (funcdecl->isSynchronized()) |
| { |
| /* Wrap the entire function body in a synchronized statement |
| */ |
| ClassDeclaration *cd = funcdecl->isThis() ? funcdecl->isThis()->isClassDeclaration() : funcdecl->parent->isClassDeclaration(); |
| |
| if (cd) |
| { |
| if (target.libraryObjectMonitors(funcdecl, sbody)) |
| { |
| Expression *vsync; |
| if (funcdecl->isStatic()) |
| { |
| // The monitor is in the ClassInfo |
| vsync = new DotIdExp(funcdecl->loc, resolve(funcdecl->loc, sc2, cd, false), Id::classinfo); |
| } |
| else |
| { |
| // 'this' is the monitor |
| vsync = new VarExp(funcdecl->loc, funcdecl->vthis); |
| } |
| sbody = new PeelStatement(sbody); // don't redo semantic() |
| sbody = new SynchronizedStatement(funcdecl->loc, vsync, sbody); |
| sbody = statementSemantic(sbody, sc2); |
| } |
| } |
| else |
| { |
| funcdecl->error("synchronized function %s must be a member of a class", funcdecl->toChars()); |
| } |
| } |
| |
| // If declaration has no body, don't set sbody to prevent incorrect codegen. |
| if (funcdecl->fbody || allowsContractWithoutBody(funcdecl)) |
| funcdecl->fbody = sbody; |
| } |
| |
| // Fix up forward-referenced gotos |
| if (funcdecl->gotos) |
| { |
| for (size_t i = 0; i < funcdecl->gotos->length; ++i) |
| { |
| (*funcdecl->gotos)[i]->checkLabel(); |
| } |
| } |
| |
| if (funcdecl->naked && (funcdecl->fensures || funcdecl->frequires)) |
| funcdecl->error("naked assembly functions with contracts are not supported"); |
| |
| sc2->callSuper = 0; |
| sc2->pop(); |
| } |
| |
| if (funcdecl->checkClosure()) |
| { |
| // We should be setting errors here instead of relying on the global error count. |
| //errors = true; |
| } |
| |
| /* If function survived being marked as impure, then it is pure |
| */ |
| if (funcdecl->flags & FUNCFLAGpurityInprocess) |
| { |
| funcdecl->flags &= ~FUNCFLAGpurityInprocess; |
| if (funcdecl->type == f) |
| f = (TypeFunction *)f->copy(); |
| f->purity = PUREfwdref; |
| } |
| |
| if (funcdecl->flags & FUNCFLAGsafetyInprocess) |
| { |
| funcdecl->flags &= ~FUNCFLAGsafetyInprocess; |
| if (funcdecl->type == f) |
| f = (TypeFunction *)f->copy(); |
| f->trust = TRUSTsafe; |
| } |
| |
| if (funcdecl->flags & FUNCFLAGnogcInprocess) |
| { |
| funcdecl->flags &= ~FUNCFLAGnogcInprocess; |
| if (funcdecl->type == f) |
| f = (TypeFunction *)f->copy(); |
| f->isnogc = true; |
| } |
| |
| if (funcdecl->flags & FUNCFLAGreturnInprocess) |
| { |
| funcdecl->flags &= ~FUNCFLAGreturnInprocess; |
| if (funcdecl->storage_class & STCreturn) |
| { |
| if (funcdecl->type == f) |
| f = (TypeFunction *)f->copy(); |
| f->isreturn = true; |
| } |
| } |
| |
| funcdecl->flags &= ~FUNCFLAGinferScope; |
| |
| // Infer STCscope |
| if (funcdecl->parameters) |
| { |
| size_t nfparams = f->parameterList.length(); |
| assert(nfparams == funcdecl->parameters->length); |
| for (size_t u = 0; u < funcdecl->parameters->length; u++) |
| { |
| VarDeclaration *v = (*funcdecl->parameters)[u]; |
| if (v->storage_class & STCmaybescope) |
| { |
| //printf("Inferring scope for %s\n", v->toChars()); |
| Parameter *p = f->parameterList[u]; |
| v->storage_class &= ~STCmaybescope; |
| v->storage_class |= STCscope | STCscopeinferred; |
| p->storageClass |= STCscope | STCscopeinferred; |
| assert(!(p->storageClass & STCmaybescope)); |
| } |
| } |
| } |
| |
| if (funcdecl->vthis && funcdecl->vthis->storage_class & STCmaybescope) |
| { |
| funcdecl->vthis->storage_class &= ~STCmaybescope; |
| funcdecl->vthis->storage_class |= STCscope | STCscopeinferred; |
| f->isscope = true; |
| f->isscopeinferred = true; |
| } |
| |
| // reset deco to apply inference result to mangled name |
| if (f != funcdecl->type) |
| f->deco = NULL; |
| |
| // Do semantic type AFTER pure/nothrow inference. |
| if (!f->deco && funcdecl->ident != Id::xopEquals && funcdecl->ident != Id::xopCmp) |
| { |
| sc = sc->push(); |
| if (funcdecl->isCtorDeclaration()) // Bugzilla #15665 |
| sc->flags |= SCOPEctor; |
| sc->stc = 0; |
| sc->linkage = funcdecl->linkage; // Bugzilla 8496 |
| funcdecl->type = typeSemantic(f, funcdecl->loc, sc); |
| sc = sc->pop(); |
| } |
| |
| /* If this function had instantiated with gagging, error reproduction will be |
| * done by TemplateInstance::semantic. |
| * Otherwise, error gagging should be temporarily ungagged by functionSemantic3. |
| */ |
| funcdecl->semanticRun = PASSsemantic3done; |
| funcdecl->semantic3Errors = (global.errors != oldErrors) || (funcdecl->fbody && funcdecl->fbody->isErrorStatement()); |
| if (funcdecl->type->ty == Terror) |
| funcdecl->errors = true; |
| //printf("-FuncDeclaration::semantic3('%s.%s', sc = %p, loc = %s)\n", funcdecl->parent->toChars(), funcdecl->toChars(), sc, funcdecl->loc.toChars()); |
| //fflush(stdout); |
| } |
| |
| void visit(Nspace *ns) |
| { |
| if (ns->semanticRun >= PASSsemantic3) |
| return; |
| ns->semanticRun = PASSsemantic3; |
| if (ns->members) |
| { |
| sc = sc->push(ns); |
| sc->linkage = LINKcpp; |
| for (size_t i = 0; i < ns->members->length; i++) |
| { |
| Dsymbol *s = (*ns->members)[i]; |
| semantic3(s, sc); |
| } |
| sc->pop(); |
| } |
| } |
| |
| void visit(AttribDeclaration *ad) |
| { |
| Dsymbols *d = ad->include(sc); |
| |
| if (d) |
| { |
| Scope *sc2 = ad->newScope(sc); |
| |
| for (size_t i = 0; i < d->length; i++) |
| { |
| Dsymbol *s = (*d)[i]; |
| semantic3(s, sc2); |
| } |
| |
| if (sc2 != sc) |
| sc2->pop(); |
| } |
| } |
| |
| void visit(AggregateDeclaration *ad) |
| { |
| //printf("AggregateDeclaration::semantic3(%s) type = %s, errors = %d\n", ad->toChars(), ad->type->toChars(), ad->errors); |
| if (!ad->members) |
| return; |
| |
| StructDeclaration *sd = ad->isStructDeclaration(); |
| if (!sc) // from runDeferredSemantic3 for TypeInfo generation |
| { |
| assert(sd); |
| sd->semanticTypeInfoMembers(); |
| return; |
| } |
| |
| Scope *sc2 = ad->newScope(sc); |
| |
| for (size_t i = 0; i < ad->members->length; i++) |
| { |
| Dsymbol *s = (*ad->members)[i]; |
| semantic3(s, sc2); |
| } |
| |
| sc2->pop(); |
| |
| // don't do it for unused deprecated types |
| // or error types |
| if (!ad->getRTInfo && Type::rtinfo && |
| (!ad->isDeprecated() || global.params.useDeprecated != DIAGNOSTICerror) && |
| (ad->type && ad->type->ty != Terror)) |
| { |
| // Evaluate: RTinfo!type |
| Objects *tiargs = new Objects(); |
| tiargs->push(ad->type); |
| TemplateInstance *ti = new TemplateInstance(ad->loc, Type::rtinfo, tiargs); |
| |
| Scope *sc3 = ti->tempdecl->_scope->startCTFE(); |
| sc3->tinst = sc->tinst; |
| sc3->minst = sc->minst; |
| if (ad->isDeprecated()) |
| sc3->stc |= STCdeprecated; |
| |
| dsymbolSemantic(ti, sc3); |
| semantic2(ti, sc3); |
| semantic3(ti, sc3); |
| Expression *e = resolve(Loc(), sc3, ti->toAlias(), false); |
| |
| sc3->endCTFE(); |
| |
| e = e->ctfeInterpret(); |
| ad->getRTInfo = e; |
| } |
| |
| if (sd) |
| sd->semanticTypeInfoMembers(); |
| ad->semanticRun = PASSsemantic3done; |
| } |
| }; |
| |
| /************************************* |
| * Does semantic analysis on function bodies. |
| */ |
| void semantic3(Dsymbol *dsym, Scope *sc) |
| { |
| Semantic3Visitor v(sc); |
| dsym->accept(&v); |
| } |
