Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
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

Compiler implementation of the D programming language.
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

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.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) `pastMixin`();
  final inout inout(Dsymbol) `pastMixinAndNspace`();
    `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, toParent2 and toParent3.
  final inout inout(Dsymbol) `toParent`();
  final inout inout(Dsymbol) `toParent2`();
  final inout inout(Dsymbol) `toParent3`();
    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 and Nspaces that are mangleOnly.
    `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.
    `toParent3`() returns a logically enclosing scope symbol this is a member of. It skips over TemplateMixin's.
    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 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

Copyright © 1999-2019 by the D Language Foundation | Page generated by Ddoc on Sat Mar 2 03:26:56 2019