dmd.attrib - D Programming Language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - 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.attrib

Compiler implementation of the D programming language.
Authors:
Walter Bright
License:
Boost License 1.0

Source attrib.d

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

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

abstract class `AttribDeclaration`: dmd.dsymbol.Dsymbol;
  static Scope* `createNewScope`(Scope* `sc`, StorageClass `stc`, LINK `linkage`, CPPMANGLE `cppmangle`, Prot `protection`, int `explicitProtection`, AlignDeclaration `aligndecl`, PINLINE `inlining`);
    Create a new scope if one or more given attributes are different from the sc's. If the returned scope != sc, the caller should pop the scope after it used.
  Scope* `newScope`(Scope* `sc`);
    A hook point to supply scope for members. addMember, setScope, importAll, semantic, semantic2 and semantic3 will use this.
  final void `addLocalClass`(ClassDeclarations* `aclasses`);
class `StorageClassDeclaration`: dmd.attrib.AttribDeclaration;
class `DeprecatedDeclaration`: dmd.attrib.StorageClassDeclaration;
  Scope* `newScope`(Scope* `sc`);
    Provides a new scope with STC.deprecated_ and Scope.depdecl set
    Calls StorageClassDeclaration.`newScope` (as it must be called or copied in any function overriding `newScope`), then set the Scope's depdecl.
    Returns:
    Always a new scope, to use for this DeprecatedDeclaration's members.
class `LinkDeclaration`: dmd.attrib.AttribDeclaration;
class `CPPMangleDeclaration`: dmd.attrib.AttribDeclaration;
class `CPPNamespaceDeclaration`: dmd.attrib.AttribDeclaration;
  A node to represent an extern(C++) namespace attribute
  There are two ways to declarate a symbol as member of a namespace: Nspace and `CPPNamespaceDeclaration`. The former creates a scope for the symbol, and inject them in the parent scope at the same time. The later, this class, has no semantic implications and is only used for mangling. Additionally, this class allows one to use reserved identifiers (D keywords) in the namespace.
  A `CPPNamespaceDeclaration` can be created from an Identifier (already resolved) or from an Expression, which is CTFE-ed and can be either a TupleExp, in which can additional `CPPNamespaceDeclaration` nodes are created, or a StringExp.
  Note that this class, like Nspace, matches only one identifier part of a namespace. For the namespace "foo::bar", the will be a `CPPNamespaceDeclaration` with its ident set to "bar", and its namespace field pointing to another `CPPNamespaceDeclaration` with its ident set to "foo".
  Expression `exp`;
    CTFE-able expression, resolving to TupleExp or StringExp
  Scope* `newScope`(Scope* `sc`);
    Returns:
    A copy of the parent scope, with this as namespace and C++ linkage
class `ProtDeclaration`: dmd.attrib.AttribDeclaration;
  this(ref const Loc `loc`, Prot `protection`, Dsymbols* `decl`);
    Parameters:

    Loc `loc` | source location of attribute token
    Prot `protection` | protection attribute data
    Dsymbols* `decl` | declarations which are affected by this protection attribute

  this(ref const Loc `loc`, Identifiers* `pkg_identifiers`, Dsymbols* `decl`);
    Parameters:

    Loc `loc` | source location of attribute token
    Identifiers* `pkg_identifiers` | list of identifiers for a qualified package name
    Dsymbols* `decl` | declarations which are affected by this protection attribute

class `AlignDeclaration`: dmd.attrib.AttribDeclaration;
class `AnonDeclaration`: dmd.attrib.AttribDeclaration;
class `PragmaDeclaration`: dmd.attrib.AttribDeclaration;
class `ConditionalDeclaration`: dmd.attrib.AttribDeclaration;
class `StaticIfDeclaration`: dmd.attrib.ConditionalDeclaration;
  Dsymbols* `include`(Scope* `sc`);
    Different from other AttribDeclaration subclasses, include() call requires the completion of addMember and setScope phases.
class `StaticForeachDeclaration`: dmd.attrib.AttribDeclaration;
  Static foreach at declaration scope, like: static foreach (i; [0, 1, 2]){ }
  StaticForeach `sfe`;
    contains static foreach expansion logic
  ScopeDsymbol `scopesym`;
    cached enclosing scope (mimics static if declaration)
  bool `onStack`;
    include can be called multiple times, but a static foreach should be expanded at most once. Achieved by caching the result of the first call. We need both cached and cache, because null is a valid value for cache.
class `ForwardingAttribDeclaration`: dmd.attrib.AttribDeclaration;
  Collection of declarations that stores foreach index variables in a local symbol table. Other symbols declared within are forwarded to another scope, like:
  static foreach (i; 0 .. 10) // loop variables for different indices do not conflict. { // this body is expanded into 10 ForwardingAttribDeclarations, where i has storage class STC.local mixin("enum x" ~ to!string(i) ~ " = i"); // ok, can access current loop variable }
  static foreach (i; 0.. 10) { pragma(msg, mixin("x" ~ to!string(i))); // ok, all 10 symbols are visible as they were forwarded to the global scope }
  static assert (!is(typeof(i))); // loop index variable is not visible outside of the static foreach loop
  A StaticForeachDeclaration generates one ForwardingAttribDeclaration for each expansion of its body. The AST of the ForwardingAttribDeclaration contains both the `static foreach variables and the respective copy of the static foreach` body. The functionality is achieved by using a ForwardingScopeDsymbol as the parent symbol for the generated declarations.
  Scope* `newScope`(Scope* `sc`);
    Use the ForwardingScopeDsymbol as the parent symbol for members.
  void `addMember`(Scope* `sc`, ScopeDsymbol `sds`);
    Lazily initializes the scope to forward to.
class `CompileDeclaration`: dmd.attrib.AttribDeclaration;
  Mixin declarations, like: mixin("int x"); https://dlang.org/spec/module.html#mixin-declaration
class `UserAttributeDeclaration`: dmd.attrib.AttribDeclaration;
  User defined attributes look like: @foo(args, ...) @(args, ...)

Copyright © 1999-2020 by the D Language Foundation | Page generated by Ddoc on Thu Mar 5 02:31:06 2020