ddmd.clone

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

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 hasIdentityOpEquals(AggregateDeclaration ad, Scope* sc);

Check given aggregate actually has an identity opEquals or not.

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 buildPostBlit(StructDeclaration sd, Scope* sc);

Create inclusive postblit for struct by aggregating all the postblits in postblits[] with the postblits for all the members. Note the close similarity with AggregateDeclaration::buildDtor(), and the ordering changes (runs forward instead of backwards).

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