dmd.clone

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