blob: 9aec87a04f5ce3cc7c40388283523685891de9ef [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/dsymbol.c
*/
#include "root/dsystem.h"
#include "root/rmem.h"
#include "root/speller.h"
#include "root/aav.h"
#include "mars.h"
#include "dsymbol.h"
#include "aggregate.h"
#include "identifier.h"
#include "module.h"
#include "mtype.h"
#include "expression.h"
#include "statement.h"
#include "declaration.h"
#include "id.h"
#include "scope.h"
#include "init.h"
#include "import.h"
#include "template.h"
#include "attrib.h"
#include "enum.h"
#include "lexer.h"
#include "nspace.h"
bool symbolIsVisible(Dsymbol *origin, Dsymbol *s);
typedef int (*ForeachDg)(void *ctx, size_t idx, Dsymbol *s);
int ScopeDsymbol_foreach(Scope *sc, Dsymbols *members, ForeachDg dg, void *ctx, size_t *pn = NULL);
Expression *semantic(Expression *e, Scope *sc);
/****************************** Dsymbol ******************************/
Dsymbol::Dsymbol()
{
//printf("Dsymbol::Dsymbol(%p)\n", this);
this->ident = NULL;
this->parent = NULL;
this->csym = NULL;
this->isym = NULL;
this->loc = Loc();
this->comment = NULL;
this->_scope = NULL;
this->prettystring = NULL;
this->semanticRun = PASSinit;
this->errors = false;
this->depdecl = NULL;
this->userAttribDecl = NULL;
this->ddocUnittest = NULL;
}
Dsymbol::Dsymbol(Identifier *ident)
{
//printf("Dsymbol::Dsymbol(%p, ident)\n", this);
this->ident = ident;
this->parent = NULL;
this->csym = NULL;
this->isym = NULL;
this->loc = Loc();
this->comment = NULL;
this->_scope = NULL;
this->prettystring = NULL;
this->semanticRun = PASSinit;
this->errors = false;
this->depdecl = NULL;
this->userAttribDecl = NULL;
this->ddocUnittest = NULL;
}
Dsymbol *Dsymbol::create(Identifier *ident)
{
return new Dsymbol(ident);
}
bool Dsymbol::equals(RootObject *o)
{
if (this == o)
return true;
Dsymbol *s = (Dsymbol *)(o);
// Overload sets don't have an ident
if (s && ident && s->ident && ident->equals(s->ident))
return true;
return false;
}
/**************************************
* Copy the syntax.
* Used for template instantiations.
* If s is NULL, allocate the new object, otherwise fill it in.
*/
Dsymbol *Dsymbol::syntaxCopy(Dsymbol *)
{
print();
printf("%s %s\n", kind(), toChars());
assert(0);
return NULL;
}
/**************************************
* Determine if this symbol is only one.
* Returns:
* false, *ps = NULL: There are 2 or more symbols
* true, *ps = NULL: There are zero symbols
* true, *ps = symbol: The one and only one symbol
*/
bool Dsymbol::oneMember(Dsymbol **ps, Identifier *)
{
//printf("Dsymbol::oneMember()\n");
*ps = this;
return true;
}
/*****************************************
* Same as Dsymbol::oneMember(), but look at an array of Dsymbols.
*/
bool Dsymbol::oneMembers(Dsymbols *members, Dsymbol **ps, Identifier *ident)
{
//printf("Dsymbol::oneMembers() %d\n", members ? members->dim : 0);
Dsymbol *s = NULL;
if (members)
{
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *sx = (*members)[i];
bool x = sx->oneMember(ps, ident);
//printf("\t[%d] kind %s = %d, s = %p\n", i, sx->kind(), x, *ps);
if (!x)
{
//printf("\tfalse 1\n");
assert(*ps == NULL);
return false;
}
if (*ps)
{
assert(ident);
if (!(*ps)->ident || !(*ps)->ident->equals(ident))
continue;
if (!s)
s = *ps;
else if (s->isOverloadable() && (*ps)->isOverloadable())
{
// keep head of overload set
FuncDeclaration *f1 = s->isFuncDeclaration();
FuncDeclaration *f2 = (*ps)->isFuncDeclaration();
if (f1 && f2)
{
assert(!f1->isFuncAliasDeclaration());
assert(!f2->isFuncAliasDeclaration());
for (; f1 != f2; f1 = f1->overnext0)
{
if (f1->overnext0 == NULL)
{
f1->overnext0 = f2;
break;
}
}
}
}
else // more than one symbol
{
*ps = NULL;
//printf("\tfalse 2\n");
return false;
}
}
}
}
*ps = s; // s is the one symbol, NULL if none
//printf("\ttrue\n");
return true;
}
/*****************************************
* Is Dsymbol a variable that contains pointers?
*/
bool Dsymbol::hasPointers()
{
//printf("Dsymbol::hasPointers() %s\n", toChars());
return false;
}
bool Dsymbol::hasStaticCtorOrDtor()
{
//printf("Dsymbol::hasStaticCtorOrDtor() %s\n", toChars());
return false;
}
void Dsymbol::setFieldOffset(AggregateDeclaration *, unsigned *, bool)
{
}
Identifier *Dsymbol::getIdent()
{
return ident;
}
const char *Dsymbol::toChars()
{
return ident ? ident->toChars() : "__anonymous";
}
const char *Dsymbol::toPrettyCharsHelper()
{
return toChars();
}
const char *Dsymbol::toPrettyChars(bool QualifyTypes)
{
if (prettystring && !QualifyTypes)
return (const char *)prettystring;
//printf("Dsymbol::toPrettyChars() '%s'\n", toChars());
if (!parent)
{
const char *s = toChars();
if (!QualifyTypes)
prettystring = (const utf8_t *)s;
return s;
}
// Computer number of components
size_t complength = 0;
for (Dsymbol *p = this; p; p = p->parent)
++complength;
// Allocate temporary array comp[]
const char **comp = (const char **)mem.xmalloc(complength * sizeof(char**));
// Fill in comp[] and compute length of final result
size_t length = 0;
int i = 0;
for (Dsymbol *p = this; p; p = p->parent)
{
const char *s = QualifyTypes ? p->toPrettyCharsHelper() : p->toChars();
const size_t len = strlen(s);
comp[i] = s;
++i;
length += len + 1;
}
char *s = (char *)mem.xmalloc(length);
char *q = s + length - 1;
*q = 0;
for (size_t j = 0; j < complength; j++)
{
const char *t = comp[j];
const size_t len = strlen(t);
q -= len;
memcpy(q, t, len);
if (q == s)
break;
*--q = '.';
}
free(comp);
if (!QualifyTypes)
prettystring = (utf8_t *)s;
return s;
}
Loc& Dsymbol::getLoc()
{
if (!loc.filename) // avoid bug 5861.
{
Module *m = getModule();
if (m && m->srcfile)
loc.filename = m->srcfile->toChars();
}
return loc;
}
const char *Dsymbol::locToChars()
{
return getLoc().toChars();
}
const char *Dsymbol::kind() const
{
return "symbol";
}
/*********************************
* If this symbol is really an alias for another,
* return that other.
* If needed, semantic() is invoked due to resolve forward reference.
*/
Dsymbol *Dsymbol::toAlias()
{
return this;
}
/*********************************
* Resolve recursive tuple expansion in eponymous template.
*/
Dsymbol *Dsymbol::toAlias2()
{
return toAlias();
}
/**
* `pastMixin` returns the enclosing symbol if this is a template mixin.
*
* `pastMixinAndNspace` does likewise, additionally skipping over Nspaces that
* are mangleOnly.
*
* See also `parent`, `toParent`, `toParent2` and `toParent3`.
*/
Dsymbol *Dsymbol::pastMixin()
{
Dsymbol *s = this;
//printf("Dsymbol::pastMixin() %s\n", toChars());
while (s && s->isTemplateMixin())
s = s->parent;
return s;
}
/// ditto
Dsymbol *Dsymbol::pastMixinAndNspace()
{
//printf("Dsymbol::pastMixinAndNspace() %s\n", toChars());
Nspace *ns = isNspace();
if (!(ns && ns->mangleOnly) && !isTemplateMixin() && !isForwardingAttribDeclaration())
return this;
if (!parent)
return NULL;
return parent->pastMixinAndNspace();
}
/**********************************
* `parent` field returns a lexically enclosing scope symbol this is a member of.
*
* `toParent()` returns a logically enclosing scope symbol this is a member of.
* It skips over TemplateMixin's and Nspaces that are mangleOnly.
*
* `toParent2()` returns an enclosing scope symbol this is living at runtime.
* It skips over both TemplateInstance's and TemplateMixin's.
* It's used when looking for the 'this' pointer of the enclosing function/class.
*
* `toParent3()` returns a logically enclosing scope symbol this is a member of.
* It skips over TemplateMixin's.
*
* Examples:
* module mod;
* template Foo(alias a) { mixin Bar!(); }
* mixin template Bar() {
* public { // ProtDeclaration
* void baz() { a = 2; }
* }
* }
* void test() {
* int v = 1;
* alias foo = Foo!(v);
* foo.baz();
* assert(v == 2);
* }
*
* // s == FuncDeclaration('mod.test.Foo!().Bar!().baz()')
* // s.parent == TemplateMixin('mod.test.Foo!().Bar!()')
* // s.toParent() == TemplateInstance('mod.test.Foo!()')
* // s.toParent2() == FuncDeclaration('mod.test')
*/
Dsymbol *Dsymbol::toParent()
{
return parent ? parent->pastMixinAndNspace() : NULL;
}
/// ditto
Dsymbol *Dsymbol::toParent2()
{
Dsymbol *s = parent;
while (s && s->isTemplateInstance())
s = s->parent;
return s;
}
/// ditto
Dsymbol *Dsymbol::toParent3()
{
return parent ? parent->pastMixin() : NULL;
}
TemplateInstance *Dsymbol::isInstantiated()
{
for (Dsymbol *s = parent; s; s = s->parent)
{
TemplateInstance *ti = s->isTemplateInstance();
if (ti && !ti->isTemplateMixin())
return ti;
}
return NULL;
}
// Check if this function is a member of a template which has only been
// instantiated speculatively, eg from inside is(typeof()).
// Return the speculative template instance it is part of,
// or NULL if not speculative.
TemplateInstance *Dsymbol::isSpeculative()
{
Dsymbol *par = parent;
while (par)
{
TemplateInstance *ti = par->isTemplateInstance();
if (ti && ti->gagged)
return ti;
par = par->toParent();
}
return NULL;
}
Ungag Dsymbol::ungagSpeculative()
{
unsigned oldgag = global.gag;
if (global.gag && !isSpeculative() && !toParent2()->isFuncDeclaration())
global.gag = 0;
return Ungag(oldgag);
}
bool Dsymbol::isAnonymous()
{
return ident == NULL;
}
/*************************************
* Set scope for future semantic analysis so we can
* deal better with forward references.
*/
void Dsymbol::setScope(Scope *sc)
{
//printf("Dsymbol::setScope() %p %s, %p stc = %llx\n", this, toChars(), sc, sc->stc);
if (!sc->nofree)
sc->setNoFree(); // may need it even after semantic() finishes
_scope = sc;
if (sc->depdecl)
depdecl = sc->depdecl;
if (!userAttribDecl)
userAttribDecl = sc->userAttribDecl;
}
void Dsymbol::importAll(Scope *)
{
}
/*************************************
* Does semantic analysis on the public face of declarations.
*/
void Dsymbol::semantic(Scope *)
{
error("%p has no semantic routine", this);
}
/*************************************
* Does semantic analysis on initializers and members of aggregates.
*/
void Dsymbol::semantic2(Scope *)
{
// Most Dsymbols have no further semantic analysis needed
}
/*************************************
* Does semantic analysis on function bodies.
*/
void Dsymbol::semantic3(Scope *)
{
// Most Dsymbols have no further semantic analysis needed
}
/*********************************************
* Search for ident as member of s.
* Params:
* loc = location to print for error messages
* ident = identifier to search for
* flags = IgnoreXXXX
* Returns:
* NULL if not found
*/
Dsymbol *Dsymbol::search(const Loc &, Identifier *, int)
{
//printf("Dsymbol::search(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars());
return NULL;
}
/***************************************************
* Search for symbol with correct spelling.
*/
void *symbol_search_fp(void *arg, const char *seed, int *cost)
{
/* 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;
*cost = 0;
Dsymbol *s = (Dsymbol *)arg;
Module::clearCache();
return (void *)s->search(Loc(), id, IgnoreErrors);
}
Dsymbol *Dsymbol::search_correct(Identifier *ident)
{
if (global.gag)
return NULL; // don't do it for speculative compiles; too time consuming
return (Dsymbol *)speller(ident->toChars(), &symbol_search_fp, (void *)this, idchars);
}
/***************************************
* Search for identifier id as a member of 'this'.
* id may be a template instance.
* Returns:
* symbol found, NULL if not
*/
Dsymbol *Dsymbol::searchX(Loc loc, Scope *sc, RootObject *id)
{
//printf("Dsymbol::searchX(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars());
Dsymbol *s = toAlias();
Dsymbol *sm;
if (Declaration *d = s->isDeclaration())
{
if (d->inuse)
{
::error(loc, "circular reference to '%s'", d->toPrettyChars());
return NULL;
}
}
switch (id->dyncast())
{
case DYNCAST_IDENTIFIER:
sm = s->search(loc, (Identifier *)id);
break;
case DYNCAST_DSYMBOL:
{
// It's a template instance
//printf("\ttemplate instance id\n");
Dsymbol *st = (Dsymbol *)id;
TemplateInstance *ti = st->isTemplateInstance();
sm = s->search(loc, ti->name);
if (!sm)
{
sm = s->search_correct(ti->name);
if (sm)
::error(loc, "template identifier '%s' is not a member of %s '%s', did you mean %s '%s'?",
ti->name->toChars(), s->kind(), s->toPrettyChars(), sm->kind(), sm->toChars());
else
::error(loc, "template identifier '%s' is not a member of %s '%s'",
ti->name->toChars(), s->kind(), s->toPrettyChars());
return NULL;
}
sm = sm->toAlias();
TemplateDeclaration *td = sm->isTemplateDeclaration();
if (!td)
{
::error(loc, "%s.%s is not a template, it is a %s", s->toPrettyChars(), ti->name->toChars(), sm->kind());
return NULL;
}
ti->tempdecl = td;
if (!ti->semanticRun)
ti->semantic(sc);
sm = ti->toAlias();
break;
}
case DYNCAST_TYPE:
case DYNCAST_EXPRESSION:
default:
assert(0);
}
return sm;
}
bool Dsymbol::overloadInsert(Dsymbol *)
{
//printf("Dsymbol::overloadInsert('%s')\n", s->toChars());
return false;
}
d_uns64 Dsymbol::size(Loc)
{
error("Dsymbol '%s' has no size", toChars());
return SIZE_INVALID;
}
bool Dsymbol::isforwardRef()
{
return false;
}
AggregateDeclaration *Dsymbol::isThis()
{
return NULL;
}
bool Dsymbol::isExport() const
{
return false;
}
bool Dsymbol::isImportedSymbol() const
{
return false;
}
bool Dsymbol::isDeprecated()
{
return false;
}
bool Dsymbol::isOverloadable()
{
return false;
}
LabelDsymbol *Dsymbol::isLabel() // is this a LabelDsymbol()?
{
return NULL;
}
/// Returns an AggregateDeclaration when toParent() is that.
AggregateDeclaration *Dsymbol::isMember()
{
//printf("Dsymbol::isMember() %s\n", toChars());
Dsymbol *parent = toParent();
//printf("parent is %s %s\n", parent->kind(), parent->toChars());
return parent ? parent->isAggregateDeclaration() : NULL;
}
/// Returns an AggregateDeclaration when toParent2() is that.
AggregateDeclaration *Dsymbol::isMember2()
{
//printf("Dsymbol::isMember2() %s\n", toChars());
Dsymbol *parent = toParent2();
//printf("parent is %s %s\n", parent->kind(), parent->toChars());
return parent ? parent->isAggregateDeclaration() : NULL;
}
// is this a member of a ClassDeclaration?
ClassDeclaration *Dsymbol::isClassMember()
{
AggregateDeclaration *ad = isMember();
return ad ? ad->isClassDeclaration() : NULL;
}
Type *Dsymbol::getType()
{
return NULL;
}
bool Dsymbol::needThis()
{
return false;
}
/*********************************
* Iterate this dsymbol or members of this scoped dsymbol, then
* call `fp` with the found symbol and `param`.
* Params:
* fp = function pointer to process the iterated symbol.
* If it returns nonzero, the iteration will be aborted.
* param = a parameter passed to fp.
* Returns:
* nonzero if the iteration is aborted by the return value of fp,
* or 0 if it's completed.
*/
int Dsymbol::apply(Dsymbol_apply_ft_t fp, void *param)
{
return (*fp)(this, param);
}
void Dsymbol::addMember(Scope *, ScopeDsymbol *sds)
{
//printf("Dsymbol::addMember('%s')\n", toChars());
//printf("Dsymbol::addMember(this = %p, '%s' scopesym = '%s')\n", this, toChars(), sds->toChars());
//printf("Dsymbol::addMember(this = %p, '%s' sds = %p, sds->symtab = %p)\n", this, toChars(), sds, sds->symtab);
parent = sds;
if (!isAnonymous()) // no name, so can't add it to symbol table
{
if (!sds->symtabInsert(this)) // if name is already defined
{
Dsymbol *s2 = sds->symtabLookup(this, ident);
if (!s2->overloadInsert(this))
{
sds->multiplyDefined(Loc(), this, s2);
errors = true;
}
}
if (sds->isAggregateDeclaration() || sds->isEnumDeclaration())
{
if (ident == Id::__sizeof || ident == Id::__xalignof || ident == Id::_mangleof)
{
error(".%s property cannot be redefined", ident->toChars());
errors = true;
}
}
}
}
void Dsymbol::error(const char *format, ...)
{
va_list ap;
va_start(ap, format);
::verror(getLoc(), format, ap, kind(), toPrettyChars());
va_end(ap);
}
void Dsymbol::error(Loc loc, const char *format, ...)
{
va_list ap;
va_start(ap, format);
::verror(loc, format, ap, kind(), toPrettyChars());
va_end(ap);
}
void Dsymbol::deprecation(Loc loc, const char *format, ...)
{
va_list ap;
va_start(ap, format);
::vdeprecation(loc, format, ap, kind(), toPrettyChars());
va_end(ap);
}
void Dsymbol::deprecation(const char *format, ...)
{
va_list ap;
va_start(ap, format);
::vdeprecation(getLoc(), format, ap, kind(), toPrettyChars());
va_end(ap);
}
void Dsymbol::checkDeprecated(Loc loc, Scope *sc)
{
if (global.params.useDeprecated != DIAGNOSTICoff && isDeprecated())
{
// Don't complain if we're inside a deprecated symbol's scope
for (Dsymbol *sp = sc->parent; sp; sp = sp->parent)
{
if (sp->isDeprecated())
goto L1;
}
for (Scope *sc2 = sc; sc2; sc2 = sc2->enclosing)
{
if (sc2->scopesym && sc2->scopesym->isDeprecated())
goto L1;
// If inside a StorageClassDeclaration that is deprecated
if (sc2->stc & STCdeprecated)
goto L1;
}
const char *message = NULL;
for (Dsymbol *p = this; p; p = p->parent)
{
message = p->depdecl ? p->depdecl->getMessage() : NULL;
if (message)
break;
}
if (message)
deprecation(loc, "is deprecated - %s", message);
else
deprecation(loc, "is deprecated");
}
L1:
Declaration *d = isDeclaration();
if (d && d->storage_class & STCdisable)
{
if (!(sc->func && sc->func->storage_class & STCdisable))
{
if (d->toParent() && d->isPostBlitDeclaration())
d->toParent()->error(loc, "is not copyable because it is annotated with @disable");
else
error(loc, "is not callable because it is annotated with @disable");
}
}
}
/**********************************
* Determine which Module a Dsymbol is in.
*/
Module *Dsymbol::getModule()
{
//printf("Dsymbol::getModule()\n");
if (TemplateInstance *ti = isInstantiated())
return ti->tempdecl->getModule();
Dsymbol *s = this;
while (s)
{
//printf("\ts = %s '%s'\n", s->kind(), s->toPrettyChars());
Module *m = s->isModule();
if (m)
return m;
s = s->parent;
}
return NULL;
}
/**********************************
* Determine which Module a Dsymbol is in, as far as access rights go.
*/
Module *Dsymbol::getAccessModule()
{
//printf("Dsymbol::getAccessModule()\n");
if (TemplateInstance *ti = isInstantiated())
return ti->tempdecl->getAccessModule();
Dsymbol *s = this;
while (s)
{
//printf("\ts = %s '%s'\n", s->kind(), s->toPrettyChars());
Module *m = s->isModule();
if (m)
return m;
TemplateInstance *ti = s->isTemplateInstance();
if (ti && ti->enclosing)
{
/* Because of local template instantiation, the parent isn't where the access
* rights come from - it's the template declaration
*/
s = ti->tempdecl;
}
else
s = s->parent;
}
return NULL;
}
/*************************************
*/
Prot Dsymbol::prot()
{
return Prot(PROTpublic);
}
/*************************************
* Do syntax copy of an array of Dsymbol's.
*/
Dsymbols *Dsymbol::arraySyntaxCopy(Dsymbols *a)
{
Dsymbols *b = NULL;
if (a)
{
b = a->copy();
for (size_t i = 0; i < b->dim; i++)
{
(*b)[i] = (*b)[i]->syntaxCopy(NULL);
}
}
return b;
}
/****************************************
* Add documentation comment to Dsymbol.
* Ignore NULL comments.
*/
void Dsymbol::addComment(const utf8_t *comment)
{
//if (comment)
//printf("adding comment '%s' to symbol %p '%s'\n", comment, this, toChars());
if (!this->comment)
this->comment = comment;
else if (comment && strcmp((const char *)comment, (const char *)this->comment) != 0)
{ // Concatenate the two
this->comment = Lexer::combineComments(this->comment, comment);
}
}
/****************************************
* Returns true if this symbol is defined in a non-root module without instantiation.
*/
bool Dsymbol::inNonRoot()
{
Dsymbol *s = parent;
for (; s; s = s->toParent())
{
if (s->isTemplateInstance())
{
return false;
}
if (Module *m = s->isModule())
{
if (!m->isRoot())
return true;
break;
}
}
return false;
}
/********************************* OverloadSet ****************************/
OverloadSet::OverloadSet(Identifier *ident, OverloadSet *os)
: Dsymbol(ident)
{
if (os)
{
for (size_t i = 0; i < os->a.dim; i++)
{
a.push(os->a[i]);
}
}
}
void OverloadSet::push(Dsymbol *s)
{
a.push(s);
}
const char *OverloadSet::kind() const
{
return "overloadset";
}
/********************************* ScopeDsymbol ****************************/
ScopeDsymbol::ScopeDsymbol()
: Dsymbol()
{
members = NULL;
symtab = NULL;
endlinnum = 0;
importedScopes = NULL;
prots = NULL;
}
ScopeDsymbol::ScopeDsymbol(Identifier *id)
: Dsymbol(id)
{
members = NULL;
symtab = NULL;
endlinnum = 0;
importedScopes = NULL;
prots = NULL;
}
Dsymbol *ScopeDsymbol::syntaxCopy(Dsymbol *s)
{
//printf("ScopeDsymbol::syntaxCopy('%s')\n", toChars());
ScopeDsymbol *sds = s ? (ScopeDsymbol *)s : new ScopeDsymbol(ident);
sds->members = arraySyntaxCopy(members);
sds->endlinnum = endlinnum;
return sds;
}
void ScopeDsymbol::semantic(Scope *)
{
}
/*****************************************
* This function is #1 on the list of functions that eat cpu time.
* Be very, very careful about slowing it down.
*/
Dsymbol *ScopeDsymbol::search(const Loc &loc, Identifier *ident, int flags)
{
//printf("%s->ScopeDsymbol::search(ident='%s', flags=x%x)\n", toChars(), ident->toChars(), flags);
//if (strcmp(ident->toChars(),"c") == 0) *(char*)0=0;
// Look in symbols declared in this module
if (symtab && !(flags & SearchImportsOnly))
{
//printf(" look in locals\n");
Dsymbol *s1 = symtab->lookup(ident);
if (s1)
{
//printf("\tfound in locals = '%s.%s'\n",toChars(),s1->toChars());
return s1;
}
}
//printf(" not found in locals\n");
// Look in imported scopes
if (importedScopes)
{
//printf(" look in imports\n");
Dsymbol *s = NULL;
OverloadSet *a = NULL;
// Look in imported modules
for (size_t i = 0; i < importedScopes->dim; i++)
{
// If private import, don't search it
if ((flags & IgnorePrivateImports) && prots[i] == PROTprivate)
continue;
int sflags = flags & (IgnoreErrors | IgnoreAmbiguous | IgnoreSymbolVisibility); // remember these in recursive searches
Dsymbol *ss = (*importedScopes)[i];
//printf("\tscanning import '%s', prots = %d, isModule = %p, isImport = %p\n", ss->toChars(), prots[i], ss->isModule(), ss->isImport());
if (ss->isModule())
{
if (flags & SearchLocalsOnly)
continue;
}
else // mixin template
{
if (flags & SearchImportsOnly)
continue;
// compatibility with -transition=import (Bugzilla 15925)
// SearchLocalsOnly should always get set for new lookup rules
sflags |= (flags & SearchLocalsOnly);
}
/* Don't find private members if ss is a module
*/
Dsymbol *s2 = ss->search(loc, ident, sflags | (ss->isModule() ? IgnorePrivateImports : IgnoreNone));
if (!s2 || (!(flags & IgnoreSymbolVisibility) && !symbolIsVisible(this, s2)))
continue;
if (!s)
{
s = s2;
if (s && s->isOverloadSet())
a = mergeOverloadSet(ident, a, s);
}
else if (s2 && s != s2)
{
if (s->toAlias() == s2->toAlias() ||
(s->getType() == s2->getType() && s->getType()))
{
/* After following aliases, we found the same
* symbol, so it's not an ambiguity. But if one
* alias is deprecated or less accessible, prefer
* the other.
*/
if (s->isDeprecated() ||
(s->prot().isMoreRestrictiveThan(s2->prot()) && s2->prot().kind != PROTnone))
s = s2;
}
else
{
/* Two imports of the same module should be regarded as
* the same.
*/
Import *i1 = s->isImport();
Import *i2 = s2->isImport();
if (!(i1 && i2 &&
(i1->mod == i2->mod ||
(!i1->parent->isImport() && !i2->parent->isImport() &&
i1->ident->equals(i2->ident))
)
)
)
{
/* Bugzilla 8668:
* Public selective import adds AliasDeclaration in module.
* To make an overload set, resolve aliases in here and
* get actual overload roots which accessible via s and s2.
*/
s = s->toAlias();
s2 = s2->toAlias();
/* If both s2 and s are overloadable (though we only
* need to check s once)
*/
if ((s2->isOverloadSet() || s2->isOverloadable()) &&
(a || s->isOverloadable()))
{
a = mergeOverloadSet(ident, a, s2);
continue;
}
if (flags & IgnoreAmbiguous) // if return NULL on ambiguity
return NULL;
if (!(flags & IgnoreErrors))
ScopeDsymbol::multiplyDefined(loc, s, s2);
break;
}
}
}
}
if (s)
{
/* Build special symbol if we had multiple finds
*/
if (a)
{
if (!s->isOverloadSet())
a = mergeOverloadSet(ident, a, s);
s = a;
}
// TODO: remove once private symbol visibility has been deprecated
if (!(flags & IgnoreErrors) && s->prot().kind == PROTprivate &&
!s->isOverloadable() && !s->parent->isTemplateMixin() && !s->parent->isNspace())
{
AliasDeclaration *ad;
// accessing private selective and renamed imports is
// deprecated by restricting the symbol visibility
if (s->isImport() || ((ad = s->isAliasDeclaration()) != NULL && ad->_import != NULL))
{}
else
error(loc, "%s %s is private", s->kind(), s->toPrettyChars());
}
//printf("\tfound in imports %s.%s\n", toChars(), s.toChars());
return s;
}
//printf(" not found in imports\n");
}
return NULL;
}
OverloadSet *ScopeDsymbol::mergeOverloadSet(Identifier *ident, OverloadSet *os, Dsymbol *s)
{
if (!os)
{
os = new OverloadSet(ident);
os->parent = this;
}
if (OverloadSet *os2 = s->isOverloadSet())
{
// Merge the cross-module overload set 'os2' into 'os'
if (os->a.dim == 0)
{
os->a.setDim(os2->a.dim);
memcpy(os->a.tdata(), os2->a.tdata(), sizeof(os->a[0]) * os2->a.dim);
}
else
{
for (size_t i = 0; i < os2->a.dim; i++)
{
os = mergeOverloadSet(ident, os, os2->a[i]);
}
}
}
else
{
assert(s->isOverloadable());
/* Don't add to os[] if s is alias of previous sym
*/
for (size_t j = 0; j < os->a.dim; j++)
{
Dsymbol *s2 = os->a[j];
if (s->toAlias() == s2->toAlias())
{
if (s2->isDeprecated() ||
(s2->prot().isMoreRestrictiveThan(s->prot()) &&
s->prot().kind != PROTnone))
{
os->a[j] = s;
}
goto Lcontinue;
}
}
os->push(s);
Lcontinue:
;
}
return os;
}
void ScopeDsymbol::importScope(Dsymbol *s, Prot protection)
{
//printf("%s->ScopeDsymbol::importScope(%s, %d)\n", toChars(), s->toChars(), protection);
// No circular or redundant import's
if (s != this)
{
if (!importedScopes)
importedScopes = new Dsymbols();
else
{
for (size_t i = 0; i < importedScopes->dim; i++)
{
Dsymbol *ss = (*importedScopes)[i];
if (ss == s) // if already imported
{
if (protection.kind > prots[i])
prots[i] = protection.kind; // upgrade access
return;
}
}
}
importedScopes->push(s);
prots = (PROTKIND *)mem.xrealloc(prots, importedScopes->dim * sizeof(prots[0]));
prots[importedScopes->dim - 1] = protection.kind;
}
}
#define BITS_PER_INDEX (sizeof(size_t) * CHAR_BIT)
static void bitArraySet(BitArray *array, size_t idx)
{
array->ptr[idx / BITS_PER_INDEX] |= 1ULL << (idx % BITS_PER_INDEX);
}
static bool bitArrayGet(BitArray *array, size_t idx)
{
const size_t boffset = idx % BITS_PER_INDEX;
return (array->ptr[idx / BITS_PER_INDEX] & (1ULL << boffset)) >> boffset;
}
static void bitArrayLength(BitArray *array, size_t len)
{
if (array->len < len)
{
const size_t obytes = (array->len + BITS_PER_INDEX - 1) / BITS_PER_INDEX;
const size_t nbytes = (len + BITS_PER_INDEX - 1) / BITS_PER_INDEX;
if (!array->ptr)
array->ptr = (size_t *)mem.xmalloc(nbytes * sizeof(size_t));
else
array->ptr = (size_t *)mem.xrealloc(array->ptr, nbytes * sizeof(size_t));
for (size_t i = obytes; i < nbytes; i++)
array->ptr[i] = 0;
array->len = nbytes * BITS_PER_INDEX;
}
}
void ScopeDsymbol::addAccessiblePackage(Package *p, Prot protection)
{
BitArray *pary = protection.kind == PROTprivate ? &privateAccessiblePackages : &accessiblePackages;
if (pary->len <= p->tag)
bitArrayLength(pary, p->tag + 1);
bitArraySet(pary, p->tag);
}
bool ScopeDsymbol::isPackageAccessible(Package *p, Prot protection, int)
{
if ((p->tag < accessiblePackages.len && bitArrayGet(&accessiblePackages, p->tag)) ||
(protection.kind == PROTprivate && p->tag < privateAccessiblePackages.len && bitArrayGet(&privateAccessiblePackages, p->tag)))
return true;
if (importedScopes)
{
for (size_t i = 0; i < importedScopes->dim; i++)
{
// only search visible scopes && imported modules should ignore private imports
Dsymbol *ss = (*importedScopes)[i];
if (protection.kind <= prots[i] &&
ss->isScopeDsymbol()->isPackageAccessible(p, protection, IgnorePrivateImports))
return true;
}
}
return false;
}
bool ScopeDsymbol::isforwardRef()
{
return (members == NULL);
}
void ScopeDsymbol::multiplyDefined(Loc loc, Dsymbol *s1, Dsymbol *s2)
{
if (loc.filename)
{ ::error(loc, "%s at %s conflicts with %s at %s",
s1->toPrettyChars(),
s1->locToChars(),
s2->toPrettyChars(),
s2->locToChars());
}
else
{
s1->error(s1->loc, "conflicts with %s %s at %s",
s2->kind(),
s2->toPrettyChars(),
s2->locToChars());
}
}
const char *ScopeDsymbol::kind() const
{
return "ScopeDsymbol";
}
Dsymbol *ScopeDsymbol::symtabInsert(Dsymbol *s)
{
return symtab->insert(s);
}
/****************************************
* Look up identifier in symbol table.
*/
Dsymbol *ScopeDsymbol::symtabLookup(Dsymbol *, Identifier *id)
{
return symtab->lookup(id);
}
/****************************************
* Return true if any of the members are static ctors or static dtors, or if
* any members have members that are.
*/
bool ScopeDsymbol::hasStaticCtorOrDtor()
{
if (members)
{
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *member = (*members)[i];
if (member->hasStaticCtorOrDtor())
return true;
}
}
return false;
}
/***************************************
* Determine number of Dsymbols, folding in AttribDeclaration members.
*/
static int dimDg(void *ctx, size_t, Dsymbol *)
{
++*(size_t *)ctx;
return 0;
}
size_t ScopeDsymbol::dim(Dsymbols *members)
{
size_t n = 0;
ScopeDsymbol_foreach(NULL, members, &dimDg, &n);
return n;
}
/***************************************
* Get nth Dsymbol, folding in AttribDeclaration members.
* Returns:
* Dsymbol* nth Dsymbol
* NULL not found, *pn gets incremented by the number
* of Dsymbols
*/
struct GetNthSymbolCtx
{
size_t nth;
Dsymbol *sym;
};
static int getNthSymbolDg(void *ctx, size_t n, Dsymbol *sym)
{
GetNthSymbolCtx *p = (GetNthSymbolCtx *)ctx;
if (n == p->nth)
{ p->sym = sym;
return 1;
}
return 0;
}
Dsymbol *ScopeDsymbol::getNth(Dsymbols *members, size_t nth, size_t *)
{
GetNthSymbolCtx ctx = { nth, NULL };
int res = ScopeDsymbol_foreach(NULL, members, &getNthSymbolDg, &ctx);
return res ? ctx.sym : NULL;
}
/***************************************
* Expands attribute declarations in members in depth first
* order. Calls dg(void *ctx, size_t symidx, Dsymbol *sym) for each
* member.
* If dg returns !=0, stops and returns that value else returns 0.
* Use this function to avoid the O(N + N^2/2) complexity of
* calculating dim and calling N times getNth.
*/
int ScopeDsymbol_foreach(Scope *sc, Dsymbols *members, ForeachDg dg, void *ctx, size_t *pn)
{
assert(dg);
if (!members)
return 0;
size_t n = pn ? *pn : 0; // take over index
int result = 0;
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
if (AttribDeclaration *a = s->isAttribDeclaration())
result = ScopeDsymbol_foreach(sc, a->include(sc, NULL), dg, ctx, &n);
else if (TemplateMixin *tm = s->isTemplateMixin())
result = ScopeDsymbol_foreach(sc, tm->members, dg, ctx, &n);
else if (s->isTemplateInstance())
;
else if (s->isUnitTestDeclaration())
;
else
result = dg(ctx, n++, s);
if (result)
break;
}
if (pn)
*pn = n; // update index
return result;
}
/*******************************************
* Look for member of the form:
* const(MemberInfo)[] getMembers(string);
* Returns NULL if not found
*/
FuncDeclaration *ScopeDsymbol::findGetMembers()
{
Dsymbol *s = search_function(this, Id::getmembers);
FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
if (fdx && fdx->isVirtual())
fdx = NULL;
return fdx;
}
/****************************** WithScopeSymbol ******************************/
WithScopeSymbol::WithScopeSymbol(WithStatement *withstate)
: ScopeDsymbol()
{
this->withstate = withstate;
}
Dsymbol *WithScopeSymbol::search(const Loc &loc, Identifier *ident, int flags)
{
//printf("WithScopeSymbol::search(%s)\n", ident->toChars());
if (flags & SearchImportsOnly)
return NULL;
// Acts as proxy to the with class declaration
Dsymbol *s = NULL;
Expression *eold = NULL;
for (Expression *e = withstate->exp; e != eold; e = resolveAliasThis(_scope, e))
{
if (e->op == TOKscope)
{
s = ((ScopeExp *)e)->sds;
}
else if (e->op == TOKtype)
{
s = e->type->toDsymbol(NULL);
}
else
{
Type *t = e->type->toBasetype();
s = t->toDsymbol(NULL);
}
if (s)
{
s = s->search(loc, ident, flags);
if (s)
return s;
}
eold = e;
}
return NULL;
}
/****************************** ArrayScopeSymbol ******************************/
ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, Expression *e)
: ScopeDsymbol()
{
assert(e->op == TOKindex || e->op == TOKslice || e->op == TOKarray);
exp = e;
type = NULL;
td = NULL;
this->sc = sc;
}
ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, TypeTuple *t)
: ScopeDsymbol()
{
exp = NULL;
type = t;
td = NULL;
this->sc = sc;
}
ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, TupleDeclaration *s)
: ScopeDsymbol()
{
exp = NULL;
type = NULL;
td = s;
this->sc = sc;
}
Dsymbol *ArrayScopeSymbol::search(const Loc &loc, Identifier *ident, int)
{
//printf("ArrayScopeSymbol::search('%s', flags = %d)\n", ident->toChars(), flags);
if (ident == Id::dollar)
{
VarDeclaration **pvar;
Expression *ce;
L1:
if (td)
{
/* $ gives the number of elements in the tuple
*/
VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL);
Expression *e = new IntegerExp(Loc(), td->objects->dim, Type::tsize_t);
v->_init = new ExpInitializer(Loc(), e);
v->storage_class |= STCtemp | STCstatic | STCconst;
v->semantic(sc);
return v;
}
if (type)
{
/* $ gives the number of type entries in the type tuple
*/
VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL);
Expression *e = new IntegerExp(Loc(), type->arguments->dim, Type::tsize_t);
v->_init = new ExpInitializer(Loc(), e);
v->storage_class |= STCtemp | STCstatic | STCconst;
v->semantic(sc);
return v;
}
if (exp->op == TOKindex)
{
/* array[index] where index is some function of $
*/
IndexExp *ie = (IndexExp *)exp;
pvar = &ie->lengthVar;
ce = ie->e1;
}
else if (exp->op == TOKslice)
{
/* array[lwr .. upr] where lwr or upr is some function of $
*/
SliceExp *se = (SliceExp *)exp;
pvar = &se->lengthVar;
ce = se->e1;
}
else if (exp->op == TOKarray)
{
/* array[e0, e1, e2, e3] where e0, e1, e2 are some function of $
* $ is a opDollar!(dim)() where dim is the dimension(0,1,2,...)
*/
ArrayExp *ae = (ArrayExp *)exp;
pvar = &ae->lengthVar;
ce = ae->e1;
}
else
{
/* Didn't find $, look in enclosing scope(s).
*/
return NULL;
}
while (ce->op == TOKcomma)
ce = ((CommaExp *)ce)->e2;
/* If we are indexing into an array that is really a type
* tuple, rewrite this as an index into a type tuple and
* try again.
*/
if (ce->op == TOKtype)
{
Type *t = ((TypeExp *)ce)->type;
if (t->ty == Ttuple)
{
type = (TypeTuple *)t;
goto L1;
}
}
/* *pvar is lazily initialized, so if we refer to $
* multiple times, it gets set only once.
*/
if (!*pvar) // if not already initialized
{
/* Create variable v and set it to the value of $
*/
VarDeclaration *v;
Type *t;
if (ce->op == TOKtuple)
{
/* It is for an expression tuple, so the
* length will be a const.
*/
Expression *e = new IntegerExp(Loc(), ((TupleExp *)ce)->exps->dim, Type::tsize_t);
v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, new ExpInitializer(Loc(), e));
v->storage_class |= STCtemp | STCstatic | STCconst;
}
else if (ce->type && (t = ce->type->toBasetype()) != NULL &&
(t->ty == Tstruct || t->ty == Tclass))
{
// Look for opDollar
assert(exp->op == TOKarray || exp->op == TOKslice);
AggregateDeclaration *ad = isAggregate(t);
assert(ad);
Dsymbol *s = ad->search(loc, Id::opDollar);
if (!s) // no dollar exists -- search in higher scope
return NULL;
s = s->toAlias();
Expression *e = NULL;
// Check for multi-dimensional opDollar(dim) template.
if (TemplateDeclaration *td = s->isTemplateDeclaration())
{
dinteger_t dim = 0;
if (exp->op == TOKarray)
{
dim = ((ArrayExp *)exp)->currentDimension;
}
else if (exp->op == TOKslice)
{
dim = 0; // slices are currently always one-dimensional
}
else
{
assert(0);
}
Objects *tiargs = new Objects();
Expression *edim = new IntegerExp(Loc(), dim, Type::tsize_t);
edim = ::semantic(edim, sc);
tiargs->push(edim);
e = new DotTemplateInstanceExp(loc, ce, td->ident, tiargs);
}
else
{
/* opDollar exists, but it's not a template.
* This is acceptable ONLY for single-dimension indexing.
* Note that it's impossible to have both template & function opDollar,
* because both take no arguments.
*/
if (exp->op == TOKarray && ((ArrayExp *)exp)->arguments->dim != 1)
{
exp->error("%s only defines opDollar for one dimension", ad->toChars());
return NULL;
}
Declaration *d = s->isDeclaration();
assert(d);
e = new DotVarExp(loc, ce, d);
}
e = ::semantic(e, sc);
if (!e->type)
exp->error("%s has no value", e->toChars());
t = e->type->toBasetype();
if (t && t->ty == Tfunction)
e = new CallExp(e->loc, e);
v = new VarDeclaration(loc, NULL, Id::dollar, new ExpInitializer(Loc(), e));
v->storage_class |= STCtemp | STCctfe | STCrvalue;
}
else
{
/* For arrays, $ will either be a compile-time constant
* (in which case its value in set during constant-folding),
* or a variable (in which case an expression is created in
* toir.c).
*/
VoidInitializer *e = new VoidInitializer(Loc());
e->type = Type::tsize_t;
v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, e);
v->storage_class |= STCtemp | STCctfe; // it's never a true static variable
}
*pvar = v;
}
(*pvar)->semantic(sc);
return (*pvar);
}
return NULL;
}
/****************************** DsymbolTable ******************************/
DsymbolTable::DsymbolTable()
{
tab = NULL;
}
Dsymbol *DsymbolTable::lookup(Identifier const * const ident)
{
//printf("DsymbolTable::lookup(%s)\n", (char*)ident->string);
return (Dsymbol *)dmd_aaGetRvalue(tab, const_cast<void *>((const void *)ident));
}
Dsymbol *DsymbolTable::insert(Dsymbol *s)
{
//printf("DsymbolTable::insert(this = %p, '%s')\n", this, s->ident->toChars());
Identifier *ident = s->ident;
Dsymbol **ps = (Dsymbol **)dmd_aaGet(&tab, (void *)ident);
if (*ps)
return NULL; // already in table
*ps = s;
return s;
}
Dsymbol *DsymbolTable::insert(Identifier const * const ident, Dsymbol *s)
{
//printf("DsymbolTable::insert()\n");
Dsymbol **ps = (Dsymbol **)dmd_aaGet(&tab, const_cast<void *>((const void *)ident));
if (*ps)
return NULL; // already in table
*ps = s;
return s;
}
Dsymbol *DsymbolTable::update(Dsymbol *s)
{
Identifier *ident = s->ident;
Dsymbol **ps = (Dsymbol **)dmd_aaGet(&tab, (void *)ident);
*ps = s;
return s;
}
/****************************** Prot ******************************/
Prot::Prot()
{
this->kind = PROTundefined;
this->pkg = NULL;
}
Prot::Prot(PROTKIND kind)
{
this->kind = kind;
this->pkg = NULL;
}
/**
* Checks if `this` is superset of `other` restrictions.
* For example, "protected" is more restrictive than "public".
*/
bool Prot::isMoreRestrictiveThan(const Prot other) const
{
return this->kind < other.kind;
}
/**
* Checks if `this` is absolutely identical protection attribute to `other`
*/
bool Prot::operator==(const Prot& other) const
{
if (this->kind == other.kind)
{
if (this->kind == PROTpackage)
return this->pkg == other.pkg;
return true;
}
return false;
}
/**
* Checks if parent defines different access restrictions than this one.
*
* Params:
* parent = protection attribute for scope that hosts this one
*
* Returns:
* 'true' if parent is already more restrictive than this one and thus
* no differentiation is needed.
*/
bool Prot::isSubsetOf(const Prot& parent) const
{
if (this->kind != parent.kind)
return false;
if (this->kind == PROTpackage)
{
if (!this->pkg)
return true;
if (!parent.pkg)
return false;
if (parent.pkg->isAncestorPackageOf(this->pkg))
return true;
}
return true;
}