#781

Committed 20 Oct 2024 04:45PM UTC coverage: 80.378%. First build

Build # #781

Build Type

Pull #55

coveralls-ruby

Committed by

web-flow

Commit Message

🧠 Ideation: Seperation-of-Concerns between AST and Instructions - remove symbol mapper (#63)

* DGen

- Removed ODO

* DGen

- Use `targetName` rather

* Simplifier

- Added this, idk

* Moved

* VariableAssignmentInstr

- Made `varName` and `data` private and added getters instead

VariableDeclaration

- Made `varName`  private and added getter instead

* VariableDeclaration

- Made `varType` private and added a getter instead

* Container

- Added new final method

* Pipelines

- Disabed requirements so we can figure out where the failures may be happening

* Revert "Pipelines"

This reverts commit 53f89db9b.

* Pipelines

- Disabed requirements so we can figure out where the failures may be happening

* DGen

- Only apply simplification to `targetName` when dealing with `VariableAssignmentInstr`
- Only apply simplification to `targetName` when dealing with `VariableDeclaration`
- Only apply simplification to `targetName` when dealing with `FetchValueVar`
- Only apply simplification to `targetName` when dealing with `FuncCallInstr`
- Only apply simplification to `targetName` when dealing with `StackArrayIndexInstruction
- `generateSignature(Function)`	now uses just `paramName` (no simplification as hat makes no sense)
- Fixed	multiple instrucmentation codes	in `emitTestingEntrypoint(File,	Module)`

* TypeChecker

- When handling the `StaticVariableDeclaration` dependency node, just use the `getName()`, don't generate a path from the container to the cvariable entity itself
- Also simplified the above code, neatened it up

* Dependency

- Fixed the for loop stuff (this change done already in another branch) #205

* DGen

- When we do ANY AST lookup do so on the un-`simplify()`'d `getTarget()`, however, the emit
should use the simplified version, call	it `emitTarget`
- Don't	do symbol mapping in `generateSignature_Variable(Variable)`

* Test cases

- Fi... (continued)

Pull Request Pull Request #55: ⚡ Feature: Partial info transfer instructions

Run Details

384 of 423 new or added lines in 13 files covered. (90.78%)

5063 of 6299 relevant lines covered (80.38%)

426.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.3

/source/tlang/compiler/symbols/containers.d

module tlang.compiler.symbols.containers;

import tlang.compiler.symbols.data;
import std.conv : to;
import tlang.compiler.symbols.typing.core;

// AST manipulation interfaces
import tlang.compiler.symbols.mcro : MStatementSearchable, MStatementReplaceable, MCloneable;

/**
* Used so often that we may as well
* declare it once
*
* TODO: Check if we could do it with interfaces?
*/
public Statement[] weightReorder(Statement[] statements)
{
    import std.algorithm.sorting : sort;
    import std.algorithm.mutation : SwapStrategy;

    /* Re-ordered by lowest wieght first */
    Statement[] stmntsRed;

    /* Comparator for Statement objects */
    bool wCmp(Statement lhs, Statement rhs)
    {
        return lhs.weight < rhs.weight;
    }
    
    stmntsRed = sort!(wCmp, SwapStrategy.stable)(statements).release;

    return stmntsRed;
}

// TODO: Honestly all contains should be a kind-of `MStatementSearchable` and `MStatementReplaceable`
// AND MCloneable
/** 
 * Represents any sort of type
 * that can store `Statement`(s)
 * (AST nodes) and retrieve them
 * again at a later stage
 *
 * Additionally also means that
 * the `MStatementSearchable` and
 * `MStatementReplaceable` types
 * are implemented
 */
public interface Container : MStatementSearchable, MStatementReplaceable
{
    /** 
     * Appends the given statement to
     * this container's body
     *
     * Params:
     *   statement = the `Statement`
     * to add
     */
    public void addStatement(Statement statement);

    /** 
     * Appends the list of statements
     * (in order) to this container's
     * body
     *
     * Params:
     *   statements = the `Statement[]`
     * to add
     */
    public void addStatements(Statement[] statements);

    /** 
     * Returns the body of this
     * container
     *
     * Returns: a `Statement[]`
     */
    public Statement[] getStatements();

    /** 
     * Determines if the given AST node
     * is present within this container
     * using `opEquals()` for comparisons.
     *
     * Params:
     *   s = the AST node to check for
     * Returns: `true` if so, `false`
     * otherwise
     */
    public final bool contains(Statement s)
    {
        foreach(Statement c; getStatements())
        {
            if(c == s)
            {
                return true;
            }
        }
        
        return false;
    }
}


public class Module : Entity, Container
{
    /** 
     * Path to the module on disk
     */
    private string moduleFilePath;

    this(string moduleName)
    {
        super(moduleName);
    }

    /** 
     * Returns the file system path where
     * this module was parsed from
     *
     * Returns: the path as a `string`
     */
    public string getFilePath()
    {
        return this.moduleFilePath;
    }

    /** 
     * Sets the file system path to the module
     *
     * Params:
     *   filePath = path to the module on disk
     */
    public void setFilePath(string filePath)
    {
        this.moduleFilePath = filePath;
    }

    private Statement[] statements;


    public void addStatement(Statement statement)
    {
        this.statements ~= statement;
    }

    public void addStatements(Statement[] statements)
    {
        this.statements ~= statements;
    }

    public Statement[] getStatements()
    {
        // TODO: Holy naai this is expensive
        return weightReorder(statements);
    }

    public override Statement[] search(TypeInfo_Class clazzType)
    {
        /* List of returned matches */
        Statement[] matches;

        /* Are we (ourselves) of this type? */
        if(clazzType.isBaseOf(this.classinfo))
        {
            matches ~= [this];
        }

        /* Recurse on each `Statement` making up our body */
        // NOTE: Using weight-reordered? Is that fine?
        foreach(Statement curStmt; getStatements())
        {
            MStatementSearchable curStmtCasted = cast(MStatementSearchable)curStmt;
            if(curStmtCasted)
            {
                matches ~= curStmtCasted.search(clazzType);
            }
        }

        return matches;
    }

    public override bool replace(Statement thiz, Statement that)
    {
        /* If we (`this`) are `thiz`, then we cannot replace */
        if(this == thiz)
        {
            return false;
        }
        /* If not ourself, then check the body statements */
        else
        {
            /**
             * First check each `Statement` that make sup our
             * body and see if we can replace that, else see
             * if we can recurse on each of the body statements
             * and apply replacement therein
             */
            // NOTE: Using weight-reordered? Is that fine?
            Statement[] bodyStmts = getStatements();
            for(ulong idx = 0; idx < bodyStmts.length; idx++)
            {
                Statement curBodyStmt = bodyStmts[idx];

                /* Should we directly replace the Statement in the body? */
                if(curBodyStmt == thiz)
                {
                    // Replace the statement in the body
                    statements[idx] = that;

                    // Re-parent `that` to us
                    that.parentTo(this);

                    return true;
                }
                /* If we cannot, then recurse (try) on it */
                else if(cast(MStatementReplaceable)curBodyStmt)
                {
                    MStatementReplaceable curBodyStmtRepl = cast(MStatementReplaceable)curBodyStmt;
                    if(curBodyStmtRepl.replace(thiz, that))
                    {
                        return true;
                    }
                }
            }

            return false;
        }
    }

    /** 
     * Provides a string representation of
     * this module
     *
     * Returns: a string
     */
    public override string toString()
    {
        return "Module [name: "~getName()~"]";
    }
}

/**
* Struct
*
* A Struct can only contain Entity's
* that are Variables (TODO: Enforce in parser)
* TODO: Possibly enforce here too
*/
public class Struct : Type, Container, MCloneable
{
    private Statement[] statements;

    public void addStatement(Statement statement)
    {
        this.statements ~= statement;
    }

    public void addStatements(Statement[] statements)
    {
        this.statements ~= statements;
    }

    public Statement[] getStatements()
    {
        // TODO: Holy naai this is expensive
        return weightReorder(statements);
    }

    this(string name)
    {
        super(name);
    }

    public override Statement[] search(TypeInfo_Class clazzType)
    {
        /* List of returned matches */
        Statement[] matches;

        /* Are we (ourselves) of this type? */
        if(clazzType.isBaseOf(this.classinfo))
        {
            matches ~= [this];
        }

        /* Recurse on each `Statement` making up our body */
        // NOTE: Using weight-reordered? Is that fine?
        foreach(Statement curStmt; getStatements())
        {
            MStatementSearchable curStmtCasted = cast(MStatementSearchable)curStmt;
            if(curStmtCasted)
            {
                matches ~= curStmtCasted.search(clazzType);
            }
        }

        return matches;
    }

    public override bool replace(Statement thiz, Statement that)
    {
        /* If we (`this`) are `thiz`, then we cannot replace */
        if(this == thiz)
        {
            return false;
        }
        /* If not ourself, then check the body statements */
        else
        {
            /**
             * First check each `Statement` that make sup our
             * body and see if we can replace that, else see
             * if we can recurse on each of the body statements
             * and apply replacement therein
             */
            // NOTE: Using weight-reordered? Is that fine?
            Statement[] bodyStmts = getStatements();
            for(ulong idx = 0; idx < bodyStmts.length; idx++)
            {
                Statement curBodyStmt = bodyStmts[idx];

                /* Should we directly replace the Statement in the body? */
                if(curBodyStmt == thiz)
                {
                    // Replace the statement in the body
                    statements[idx] = that;

                    // Re-parent `that` to us
                    that.parentTo(this);

                    return true;
                }
                /* If we cannot, then recurse (try) on it */
                else if(cast(MStatementReplaceable)curBodyStmt)
                {
                    MStatementReplaceable curBodyStmtRepl = cast(MStatementReplaceable)curBodyStmt;
                    if(curBodyStmtRepl.replace(thiz, that))
                    {
                        return true;
                    }
                }
            }

            return false;
        }
    }

    /** 
     * Clones this struct recursively returning a
     * fresh copy of all its members and the struct
     * itself.
     *
     * Param:
     *   newParent = the `Container` to re-parent the
     *   cloned `Statement`'s self to
     *
     * Returns: the cloned `Statement`
     */
    public override Statement clone(Container newParent = null)
    {
        Struct clonedStruct = new Struct(this.name);

        /** 
         * Clone all the statements and re-parent them
         * to the clone
         */
        Statement[] clonedStatements;
        foreach(Statement curStmt; this.getStatements())
        {
            Statement clonedStmt;
            if(cast(MCloneable)curStmt)
            {
                MCloneable cloneableCurStmt = cast(MCloneable)curStmt;
                clonedStmt = cloneableCurStmt.clone();
            }

            // Re-parent to the cloned struct
            clonedStmt.parentTo(clonedStruct);

            // Add it to the cloned struct's body
            clonedStruct.addStatement(clonedStmt);
        }

        // Parent ourselves to the given parent
        clonedStruct.parentTo(newParent);

        return clonedStruct;
    }
}

public class Clazz : Type, Container
{
    private Statement[] statements;

    private string[] interfacesClasses;

    this(string name)
    {
        super(name);

        /* Weighted as 0 */
        weight = 0;
    }

    public void addInherit(string[] l)
    {
        interfacesClasses ~= l;
    }

    public string[] getInherit()
    {
        return interfacesClasses;
    }

    public override string toString()
    {
        return "Class (Name: "~name~", Parents (Class/Interfaces): "~to!(string)(interfacesClasses)~")";
    }

    public void addStatement(Statement statement)
    {
        this.statements ~= statement;
    }

    public void addStatements(Statement[] statements)
    {
        this.statements ~= statements;
    }

    public Statement[] getStatements()
    {
        // TODO: Holy naai this is expensive
        return weightReorder(statements);
    }

    public override Statement[] search(TypeInfo_Class clazzType)
    {
        /* List of returned matches */
        Statement[] matches;

        /* Are we (ourselves) of this type? */
        if(clazzType.isBaseOf(this.classinfo))
        {
            matches ~= [this];
        }

        /* Recurse on each `Statement` making up our body */
        // NOTE: Using weight-reordered? Is that fine?
        foreach(Statement curStmt; getStatements())
        {
            MStatementSearchable curStmtCasted = cast(MStatementSearchable)curStmt;
            if(curStmtCasted)
            {
                matches ~= curStmtCasted.search(clazzType);
            }
        }

        return matches;
    }

    public override bool replace(Statement thiz, Statement that)
    {
        /* If we (`this`) are `thiz`, then we cannot replace */
        if(this == thiz)
        {
            return false;
        }
        /* If not ourself, then check the body statements */
        else
        {
            /**
             * First check each `Statement` that make sup our
             * body and see if we can replace that, else see
             * if we can recurse on each of the body statements
             * and apply replacement therein
             */
            // NOTE: Using weight-reordered? Is that fine?
            Statement[] bodyStmts = getStatements();
            for(ulong idx = 0; idx < bodyStmts.length; idx++)
            {
                Statement curBodyStmt = bodyStmts[idx];

                /* Should we directly replace the Statement in the body? */
                if(curBodyStmt == thiz)
                {
                    // Replace the statement in the body
                    statements[idx] = that;

                    // Re-parent `that` to us
                    that.parentTo(this);

                    return true;
                }
                /* If we cannot, then recurse (try) on it */
                else if(cast(MStatementReplaceable)curBodyStmt)
                {
                    MStatementReplaceable curBodyStmtRepl = cast(MStatementReplaceable)curBodyStmt;
                    if(curBodyStmtRepl.replace(thiz, that))
                    {
                        return true;
                    }
                }
            }

            return false;
        }
    }
    
}


/**
 * Test the `MCloneable`-ity support of `Struct`
 * which has two `Variable` members (therefore
 * also testing the `clone()` on `Variable`)
 */
unittest
{
    Struct original = new Struct("User");
    Variable originalVar_Name = new Variable("byte*", "name");
    Variable originalVar_Age = new Variable("int", "age");
    originalVar_Name.parentTo(original);
    originalVar_Age.parentTo(original);
    original.addStatement(originalVar_Name);
    original.addStatement(originalVar_Age);
    
    // Now clone it
    Struct cloned = cast(Struct)original.clone();

    // Cloned version should differ
    assert(cloned !is original);

    // Cloned statements versus original statements
    Statement[] clonedStmts = cloned.getStatements();
    Statement[] originalStmts = original.getStatements();
    assert(clonedStmts[0] !is originalStmts[0]);
    assert(clonedStmts[1] !is originalStmts[1]);

    // Compare the variables (members) of both
    Variable origStruct_MemberOne = cast(Variable)originalStmts[0];
    Variable origStruct_MemberTwo = cast(Variable)originalStmts[1];
    Variable clonedStruct_MemberOne = cast(Variable)clonedStmts[0];
    Variable clonedStruct_MemberTwo = cast(Variable)clonedStmts[1];
    assert(origStruct_MemberOne !is clonedStruct_MemberOne);
    assert(origStruct_MemberTwo !is clonedStruct_MemberTwo);
    assert(originalVar_Name.getName() == clonedStruct_MemberOne.getName()); // Names should match
    assert(origStruct_MemberTwo.getName() == clonedStruct_MemberTwo.getName()); // Names should match

    // Ensure re-parenting is correct
    assert(origStruct_MemberOne.parentOf() == original);
    assert(origStruct_MemberTwo.parentOf() == original);
    assert(clonedStruct_MemberOne.parentOf() == cloned);
    assert(clonedStruct_MemberTwo.parentOf() == cloned);

    // TODO: Make this more deeper this test as a few
    // ... more things were left out that can be checked
}

1	module tlang.compiler.symbols.containers;
2
3	import tlang.compiler.symbols.data;
4	import std.conv : to;
5	import tlang.compiler.symbols.typing.core;
6
7	// AST manipulation interfaces
8	import tlang.compiler.symbols.mcro : MStatementSearchable, MStatementReplaceable, MCloneable;
9
10	/**
11	* Used so often that we may as well
12	* declare it once
13	*
14	* TODO: Check if we could do it with interfaces?
15	*/
16	public Statement[] weightReorder(Statement[] statements)
17	{
18	import std.algorithm.sorting : sort;
19	import std.algorithm.mutation : SwapStrategy;
20
21	/* Re-ordered by lowest wieght first */
22	Statement[] stmntsRed;	3,017✔
23
24	/* Comparator for Statement objects */
25	bool wCmp(Statement lhs, Statement rhs)
26	{
27	return lhs.weight < rhs.weight;	22,116✔
28	}
29
30	stmntsRed = sort!(wCmp, SwapStrategy.stable)(statements).release;	3,017✔
31
32	return stmntsRed;	3,017✔
33	}
34
35	// TODO: Honestly all contains should be a kind-of `MStatementSearchable` and `MStatementReplaceable`
36	// AND MCloneable
37	/**
38	* Represents any sort of type
39	* that can store `Statement`(s)
40	* (AST nodes) and retrieve them
41	* again at a later stage
42	*
43	* Additionally also means that
44	* the `MStatementSearchable` and
45	* `MStatementReplaceable` types
46	* are implemented
47	*/
48	public interface Container : MStatementSearchable, MStatementReplaceable
49	{
50	/**
51	* Appends the given statement to
52	* this container's body
53	*
54	* Params:
55	* statement = the `Statement`
56	* to add
57	*/
58	public void addStatement(Statement statement);
59
60	/**
61	* Appends the list of statements
62	* (in order) to this container's
63	* body
64	*
65	* Params:
66	* statements = the `Statement[]`
67	* to add
68	*/
69	public void addStatements(Statement[] statements);
70
71	/**
72	* Returns the body of this
73	* container
74	*
75	* Returns: a `Statement[]`
76	*/
77	public Statement[] getStatements();
78
79	/**
80	* Determines if the given AST node
81	* is present within this container
82	* using `opEquals()` for comparisons.
83	*
84	* Params:
85	* s = the AST node to check for
86	* Returns: `true` if so, `false`
87	* otherwise
88	*/
89	public final bool contains(Statement s)
90	{
NEW 91	foreach(Statement c; getStatements())	×
92	{
NEW 93	if(c == s)	×
94	{
NEW 95	return true;	×
96	}
97	}
98
NEW 99	return false;	×
100	}
101	}
102
103
104	public class Module : Entity, Container
105	{
106	/**
107	* Path to the module on disk
108	*/
109	private string moduleFilePath;
110
111	this(string moduleName)	103✔
112	{
113	super(moduleName);	103✔
114	}
115
116	/**
117	* Returns the file system path where
118	* this module was parsed from
119	*
120	* Returns: the path as a `string`
121	*/
122	public string getFilePath()
123	{
124	return this.moduleFilePath;	98✔
125	}
126
127	/**
128	* Sets the file system path to the module
129	*
130	* Params:
131	* filePath = path to the module on disk
132	*/
133	public void setFilePath(string filePath)
134	{
135	this.moduleFilePath = filePath;	101✔
136	}
137
138	private Statement[] statements;
139
140
141	public void addStatement(Statement statement)
142	{
143	this.statements ~= statement;	183✔
144	}
145
146	public void addStatements(Statement[] statements)
147	{
148	this.statements ~= statements;	×
149	}
150
151	public Statement[] getStatements()
152	{
153	// TODO: Holy naai this is expensive
154	return weightReorder(statements);	1,263✔
155	}
156
157	public override Statement[] search(TypeInfo_Class clazzType)
158	{
159	/* List of returned matches */
160	Statement[] matches;	166✔
161
162	/* Are we (ourselves) of this type? */
163	if(clazzType.isBaseOf(this.classinfo))	166✔
164	{
165	matches ~= [this];	×
166	}
167
168	/* Recurse on each `Statement` making up our body */
169	// NOTE: Using weight-reordered? Is that fine?
170	foreach(Statement curStmt; getStatements())	1,452✔
171	{
172	MStatementSearchable curStmtCasted = cast(MStatementSearchable)curStmt;	318✔
173	if(curStmtCasted)	318✔
174	{
175	matches ~= curStmtCasted.search(clazzType);	318✔
176	}
177	}
178
179	return matches;	166✔
180	}
181
182	public override bool replace(Statement thiz, Statement that)
183	{
184	/* If we (`this`) are `thiz`, then we cannot replace */
185	if(this == thiz)	×
186	{
187	return false;	×
188	}
189	/* If not ourself, then check the body statements */
190	else
191	{
192	/**
193	* First check each `Statement` that make sup our
194	* body and see if we can replace that, else see
195	* if we can recurse on each of the body statements
196	* and apply replacement therein
197	*/
198	// NOTE: Using weight-reordered? Is that fine?
199	Statement[] bodyStmts = getStatements();	×
200	for(ulong idx = 0; idx < bodyStmts.length; idx++)	×
201	{
202	Statement curBodyStmt = bodyStmts[idx];	×
203
204	/* Should we directly replace the Statement in the body? */
205	if(curBodyStmt == thiz)	×
206	{
207	// Replace the statement in the body
208	statements[idx] = that;	×
209
210	// Re-parent `that` to us
211	that.parentTo(this);	×
212
213	return true;	×
214	}
215	/* If we cannot, then recurse (try) on it */
216	else if(cast(MStatementReplaceable)curBodyStmt)	×
217	{
218	MStatementReplaceable curBodyStmtRepl = cast(MStatementReplaceable)curBodyStmt;	×
219	if(curBodyStmtRepl.replace(thiz, that))	×
220	{
221	return true;	×
222	}
223	}
224	}
225
226	return false;	×
227	}
228	}
229
230	/**
231	* Provides a string representation of
232	* this module
233	*
234	* Returns: a string
235	*/
236	public override string toString()
237	{
238	return "Module [name: "~getName()~"]";	7,531✔
239	}
240	}
241
242	/**
243	* Struct
244	*
245	* A Struct can only contain Entity's
246	* that are Variables (TODO: Enforce in parser)
247	* TODO: Possibly enforce here too
248	*/
249	public class Struct : Type, Container, MCloneable
250	{
251	private Statement[] statements;
252
253	public void addStatement(Statement statement)
254	{
255	this.statements ~= statement;	4✔
256	}
257
258	public void addStatements(Statement[] statements)
259	{
260	this.statements ~= statements;	×
261	}
262
263	public Statement[] getStatements()
264	{
265	// TODO: Holy naai this is expensive
266	return weightReorder(statements);	3✔
267	}
268
269	this(string name)	2✔
270	{
271	super(name);	2✔
272	}
273
274	public override Statement[] search(TypeInfo_Class clazzType)
275	{
276	/* List of returned matches */
277	Statement[] matches;	×
278
279	/* Are we (ourselves) of this type? */
280	if(clazzType.isBaseOf(this.classinfo))	×
281	{
282	matches ~= [this];	×
283	}
284
285	/* Recurse on each `Statement` making up our body */
286	// NOTE: Using weight-reordered? Is that fine?
287	foreach(Statement curStmt; getStatements())	×
288	{
289	MStatementSearchable curStmtCasted = cast(MStatementSearchable)curStmt;	×
290	if(curStmtCasted)	×
291	{
292	matches ~= curStmtCasted.search(clazzType);	×
293	}
294	}
295
296	return matches;	×
297	}
298
299	public override bool replace(Statement thiz, Statement that)
300	{
301	/* If we (`this`) are `thiz`, then we cannot replace */
302	if(this == thiz)	×
303	{
304	return false;	×
305	}
306	/* If not ourself, then check the body statements */
307	else
308	{
309	/**
310	* First check each `Statement` that make sup our
311	* body and see if we can replace that, else see
312	* if we can recurse on each of the body statements
313	* and apply replacement therein
314	*/
315	// NOTE: Using weight-reordered? Is that fine?
316	Statement[] bodyStmts = getStatements();	×
317	for(ulong idx = 0; idx < bodyStmts.length; idx++)	×
318	{
319	Statement curBodyStmt = bodyStmts[idx];	×
320
321	/* Should we directly replace the Statement in the body? */
322	if(curBodyStmt == thiz)	×
323	{
324	// Replace the statement in the body
325	statements[idx] = that;	×
326
327	// Re-parent `that` to us
328	that.parentTo(this);	×
329
330	return true;	×
331	}
332	/* If we cannot, then recurse (try) on it */
333	else if(cast(MStatementReplaceable)curBodyStmt)	×
334	{
335	MStatementReplaceable curBodyStmtRepl = cast(MStatementReplaceable)curBodyStmt;	×
336	if(curBodyStmtRepl.replace(thiz, that))	×
337	{
338	return true;	×
339	}
340	}
341	}
342
343	return false;	×
344	}
345	}
346
347	/**
348	* Clones this struct recursively returning a
349	* fresh copy of all its members and the struct
350	* itself.
351	*
352	* Param:
353	* newParent = the `Container` to re-parent the
354	* cloned `Statement`'s self to
355	*
356	* Returns: the cloned `Statement`
357	*/
358	public override Statement clone(Container newParent = null)
359	{
360	Struct clonedStruct = new Struct(this.name);	1✔
361
362	/**
363	* Clone all the statements and re-parent them
364	* to the clone
365	*/
366	Statement[] clonedStatements;	1✔
367	foreach(Statement curStmt; this.getStatements())	9✔
368	{
369	Statement clonedStmt;	2✔
370	if(cast(MCloneable)curStmt)	2✔
371	{
372	MCloneable cloneableCurStmt = cast(MCloneable)curStmt;	2✔
373	clonedStmt = cloneableCurStmt.clone();	2✔
374	}
375
376	// Re-parent to the cloned struct
377	clonedStmt.parentTo(clonedStruct);	2✔
378
379	// Add it to the cloned struct's body
380	clonedStruct.addStatement(clonedStmt);	2✔
381	}
382
383	// Parent ourselves to the given parent
384	clonedStruct.parentTo(newParent);	1✔
385
386	return clonedStruct;	1✔
387	}
388	}
389
390	public class Clazz : Type, Container
391	{
392	private Statement[] statements;
393
394	private string[] interfacesClasses;
395
396	this(string name)	33✔
397	{
398	super(name);	33✔
399
400	/* Weighted as 0 */
401	weight = 0;	33✔
402	}
403
404	public void addInherit(string[] l)
405	{
406	interfacesClasses ~= l;	32✔
407	}
408
409	public string[] getInherit()
410	{
411	return interfacesClasses;	4✔
412	}
413
414	public override string toString()
415	{
416	return "Class (Name: "~name~", Parents (Class/Interfaces): "~to!(string)(interfacesClasses)~")";	658✔
417	}
418
419	public void addStatement(Statement statement)
420	{
421	this.statements ~= statement;	×
422	}
423
424	public void addStatements(Statement[] statements)
425	{
426	this.statements ~= statements;	32✔
427	}
428
429	public Statement[] getStatements()
430	{
431	// TODO: Holy naai this is expensive
432	return weightReorder(statements);	269✔
433	}
434
435	public override Statement[] search(TypeInfo_Class clazzType)
436	{
437	/* List of returned matches */
438	Statement[] matches;	172✔
439
440	/* Are we (ourselves) of this type? */
441	if(clazzType.isBaseOf(this.classinfo))	172✔
442	{
443	matches ~= [this];	×
444	}
445
446	/* Recurse on each `Statement` making up our body */
447	// NOTE: Using weight-reordered? Is that fine?
448	foreach(Statement curStmt; getStatements())	852✔
449	{
450	MStatementSearchable curStmtCasted = cast(MStatementSearchable)curStmt;	112✔
451	if(curStmtCasted)	112✔
452	{
453	matches ~= curStmtCasted.search(clazzType);	112✔
454	}
455	}
456
457	return matches;	172✔
458	}
459
460	public override bool replace(Statement thiz, Statement that)
461	{
462	/* If we (`this`) are `thiz`, then we cannot replace */
463	if(this == thiz)	×
464	{
465	return false;	×
466	}
467	/* If not ourself, then check the body statements */
468	else
469	{
470	/**
471	* First check each `Statement` that make sup our
472	* body and see if we can replace that, else see
473	* if we can recurse on each of the body statements
474	* and apply replacement therein
475	*/
476	// NOTE: Using weight-reordered? Is that fine?
477	Statement[] bodyStmts = getStatements();	×
478	for(ulong idx = 0; idx < bodyStmts.length; idx++)	×
479	{
480	Statement curBodyStmt = bodyStmts[idx];	×
481
482	/* Should we directly replace the Statement in the body? */
483	if(curBodyStmt == thiz)	×
484	{
485	// Replace the statement in the body
486	statements[idx] = that;	×
487
488	// Re-parent `that` to us
489	that.parentTo(this);	×
490
491	return true;	×
492	}
493	/* If we cannot, then recurse (try) on it */
494	else if(cast(MStatementReplaceable)curBodyStmt)	×
495	{
496	MStatementReplaceable curBodyStmtRepl = cast(MStatementReplaceable)curBodyStmt;	×
497	if(curBodyStmtRepl.replace(thiz, that))	×
498	{
499	return true;	×
500	}
501	}
502	}
503
504	return false;	×
505	}
506	}
507
508	}
509
510
511	/**
512	* Test the `MCloneable`-ity support of `Struct`
513	* which has two `Variable` members (therefore
514	* also testing the `clone()` on `Variable`)
515	*/
516	unittest
517	{
518	Struct original = new Struct("User");	1✔
519	Variable originalVar_Name = new Variable("byte*", "name");	1✔
520	Variable originalVar_Age = new Variable("int", "age");	1✔
521	originalVar_Name.parentTo(original);	1✔
522	originalVar_Age.parentTo(original);	1✔
523	original.addStatement(originalVar_Name);	1✔
524	original.addStatement(originalVar_Age);	1✔
525
526	// Now clone it
527	Struct cloned = cast(Struct)original.clone();	1✔
528
529	// Cloned version should differ
530	assert(cloned !is original);	1✔
531
532	// Cloned statements versus original statements
533	Statement[] clonedStmts = cloned.getStatements();	1✔
534	Statement[] originalStmts = original.getStatements();	1✔
535	assert(clonedStmts[0] !is originalStmts[0]);	1✔
536	assert(clonedStmts[1] !is originalStmts[1]);	1✔
537
538	// Compare the variables (members) of both
539	Variable origStruct_MemberOne = cast(Variable)originalStmts[0];	1✔
540	Variable origStruct_MemberTwo = cast(Variable)originalStmts[1];	1✔
541	Variable clonedStruct_MemberOne = cast(Variable)clonedStmts[0];	1✔
542	Variable clonedStruct_MemberTwo = cast(Variable)clonedStmts[1];	1✔
543	assert(origStruct_MemberOne !is clonedStruct_MemberOne);	1✔
544	assert(origStruct_MemberTwo !is clonedStruct_MemberTwo);	1✔
545	assert(originalVar_Name.getName() == clonedStruct_MemberOne.getName()); // Names should match	1✔
546	assert(origStruct_MemberTwo.getName() == clonedStruct_MemberTwo.getName()); // Names should match	1✔
547
548	// Ensure re-parenting is correct
549	assert(origStruct_MemberOne.parentOf() == original);	1✔
550	assert(origStruct_MemberTwo.parentOf() == original);	1✔
551	assert(clonedStruct_MemberOne.parentOf() == cloned);	1✔
552	assert(clonedStruct_MemberTwo.parentOf() == cloned);	1✔
553
554	// TODO: Make this more deeper this test as a few
555	// ... more things were left out that can be checked
556	}

tbklang / tlang / #781

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous