11746327569

Committed 08 Nov 2024 05:02PM UTC coverage: 74.055%. Remained the same

Build # 11746327569

Build Type

push

github

Committed by

shargon

Commit Message

Revert "Compiler info in DebugInfo"

This reverts commit 57ca7af40.

Run Details

4825 of 7080 branches covered (68.15%)

Branch coverage included in aggregate %.

23 of 24 new or added lines in 5 files covered. (95.83%)

39 existing lines in 2 files now uncovered.

12909 of 16867 relevant lines covered (76.53%)

17628.99 hits per line

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

82.07

/src/Neo.Compiler.CSharp/MethodConvert/Helpers/StackHelpers.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// The Neo.Compiler.CSharp is free software distributed under the MIT
// software license, see the accompanying file LICENSE in the main directory
// of the project or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.

extern alias scfx;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Neo.VM;
using System;
using System.Buffers.Binary;
using System.Numerics;
using scfx::Neo.SmartContract.Framework;
using OpCode = Neo.VM.OpCode;
using System.IO;

namespace Neo.Compiler;

internal partial class MethodConvert
{
    #region Instructions
    private Instruction AddInstruction(Instruction instruction)
    {
        _instructions.Add(instruction);
        return instruction;
    }

    private Instruction AddInstruction(OpCode opcode)
    {
        return AddInstruction(new Instruction
        {
            OpCode = opcode
        });
    }

    private SequencePointInserter InsertSequencePoint(SyntaxNodeOrToken? syntax)
    {
        return new SequencePointInserter(_instructions, syntax);
    }

    private SequencePointInserter InsertSequencePoint(SyntaxReference? syntax)
    {
        return new SequencePointInserter(_instructions, syntax);
    }

    private SequencePointInserter InsertSequencePoint(Location? location)
    {
        return new SequencePointInserter(_instructions, location);
    }

    #endregion

    private Instruction Jump(OpCode opcode, JumpTarget target)
    {
        return AddInstruction(new Instruction
        {
            OpCode = opcode,
            Target = target
        });
    }

    private void Push(bool value)
    {
        AddInstruction(value ? OpCode.PUSHT : OpCode.PUSHF);
    }

    private Instruction Ret() => AddInstruction(OpCode.RET);

    private Instruction Push(BigInteger number)
    {
        if (number >= -1 && number <= 16) return AddInstruction(number == -1 ? OpCode.PUSHM1 : OpCode.PUSH0 + (byte)(int)number);
        Span<byte> buffer = stackalloc byte[32];
        if (!number.TryWriteBytes(buffer, out var bytesWritten, isUnsigned: false, isBigEndian: false))
            throw new ArgumentOutOfRangeException(nameof(number));
        var instruction = bytesWritten switch
        {
            1 => new Instruction
            {
                OpCode = OpCode.PUSHINT8,
                Operand = PadRight(buffer, bytesWritten, 1, number.Sign < 0).ToArray()
            },
            2 => new Instruction
            {
                OpCode = OpCode.PUSHINT16,
                Operand = PadRight(buffer, bytesWritten, 2, number.Sign < 0).ToArray()
            },
            <= 4 => new Instruction
            {
                OpCode = OpCode.PUSHINT32,
                Operand = PadRight(buffer, bytesWritten, 4, number.Sign < 0).ToArray()
            },
            <= 8 => new Instruction
            {
                OpCode = OpCode.PUSHINT64,
                Operand = PadRight(buffer, bytesWritten, 8, number.Sign < 0).ToArray()
            },
            <= 16 => new Instruction
            {
                OpCode = OpCode.PUSHINT128,
                Operand = PadRight(buffer, bytesWritten, 16, number.Sign < 0).ToArray()
            },
            <= 32 => new Instruction
            {
                OpCode = OpCode.PUSHINT256,
                Operand = PadRight(buffer, bytesWritten, 32, number.Sign < 0).ToArray()
            },
            _ => throw new ArgumentOutOfRangeException($"Number too large: {bytesWritten}")
        };
        AddInstruction(instruction);
        return instruction;
    }

    /// <summary>
    /// If all char in the input is no greater than byte.MaxValue == 255, get the byte for each char
    /// If any char in the input is greater than byte.MaxValue == 255, encode in UTF8
    /// This ensures "a\xff\x80\x79\x00" accurately translated to 0x61 0xff 0x80 0x79 0x00
    /// </summary>
    /// <param name="s">String value to push</param>
    /// <returns>Instruction</returns>
    private Instruction Push(string s)
    {
        try
        {// Handle byte-like "\xff\x80\x79\x00..."
         // fails on non-ascii char (> byte.MaxValue == 255) like "悪い文字"
         // fails on long \x, e.g. \x123, \x1234
         // does not fail on ascii chars
            MemoryStream pushed = new();
            BinaryWriter writer = new(pushed);
            foreach (char c in s)
                writer.Write(System.Convert.ToByte(c));
            return Push(pushed.ToArray());
        }
        catch { }
        return Push(Utility.StrictUTF8.GetBytes(s));
        // \xff (and each byte >= \x80) will be decoded to 2 bytes (0xc3 0xbf for \xff) by UTF8 decoder
    }

    private Instruction Push(byte[] data)
    {
        OpCode opcode;
        byte[] buffer;
        switch (data.Length)
        {
            case <= byte.MaxValue:
                opcode = OpCode.PUSHDATA1;
                buffer = new byte[sizeof(byte) + data.Length];
                buffer[0] = (byte)data.Length;
                Buffer.BlockCopy(data, 0, buffer, sizeof(byte), data.Length);
                break;
            case <= ushort.MaxValue:
                opcode = OpCode.PUSHDATA2;
                buffer = new byte[sizeof(ushort) + data.Length];
                BinaryPrimitives.WriteUInt16LittleEndian(buffer, (ushort)data.Length);
                Buffer.BlockCopy(data, 0, buffer, sizeof(ushort), data.Length);
                break;
            default:
                opcode = OpCode.PUSHDATA4;
                buffer = new byte[sizeof(uint) + data.Length];
                BinaryPrimitives.WriteUInt32LittleEndian(buffer, (uint)data.Length);
                Buffer.BlockCopy(data, 0, buffer, sizeof(uint), data.Length);
                break;
        }
        return AddInstruction(new Instruction
        {
            OpCode = opcode,
            Operand = buffer
        });
    }

    private void Push(object? obj)
    {
        switch (obj)
        {
            case bool data:
                Push(data);
                break;
            case byte[] data:
                Push(data);
                break;
            case string data:
                Push(data);
                break;
            case BigInteger data:
                Push(data);
                break;
            case char data:
                Push((ushort)data);
                break;
            case sbyte data:
                Push(data);
                break;
            case byte data:
                Push(data);
                break;
            case short data:
                Push(data);
                break;
            case ushort data:
                Push(data);
                break;
            case int data:
                Push(data);
                break;
            case uint data:
                Push(data);
                break;
            case long data:
                Push(data);
                break;
            case ulong data:
                Push(data);
                break;
            case Enum data:
                Push(BigInteger.Parse(data.ToString("d")));
                break;
            case null:
                AddInstruction(OpCode.PUSHNULL);
                break;
            case float or double or decimal:
                throw new CompilationException(DiagnosticId.FloatingPointNumber, "Floating-point numbers are not supported.");
            default:
                throw new NotSupportedException($"Unsupported constant value: {obj}");
        }
    }

    private Instruction PushDefault(ITypeSymbol type)
    {
        return AddInstruction(type.GetStackItemType() switch
        {// https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/default-values
            VM.Types.StackItemType.Boolean => OpCode.PUSHF,
            VM.Types.StackItemType.Integer => OpCode.PUSH0,
            _ => OpCode.PUSHNULL,
        });
    }

    // Helper method to reverse stack items
    private void ReverseStackItems(int count)
    {
        switch (count)
        {
            case 2:
                AddInstruction(OpCode.SWAP);
                break;
            case 3:
                AddInstruction(OpCode.REVERSE3);
                break;
            case 4:
                AddInstruction(OpCode.REVERSE4);
                break;
            default:
                Push(count);
                AddInstruction(OpCode.REVERSEN);
                break;
        }
    }

    #region LabelsAndTargets

    private JumpTarget AddLabel(ILabelSymbol symbol, bool checkTryStack)
    {
        if (!_labels.TryGetValue(symbol, out JumpTarget? target))
        {
            target = new JumpTarget();
            _labels.Add(symbol, target);
        }
        if (checkTryStack && _tryStack.TryPeek(out ExceptionHandling? result) && result.State != ExceptionHandlingState.Finally)
        {
            result.Labels.Add(symbol);
        }
        return target;
    }

    #endregion

    private void PushSwitchLabels((SwitchLabelSyntax, JumpTarget)[] labels)
    {
        _switchStack.Push(labels);
        if (_tryStack.TryPeek(out ExceptionHandling? result))
            result.SwitchCount++;
    }

    private void PopSwitchLabels()
    {
        _switchStack.Pop();
        if (_tryStack.TryPeek(out ExceptionHandling? result))
            result.SwitchCount--;
    }

    private void PushContinueTarget(JumpTarget target)
    {
        _continueTargets.Push(target);
        if (_tryStack.TryPeek(out ExceptionHandling? result))
            result.ContinueTargetCount++;
    }

    private void PopContinueTarget()
    {
        _continueTargets.Pop();
        if (_tryStack.TryPeek(out ExceptionHandling? result))
            result.ContinueTargetCount--;
    }

    private void PushBreakTarget(JumpTarget target)
    {
        _breakTargets.Push(target);
        if (_tryStack.TryPeek(out ExceptionHandling? result))
            result.BreakTargetCount++;
    }

    private void PopBreakTarget()
    {
        _breakTargets.Pop();
        if (_tryStack.TryPeek(out ExceptionHandling? result))
            result.BreakTargetCount--;
    }

    private static ReadOnlySpan<byte> PadRight(Span<byte> buffer, int dataLength, int padLength, bool negative)
    {
        byte pad = negative ? (byte)0xff : (byte)0;
        for (int x = dataLength; x < padLength; x++)
            buffer[x] = pad;
        return buffer[..padLength];
    }

    /// <summary>
    /// Convert a throw expression or throw statement to OpCodes.
    /// </summary>
    /// <param name="model">The semantic model providing context and information about the Throw.</param>
    /// <param name="exception">The content of exception</param>
    /// <exception cref="CompilationException">Only a single parameter is supported for exceptions.</exception>
    /// <example>
    /// throw statement:
    /// <code>
    /// if (shapeAmount <= 0)
    /// {
    ///     throw new Exception("Amount of shapes must be positive.");
    /// }
    ///</code>
    /// throw expression:
    /// <code>
    /// string a = null;
    /// var b = a ?? throw new Exception();
    /// </code>
    /// <code>
    /// var first = args.Length >= 1 ? args[0] : throw new Exception();
    /// </code>
    /// </example>
    /// <seealso href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/exception-handling-statements#the-throw-expression">The throw expression</seealso>
    /// <seealso href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/exception-handling-statements#the-try-catch-statement">Exception-handling statements - throw</seealso>
    private void Throw(SemanticModel model, ExpressionSyntax? exception)
    {
        if (exception is not null)
        {
            var type = model.GetTypeInfo(exception).Type!;
            if (type.IsSubclassOf(nameof(UncatchableException), includeThisClass: true))
            {
                AddInstruction(OpCode.ABORT);
                return;
            }
        }
        switch (exception)
        {
            case ObjectCreationExpressionSyntax expression:
                switch (expression.ArgumentList?.Arguments.Count)
                {
                    case null:
                    case 0:
                        Push("exception");
                        break;
                    case 1:
                        ConvertExpression(model, expression.ArgumentList.Arguments[0].Expression);
                        break;
                    default:
                        throw new CompilationException(expression, DiagnosticId.MultiplyThrows, "Only a single parameter is supported for exceptions.");
                }
                break;
            case null:
                AccessSlot(OpCode.LDLOC, _exceptionStack.Peek());
                break;
            default:
                ConvertExpression(model, exception);
                break;
        }
        AddInstruction(OpCode.THROW);
    }

    private Instruction IsType(VM.Types.StackItemType type)
    {
        return AddInstruction(new Instruction
        {
            OpCode = OpCode.ISTYPE,
            Operand = [(byte)type]
        });
    }

    private Instruction ChangeType(VM.Types.StackItemType type)
    {
        return AddInstruction(new Instruction
        {
            OpCode = OpCode.CONVERT,
            Operand = [(byte)type]
        });
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// The Neo.Compiler.CSharp is free software distributed under the MIT
4	// software license, see the accompanying file LICENSE in the main directory
5	// of the project or http://www.opensource.org/licenses/mit-license.php
6	// for more details.
7	//
8	// Redistribution and use in source and binary forms with or without
9	// modifications are permitted.
10
11	extern alias scfx;
12	using Microsoft.CodeAnalysis;
13	using Microsoft.CodeAnalysis.CSharp.Syntax;
14	using Neo.VM;
15	using System;
16	using System.Buffers.Binary;
17	using System.Numerics;
18	using scfx::Neo.SmartContract.Framework;
19	using OpCode = Neo.VM.OpCode;
20	using System.IO;
21
22	namespace Neo.Compiler;
23
24	internal partial class MethodConvert
25	{
26	#region Instructions
27	private Instruction AddInstruction(Instruction instruction)
28	{	30,432✔
29	_instructions.Add(instruction);	30,432✔
30	return instruction;	30,432✔
31	}	30,432✔
32
33	private Instruction AddInstruction(OpCode opcode)
34	{	20,495✔
35	return AddInstruction(new Instruction	20,495✔
36	{	20,495✔
37	OpCode = opcode	20,495✔
38	});	20,495✔
39	}	20,495✔
40
41	private SequencePointInserter InsertSequencePoint(SyntaxNodeOrToken? syntax)
42	{	15,336✔
43	return new SequencePointInserter(_instructions, syntax);	15,336✔
44	}	15,336✔
45
46	private SequencePointInserter InsertSequencePoint(SyntaxReference? syntax)
47	{	1,025✔
48	return new SequencePointInserter(_instructions, syntax);	1,025✔
49	}	1,025✔
50
51	private SequencePointInserter InsertSequencePoint(Location? location)
52	{	×
NEW 53	return new SequencePointInserter(_instructions, location);	×
UNCOV 54	}	×
55
56	#endregion
57
58	private Instruction Jump(OpCode opcode, JumpTarget target)
59	{	4,304✔
60	return AddInstruction(new Instruction	4,304✔
61	{	4,304✔
62	OpCode = opcode,	4,304✔
63	Target = target	4,304✔
64	});	4,304✔
65	}	4,304✔
66
67	private void Push(bool value)
68	{	375✔
69	AddInstruction(value ? OpCode.PUSHT : OpCode.PUSHF);	375✔
70	}	375✔
71
72	private Instruction Ret() => AddInstruction(OpCode.RET);	9✔
73
74	private Instruction Push(BigInteger number)
75	{	2,958✔
76	if (number >= -1 && number <= 16) return AddInstruction(number == -1 ? OpCode.PUSHM1 : OpCode.PUSH0 + (byte)(int)number);	4,523✔
77	Span<byte> buffer = stackalloc byte[32];	1,393✔
78	if (!number.TryWriteBytes(buffer, out var bytesWritten, isUnsigned: false, isBigEndian: false))	1,393!
UNCOV 79	throw new ArgumentOutOfRangeException(nameof(number));	×
80	var instruction = bytesWritten switch	1,393!
81	{	1,393✔
82	1 => new Instruction	220✔
83	{	220✔
84	OpCode = OpCode.PUSHINT8,	220✔
85	Operand = PadRight(buffer, bytesWritten, 1, number.Sign < 0).ToArray()	220✔
86	},	220✔
87	2 => new Instruction	80✔
88	{	80✔
89	OpCode = OpCode.PUSHINT16,	80✔
90	Operand = PadRight(buffer, bytesWritten, 2, number.Sign < 0).ToArray()	80✔
91	},	80✔
92	<= 4 => new Instruction	596✔
93	{	596✔
94	OpCode = OpCode.PUSHINT32,	596✔
95	Operand = PadRight(buffer, bytesWritten, 4, number.Sign < 0).ToArray()	596✔
96	},	596✔
97	<= 8 => new Instruction	439✔
98	{	439✔
99	OpCode = OpCode.PUSHINT64,	439✔
100	Operand = PadRight(buffer, bytesWritten, 8, number.Sign < 0).ToArray()	439✔
101	},	439✔
102	<= 16 => new Instruction	58✔
103	{	58✔
104	OpCode = OpCode.PUSHINT128,	58✔
105	Operand = PadRight(buffer, bytesWritten, 16, number.Sign < 0).ToArray()	58✔
106	},	58✔
107	<= 32 => new Instruction	×
108	{	×
109	OpCode = OpCode.PUSHINT256,	×
110	Operand = PadRight(buffer, bytesWritten, 32, number.Sign < 0).ToArray()	×
UNCOV 111	},	×
UNCOV 112	_ => throw new ArgumentOutOfRangeException($"Number too large: {bytesWritten}")	×
113	};	1,393✔
114	AddInstruction(instruction);	1,393✔
115	return instruction;	1,393✔
116	}	2,958✔
117
118	/// <summary>
119	/// If all char in the input is no greater than byte.MaxValue == 255, get the byte for each char
120	/// If any char in the input is greater than byte.MaxValue == 255, encode in UTF8
121	/// This ensures "a\xff\x80\x79\x00" accurately translated to 0x61 0xff 0x80 0x79 0x00
122	/// </summary>
123	/// <param name="s">String value to push</param>
124	/// <returns>Instruction</returns>
125	private Instruction Push(string s)
126	{	595✔
127	try
128	{// Handle byte-like "\xff\x80\x79\x00..."	595✔
129	// fails on non-ascii char (> byte.MaxValue == 255) like "悪い文字"
130	// fails on long \x, e.g. \x123, \x1234
131	// does not fail on ascii chars
132	MemoryStream pushed = new();	595✔
133	BinaryWriter writer = new(pushed);	595✔
134	foreach (char c in s)	12,614✔
135	writer.Write(System.Convert.ToByte(c));	5,415✔
136	return Push(pushed.ToArray());	594✔
137	}
138	catch { }	3✔
139	return Push(Utility.StrictUTF8.GetBytes(s));	1✔
140	// \xff (and each byte >= \x80) will be decoded to 2 bytes (0xc3 0xbf for \xff) by UTF8 decoder
141	}	595✔
142
143	private Instruction Push(byte[] data)
144	{	719✔
145	OpCode opcode;
146	byte[] buffer;
147	switch (data.Length)	719!
148	{
149	case <= byte.MaxValue:
150	opcode = OpCode.PUSHDATA1;	718✔
151	buffer = new byte[sizeof(byte) + data.Length];	718✔
152	buffer[0] = (byte)data.Length;	718✔
153	Buffer.BlockCopy(data, 0, buffer, sizeof(byte), data.Length);	718✔
154	break;	718✔
155	case <= ushort.MaxValue:
156	opcode = OpCode.PUSHDATA2;	1✔
157	buffer = new byte[sizeof(ushort) + data.Length];	1✔
158	BinaryPrimitives.WriteUInt16LittleEndian(buffer, (ushort)data.Length);	1✔
159	Buffer.BlockCopy(data, 0, buffer, sizeof(ushort), data.Length);	1✔
160	break;	1✔
161	default:
162	opcode = OpCode.PUSHDATA4;	×
163	buffer = new byte[sizeof(uint) + data.Length];	×
164	BinaryPrimitives.WriteUInt32LittleEndian(buffer, (uint)data.Length);	×
UNCOV 165	Buffer.BlockCopy(data, 0, buffer, sizeof(uint), data.Length);	×
UNCOV 166	break;	×
167	}
168	return AddInstruction(new Instruction	719✔
169	{	719✔
170	OpCode = opcode,	719✔
171	Operand = buffer	719✔
172	});	719✔
173	}	719✔
174
175	private void Push(object? obj)
176	{	1,659✔
177	switch (obj)	1,659!
178	{
179	case bool data:
180	Push(data);	98✔
181	break;	98✔
182	case byte[] data:
183	Push(data);	6✔
184	break;	6✔
185	case string data:
186	Push(data);	386✔
187	break;	386✔
188	case BigInteger data:
UNCOV 189	Push(data);	×
UNCOV 190	break;	×
191	case char data:
192	Push((ushort)data);	5✔
193	break;	5✔
194	case sbyte data:
195	Push(data);	5✔
196	break;	5✔
197	case byte data:
198	Push(data);	67✔
199	break;	67✔
200	case short data:
201	Push(data);	4✔
202	break;	4✔
203	case ushort data:
204	Push(data);	4✔
205	break;	4✔
206	case int data:
207	Push(data);	913✔
208	break;	913✔
209	case uint data:
210	Push(data);	23✔
211	break;	23✔
212	case long data:
213	Push(data);	6✔
214	break;	6✔
215	case ulong data:
216	Push(data);	3✔
217	break;	3✔
218	case Enum data:
UNCOV 219	Push(BigInteger.Parse(data.ToString("d")));	×
UNCOV 220	break;	×
221	case null:
222	AddInstruction(OpCode.PUSHNULL);	139✔
223	break;	139✔
224	case float or double or decimal:
225	throw new CompilationException(DiagnosticId.FloatingPointNumber, "Floating-point numbers are not supported.");	×
226	default:
UNCOV 227	throw new NotSupportedException($"Unsupported constant value: {obj}");	×
228	}
229	}	1,659✔
230
231	private Instruction PushDefault(ITypeSymbol type)
232	{	129✔
233	return AddInstruction(type.GetStackItemType() switch	129✔
234	{// https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/default-values	129✔
235	VM.Types.StackItemType.Boolean => OpCode.PUSHF,	7✔
236	VM.Types.StackItemType.Integer => OpCode.PUSH0,	62✔
237	_ => OpCode.PUSHNULL,	60✔
238	});	129✔
239	}	129✔
240
241	// Helper method to reverse stack items
242	private void ReverseStackItems(int count)
243	{	13✔
244	switch (count)	13!
245	{
246	case 2:
UNCOV 247	AddInstruction(OpCode.SWAP);	×
UNCOV 248	break;	×
249	case 3:
250	AddInstruction(OpCode.REVERSE3);	13✔
251	break;	13✔
252	case 4:
UNCOV 253	AddInstruction(OpCode.REVERSE4);	×
254	break;	×
255	default:
256	Push(count);	×
UNCOV 257	AddInstruction(OpCode.REVERSEN);	×
UNCOV 258	break;	×
259	}
260	}	13✔
261
262	#region LabelsAndTargets
263
264	private JumpTarget AddLabel(ILabelSymbol symbol, bool checkTryStack)
265	{	4✔
266	if (!_labels.TryGetValue(symbol, out JumpTarget? target))	4✔
267	{	2✔
268	target = new JumpTarget();	2✔
269	_labels.Add(symbol, target);	2✔
270	}	2✔
271	if (checkTryStack && _tryStack.TryPeek(out ExceptionHandling? result) && result.State != ExceptionHandlingState.Finally)	4!
272	{	×
UNCOV 273	result.Labels.Add(symbol);	×
UNCOV 274	}	×
275	return target;	4✔
276	}	4✔
277
278	#endregion
279
280	private void PushSwitchLabels((SwitchLabelSyntax, JumpTarget)[] labels)
281	{	6✔
282	_switchStack.Push(labels);	6✔
283	if (_tryStack.TryPeek(out ExceptionHandling? result))	6!
UNCOV 284	result.SwitchCount++;	×
285	}	6✔
286
287	private void PopSwitchLabels()
288	{	6✔
289	_switchStack.Pop();	6✔
290	if (_tryStack.TryPeek(out ExceptionHandling? result))	6!
UNCOV 291	result.SwitchCount--;	×
292	}	6✔
293
294	private void PushContinueTarget(JumpTarget target)
295	{	62✔
296	_continueTargets.Push(target);	62✔
297	if (_tryStack.TryPeek(out ExceptionHandling? result))	62✔
298	result.ContinueTargetCount++;	2✔
299	}	62✔
300
301	private void PopContinueTarget()
302	{	62✔
303	_continueTargets.Pop();	62✔
304	if (_tryStack.TryPeek(out ExceptionHandling? result))	62✔
305	result.ContinueTargetCount--;	2✔
306	}	62✔
307
308	private void PushBreakTarget(JumpTarget target)
309	{	68✔
310	_breakTargets.Push(target);	68✔
311	if (_tryStack.TryPeek(out ExceptionHandling? result))	68✔
312	result.BreakTargetCount++;	2✔
313	}	68✔
314
315	private void PopBreakTarget()
316	{	68✔
317	_breakTargets.Pop();	68✔
318	if (_tryStack.TryPeek(out ExceptionHandling? result))	68✔
319	result.BreakTargetCount--;	2✔
320	}	68✔
321
322	private static ReadOnlySpan<byte> PadRight(Span<byte> buffer, int dataLength, int padLength, bool negative)
323	{	1,393✔
324	byte pad = negative ? (byte)0xff : (byte)0;	1,393✔
325	for (int x = dataLength; x < padLength; x++)	6,196✔
326	buffer[x] = pad;	1,705✔
327	return buffer[..padLength];	1,393✔
328	}	1,393✔
329
330	/// <summary>
331	/// Convert a throw expression or throw statement to OpCodes.
332	/// </summary>
333	/// <param name="model">The semantic model providing context and information about the Throw.</param>
334	/// <param name="exception">The content of exception</param>
335	/// <exception cref="CompilationException">Only a single parameter is supported for exceptions.</exception>
336	/// <example>
337	/// throw statement:
338	/// <code>
339	/// if (shapeAmount <= 0)
340	/// {
341	/// throw new Exception("Amount of shapes must be positive.");
342	/// }
343	///</code>
344	/// throw expression:
345	/// <code>
346	/// string a = null;
347	/// var b = a ?? throw new Exception();
348	/// </code>
349	/// <code>
350	/// var first = args.Length >= 1 ? args[0] : throw new Exception();
351	/// </code>
352	/// </example>
353	/// <seealso href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/exception-handling-statements#the-throw-expression">The throw expression</seealso>
354	/// <seealso href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/exception-handling-statements#the-try-catch-statement">Exception-handling statements - throw</seealso>
355	private void Throw(SemanticModel model, ExpressionSyntax? exception)
356	{	152✔
357	if (exception is not null)	152✔
358	{	152✔
359	var type = model.GetTypeInfo(exception).Type!;	152✔
360	if (type.IsSubclassOf(nameof(UncatchableException), includeThisClass: true))	152✔
361	{	1✔
362	AddInstruction(OpCode.ABORT);	1✔
363	return;	1✔
364	}
365	}	151✔
366	switch (exception)	151!
367	{
368	case ObjectCreationExpressionSyntax expression:
369	switch (expression.ArgumentList?.Arguments.Count)	151!
370	{
371	case null:
372	case 0:
373	Push("exception");	87✔
374	break;	87✔
375	case 1:
376	ConvertExpression(model, expression.ArgumentList.Arguments[0].Expression);	64✔
377	break;	64✔
378	default:
UNCOV 379	throw new CompilationException(expression, DiagnosticId.MultiplyThrows, "Only a single parameter is supported for exceptions.");	×
380	}
381	break;	151✔
382	case null:
UNCOV 383	AccessSlot(OpCode.LDLOC, _exceptionStack.Peek());	×
384	break;	×
385	default:
UNCOV 386	ConvertExpression(model, exception);	×
UNCOV 387	break;	×
388	}
389	AddInstruction(OpCode.THROW);	151✔
390	}	152✔
391
392	private Instruction IsType(VM.Types.StackItemType type)
393	{	10✔
394	return AddInstruction(new Instruction	10✔
395	{	10✔
396	OpCode = OpCode.ISTYPE,	10✔
397	Operand = [(byte)type]	10✔
398	});	10✔
399	}	10✔
400
401	private Instruction ChangeType(VM.Types.StackItemType type)
402	{	174✔
403	return AddInstruction(new Instruction	174✔
404	{	174✔
405	OpCode = OpCode.CONVERT,	174✔
406	Operand = [(byte)type]	174✔
407	});	174✔
408	}	174✔
409	}

neo-project / neo-devpack-dotnet / 11746327569

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