int Import::addMember(Scope *sc, ScopeDsymbol *sd, int memnum)
{
int result = 0;
if (names.dim == 0)
return Dsymbol::addMember(sc, sd, memnum);
if (aliasId)
result = Dsymbol::addMember(sc, sd, memnum);
/* Instead of adding the import to sd's symbol table,
* add each of the alias=name pairs
*/
for (size_t i = 0; i < names.dim; i++)
{
Identifier *name = names[i];
Identifier *alias = aliases[i];
if (!alias)
alias = name;
TypeIdentifier *tname = new TypeIdentifier(loc, name);
AliasDeclaration *ad = new AliasDeclaration(loc, alias, tname);
result |= ad->addMember(sc, sd, memnum);
aliasdecls.push(ad);
}
return result;
}
int Import::addMember(Scope *sc, ScopeDsymbol *sd, int memnum)
{
int result = 0;
if (names.dim == 0)
return Dsymbol::addMember(sc, sd, memnum);
if (aliasId)
result = Dsymbol::addMember(sc, sd, memnum);
for (size_t i = 0; i < names.dim; i++)
{
Identifier *name = (Identifier *)names.data[i];
Identifier *alias = (Identifier *)aliases.data[i];
if (!alias)
alias = name;
#if 1
TypeIdentifier *tname = new TypeIdentifier(loc, name);
#else
TypeIdentifier *tname = new TypeIdentifier(loc, NULL);
if (packages)
{
for (size_t j = 0; j < packages->dim; j++)
{ Identifier *pid = (Identifier *)packages->data[j];
if (!tname->ident)
tname->ident = pid;
else
tname->addIdent(pid);
}
}
if (!tname->ident)
tname->ident = id;
else
tname->addIdent(id);
tname->addIdent(name);
#endif
AliasDeclaration *ad = new AliasDeclaration(loc, alias, tname);
result |= ad->addMember(sc, sd, memnum);
aliasdecls.push(ad);
}
return result;
}
void test_visitors()
{
TestVisitor tv;
Loc loc;
Identifier *ident = Identifier::idPool("test");
IntegerExp *ie = IntegerExp::createi(loc, 42, Type::tint32);
ie->accept(&tv);
assert(tv.expr == true);
IdentifierExp *id = IdentifierExp::create (loc, ident);
id->accept(&tv);
assert(tv.idexpr == true);
Module *mod = Module::create("test", ident, 0, 0);
mod->accept(&tv);
assert(tv.package == true);
ExpStatement *es = ExpStatement::create(loc, ie);
es->accept(&tv);
assert(tv.stmt == true);
TypePointer *tp = TypePointer::create(Type::tvoid);
tp->accept(&tv);
assert(tv.type == true);
LinkDeclaration *ld = LinkDeclaration::create(LINKd, NULL);
ld->accept(&tv);
assert(tv.attrib == true);
ClassDeclaration *cd = ClassDeclaration::create(loc, Identifier::idPool("TypeInfo"), NULL, NULL, true);
cd->accept(&tv);
assert(tv.aggr = true);
AliasDeclaration *ad = AliasDeclaration::create(loc, ident, tp);
ad->accept(&tv);
assert(tv.decl == true);
cd = ClassDeclaration::create(loc, Identifier::idPool("TypeInfo_Pointer"), NULL, NULL, true);
TypeInfoPointerDeclaration *ti = TypeInfoPointerDeclaration::create(tp);
ti->accept(&tv);
assert(tv.typeinfo == true);
}
AliasDeclaration::AliasDeclaration(const AliasDeclaration& rhs)
: ClassMemberDeclaration(*new AliasDeclarationData(*rhs.d_func())) {
}
/*****************************************
* Create inclusive destructor for struct/class by aggregating
* all the destructors in dtors[] with the destructors for
* all the members.
* Note the close similarity with StructDeclaration::buildPostBlit(),
* and the ordering changes (runs backward instead of forwards).
*/
FuncDeclaration *buildDtor(AggregateDeclaration *ad, Scope *sc)
{
//printf("AggregateDeclaration::buildDtor() %s\n", ad->toChars());
StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
Loc declLoc = ad->dtors.dim ? ad->dtors[0]->loc : ad->loc;
Loc loc = Loc(); // internal code should have no loc to prevent coverage
Expression *e = NULL;
for (size_t i = 0; i < ad->fields.dim; i++)
{
VarDeclaration *v = ad->fields[i];
if (v->storage_class & STCref)
continue;
Type *tv = v->type->baseElemOf();
if (tv->ty != Tstruct || !v->type->size())
continue;
StructDeclaration *sdv = ((TypeStruct *)tv)->sym;
if (!sdv->dtor)
continue;
sdv->dtor->functionSemantic();
stc = mergeFuncAttrs(stc, sdv->dtor);
if (stc & STCdisable)
{
e = NULL;
break;
}
Expression *ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v, 0);
if (v->type->toBasetype()->ty == Tstruct)
{
// this.v.__xdtor()
// This is a hack so we can call destructors on const/immutable objects.
ex = new AddrExp(loc, ex);
ex = new CastExp(loc, ex, v->type->mutableOf()->pointerTo());
ex = new PtrExp(loc, ex);
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new DotVarExp(loc, ex, sdv->dtor, 0);
ex = new CallExp(loc, ex);
}
else
{
// _ArrayDtor((cast(S*)this.v.ptr)[0 .. n])
// This is a hack so we can call destructors on const/immutable objects.
ex = new DotIdExp(loc, ex, Id::ptr);
ex = new CastExp(loc, ex, sdv->type->pointerTo());
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
uinteger_t n = v->type->size() / sdv->type->size();
ex = new SliceExp(loc, ex, new IntegerExp(loc, 0, Type::tsize_t),
new IntegerExp(loc, n, Type::tsize_t));
// Prevent redundant bounds check
((SliceExp *)ex)->upperIsInBounds = true;
((SliceExp *)ex)->lowerIsLessThanUpper = true;
ex = new CallExp(loc, new IdentifierExp(loc, Id::_ArrayDtor), ex);
}
e = Expression::combine(ex, e); // combine in reverse order
}
/* Build our own "destructor" which executes e
*/
if (e || (stc & STCdisable))
{
//printf("Building __fieldDtor()\n");
DtorDeclaration *dd = new DtorDeclaration(declLoc, Loc(), stc, Id::__fieldDtor);
dd->storage_class |= STCinference;
dd->fbody = new ExpStatement(loc, e);
ad->dtors.shift(dd);
ad->members->push(dd);
dd->semantic(sc);
}
FuncDeclaration *xdtor = NULL;
switch (ad->dtors.dim)
{
case 0:
break;
case 1:
xdtor = ad->dtors[0];
break;
default:
e = NULL;
stc = STCsafe | STCnothrow | STCpure | STCnogc;
for (size_t i = 0; i < ad->dtors.dim; i++)
{
FuncDeclaration *fd = ad->dtors[i];
stc = mergeFuncAttrs(stc, fd);
if (stc & STCdisable)
{
e = NULL;
break;
}
Expression *ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, fd, 0);
ex = new CallExp(loc, ex);
e = Expression::combine(ex, e);
}
DtorDeclaration *dd = new DtorDeclaration(declLoc, Loc(), stc, Id::__aggrDtor);
dd->storage_class |= STCinference;
dd->fbody = new ExpStatement(loc, e);
ad->members->push(dd);
dd->semantic(sc);
xdtor = dd;
break;
}
// Add an __xdtor alias to make the inclusive dtor accessible
if (xdtor)
{
AliasDeclaration *alias = new AliasDeclaration(Loc(), Id::__xdtor, xdtor);
alias->semantic(sc);
ad->members->push(alias);
alias->addMember(sc, ad); // add to symbol table
}
return xdtor;
}
/*****************************************
* Create inclusive postblit for struct by aggregating
* all the postblits in postblits[] with the postblits for
* all the members.
* Note the close similarity with AggregateDeclaration::buildDtor(),
* and the ordering changes (runs forward instead of backwards).
*/
FuncDeclaration *buildPostBlit(StructDeclaration *sd, Scope *sc)
{
//printf("StructDeclaration::buildPostBlit() %s\n", sd->toChars());
StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
Loc declLoc = sd->postblits.dim ? sd->postblits[0]->loc : sd->loc;
Loc loc = Loc(); // internal code should have no loc to prevent coverage
for (size_t i = 0; i < sd->postblits.dim; i++)
{
stc |= sd->postblits[i]->storage_class & STCdisable;
}
Statements *a = NULL;
for (size_t i = 0; i < sd->fields.dim && !(stc & STCdisable); i++)
{
VarDeclaration *v = sd->fields[i];
if (v->storage_class & STCref)
continue;
Type *tv = v->type->baseElemOf();
if (tv->ty != Tstruct || !v->type->size())
continue;
StructDeclaration *sdv = ((TypeStruct *)tv)->sym;
if (!sdv->postblit)
continue;
sdv->postblit->functionSemantic();
stc = mergeFuncAttrs(stc, sdv->postblit);
stc = mergeFuncAttrs(stc, sdv->dtor);
if (stc & STCdisable)
{
a = NULL;
break;
}
if (!a)
a = new Statements();
Expression *ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v, 0);
if (v->type->toBasetype()->ty == Tstruct)
{
// this.v.__xpostblit()
// This is a hack so we can call postblits on const/immutable objects.
ex = new AddrExp(loc, ex);
ex = new CastExp(loc, ex, v->type->mutableOf()->pointerTo());
ex = new PtrExp(loc, ex);
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new DotVarExp(loc, ex, sdv->postblit, 0);
ex = new CallExp(loc, ex);
}
else
{
// _ArrayPostblit((cast(S*)this.v.ptr)[0 .. n])
// This is a hack so we can call postblits on const/immutable objects.
ex = new DotIdExp(loc, ex, Id::ptr);
ex = new CastExp(loc, ex, sdv->type->pointerTo());
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
uinteger_t n = v->type->size() / sdv->type->size();
ex = new SliceExp(loc, ex, new IntegerExp(loc, 0, Type::tsize_t),
new IntegerExp(loc, n, Type::tsize_t));
// Prevent redundant bounds check
((SliceExp *)ex)->upperIsInBounds = true;
((SliceExp *)ex)->lowerIsLessThanUpper = true;
ex = new CallExp(loc, new IdentifierExp(loc, Id::_ArrayPostblit), ex);
}
a->push(new ExpStatement(loc, ex)); // combine in forward order
/* Bugzilla 10972: When the following field postblit calls fail,
* this field should be destructed for Exception Safety.
*/
if (!sdv->dtor)
continue;
sdv->dtor->functionSemantic();
ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v, 0);
if (v->type->toBasetype()->ty == Tstruct)
{
// this.v.__xdtor()
// This is a hack so we can call destructors on const/immutable objects.
ex = new AddrExp(loc, ex);
ex = new CastExp(loc, ex, v->type->mutableOf()->pointerTo());
ex = new PtrExp(loc, ex);
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new DotVarExp(loc, ex, sdv->dtor, 0);
ex = new CallExp(loc, ex);
}
else
{
// _ArrayDtor((cast(S*)this.v.ptr)[0 .. n])
// This is a hack so we can call destructors on const/immutable objects.
ex = new DotIdExp(loc, ex, Id::ptr);
ex = new CastExp(loc, ex, sdv->type->pointerTo());
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
uinteger_t n = v->type->size() / sdv->type->size();
ex = new SliceExp(loc, ex, new IntegerExp(loc, 0, Type::tsize_t),
new IntegerExp(loc, n, Type::tsize_t));
// Prevent redundant bounds check
((SliceExp *)ex)->upperIsInBounds = true;
((SliceExp *)ex)->lowerIsLessThanUpper = true;
ex = new CallExp(loc, new IdentifierExp(loc, Id::_ArrayDtor), ex);
}
a->push(new OnScopeStatement(loc, TOKon_scope_failure, new ExpStatement(loc, ex)));
}
/* Build our own "postblit" which executes a
*/
if (a || (stc & STCdisable))
{
//printf("Building __fieldPostBlit()\n");
PostBlitDeclaration *dd = new PostBlitDeclaration(declLoc, Loc(), stc, Id::__fieldPostblit);
dd->storage_class |= STCinference;
dd->fbody = a ? new CompoundStatement(loc, a) : NULL;
sd->postblits.shift(dd);
sd->members->push(dd);
dd->semantic(sc);
}
FuncDeclaration *xpostblit = NULL;
switch (sd->postblits.dim)
{
case 0:
break;
case 1:
xpostblit = sd->postblits[0];
break;
default:
Expression *e = NULL;
stc = STCsafe | STCnothrow | STCpure | STCnogc;
for (size_t i = 0; i < sd->postblits.dim; i++)
{
FuncDeclaration *fd = sd->postblits[i];
stc = mergeFuncAttrs(stc, fd);
if (stc & STCdisable)
{
e = NULL;
break;
}
Expression *ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, fd, 0);
ex = new CallExp(loc, ex);
e = Expression::combine(e, ex);
}
PostBlitDeclaration *dd = new PostBlitDeclaration(declLoc, Loc(), stc, Id::__aggrPostblit);
dd->storage_class |= STCinference;
dd->fbody = new ExpStatement(loc, e);
sd->members->push(dd);
dd->semantic(sc);
xpostblit = dd;
break;
}
// Add an __xpostblit alias to make the inclusive postblit accessible
if (xpostblit)
{
AliasDeclaration *alias = new AliasDeclaration(Loc(), Id::__xpostblit, xpostblit);
alias->semantic(sc);
sd->members->push(alias);
alias->addMember(sc, sd); // add to symbol table
}
return xpostblit;
}
void Import::semantic(Scope *sc)
{
//printf("Import::semantic('%s')\n", toChars());
// Load if not already done so
if (!mod)
{ load(sc);
mod->importAll(0);
}
if (mod)
{
#if 0
if (mod->loc.linnum != 0)
{ /* If the line number is not 0, then this is not
* a 'root' module, i.e. it was not specified on the command line.
*/
mod->importedFrom = sc->module->importedFrom;
assert(mod->importedFrom);
}
#endif
// Modules need a list of each imported module
//printf("%s imports %s\n", sc->module->toChars(), mod->toChars());
sc->module->aimports.push(mod);
/* Default to private importing
*/
protection = sc->protection;
if (!sc->explicitProtection)
protection = PROTprivate;
if (!isstatic && !aliasId && !names.dim)
{
sc->scopesym->importScope(mod, protection);
}
mod->semantic();
if (mod->needmoduleinfo)
sc->module->needmoduleinfo = 1;
sc = sc->push(mod);
for (size_t i = 0; i < aliasdecls.dim; i++)
{ AliasDeclaration *ad = (AliasDeclaration *)aliasdecls.data[i];
//printf("\tImport alias semantic('%s')\n", s->toChars());
if (!mod->search(loc, (Identifier *)names.data[i], 0))
error("%s not found", ((Identifier *)names.data[i])->toChars());
ad->importprot = protection;
ad->semantic(sc);
}
sc = sc->pop();
}
//printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
if (global.params.moduleDeps != NULL)
{
/* The grammar of the file is:
* ImportDeclaration
* ::= BasicImportDeclaration [ " : " ImportBindList ] [ " -> "
* ModuleAliasIdentifier ] "\n"
*
* BasicImportDeclaration
* ::= ModuleFullyQualifiedName " (" FilePath ") : " Protection
* " [ " static" ] : " ModuleFullyQualifiedName " (" FilePath ")"
*
* FilePath
* - any string with '(', ')' and '\' escaped with the '\' character
*/
OutBuffer *ob = global.params.moduleDeps;
ob->writestring(sc->module->toPrettyChars());
ob->writestring(" (");
escapePath(ob, sc->module->srcfile->toChars());
ob->writestring(") : ");
ProtDeclaration::protectionToCBuffer(ob, sc->protection);
if (isstatic)
StorageClassDeclaration::stcToCBuffer(ob, STCstatic);
ob->writestring(": ");
if (packages)
{
for (size_t i = 0; i < packages->dim; i++)
{
Identifier *pid = (Identifier *)packages->data[i];
ob->printf("%s.", pid->toChars());
}
}
ob->writestring(id->toChars());
ob->writestring(" (");
if (mod)
escapePath(ob, mod->srcfile->toChars());
else
ob->writestring("???");
ob->writebyte(')');
for (size_t i = 0; i < names.dim; i++)
{
if (i == 0)
ob->writebyte(':');
else
ob->writebyte(',');
Identifier *name = (Identifier *)names.data[i];
Identifier *alias = (Identifier *)aliases.data[i];
if (!alias)
{
ob->printf("%s", name->toChars());
alias = name;
}
else
ob->printf("%s=%s", alias->toChars(), name->toChars());
}
if (aliasId)
ob->printf(" -> %s", aliasId->toChars());
ob->writenl();
}
//printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
}
void DeclarationBuilder::visitAssignmentStatement(Ast *node)
{
QList<AbstractType::Ptr> values;
QList<DeclarationPointer> declarations;
QList<bool> alias;
DUChainReadLocker lock;
/* First of all, fetch the types and declaration on the right side */
Ast *aux = new Ast(node->tree->r, node->context);
for (Node *n = aux->tree; n != nullptr; n = n->next) {
ExpressionVisitor v(currentContext(), m_editor);
aux->tree = n;
lock.unlock();
// TODO: improve this
DeclarationBuilderBase::visitNode(aux);
v.visitNode(aux);
lock.lock();
values << v.lastType();
alias << v.lastAlias();
declarations << v.lastDeclaration();
}
lock.unlock();
/*
* Check if we can unpack. If it's possible, do it and get out! We can
* unpack if the following conditions are satisfied:
* - More than 1 expressions on the left side.
* - Just one expression on the right side, which has Array as its type.
*/
int rsize = values.length();
if (rsize == 1) {
int rest = nodeListSize(node->tree->l);
ClassType::Ptr ct = values.first().cast<ClassType>();
if (rest > 1 && ct && ct->contentType()) {
lock.lock();
QualifiedIdentifier qi = ct.data()->declaration(topContext())->qualifiedIdentifier();
lock.unlock();
if (qi == QualifiedIdentifier("Array")) {
for (Node *n = node->tree->l; n != nullptr; n = n->next) {
aux->tree = n;
QualifiedIdentifier id = getIdentifier(aux);
declareVariable(id, ct->contentType().abstractType(), aux);
}
delete aux;
return;
}
}
}
/*
* We cannot unpack, so iterate over the left side expressions
* and assign types.
*/
int i = 0;
AbstractType::Ptr type;
for (Node *n = node->tree->l; n != nullptr; n = n->next, i++) {
if (n->kind == token_method_call)
continue;
aux->tree = n;
if (has_star(n)) {
int rest = nodeListSize(n) - 1;
int pack = rsize - i - rest;
ClassType::Ptr newType = getBuiltinsType(QStringLiteral("Array"), currentContext()).cast<ClassType>();
DUChainWriteLocker wlock;
for (int j = pack; j > 0; j--, i++) {
newType->addContentType(values.at(i));
}
wlock.unlock();
i--;
if (!is_just_a_star(n)) {
QualifiedIdentifier id = getIdentifier(aux);
declareVariable(id, newType.cast<AbstractType>(), aux);
}
} else if (i < rsize) {
if (alias.at(i)) {
DUChainWriteLocker wlock;
RangeInRevision range = getNameRange(aux);
QualifiedIdentifier id = getIdentifier(aux);
AliasDeclaration *d = openDeclaration<AliasDeclaration>(id, range);
d->setAliasedDeclaration(declarations.at(i).data());
closeDeclaration();
} else {
type = values.at(i);
if (!type) { // HACK: provisional fix, should be removed in the future
type = getBuiltinsType(QStringLiteral("Object"), currentContext());
}
QualifiedIdentifier id = getIdentifier(aux);
declareVariable(id, type, aux);
}
} else {
lock.lock();
type = getBuiltinsType(QStringLiteral("NilClass"), currentContext());
lock.unlock();
QualifiedIdentifier id = getIdentifier(aux);
declareVariable(id, type, aux);
}
}
delete aux;
}
void Import::semantic(Scope *sc)
{
//printf("Import::semantic('%s')\n", toPrettyChars());
if (scope)
{
sc = scope;
scope = NULL;
}
// Load if not already done so
if (!mod)
{
load(sc);
if (mod)
mod->importAll(NULL);
}
if (mod)
{
// Modules need a list of each imported module
//printf("%s imports %s\n", sc->module->toChars(), mod->toChars());
sc->module->aimports.push(mod);
if (!isstatic && !aliasId && !names.dim)
{
if (sc->explicitProtection)
protection = sc->protection;
for (Scope *scd = sc; scd; scd = scd->enclosing)
{
if (scd->scopesym)
{
scd->scopesym->importScope(mod, protection);
break;
}
}
}
mod->semantic();
if (mod->needmoduleinfo)
{
//printf("module4 %s because of %s\n", sc->module->toChars(), mod->toChars());
sc->module->needmoduleinfo = 1;
}
sc = sc->push(mod);
/* BUG: Protection checks can't be enabled yet. The issue is
* that Dsymbol::search errors before overload resolution.
*/
#if 0
sc->protection = protection;
#else
sc->protection = PROTpublic;
#endif
for (size_t i = 0; i < aliasdecls.dim; i++)
{
AliasDeclaration *ad = aliasdecls[i];
//printf("\tImport alias semantic('%s')\n", ad->toChars());
if (mod->search(loc, names[i]))
{
ad->semantic(sc);
}
else
{
Dsymbol *s = mod->search_correct(names[i]);
if (s)
mod->error(loc, "import '%s' not found, did you mean '%s %s'?", names[i]->toChars(), s->kind(), s->toChars());
else
mod->error(loc, "import '%s' not found", names[i]->toChars());
ad->type = Type::terror;
}
}
sc = sc->pop();
}
// object self-imports itself, so skip that (Bugzilla 7547)
// don't list pseudo modules __entrypoint.d, __main.d (Bugzilla 11117, 11164)
if (global.params.moduleDeps != NULL &&
!(id == Id::object && sc->module->ident == Id::object) &&
sc->module->ident != Id::entrypoint &&
strcmp(sc->module->ident->string, "__main") != 0)
{
/* The grammar of the file is:
* ImportDeclaration
* ::= BasicImportDeclaration [ " : " ImportBindList ] [ " -> "
* ModuleAliasIdentifier ] "\n"
*
* BasicImportDeclaration
* ::= ModuleFullyQualifiedName " (" FilePath ") : " Protection|"string"
* " [ " static" ] : " ModuleFullyQualifiedName " (" FilePath ")"
*
* FilePath
* - any string with '(', ')' and '\' escaped with the '\' character
*/
OutBuffer *ob = global.params.moduleDeps;
Module* imod = sc->instantiatingModule();
if (!global.params.moduleDepsFile)
ob->writestring("depsImport ");
ob->writestring(imod->toPrettyChars());
ob->writestring(" (");
escapePath(ob, imod->srcfile->toChars());
ob->writestring(") : ");
// use protection instead of sc->protection because it couldn't be
// resolved yet, see the comment above
protectionToBuffer(ob, protection);
ob->writeByte(' ');
if (isstatic)
StorageClassDeclaration::stcToCBuffer(ob, STCstatic);
ob->writestring(": ");
if (packages)
{
for (size_t i = 0; i < packages->dim; i++)
{
Identifier *pid = (*packages)[i];
ob->printf("%s.", pid->toChars());
}
}
ob->writestring(id->toChars());
ob->writestring(" (");
if (mod)
escapePath(ob, mod->srcfile->toChars());
else
ob->writestring("???");
ob->writeByte(')');
for (size_t i = 0; i < names.dim; i++)
{
if (i == 0)
ob->writeByte(':');
else
ob->writeByte(',');
Identifier *name = names[i];
Identifier *alias = aliases[i];
if (!alias)
{
ob->printf("%s", name->toChars());
alias = name;
}
else
ob->printf("%s=%s", alias->toChars(), name->toChars());
}
if (aliasId)
ob->printf(" -> %s", aliasId->toChars());
ob->writenl();
}
//printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
}
void Import::semantic(Scope *sc)
{
//printf("Import::semantic('%s')\n", toChars());
// Load if not already done so
if (!mod)
{ load(sc);
if (mod)
mod->importAll(0);
}
if (mod)
{
#if 0
if (mod->loc.linnum != 0)
{ /* If the line number is not 0, then this is not
* a 'root' module, i.e. it was not specified on the command line.
*/
mod->importedFrom = sc->module->importedFrom;
assert(mod->importedFrom);
}
#endif
// Modules need a list of each imported module
//printf("%s imports %s\n", sc->module->toChars(), mod->toChars());
sc->module->aimports.push(mod);
/* Default to private importing
*/
enum PROT prot = sc->protection;
if (!sc->explicitProtection)
prot = PROTprivate;
for (Scope *scd = sc; scd; scd = scd->enclosing)
{
if (scd->scopesym)
{
scd->scopesym->importScope(this, prot);
break;
}
}
mod->semantic();
if (mod->needmoduleinfo)
{ //printf("module4 %s because of %s\n", sc->module->toChars(), mod->toChars());
sc->module->needmoduleinfo = 1;
}
if (aliasId)
{
AliasDeclaration *ad = new AliasDeclaration(loc, aliasId, mod);
sc->insert(ad);
ad->semantic(sc);
}
}
//printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
if (global.params.moduleDeps != NULL &&
// object self-imports itself, so skip that (Bugzilla 7547)
!(id == Id::object && sc->module->ident == Id::object))
{
/* The grammar of the file is:
* ImportDeclaration
* ::= BasicImportDeclaration [ " : " ImportBindList ] [ " -> "
* ModuleAliasIdentifier ] "\n"
*
* BasicImportDeclaration
* ::= ModuleFullyQualifiedName " (" FilePath ") : " Protection
* " [ " static" ] : " ModuleFullyQualifiedName " (" FilePath ")"
*
* FilePath
* - any string with '(', ')' and '\' escaped with the '\' character
*/
OutBuffer *ob = global.params.moduleDeps;
ob->writestring(sc->module->toPrettyChars());
ob->writestring(" (");
escapePath(ob, sc->module->srcfile->toChars());
ob->writestring(") : ");
ProtDeclaration::protectionToCBuffer(ob, sc->protection);
if (isstatic)
StorageClassDeclaration::stcToCBuffer(ob, STCstatic);
ob->writestring(": ");
if (packages)
{
for (size_t i = 0; i < packages->dim; i++)
{
Identifier *pid = (*packages)[i];
ob->printf("%s.", pid->toChars());
}
}
ob->writestring(id->toChars());
ob->writestring(" (");
if (mod)
escapePath(ob, mod->srcfile->toChars());
else
ob->writestring("???");
ob->writebyte(')');
for (size_t i = 0; i < names.dim; i++)
{
if (i == 0)
ob->writebyte(':');
else
ob->writebyte(',');
Identifier *name = names[i];
Identifier *alias = aliases[i];
if (!alias)
{
ob->printf("%s", name->toChars());
alias = name;
}
else
ob->printf("%s=%s", alias->toChars(), name->toChars());
}
if (aliasId)
ob->printf(" -> %s", aliasId->toChars());
ob->writenl();
}
//printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
}