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

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

Source clone.d

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

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

pure StorageClass `mergeFuncAttrs`(StorageClass `s1`, const FuncDeclaration `f`);
  Merge function attributes pure, nothrow, @safe, @nogc, and @disable from f into s1.
  Parameters:

  StorageClass `s1` | storage class to merge into
  FuncDeclaration `f` | function

  Returns:
  merged storage class
FuncDeclaration `hasIdentityOpAssign`(AggregateDeclaration `ad`, Scope* `sc`);
  Check given aggregate actually has an identity opAssign or not.
  Parameters:

  AggregateDeclaration `ad` | struct or class
  Scope* `sc` | current scope

  Returns:
  if found, returns FuncDeclaration of opAssign, otherwise null
FuncDeclaration `buildOpAssign`(StructDeclaration `sd`, Scope* `sc`);
  Build opAssign for struct. ref S opAssign(S s) { ... }
  Note that s will be constructed onto the stack, and probably copy-constructed in caller site.
  If S has copy copy construction and/or destructor, the body will make bit-wise object swap: S _swap = this; // bit copy this = s; // bit copy _swap.dtor(); Instead of running the destructor on s, run it on tmp instead.
  Otherwise, the body will make member-wise assignments: Then, the body is: this.field1 = s.field1; this.field2 = s.field2; ...;

  References https://dlang.org/spec/struct.html#assign-overload

  Parameters:

  StructDeclaration `sd` | struct to generate opAssign for
  Scope* `sc` | context

  Returns:
  generated opAssign function
bool `needOpEquals`(StructDeclaration `sd`);
  We need an opEquals for the struct if any fields has an opEquals. Generate one if a user-specified one does not exist.
FuncDeclaration `buildOpEquals`(StructDeclaration `sd`, Scope* `sc`);
  Build opEquals for struct. const bool opEquals(const S s) { ... }
  By fixing https://issues.dlang.org/show_bug.cgi?id=3789 opEquals is changed to be never implicitly generated. Now, struct objects comparison s1 == s2 is translated to: s1.tupleof == s2.tupleof to calculate structural equality. See EqualExp.op_overload.
FuncDeclaration `buildXopEquals`(StructDeclaration `sd`, Scope* `sc`);
  Build __xopEquals for TypeInfo_Struct static bool __xopEquals(ref const S p, ref const S q) { return p == q; }
  This is called by TypeInfo.equals(p1, p2). If the struct does not support const objects comparison, it will throw "not implemented" Error in runtime.
FuncDeclaration `buildXopCmp`(StructDeclaration `sd`, Scope* `sc`);
  Build __xopCmp for TypeInfo_Struct static bool __xopCmp(ref const S p, ref const S q) { return p.opCmp(q); }
  This is called by TypeInfo.compare(p1, p2). If the struct does not support const objects comparison, it will throw "not implemented" Error in runtime.
FuncDeclaration `buildXtoHash`(StructDeclaration `sd`, Scope* `sc`);
  Build _xtoHash for non-bitwise hashing static hash_t xtoHash(ref const S p) nothrow @trusted;
DtorDeclaration `buildDtor`(AggregateDeclaration `ad`, Scope* `sc`);
  Create inclusive destructor for struct/class by aggregating all the destructors in dtors[] with the destructors for all the members.
  Parameters:

  AggregateDeclaration `ad` | struct or class to build destructor for
  Scope* `sc` | context

  Returns:
  generated function, null if none needed

  Note Close similarity with StructDeclaration::buildPostBlit(), and the ordering changes (runs backward instead of forwards).

DtorDeclaration `buildExternDDtor`(AggregateDeclaration `ad`, Scope* `sc`);
  build a shim function around the compound dtor that translates a C++ destructor to a destructor with extern(D) calling convention
  Parameters:

  AggregateDeclaration `ad` | the aggregate that contains the destructor to wrap
  Scope* `sc` | the scope in which to analyze the new function

  Returns:
  the shim destructor, semantically analyzed and added to the class as a member
FuncDeclaration `buildInv`(AggregateDeclaration `ad`, Scope* `sc`);
  Create inclusive invariant for struct/class by aggregating all the invariants in invs[]. void __invariant() const [pure nothrow @trusted] { invs[0](), invs[1](), ...; }

Copyright © 1999-2018 by the D Language Foundation | Page generated by Ddoc on Tue Jul 3 18:16:05 2018