Implement cloning of IInterimOperands. The 'block' parameter is required so nested IResultingInstructions can know which BasicBlock they're within.

Author: DBooots

src/kOS.Safe/Compilation/IR/IInterimOperand.cs

@@ -31,5 +31,11 @@ public interface IInterimOperand
         /// </summary>
         /// <returns><c>true</c> if the operands are equal, otherwise <c>false</c>.</returns>
         bool Equals(IInterimOperand other);
+
+        /// <summary>
+        /// Clones this instance.
+        /// </summary>
+        /// <param name="block">The block within which this instance is being cloned.</param>
+        IInterimOperand Clone(BasicBlock block);
     }
 }

src/kOS.Safe/Compilation/IR/IRInstruction.cs

@@ -255,6 +255,10 @@ public bool SwapOperands()
             }
             return true;
         }
+
+        public IInterimOperand Clone(BasicBlock block)
+            => new IRBinaryOp(block, (BinaryOpcode)SetSourceLocation(Operation), Left.Clone(block), Right.Clone(block));
+
         public override IEnumerable<Opcode> EmitOpcodes()
         {
             foreach (Opcode opcode in Left.EmitOpcodes())
@@ -264,6 +268,7 @@ public override IEnumerable<Opcode> EmitOpcodes()
             Operation.Label = string.Empty;
             yield return SetSourceLocation(Operation);
         }
+
         public override string ToString()
             => Operation.ToString();
         public bool Equals(IInterimOperand other)
@@ -340,6 +345,9 @@ public IRUnaryOp(BasicBlock block, Opcode operation, IInterimOperand operand) :
             Operation = operation;
             Operand = operand;
         }
+
+        public IInterimOperand Clone(BasicBlock block)
+            => new IRUnaryOp(block, Operation, Operand.Clone(block));
         public override IEnumerable<Opcode> EmitOpcodes()
         {
             foreach (Opcode opcode in Operand.EmitOpcodes())
@@ -477,6 +485,8 @@ public IRNonVarPush(BasicBlock block, Opcode opcode) : base(opcode, block)
         {
             Operation = opcode;
         }
+        public IInterimOperand Clone(BasicBlock block)
+            => new IRNonVarPush(block, Operation);
         public override IEnumerable<Opcode> EmitOpcodes()
         {
             Operation.Label = string.Empty;
@@ -501,6 +511,8 @@ public IRSuffixGet(BasicBlock block, IInterimOperand obj, OpcodeGetMember opcode
             Object = obj;
             Suffix = opcodeGetMember.Identifier;
         }
+        public IInterimOperand Clone(BasicBlock block)
+            => new IRSuffixGet(block, Object.Clone(block), new OpcodeGetMember(Suffix) { SourceLine = SourceLine, SourceColumn = SourceColumn });
         public override IEnumerable<Opcode> EmitOpcodes()
         {
             foreach (Opcode opcode in Object.EmitOpcodes())
@@ -533,7 +545,6 @@ public InterimConstantValue Evaluate()
             if (!IsInvariant)
                 throw new InvalidOperationException();
             throw new NotImplementedException();
-            // MUSTFIX:
 #pragma warning disable CS0162 // Unreachable code detected
             Encapsulation.Structure obj = (Encapsulation.Structure)(Object as IEvaluatableToConstant).Evaluate()?.Value;
 #pragma warning restore CS0162 // Unreachable code detected
@@ -633,6 +644,8 @@ public IRIndexGet(BasicBlock block, IInterimOperand obj, IInterimOperand index,
             Object = obj;
             Index = index;
         }
+        public IInterimOperand Clone(BasicBlock block)
+            => new IRIndexGet(block, Object.Clone(block), Index.Clone(block), new OpcodeGetIndex() { SourceLine = SourceLine, SourceColumn = SourceColumn });
         public override IEnumerable<Opcode> EmitOpcodes()
         {
             foreach (Opcode opcode in Object.EmitOpcodes())
@@ -664,7 +677,6 @@ public InterimConstantValue Evaluate()
         {
             if (!IsInvariant)
                 throw new InvalidOperationException();
-            // MUSTFIX:
             throw new NotImplementedException();
             //((Encapsulation.IIndexable)Object).GetIndex();
         }
@@ -795,6 +807,17 @@ public override IEnumerable<Opcode> EmitOpcodes()
                 yield return SetSourceLocation(new OpcodeBranchJump() { DestinationLabel = False.Label });
             }
         }
+        public IRBranch Clone(BasicBlock block)
+        {
+            BranchOpcode opcode;
+            if (PreferFalse)
+                opcode = new OpcodeBranchIfFalse();
+            else
+                opcode = new OpcodeBranchIfTrue();
+            opcode.SourceLine = SourceLine;
+            opcode.SourceColumn = SourceColumn;
+            return new IRBranch(block, Condition.Clone(block), True, False, opcode);
+        }
         public override string ToString()
             => string.Format("{{br.? {0}/{1}}}", True.Label, False.Label);
         public override bool Equals(object obj)
@@ -838,13 +861,22 @@ private bool IsCallInvariant()
         }
         private Type GetDefaultReturnType()
         {
-            IRCodePart.IRFunction function = Block.CodePart.GetFunction(this);
+            IRCodePart.IRFunction function = Block?.CodePart?.GetFunction(this);
+            if (function != null)
+                return function.Returns.Type;
             if (Optimization.Optimizer.FunctionManager.Exists(Function.Replace("()", "")))
                 return Optimization.Optimizer.FunctionManager.FunctionReturnType(Function.Replace("()", ""));
             if (!Direct && IndirectMethod is IRSuffixGetMethod suffixGetMethod)
                 return suffixGetMethod.Type;
             return typeof(Encapsulation.Structure);
         }
+        public IInterimOperand Clone(BasicBlock block)
+            => new IRCall(block, new OpcodeCall(Function)
+            {
+                Direct = Direct,
+                SourceLine = SourceLine,
+                SourceColumn = SourceColumn
+            }, EmitArgMarker, Arguments);
         public override IEnumerable<Opcode> EmitOpcodes()
         {
             if (EmitArgMarker)

src/kOS.Safe/Compilation/IR/InterimConstantValue.cs

@@ -46,6 +46,9 @@ public override string ToString()
 
         InterimConstantValue IEvaluatableToConstant.Evaluate()
             => this;
+
+        IInterimOperand IInterimOperand.Clone(BasicBlock _)
+            => this;
     }
 
     public class IRRelocateLater : InterimConstantValue
@@ -90,5 +93,8 @@ public class IRParameter : IInterimOperand
         public IEnumerable<Opcode> EmitOpcodes() => System.Linq.Enumerable.Empty<Opcode>();
         public bool Equals(IInterimOperand other)
             => other == this;
+        // This shouldn't need to be implemented... Shouldn't.
+        public IInterimOperand Clone(BasicBlock _)
+            => throw new NotImplementedException();
     }
 }

src/kOS.Safe/Compilation/IR/InterimVariables.cs

@@ -30,6 +30,9 @@ public InterimVariableReference(string name, short sourceLine, short sourceColum
             SourceColumn = sourceColumn;
         }
 
+        public IInterimOperand Clone(BasicBlock _)
+            => this;
+
         public IEnumerable<Opcode> EmitOpcodes()
         {
             yield return new OpcodePush(Name)
@@ -78,6 +81,9 @@ public InterimResolvedReference(SSADefinition reference, short sourceLine, short
             SourceColumn = sourceColumn;
         }
 
+        public IInterimOperand Clone(BasicBlock _)
+            => this;
+
         public IEnumerable<Opcode> EmitOpcodes()
         {
             yield return new OpcodePush(Name)
@@ -160,6 +166,9 @@ public void AddReference(SSADefinition reference)
             references.Add(reference);
         }
 
+        public IInterimOperand Clone(BasicBlock _)
+            => new InterimUnresolvedReference(References, SourceLine, SourceColumn);
+
         public IEnumerable<Opcode> EmitOpcodes()
         {
             yield return new OpcodePush(Name)