# dmd.dsymbol

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

#### Authors

Walter Bright

#### License

Boost License 1.0

Source: dsymbol.d

Documentation: https://dlang.org/phobos/dmd_dsymbol.html

Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dsymbol.d

- `foreachDsymbol`

  #### Declaration

  `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

  #### Return Value

  last value returned by `dg`()

  #### See Also

- `foreachDsymbol`

  #### Declaration

  `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

  #### See Also

- `Dsymbol`

  #### Declaration

  `class `Dsymbol`: dmd.ast_node.ASTNode;`

  - `cppnamespace`

    #### Declaration

    `CPPNamespaceDeclaration `cppnamespace`;`

    C++ namespace this symbol belongs to

  - `getModule`

    #### Declaration

    `final Module `getModule`();`

    Determine which Module a Dsymbol is in.

  - `getAccessModule`

    #### Declaration

    `final Module `getAccessModule`();`

    Determine which Module a Dsymbol is in, as far as access rights go.

  - `pastMixin`

    #### Declaration

    `final inout inout(Dsymbol) `pastMixin`();`

    ``pastMixin`` returns the enclosing symbol if this is a template mixin.

    #### Discussion

    `pastMixinAndNspace` does likewise, additionally skipping over Nspaces that are mangleOnly.
    See also `parent`, `toParent` and `toParent2`.

  - `toParent`

    #### Declaration

    `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.

    #### Discussion

    ``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

    1. `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')`
  - `toParentP`

    #### Declaration

    `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.

  - `followInstantiationContext`

    #### Declaration

    `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`.

  - `arraySyntaxCopy`

    #### Declaration

    `static Dsymbols* `arraySyntaxCopy`(Dsymbols* `a`);`

    Do syntax copy of an array of Dsymbol's.

  - `toAlias`

    #### Declaration

    `Dsymbol `toAlias`();`

    If this symbol is really an alias for another, return that other. If needed, semantic() is invoked due to resolve forward reference.

  - `toAlias2`

    #### Declaration

    `Dsymbol `toAlias2`();`

    Resolve recursive tuple expansion in eponymous template.

  - `setScope`

    #### Declaration

    `void `setScope`(Scope* `sc`);`

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

  - `search`

    #### Declaration

    `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

    #### Return Value

    `null` if not found

  - `searchX`

    #### Declaration

    `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`

    #### Return Value

    symbol found, NULL if not

  - `size`

    #### Declaration

    `d_uns64 `size`(ref const Loc `loc`);`

    #### Return Value

    SIZE_INVALID when the `size` cannot be determined

  - `isMember`

    #### Declaration

    `final inout inout(AggregateDeclaration) `isMember`();`

    Returns an AggregateDeclaration when toParent() is that.

  - `isMember2`

    #### Declaration

    `final inout inout(AggregateDeclaration) `isMember2`();`

    Returns an AggregateDeclaration when toParent2() is that.

  - `isMemberDecl`

    #### Declaration

    `final inout inout(AggregateDeclaration) `isMemberDecl`();`

    Returns an AggregateDeclaration when toParentDecl() is that.

  - `isMemberLocal`

    #### Declaration

    `final inout inout(AggregateDeclaration) `isMemberLocal`();`

    Returns an AggregateDeclaration when toParentLocal() is that.

  - `prot`

    #### Declaration

    `pure nothrow @nogc @safe Prot `prot`();`

  - `syntaxCopy`

    #### Declaration

    `Dsymbol `syntaxCopy`(Dsymbol `s`);`

    Copy the syntax. Used for template instantiations. If `s` is NULL, allocate the new object, otherwise fill it in.

  - `oneMember`

    #### Declaration

    `bool `oneMember`(Dsymbol* `ps`, Identifier `ident`);`

    Determine if this symbol is only one.

    #### Return Value

    `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

  - `oneMembers`

    #### Declaration

    `static bool `oneMembers`(Dsymbols* `members`, Dsymbol* `ps`, Identifier `ident`);`

    Same as Dsymbol::oneMember(), but look at an array of Dsymbols.

  - `hasPointers`

    #### Declaration

    `bool `hasPointers`();`

    Is Dsymbol a variable that contains pointers?

  - `addComment`

    #### Declaration

    `void `addComment`(const(char)* `comment`);`

    Add documentation `comment` to Dsymbol. Ignore NULL comments.

  - `inNonRoot`

    #### Declaration

    `final bool `inNonRoot`();`

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

  - `accept`

    #### Declaration

    `void `accept`(Visitor `v`);`

- `ScopeDsymbol`

  #### Declaration

  `class `ScopeDsymbol`: dmd.dsymbol.Dsymbol;`

  Dsymbol that generates a scope

  - `search`

    #### Declaration

    `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.

  - `findGetMembers`

    #### Declaration

    `final FuncDeclaration `findGetMembers`();`

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

  - `symtabLookup`

    #### Declaration

    `Dsymbol `symtabLookup`(Dsymbol `s`, Identifier `id`);`

    Look up identifier in symbol table.

  - `hasStaticCtorOrDtor`

    #### Declaration

    `bool `hasStaticCtorOrDtor`();`

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

  - `_foreach`

    #### Declaration

    `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.

    #### Return Value

    last value returned by `dg`()

- `WithScopeSymbol`

  #### Declaration

  `class `WithScopeSymbol`: dmd.dsymbol.ScopeDsymbol;`

  With statement scope

- `ArrayScopeSymbol`

  #### Declaration

  `class `ArrayScopeSymbol`: dmd.dsymbol.ScopeDsymbol;`

  Array Index/Slice scope

  - `search`

    #### Declaration

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

    This override is used to solve `$`

- `OverloadSet`

  #### Declaration

  `class `OverloadSet`: dmd.dsymbol.Dsymbol;`

  Overload Sets

- `ForwardingScopeDsymbol`

  #### Declaration

  `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.

  - `forward`

    #### Declaration

    `ScopeDsymbol `forward`;`

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

  - `symtabLookup`

    #### Declaration

    `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; }

- `ExpressionDsymbol`

  #### Declaration

  `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.

- `DsymbolTable`

  #### Declaration

  `class `DsymbolTable`: dmd.root.rootobject.RootObject;`

  Table of Dsymbol's

  - `length`

    #### Declaration

    `const pure size_t `length`();`

    #### Return Value

    number of symbols in symbol table