dmd.dsymbol

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

class Dsymbol: dmd.ast_node.ASTNode;

CPPNamespaceDeclaration cppnamespace;

C++ namespace this symbol belongs to

final Module getModule();

Determine which Module a Dsymbol is in.

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 { // 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') // s.toParentDecl() == Module('mod') // s.toParentLocal() == FuncDeclaration('mod.test')

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.

int apply(Dsymbol_apply_ft_t fp, void* param);

Iterate this dsymbol or members of this scoped dsymbol, then call fp with the found symbol and param.

Parameters:

Dsymbol_apply_ft_t fp	function pointer to process the iterated symbol. If it returns nonzero, the iteration will be aborted.
void* 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.

void setScope(Scope* sc);

Set scope for future semantic analysis so we can deal better with forward references.

Dsymbol search(ref const Loc loc, Identifier ident, int flags = IgnoreNone);

Search for ident as member of s.

Parameters:

Loc loc	location to print for error messages
Identifier ident	identifier to search for
int flags	IgnoreXXXX

Returns:

null if not found

final Dsymbol searchX(ref const Loc loc, Scope* sc, RootObject id, int flags);

Search for identifier id as a member of this. id may be a template instance.

Parameters:

Loc loc	location to print the error messages
Scope* sc	the scope where the symbol is located
RootObject id	the id of the symbol
int flags	the search flags which can be SearchLocalsOnly or IgnorePrivateImports

Returns:

symbol found, NULL if not

d_uns64 size(ref const 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 Prot prot();

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(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, 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 bool inNonRoot();

Returns true if this symbol is defined in a non-root module without instantiation.

void accept(Visitor v);

class ScopeDsymbol: dmd.dsymbol.Dsymbol;

Dsymbol that generates a scope

Dsymbol search(ref const Loc loc, Identifier ident, int flags = SearchLocalsOnly);

This function is #1 on the list of functions that eat cpu time. Be very, very careful about slowing it down.

final FuncDeclaration findGetMembers();

Look for member of the form: const(MemberInfo)[] getMembers(string); Returns NULL if not found

Dsymbol symtabLookup(Dsymbol s, Identifier id);

Look up identifier in symbol table.

bool hasStaticCtorOrDtor();

Return true if any of the members are static ctors or static dtors, or if any members have members that are.

static int _foreach(Scope* sc, Dsymbols* members, scope ForeachDg dg, size_t* pn = null);

Expands attribute declarations in members in depth first order. Calls dg(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.

Returns:

last value returned by dg()

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.

ScopeDsymbol forward;

Symbol to forward insertions to. Can be null before being lazily initialized.

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 wraper. This is not an AST node, but a class used to pass an expression as a function parameter of type Dsymbol.

class DsymbolTable: dmd.root.rootobject.RootObject;

Table of Dsymbol's

const pure uint len();

Returns:

number of symbols in symbol table