Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

dmd.dsymbol

The base class for a D symbol, which can be a module, variable, function, enum, etc.
Authors:

Source dsymbol.d

int foreachDsymbol(Dsymbols* symbols, scope int delegate(Dsymbol) dg);
Calls dg(Dsymbol *sym) for each Dsymbol. If dg returns !=0, stops and returns that value else returns 0.
Parameters:
Dsymbols* symbols Dsymbols
int delegate(Dsymbol) dg delegate to call for each Dsymbol
Returns:
last value returned by dg()
void foreachDsymbol(Dsymbols* symbols, scope void delegate(Dsymbol) dg);
Calls dg(Dsymbol *sym) for each Dsymbol.
Parameters:
Dsymbols* symbols Dsymbols
void delegate(Dsymbol) dg delegate to call for each Dsymbol
struct FieldState;
Struct/Class/Union field state. Used for transitory information when setting field offsets, such as bit fields.
uint offset;
byte offset for next field
uint fieldOffset;
byte offset for the start of the bit field
uint fieldSize;
byte size of field
uint fieldAlign;
byte alignment of field
uint bitOffset;
bit offset for field
bool inFlight;
bit field is in flight
class Dsymbol: dmd.ast_node.ASTNode;
ushort localNum;
perturb mangled name to avoid collisions with those in FuncDeclaration.localsymtab
final Module getModule();
Determine which Module a Dsymbol is in.
final bool isCsymbol();
Does this Dsymbol come from a C file?
Returns:
true if it does
final Module getAccessModule();
Determine which Module a Dsymbol is in, as far as access rights go.
final inout inout(Dsymbol) pastMixin();
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 and toParent2.
final inout inout(Dsymbol) toParent();

final inout inout(Dsymbol) toParent2();

final inout inout(Dsymbol) toParentDecl();

final inout inout(Dsymbol) toParentLocal();
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.
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.
toParentDecl() similar to toParent2() but always follows the template declaration scope instead of the instantiation scope.
toParentLocal() similar to toParentDecl() but follows the instantiation scope if a template declaration is non-local i.e. global or static.
Examples:
 module mod;
 template Foo(alias a) { mixin Bar!(); }
 mixin template Bar() {
   public {  // VisibilityDeclaration
     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')
 // s.toParentDecl() == Module('mod')
 // s.toParentLocal() == FuncDeclaration('mod.test')
final Dsymbol toParentP(Dsymbol p1, Dsymbol p2 = null);
Returns the declaration scope scope of this unless any of the symbols p1 or p2 resides in its enclosing instantiation scope then the latter is returned.
final bool followInstantiationContext(Dsymbol p1, Dsymbol p2 = null);
Returns true if any of the symbols p1 or p2 resides in the enclosing instantiation scope of this.
static Dsymbols* arraySyntaxCopy(Dsymbols* a);
Do syntax copy of an array of Dsymbol's.
Dsymbol toAlias();
If this symbol is really an alias for another, return that other. If needed, semantic() is invoked due to resolve forward reference.
Dsymbol toAlias2();
Resolve recursive tuple expansion in eponymous template.
uinteger_t size(const ref Loc loc);
Returns:
SIZE_INVALID when the size cannot be determined
final inout inout(AggregateDeclaration) isMember();
Returns an AggregateDeclaration when toParent() is that.
final inout inout(AggregateDeclaration) isMember2();
Returns an AggregateDeclaration when toParent2() is that.
final inout inout(AggregateDeclaration) isMemberDecl();
Returns an AggregateDeclaration when toParentDecl() is that.
final inout inout(AggregateDeclaration) isMemberLocal();
Returns an AggregateDeclaration when toParentLocal() is that.
pure nothrow @nogc @safe Visibility visible();
Dsymbol syntaxCopy(Dsymbol s);
Copy the syntax. Used for template instantiations. If s is NULL, allocate the new object, otherwise fill it in.
bool oneMember(out Dsymbol ps, Identifier ident);
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
static bool oneMembers(Dsymbols* members, out Dsymbol ps, Identifier ident);
Same as Dsymbol::oneMember(), but look at an array of Dsymbols.
bool hasPointers();
Is Dsymbol a variable that contains pointers?
void addComment(const(char)* comment);
Add documentation comment to Dsymbol. Ignore NULL comments.
final const(char)* comment();
get documentation comment for this Dsymbol
final UnitTestDeclaration ddocUnittest();
Get ddoc unittest associated with this symbol. (only use this with ddoc)
Returns:
ddoc unittest, null if none
final void ddocUnittest(UnitTestDeclaration utd);
Set ddoc unittest associated with this symbol.
final bool inNonRoot();
Returns true if this symbol is defined in a non-root module without instantiation.
static void deinitialize();
Deinitializes the global state of the compiler.
This can be used to restore the state set by _init to its original state.
void accept(Visitor v);
class ScopeDsymbol: dmd.dsymbol.Dsymbol;
Dsymbol that generates a scope
Dsymbols* importedScopes;
symbols whose members have been imported, i.e. imported modules and template mixins
final pure nothrow @nogc @safe Dsymbols* getImportedScopes();
Returns:
the symbols whose members have been imported, i.e. imported modules and template mixins.
See Also:
importScope
final pure nothrow @nogc @safe Visibility.Kind[] getImportVisibilities();
Returns:
the array of visibilities associated with each imported scope. The length of the array matches the imported scopes array.
See Also:
getImportedScopes
nothrow Dsymbol symtabInsert(Dsymbol s);
Insert Dsymbol in table.
Parameters:
Dsymbol s symbol to add
Returns:
null if already in table, s if inserted
nothrow Dsymbol symtabLookup(Dsymbol s, Identifier id);
Look up identifier in symbol table.
Parameters:
Dsymbol s symbol
Identifier id identifier to look up
Returns:
Dsymbol if found, null if not
bool hasStaticCtorOrDtor();
Return true if any of the members are static ctors or static dtors, or if any members have members that are.
class WithScopeSymbol: dmd.dsymbol.ScopeDsymbol;
With statement scope
class ArrayScopeSymbol: dmd.dsymbol.ScopeDsymbol;
Array Index/Slice scope
class OverloadSet: dmd.dsymbol.Dsymbol;
Overload Sets
class ForwardingScopeDsymbol: dmd.dsymbol.ScopeDsymbol;
Forwarding ScopeDsymbol. Used by ForwardingAttribDeclaration and ForwardingScopeDeclaration to forward symbol insertions to another scope. See dmd.attrib.ForwardingAttribDeclaration for more details.
nothrow Dsymbol symtabLookup(Dsymbol s, Identifier id);
This override handles the following two cases: static foreach (i, i; [0]) { ... } and static foreach (i; [0]) { enum i = 2; }
class ExpressionDsymbol: dmd.dsymbol.Dsymbol;
Class that holds an expression in a Dsymbol wrapper. This is not an AST node, but a class used to pass an expression as a function parameter of type Dsymbol.
class AliasAssign: dmd.dsymbol.Dsymbol;
Encapsulate assigning to an alias: identifier = type; identifier = symbol; where identifier is an AliasDeclaration in scope.
Identifier ident;
Dsymbol's ident will be null, as this class is anonymous
Type type;
replace previous RHS of AliasDeclaration with type
Dsymbol aliassym;
replace previous RHS of AliasDeclaration with aliassym
nothrow @safe this(const ref Loc loc, Identifier ident, Type type, Dsymbol aliassym);
only one of type and aliassym can be != null
class DsymbolTable: dmd.rootobject.RootObject;
Table of Dsymbol's
nothrow Dsymbol lookup(const Identifier ident);
Look up Identifier in symbol table
Parameters:
Identifier ident identifer to look up
Returns:
Dsymbol if found, null if not
nothrow void update(Dsymbol s);
Replace existing symbol in symbol table with s. If it's not there, add it.
Parameters:
Dsymbol s replacement symbol with same identifier
nothrow Dsymbol insert(Dsymbol s);
Insert Dsymbol in table.
Parameters:
Dsymbol s symbol to add
Returns:
null if already in table, s if inserted
nothrow Dsymbol insert(const Identifier ident, Dsymbol s);
Insert Dsymbol in table.
Parameters:
Identifier ident identifier to serve as index
Dsymbol s symbol to add
Returns:
null if already in table, s if inserted
const pure nothrow size_t length();
Returns:
number of symbols in symbol table
Dsymbol handleTagSymbols(ref Scope sc, Dsymbol s, Dsymbol s2, ScopeDsymbol sds);
ImportC tag symbols sit in a parallel symbol table, so that this C code works:
struct S { a; };
int S;
struct S s;
But there are relatively few such tag symbols, so that would be a waste of memory and complexity. An additional problem is we'd like the D side to find the tag symbols with ordinary lookup, not lookup in both tables, if the tag symbol is not conflicting with an ordinary symbol. The solution is to put the tag symbols that conflict into an associative array, indexed by the address of the ordinary symbol that conflicts with it. C has no modules, so this associative array is tagSymTab[] in ModuleDeclaration. A side effect of our approach is that D code cannot access a tag symbol that is hidden by an ordinary symbol. This is more of a theoretical problem, as nobody has mentioned it when importing C headers. If someone wants to do it, too bad so sad. Change the C code. This function fixes up the symbol table when faced with adding a new symbol s when there is an existing symbol s2 with the same name. C also allows forward and prototype declarations of tag symbols, this function merges those.
Parameters:
Scope sc context
Dsymbol s symbol to add to symbol table
Dsymbol s2 existing declaration
ScopeDsymbol sds symbol table
Returns:
if s and s2 are successfully put in symbol table then return the merged symbol, null if they conflict
Dsymbol handleSymbolRedeclarations(ref Scope sc, Dsymbol s, Dsymbol s2, ScopeDsymbol sds);
ImportC allows redeclarations of C variables, functions and typedefs. extern int x; int x = 3; and: extern void f(); void f() { } Attempt to merge them.
Parameters:
Scope sc context
Dsymbol s symbol to add to symbol table
Dsymbol s2 existing declaration
ScopeDsymbol sds symbol table
Returns:
if s and s2 are successfully put in symbol table then return the merged symbol, null if they conflict