/**
* A scope as defined by curly braces `{}`.
*
* Not to be confused with the `scope` storage class.
*
* Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dscope.d, _dscope.d)
* Documentation: https://dlang.org/phobos/dmd_dscope.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dscope.d
*/
module dmd.dscope;
import core.stdc.stdio;
import core.stdc.string;
import dmd.aggregate;
import dmd.arraytypes;
import dmd.astenums;
import dmd.attrib;
import dmd.ctorflow;
import dmd.dclass;
import dmd.declaration;
import dmd.dmodule;
import dmd.doc;
import dmd.dsymbol;
import dmd.dsymbolsem;
import dmd.dtemplate;
import dmd.expression;
import dmd.errors;
import dmd.func;
import dmd.globals;
import dmd.id;
import dmd.identifier;
import dmd.location;
import dmd.common.outbuffer;
import dmd.root.rmem;
import dmd.root.speller;
import dmd.statement;
import dmd.target;
import dmd.tokens;
//version=LOGSEARCH;
// List of flags that can be applied to this `Scope`
enum SCOPE
{
ctor = 0x0001, /// constructor type
noaccesscheck = 0x0002, /// don't do access checks
condition = 0x0004, /// inside static if/assert condition
debug_ = 0x0008, /// inside debug conditional
constraint = 0x0010, /// inside template constraint
invariant_ = 0x0020, /// inside invariant code
require = 0x0040, /// inside in contract code
ensure = 0x0060, /// inside out contract code
contract = 0x0060, /// [mask] we're inside contract code
ctfe = 0x0080, /// inside a ctfe-only expression
compile = 0x0100, /// inside __traits(compile)
ignoresymbolvisibility = 0x0200, /// ignore symbol visibility
/// https://issues.dlang.org/show_bug.cgi?id=15907
Cfile = 0x0800, /// C semantics apply
free = 0x8000, /// is on free list
fullinst = 0x10000, /// fully instantiate templates
ctfeBlock = 0x20000, /// inside a `if (__ctfe)` block
}
/// Flags that are carried along with a scope push()
private enum PersistentFlags =
SCOPE.contract | SCOPE.debug_ | SCOPE.ctfe | SCOPE.compile | SCOPE.constraint |
SCOPE.noaccesscheck | SCOPE.ignoresymbolvisibility |
SCOPE.Cfile | SCOPE.ctfeBlock;
extern (C++) struct Scope
{
Scope* enclosing; /// enclosing Scope
Module _module; /// Root module
ScopeDsymbol scopesym; /// current symbol
FuncDeclaration func; /// function we are in
VarDeclaration varDecl; /// variable we are in during semantic2
Dsymbol parent; /// parent to use
LabelStatement slabel; /// enclosing labelled statement
SwitchStatement sw; /// enclosing switch statement
Statement tryBody; /// enclosing _body of TryCatchStatement or TryFinallyStatement
TryFinallyStatement tf; /// enclosing try finally statement
ScopeGuardStatement os; /// enclosing scope(xxx) statement
Statement sbreak; /// enclosing statement that supports "break"
Statement scontinue; /// enclosing statement that supports "continue"
ForeachStatement fes; /// if nested function for ForeachStatement, this is it
Scope* callsc; /// used for __FUNCTION__, __PRETTY_FUNCTION__ and __MODULE__
Dsymbol inunion; /// != null if processing members of a union
bool nofree; /// true if shouldn't free it
bool inLoop; /// true if inside a loop (where constructor calls aren't allowed)
int intypeof; /// in typeof(exp)
VarDeclaration lastVar; /// Previous symbol used to prevent goto-skips-init
/* If minst && !tinst, it's in definitely non-speculative scope (eg. module member scope).
* If !minst && !tinst, it's in definitely speculative scope (eg. template constraint).
* If minst && tinst, it's in instantiated code scope without speculation.
* If !minst && tinst, it's in instantiated code scope with speculation.
*/
Module minst; /// root module where the instantiated templates should belong to
TemplateInstance tinst; /// enclosing template instance
CtorFlow ctorflow; /// flow analysis for constructors
/// alignment for struct members
AlignDeclaration aligndecl;
/// C++ namespace this symbol is in
CPPNamespaceDeclaration namespace;
/// linkage for external functions
LINK linkage = LINK.d;
/// mangle type
CPPMANGLE cppmangle = CPPMANGLE.def;
/// inlining strategy for functions
PragmaDeclaration inlining;
/// visibility for class members
Visibility visibility = Visibility(Visibility.Kind.public_);
int explicitVisibility; /// set if in an explicit visibility attribute
StorageClass stc; /// storage class
DeprecatedDeclaration depdecl; /// customized deprecation message
uint flags;
// user defined attributes
UserAttributeDeclaration userAttribDecl;
DocComment* lastdc; /// documentation comment for last symbol at this scope
uint[void*] anchorCounts; /// lookup duplicate anchor name count
Identifier prevAnchor; /// qualified symbol name of last doc anchor
AliasDeclaration aliasAsg; /// if set, then aliasAsg is being assigned a new value,
/// do not set wasRead for it
extern (D) __gshared Scope* freelist;
extern (D) static Scope* alloc()
{
if (freelist)
{
Scope* s = freelist;
freelist = s.enclosing;
//printf("freelist %p\n", s);
assert(s.flags & SCOPE.free);
s.flags &= ~SCOPE.free;
return s;
}
return new Scope();
}
extern (D) static Scope* createGlobal(Module _module)
{
Scope* sc = Scope.alloc();
*sc = Scope.init;
sc._module = _module;
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()
if (_module.filetype == FileType.c)
sc.flags |= SCOPE.Cfile;
// Create the module scope underneath the global scope
sc = sc.push(_module);
sc.parent = _module;
return sc;
}
extern (D) Scope* copy()
{
Scope* sc = Scope.alloc();
*sc = this;
/* https://issues.dlang.org/show_bug.cgi?id=11777
* The copied scope should not inherit fieldinit.
*/
sc.ctorflow.fieldinit = null;
return sc;
}
extern (D) Scope* push()
{
Scope* s = copy();
//printf("Scope::push(this = %p) new = %p\n", this, s);
assert(!(flags & SCOPE.free));
s.scopesym = null;
s.enclosing = &this;
debug
{
if (enclosing)
assert(!(enclosing.flags & SCOPE.free));
if (s == enclosing)
{
printf("this = %p, enclosing = %p, enclosing.enclosing = %p\n", s, &this, enclosing);
}
assert(s != enclosing);
}
s.slabel = null;
s.nofree = false;
s.ctorflow.fieldinit = ctorflow.fieldinit.arraydup;
s.flags = (flags & PersistentFlags);
s.lastdc = null;
assert(&this != s);
return s;
}
extern (D) Scope* push(ScopeDsymbol ss)
{
//printf("Scope::push(%s)\n", ss.toChars());
Scope* s = push();
s.scopesym = ss;
return s;
}
extern (D) Scope* pop()
{
//printf("Scope::pop() %p nofree = %d\n", this, nofree);
if (enclosing)
enclosing.ctorflow.OR(ctorflow);
ctorflow.freeFieldinit();
Scope* enc = enclosing;
if (!nofree)
{
if (mem.isGCEnabled)
this = this.init;
enclosing = freelist;
freelist = &this;
flags |= SCOPE.free;
}
return enc;
}
/*************************
* Similar to pop(), but the results in `this` are not folded
* into `enclosing`.
*/
extern (D) void detach()
{
ctorflow.freeFieldinit();
enclosing = null;
pop();
}
extern (D) Scope* startCTFE()
{
Scope* sc = this.push();
sc.flags = this.flags | SCOPE.ctfe;
version (none)
{
/* TODO: Currently this is not possible, because we need to
* unspeculative some types and symbols if they are necessary for the
* final executable. Consider:
*
* struct S(T) {
* string toString() const { return "instantiated"; }
* }
* enum x = S!int();
* void main() {
* // To call x.toString in runtime, compiler should unspeculative S!int.
* assert(x.toString() == "instantiated");
* }
*
* This results in an undefined reference to `RTInfoImpl`:
* class C { int a,b,c; int* p,q; }
* void test() { C c = new C(); }
*/
// If a template is instantiated from CT evaluated expression,
// compiler can elide its code generation.
sc.tinst = null;
sc.minst = null;
}
return sc;
}
extern (D) Scope* endCTFE()
{
assert(flags & SCOPE.ctfe);
return pop();
}
/*******************************
* Merge results of `ctorflow` into `this`.
* Params:
* loc = for error messages
* ctorflow = flow results to merge in
*/
extern (D) void merge(const ref Loc loc, const ref CtorFlow ctorflow)
{
if (!mergeCallSuper(this.ctorflow.callSuper, ctorflow.callSuper))
error(loc, "one path skips constructor");
const fies = ctorflow.fieldinit;
if (this.ctorflow.fieldinit.length && fies.length)
{
FuncDeclaration f = func;
if (fes)
f = fes.func;
auto ad = f.isMemberDecl();
assert(ad);
foreach (i, v; ad.fields)
{
bool mustInit = (v.storage_class & STC.nodefaultctor || v.type.needsNested());
auto fieldInit = &this.ctorflow.fieldinit[i];
const fiesCurrent = fies[i];
if (fieldInit.loc is Loc.init)
fieldInit.loc = fiesCurrent.loc;
if (!mergeFieldInit(this.ctorflow.fieldinit[i].csx, fiesCurrent.csx) && mustInit)
{
error(loc, "one path skips field `%s`", v.toChars());
}
}
}
}
/************************************
* 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
*/
extern (C++) Dsymbol search(const ref Loc loc, Identifier ident, Dsymbol* pscopesym, int flags = IgnoreNone)
{
version (LOGSEARCH)
{
printf("Scope.search(%p, '%s' flags=x%x)\n", &this, ident.toChars(), flags);
// Print scope chain
for (Scope* sc = &this; sc; sc = sc.enclosing)
{
if (!sc.scopesym)
continue;
printf("\tscope %s\n", sc.scopesym.toChars());
}
static void printMsg(string txt, Dsymbol s)
{
printf("%.*s %s.%s, kind = '%s'\n", cast(int)txt.length, txt.ptr,
s.parent ? s.parent.toChars() : "", s.toChars(), s.kind());
}
}
// 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())
{
//printMsg("\tfound", s);
if (pscopesym)
*pscopesym = sc.scopesym;
return s;
}
}
return null;
}
Dsymbol checkAliasThis(AggregateDeclaration ad, Identifier ident, int flags, Expression* exp)
{
import dmd.mtype;
if (!ad || !ad.aliasthis)
return null;
Declaration decl = ad.aliasthis.sym.isDeclaration();
if (!decl)
return null;
Type t = decl.type;
ScopeDsymbol sds;
TypeClass tc;
TypeStruct ts;
switch(t.ty)
{
case Tstruct:
ts = cast(TypeStruct)t;
sds = ts.sym;
break;
case Tclass:
tc = cast(TypeClass)t;
sds = tc.sym;
break;
case Tinstance:
sds = (cast(TypeInstance)t).tempinst;
break;
case Tenum:
sds = (cast(TypeEnum)t).sym;
break;
default: break;
}
if (!sds)
return null;
Dsymbol ret = sds.search(loc, ident, flags);
if (ret)
{
*exp = new DotIdExp(loc, *exp, ad.aliasthis.ident);
*exp = new DotIdExp(loc, *exp, ident);
return ret;
}
if (!ts && !tc)
return null;
Dsymbol s;
*exp = new DotIdExp(loc, *exp, ad.aliasthis.ident);
if (ts && !(ts.att & AliasThisRec.tracing))
{
ts.att = cast(AliasThisRec)(ts.att | AliasThisRec.tracing);
s = checkAliasThis(sds.isAggregateDeclaration(), ident, flags, exp);
ts.att = cast(AliasThisRec)(ts.att & ~AliasThisRec.tracing);
}
else if(tc && !(tc.att & AliasThisRec.tracing))
{
tc.att = cast(AliasThisRec)(tc.att | AliasThisRec.tracing);
s = checkAliasThis(sds.isAggregateDeclaration(), ident, flags, exp);
tc.att = cast(AliasThisRec)(tc.att & ~AliasThisRec.tracing);
}
return s;
}
Dsymbol searchScopes(int flags)
{
for (Scope* sc = &this; 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
else if (sc.flags & SCOPE.Cfile && sc.scopesym.isStructDeclaration())
continue; // C doesn't have struct scope
if (Dsymbol s = sc.scopesym.search(loc, ident, flags))
{
if (flags & TagNameSpace)
{
// ImportC: if symbol is not a tag, look for it in tag table
if (!s.isScopeDsymbol())
{
auto ps = cast(void*)s in sc._module.tagSymTab;
if (!ps)
goto NotFound;
s = *ps;
}
}
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");
}
//printMsg("\tfound local", s);
if (pscopesym)
*pscopesym = sc.scopesym;
return s;
}
NotFound:
if (global.params.fixAliasThis)
{
Expression exp = new ThisExp(loc);
Dsymbol aliasSym = checkAliasThis(sc.scopesym.isAggregateDeclaration(), ident, flags, &exp);
if (aliasSym)
{
//printf("found aliassym: %s\n", aliasSym.toChars());
if (pscopesym)
*pscopesym = new ExpressionDsymbol(exp);
return aliasSym;
}
}
// 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;
}
if (this.flags & SCOPE.ignoresymbolvisibility)
flags |= IgnoreSymbolVisibility;
// First look in local scopes
Dsymbol s = searchScopes(flags | SearchLocalsOnly);
version (LOGSEARCH) if (s) printMsg("-Scope.search() found local", s);
if (!s)
{
// Second look in imported modules
s = searchScopes(flags | SearchImportsOnly);
version (LOGSEARCH) if (s) printMsg("-Scope.search() found import", s);
}
return s;
}
extern (D) Dsymbol search_correct(Identifier ident)
{
if (global.gag)
return null; // don't do it for speculative compiles; too time consuming
/************************************************
* Given the failed search attempt, try to find
* one with a close spelling.
* Params:
* seed = identifier to search for
* cost = set to the cost, which rises with each outer scope
* Returns:
* Dsymbol if found, null if not
*/
extern (D) Dsymbol scope_search_fp(const(char)[] seed, out 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.
*/
if (!seed.length)
return null;
Identifier id = Identifier.lookup(seed);
if (!id)
return null;
Scope* sc = &this;
Module.clearCache();
Dsymbol scopesym = null;
Dsymbol s = sc.search(Loc.initial, id, &scopesym, IgnoreErrors);
if (!s)
return null;
// Do not show `@disable`d declarations
if (auto decl = s.isDeclaration())
if (decl.storage_class & STC.disable)
return null;
// Or `deprecated` ones if we're not in a deprecated scope
if (s.isDeprecated() && !sc.isDeprecated())
return null;
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.visible().kind == Visibility.Kind.private_)
return null;
}
return s;
}
Dsymbol scopesym = null;
// search for exact name first
if (auto s = search(Loc.initial, ident, &scopesym, IgnoreErrors))
return s;
return speller!scope_search_fp(ident.toString());
}
/************************************
* 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
*/
extern (D) static const(char)* search_correct_C(Identifier ident)
{
import dmd.astenums : Twchar;
TOK tok;
if (ident == Id.NULL)
tok = TOK.null_;
else if (ident == Id.TRUE)
tok = TOK.true_;
else if (ident == Id.FALSE)
tok = TOK.false_;
else if (ident == Id.unsigned)
tok = TOK.uns32;
else if (ident == Id.wchar_t)
tok = target.c.wchar_tsize == 2 ? TOK.wchar_ : TOK.dchar_;
else
return null;
return Token.toChars(tok);
}
/***************************
* Find the innermost scope with a symbol table.
* Returns:
* innermost scope, null if none
*/
extern (D) Scope* inner() return
{
for (Scope* sc = &this; sc; sc = sc.enclosing)
{
if (sc.scopesym)
return sc;
}
return null;
}
/******************************
* Add symbol s to innermost symbol table.
* Params:
* s = symbol to insert
* Returns:
* null if already in table, `s` if not
*/
extern (D) Dsymbol insert(Dsymbol s)
{
//printf("insert() %s\n", s.toChars());
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;
}
auto scopesym = inner().scopesym;
//printf("\t\tscopesym = %p\n", scopesym);
if (!scopesym.symtab)
scopesym.symtab = new DsymbolTable();
if (!(flags & SCOPE.Cfile))
return scopesym.symtabInsert(s);
// ImportC insert
if (!scopesym.symtabInsert(s)) // if already in table
{
Dsymbol s2 = scopesym.symtabLookup(s, s.ident); // s2 is existing entry
return handleTagSymbols(this, s, s2, scopesym);
}
return s; // inserted
}
/********************************************
* Search enclosing scopes for ScopeDsymbol.
*/
extern (D) ScopeDsymbol getScopesym()
{
for (Scope* sc = &this; sc; sc = sc.enclosing)
{
if (sc.scopesym)
return sc.scopesym;
}
return null; // not found
}
/********************************************
* Search enclosing scopes for ClassDeclaration.
*/
extern (D) ClassDeclaration getClassScope()
{
for (Scope* sc = &this; sc; sc = sc.enclosing)
{
if (!sc.scopesym)
continue;
if (ClassDeclaration cd = sc.scopesym.isClassDeclaration())
return cd;
}
return null;
}
/********************************************
* Search enclosing scopes for ClassDeclaration or StructDeclaration.
*/
extern (D) AggregateDeclaration getStructClassScope()
{
for (Scope* sc = &this; sc; sc = sc.enclosing)
{
if (!sc.scopesym)
continue;
if (AggregateDeclaration ad = sc.scopesym.isClassDeclaration())
return ad;
if (AggregateDeclaration ad = sc.scopesym.isStructDeclaration())
return ad;
}
return null;
}
/********************************************
* Find the lexically enclosing function (if any).
*
* This function skips through generated FuncDeclarations,
* e.g. rewritten foreach bodies.
*
* Returns: the function or null
*/
extern (D) inout(FuncDeclaration) getEnclosingFunction() inout
{
if (!this.func)
return null;
auto fd = cast(FuncDeclaration) this.func;
// Look through foreach bodies rewritten as delegates
while (fd.fes)
{
assert(fd.fes.func);
fd = fd.fes.func;
}
return cast(inout(FuncDeclaration)) fd;
}
/*******************************************
* For TemplateDeclarations, we need to remember the Scope
* where it was declared. So mark the Scope as not
* to be free'd.
*/
extern (D) void 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 = true;
assert(!(flags & SCOPE.free));
//assert(sc != sc.enclosing);
//assert(!sc.enclosing || sc != sc.enclosing.enclosing);
//if (++i == 10)
// assert(0);
}
}
/******************************
*/
extern (D) structalign_t alignment()
{
if (aligndecl)
{
auto ad = aligndecl.getAlignment(&this);
return ad.salign;
}
else
{
structalign_t sa;
sa.setDefault();
return sa;
}
}
@safe @nogc pure nothrow const:
/**********************************
* Checks whether the current scope (or any of its parents) is deprecated.
*
* Returns: `true` if this or any parent scope is deprecated, `false` otherwise`
*/
extern (D) bool isDeprecated()
{
for (const(Dsymbol)* sp = &(this.parent); *sp; sp = &(sp.parent))
{
if (sp.isDeprecated())
return true;
}
for (const(Scope)* sc2 = &this; sc2; sc2 = sc2.enclosing)
{
if (sc2.scopesym && sc2.scopesym.isDeprecated())
return true;
// If inside a StorageClassDeclaration that is deprecated
if (sc2.stc & STC.deprecated_)
return true;
}
if (_module.md && _module.md.isdeprecated)
{
return true;
}
return false;
}
/**
* dmd relies on mutation of state during semantic analysis, however
* sometimes semantic is being performed in a speculative context that should
* not have any visible effect on the rest of the compilation: for example when compiling
* a typeof() or __traits(compiles).
*
* Returns: `true` if this `Scope` is known to be from one of these speculative contexts
*/
extern (D) bool isFromSpeculativeSemanticContext() scope
{
return this.intypeof || this.flags & SCOPE.compile;
}
}