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:

Source clone.d

StorageClass mergeFuncAttrs(StorageClass s1, FuncDeclaration f);
Merge function attributes pure, nothrow, @safe, @nogc, and @disable
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; ...;
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;
FuncDeclaration 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).

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](), ...; }