blob: def448a2408080c694e05710748dc527fb112a91 [file] [log] [blame]
/* Compiler implementation of the D programming language
* Copyright (C) 1999-2019 by The D Language Foundation, All Rights Reserved
* written by Walter Bright
* http://www.digitalmars.com
* Distributed under the Boost Software License, Version 1.0.
* http://www.boost.org/LICENSE_1_0.txt
* https://github.com/D-Programming-Language/dmd/blob/master/src/scope.c
*/
#include "root/dsystem.h" // strlen()
#include "root/root.h"
#include "root/rmem.h"
#include "root/speller.h"
#include "mars.h"
#include "init.h"
#include "identifier.h"
#include "scope.h"
#include "attrib.h"
#include "dsymbol.h"
#include "declaration.h"
#include "statement.h"
#include "aggregate.h"
#include "module.h"
#include "id.h"
#include "template.h"
Scope *Scope::freelist = NULL;
void allocFieldinit(Scope *sc, size_t dim)
{
sc->fieldinit = (unsigned *)mem.xcalloc(sizeof(unsigned), dim);
sc->fieldinit_dim = dim;
}
void freeFieldinit(Scope *sc)
{
if (sc->fieldinit)
mem.xfree(sc->fieldinit);
sc->fieldinit = NULL;
sc->fieldinit_dim = 0;
}
Scope *Scope::alloc()
{
if (freelist)
{
Scope *s = freelist;
freelist = s->enclosing;
//printf("freelist %p\n", s);
assert(s->flags & SCOPEfree);
s->flags &= ~SCOPEfree;
return s;
}
return new Scope();
}
Scope::Scope()
{
// Create root scope
//printf("Scope::Scope() %p\n", this);
this->_module = NULL;
this->scopesym = NULL;
this->sds = NULL;
this->enclosing = NULL;
this->parent = NULL;
this->sw = NULL;
this->tf = NULL;
this->os = NULL;
this->tinst = NULL;
this->minst = NULL;
this->sbreak = NULL;
this->scontinue = NULL;
this->fes = NULL;
this->callsc = NULL;
this->aligndecl = NULL;
this->func = NULL;
this->slabel = NULL;
this->linkage = LINKd;
this->cppmangle = CPPMANGLEdefault;
this->inlining = PINLINEdefault;
this->protection = Prot(PROTpublic);
this->explicitProtection = 0;
this->stc = 0;
this->depdecl = NULL;
this->inunion = 0;
this->nofree = 0;
this->noctor = 0;
this->intypeof = 0;
this->lastVar = NULL;
this->callSuper = 0;
this->fieldinit = NULL;
this->fieldinit_dim = 0;
this->flags = 0;
this->lastdc = NULL;
this->anchorCounts = NULL;
this->prevAnchor = NULL;
this->userAttribDecl = NULL;
}
Scope *Scope::copy()
{
Scope *sc = Scope::alloc();
*sc = *this; // memcpy
/* Bugzilla 11777: The copied scope should not inherit fieldinit.
*/
sc->fieldinit = NULL;
return sc;
}
Scope *Scope::createGlobal(Module *_module)
{
Scope *sc = Scope::alloc();
*sc = Scope(); // memset
sc->aligndecl = NULL;
sc->linkage = LINKd;
sc->inlining = PINLINEdefault;
sc->protection = Prot(PROTpublic);
sc->_module = _module;
sc->tinst = NULL;
sc->minst = _module;
sc->scopesym = new ScopeDsymbol();
sc->scopesym->symtab = new DsymbolTable();
// Add top level package as member of this global scope
Dsymbol *m = _module;
while (m->parent)
m = m->parent;
m->addMember(NULL, sc->scopesym);
m->parent = NULL; // got changed by addMember()
// Create the module scope underneath the global scope
sc = sc->push(_module);
sc->parent = _module;
return sc;
}
Scope *Scope::push()
{
Scope *s = copy();
//printf("Scope::push(this = %p) new = %p\n", this, s);
assert(!(flags & SCOPEfree));
s->scopesym = NULL;
s->sds = NULL;
s->enclosing = this;
s->slabel = NULL;
s->nofree = 0;
s->fieldinit = saveFieldInit();
s->flags = (flags & (SCOPEcontract | SCOPEdebug | SCOPEctfe | SCOPEcompile | SCOPEconstraint |
SCOPEnoaccesscheck | SCOPEignoresymbolvisibility));
s->lastdc = NULL;
assert(this != s);
return s;
}
Scope *Scope::push(ScopeDsymbol *ss)
{
//printf("Scope::push(%s)\n", ss->toChars());
Scope *s = push();
s->scopesym = ss;
return s;
}
Scope *Scope::pop()
{
//printf("Scope::pop() %p nofree = %d\n", this, nofree);
Scope *enc = enclosing;
if (enclosing)
{
enclosing->callSuper |= callSuper;
if (fieldinit)
{
if (enclosing->fieldinit)
{
assert(fieldinit != enclosing->fieldinit);
size_t dim = fieldinit_dim;
for (size_t i = 0; i < dim; i++)
enclosing->fieldinit[i] |= fieldinit[i];
}
freeFieldinit(this);
}
}
if (!nofree)
{
enclosing = freelist;
freelist = this;
flags |= SCOPEfree;
}
return enc;
}
Scope *Scope::startCTFE()
{
Scope *sc = this->push();
sc->flags = this->flags | SCOPEctfe;
return sc;
}
Scope *Scope::endCTFE()
{
assert(flags & SCOPEctfe);
return pop();
}
void Scope::mergeCallSuper(Loc loc, unsigned cs)
{
// This does a primitive flow analysis to support the restrictions
// regarding when and how constructors can appear.
// It merges the results of two paths.
// The two paths are callSuper and cs; the result is merged into callSuper.
if (cs != callSuper)
{
// Have ALL branches called a constructor?
int aAll = (cs & (CSXthis_ctor | CSXsuper_ctor)) != 0;
int bAll = (callSuper & (CSXthis_ctor | CSXsuper_ctor)) != 0;
// Have ANY branches called a constructor?
bool aAny = (cs & CSXany_ctor) != 0;
bool bAny = (callSuper & CSXany_ctor) != 0;
// Have any branches returned?
bool aRet = (cs & CSXreturn) != 0;
bool bRet = (callSuper & CSXreturn) != 0;
// Have any branches halted?
bool aHalt = (cs & CSXhalt) != 0;
bool bHalt = (callSuper & CSXhalt) != 0;
bool ok = true;
if (aHalt && bHalt)
{
callSuper = CSXhalt;
}
else if ((!aHalt && aRet && !aAny && bAny) ||
(!bHalt && bRet && !bAny && aAny))
{
// If one has returned without a constructor call, there must be never
// have been ctor calls in the other.
ok = false;
}
else if (aHalt || (aRet && aAll))
{
// If one branch has called a ctor and then exited, anything the
// other branch has done is OK (except returning without a
// ctor call, but we already checked that).
callSuper |= cs & (CSXany_ctor | CSXlabel);
}
else if (bHalt || (bRet && bAll))
{
callSuper = cs | (callSuper & (CSXany_ctor | CSXlabel));
}
else
{
// Both branches must have called ctors, or both not.
ok = (aAll == bAll);
// If one returned without a ctor, we must remember that
// (Don't bother if we've already found an error)
if (ok && aRet && !aAny)
callSuper |= CSXreturn;
callSuper |= cs & (CSXany_ctor | CSXlabel);
}
if (!ok)
error(loc, "one path skips constructor");
}
}
unsigned *Scope::saveFieldInit()
{
unsigned *fi = NULL;
if (fieldinit) // copy
{
size_t dim = fieldinit_dim;
fi = (unsigned *)mem.xmalloc(sizeof(unsigned) * dim);
for (size_t i = 0; i < dim; i++)
fi[i] = fieldinit[i];
}
return fi;
}
static bool mergeFieldInit(unsigned &fieldInit, unsigned fi, bool mustInit)
{
if (fi != fieldInit)
{
// Have any branches returned?
bool aRet = (fi & CSXreturn) != 0;
bool bRet = (fieldInit & CSXreturn) != 0;
// Have any branches halted?
bool aHalt = (fi & CSXhalt) != 0;
bool bHalt = (fieldInit & CSXhalt) != 0;
bool ok;
if (aHalt && bHalt)
{
ok = true;
fieldInit = CSXhalt;
}
else if (!aHalt && aRet)
{
ok = !mustInit || (fi & CSXthis_ctor);
fieldInit = fieldInit;
}
else if (!bHalt && bRet)
{
ok = !mustInit || (fieldInit & CSXthis_ctor);
fieldInit = fi;
}
else if (aHalt)
{
ok = !mustInit || (fieldInit & CSXthis_ctor);
fieldInit = fieldInit;
}
else if (bHalt)
{
ok = !mustInit || (fi & CSXthis_ctor);
fieldInit = fi;
}
else
{
ok = !mustInit || !((fieldInit ^ fi) & CSXthis_ctor);
fieldInit |= fi;
}
return ok;
}
return true;
}
void Scope::mergeFieldInit(Loc loc, unsigned *fies)
{
if (fieldinit && fies)
{
FuncDeclaration *f = func;
if (fes) f = fes->func;
AggregateDeclaration *ad = f->isMember2();
assert(ad);
for (size_t i = 0; i < ad->fields.dim; i++)
{
VarDeclaration *v = ad->fields[i];
bool mustInit = (v->storage_class & STCnodefaultctor ||
v->type->needsNested());
if (!::mergeFieldInit(fieldinit[i], fies[i], mustInit))
{
::error(loc, "one path skips field %s", ad->fields[i]->toChars());
}
}
}
}
Module *Scope::instantiatingModule()
{
// TODO: in speculative context, returning 'module' is correct?
return minst ? minst : _module;
}
static Dsymbol *searchScopes(Scope *scope, Loc loc, Identifier *ident, Dsymbol **pscopesym, int flags)
{
for (Scope *sc = scope; sc; sc = sc->enclosing)
{
assert(sc != sc->enclosing);
if (!sc->scopesym)
continue;
//printf("\tlooking in scopesym '%s', kind = '%s', flags = x%x\n", sc->scopesym->toChars(), sc->scopesym->kind(), flags);
if (sc->scopesym->isModule())
flags |= SearchUnqualifiedModule; // tell Module.search() that SearchLocalsOnly is to be obeyed
if (Dsymbol *s = sc->scopesym->search(loc, ident, flags))
{
if (!(flags & (SearchImportsOnly | IgnoreErrors)) &&
ident == Id::length && sc->scopesym->isArrayScopeSymbol() &&
sc->enclosing && sc->enclosing->search(loc, ident, NULL, flags))
{
warning(s->loc, "array 'length' hides other 'length' name in outer scope");
}
if (pscopesym)
*pscopesym = sc->scopesym;
return s;
}
// Stop when we hit a module, but keep going if that is not just under the global scope
if (sc->scopesym->isModule() && !(sc->enclosing && !sc->enclosing->enclosing))
break;
}
return NULL;
}
/************************************
* Perform unqualified name lookup by following the chain of scopes up
* until found.
*
* Params:
* loc = location to use for error messages
* ident = name to look up
* pscopesym = if supplied and name is found, set to scope that ident was found in
* flags = modify search based on flags
*
* Returns:
* symbol if found, null if not
*/
Dsymbol *Scope::search(Loc loc, Identifier *ident, Dsymbol **pscopesym, int flags)
{
// This function is called only for unqualified lookup
assert(!(flags & (SearchLocalsOnly | SearchImportsOnly)));
/* If ident is "start at module scope", only look at module scope
*/
if (ident == Id::empty)
{
// Look for module scope
for (Scope *sc = this; sc; sc = sc->enclosing)
{
assert(sc != sc->enclosing);
if (!sc->scopesym)
continue;
if (Dsymbol *s = sc->scopesym->isModule())
{
if (pscopesym)
*pscopesym = sc->scopesym;
return s;
}
}
return NULL;
}
if (this->flags & SCOPEignoresymbolvisibility)
flags |= IgnoreSymbolVisibility;
Dsymbol *sold = NULL;
if (global.params.bug10378 || global.params.check10378)
{
sold = searchScopes(this, loc, ident, pscopesym, flags | IgnoreSymbolVisibility);
if (!global.params.check10378)
return sold;
if (ident == Id::dollar) // Bugzilla 15825
return sold;
// Search both ways
}
// First look in local scopes
Dsymbol *s = searchScopes(this, loc, ident, pscopesym, flags | SearchLocalsOnly);
if (!s)
{
// Second look in imported modules
s = searchScopes(this, loc, ident, pscopesym, flags | SearchImportsOnly);
/** Still find private symbols, so that symbols that weren't access
* checked by the compiler remain usable. Once the deprecation is over,
* this should be moved to search_correct instead.
*/
if (!s && !(flags & IgnoreSymbolVisibility))
{
s = searchScopes(this, loc, ident, pscopesym, flags | SearchLocalsOnly | IgnoreSymbolVisibility);
if (!s)
s = searchScopes(this, loc, ident, pscopesym, flags | SearchImportsOnly | IgnoreSymbolVisibility);
if (s && !(flags & IgnoreErrors))
::deprecation(loc, "%s is not visible from module %s", s->toPrettyChars(), _module->toChars());
}
}
if (global.params.check10378)
{
Dsymbol *snew = s;
if (sold != snew)
deprecation10378(loc, sold, snew);
if (global.params.bug10378)
s = sold;
}
return s;
}
Dsymbol *Scope::insert(Dsymbol *s)
{
if (VarDeclaration *vd = s->isVarDeclaration())
{
if (lastVar)
vd->lastVar = lastVar;
lastVar = vd;
}
else if (WithScopeSymbol *ss = s->isWithScopeSymbol())
{
if (VarDeclaration *vd = ss->withstate->wthis)
{
if (lastVar)
vd->lastVar = lastVar;
lastVar = vd;
}
return NULL;
}
for (Scope *sc = this; sc; sc = sc->enclosing)
{
//printf("\tsc = %p\n", sc);
if (sc->scopesym)
{
//printf("\t\tsc->scopesym = %p\n", sc->scopesym);
if (!sc->scopesym->symtab)
sc->scopesym->symtab = new DsymbolTable();
return sc->scopesym->symtabInsert(s);
}
}
assert(0);
return NULL;
}
/********************************************
* Search enclosing scopes for ClassDeclaration.
*/
ClassDeclaration *Scope::getClassScope()
{
for (Scope *sc = this; sc; sc = sc->enclosing)
{
if (!sc->scopesym)
continue;
ClassDeclaration *cd = sc->scopesym->isClassDeclaration();
if (cd)
return cd;
}
return NULL;
}
/********************************************
* Search enclosing scopes for ClassDeclaration.
*/
AggregateDeclaration *Scope::getStructClassScope()
{
for (Scope *sc = this; sc; sc = sc->enclosing)
{
if (!sc->scopesym)
continue;
AggregateDeclaration *ad = sc->scopesym->isClassDeclaration();
if (ad)
return ad;
ad = sc->scopesym->isStructDeclaration();
if (ad)
return ad;
}
return NULL;
}
/*******************************************
* For TemplateDeclarations, we need to remember the Scope
* where it was declared. So mark the Scope as not
* to be free'd.
*/
void Scope::setNoFree()
{
//int i = 0;
//printf("Scope::setNoFree(this = %p)\n", this);
for (Scope *sc = this; sc; sc = sc->enclosing)
{
//printf("\tsc = %p\n", sc);
sc->nofree = 1;
assert(!(flags & SCOPEfree));
//assert(sc != sc->enclosing);
//assert(!sc->enclosing || sc != sc->enclosing->enclosing);
//if (++i == 10)
//assert(0);
}
}
structalign_t Scope::alignment()
{
if (aligndecl)
return aligndecl->getAlignment(this);
else
return STRUCTALIGN_DEFAULT;
}
/************************************************
* Given the failed search attempt, try to find
* one with a close spelling.
*/
void *scope_search_fp(void *arg, const char *seed, int* cost)
{
//printf("scope_search_fp('%s')\n", seed);
/* If not in the lexer's string table, it certainly isn't in the symbol table.
* Doing this first is a lot faster.
*/
size_t len = strlen(seed);
if (!len)
return NULL;
Identifier *id = Identifier::lookup(seed, len);
if (!id)
return NULL;
Scope *sc = (Scope *)arg;
Module::clearCache();
Dsymbol *scopesym = NULL;
Dsymbol *s = sc->search(Loc(), id, &scopesym, IgnoreErrors);
if (s)
{
for (*cost = 0; sc; sc = sc->enclosing, (*cost)++)
if (sc->scopesym == scopesym)
break;
if (scopesym != s->parent)
{
(*cost)++; // got to the symbol through an import
if (s->prot().kind == PROTprivate)
return NULL;
}
}
return (void*)s;
}
void Scope::deprecation10378(Loc loc, Dsymbol *sold, Dsymbol *snew)
{
// Bugzilla 15857
//
// The overloadset found via the new lookup rules is either
// equal or a subset of the overloadset found via the old
// lookup rules, so it suffices to compare the dimension to
// check for equality.
OverloadSet *osold = NULL;
OverloadSet *osnew = NULL;
if (sold && (osold = sold->isOverloadSet()) != NULL &&
snew && (osnew = snew->isOverloadSet()) != NULL &&
osold->a.dim == osnew->a.dim)
return;
OutBuffer buf;
buf.writestring("local import search method found ");
if (osold)
buf.printf("%s %s (%d overloads)", sold->kind(), sold->toPrettyChars(), (int)osold->a.dim);
else if (sold)
buf.printf("%s %s", sold->kind(), sold->toPrettyChars());
else
buf.writestring("nothing");
buf.writestring(" instead of ");
if (osnew)
buf.printf("%s %s (%d overloads)", snew->kind(), snew->toPrettyChars(), (int)osnew->a.dim);
else if (snew)
buf.printf("%s %s", snew->kind(), snew->toPrettyChars());
else
buf.writestring("nothing");
deprecation(loc, "%s", buf.peekString());
}
Dsymbol *Scope::search_correct(Identifier *ident)
{
if (global.gag)
return NULL; // don't do it for speculative compiles; too time consuming
return (Dsymbol *)speller(ident->toChars(), &scope_search_fp, this, idchars);
}
/************************************
* Maybe `ident` was a C or C++ name. Check for that,
* and suggest the D equivalent.
* Params:
* ident = unknown identifier
* Returns:
* D identifier string if found, null if not
*/
const char *Scope::search_correct_C(Identifier *ident)
{
TOK tok;
if (ident == Id::C_NULL)
tok = TOKnull;
else if (ident == Id::C_TRUE)
tok = TOKtrue;
else if (ident == Id::C_FALSE)
tok = TOKfalse;
else if (ident == Id::C_unsigned)
tok = TOKuns32;
else if (ident == Id::C_wchar_t)
tok = global.params.isWindows ? TOKwchar : TOKdchar;
else
return NULL;
return Token::toChars(tok);
}