dmd.dsymbol

class Dsymbol: dmd.root.rootobject.RootObject;

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) toParent();

final inout inout(Dsymbol) toParent2();

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.

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')

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.

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 size_t dim(Dsymbols* members);

Determine number of Dsymbols, folding in AttribDeclaration members.

static Dsymbol getNth(Dsymbols* members, size_t nth, size_t* pn = null);

Get nth Dsymbol, folding in AttribDeclaration members.

Returns:

Dsymbol* nth Dsymbol NULL not found, *pn gets incremented by the number of Dsymbols

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 DsymbolTable: dmd.root.rootobject.RootObject;

Table of Dsymbol's

const pure uint len();

Returns:

number of symbols in symbol table