11746648589

Committed 08 Nov 2024 05:23PM UTC coverage: 74.081% (+0.03%) from 74.055%

Build # 11746648589

Build Type

Pull #1235

github

Committed by

web-flow

Commit Message

Merge 078643964 into e5c8d243b

Pull Request Pull Request #1235: Compiler source info into `DebugInfo`

Run Details

4832 of 7092 branches covered (68.13%)

Branch coverage included in aggregate %.

62 of 65 new or added lines in 6 files covered. (95.38%)

92 existing lines in 2 files now uncovered.

12946 of 16906 relevant lines covered (76.58%)

17668.37 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 scfx::Neo.SmartContract.Framework;
using System;
using System.Buffers.Binary;
using System.IO;
using System.Numerics;
using System.Runtime.CompilerServices;
using OpCode = Neo.VM.OpCode;

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, [CallerLineNumber] int lineNumber = 0, [CallerFilePath] string? callerPath = null, [CallerMemberName] string? caller = null)
    {
        return new SequencePointInserter(_instructions, syntax, LocationInformation.BuildCompilerLocation(lineNumber, callerPath, caller));
    }

    private SequencePointInserter InsertSequencePoint(SyntaxReference? syntax, [CallerLineNumber] int lineNumber = 0, [CallerFilePath] string? callerPath = null, [CallerMemberName] string? caller = null)
    {
        return new SequencePointInserter(_instructions, syntax, LocationInformation.BuildCompilerLocation(lineNumber, callerPath, caller));
    }

    private SequencePointInserter InsertSequencePoint(Location? location, [CallerLineNumber] int lineNumber = 0, [CallerFilePath] string? callerPath = null, [CallerMemberName] string? caller = null)
    {
        return new SequencePointInserter(_instructions, location, LocationInformation.BuildCompilerLocation(lineNumber, callerPath, caller));
    }

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

neo-project / neo-devpack-dotnet / 11746648589

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