11772669734

Committed 11 Nov 2024 05:24AM UTC coverage: 74.183% (+0.1%) from 74.058%

Build # 11772669734

Build Type

Pull #1233

github

Committed by

web-flow

Commit Message

Merge 408d28d21 into c3355f2c0

Pull Request Pull Request #1233: add ut for property

Run Details

4834 of 7084 branches covered (68.24%)

Branch coverage included in aggregate %.

21 of 22 new or added lines in 3 files covered. (95.45%)

33 existing lines in 3 files now uncovered.

12941 of 16877 relevant lines covered (76.68%)

17641.53 hits per line

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

84.26

/src/Neo.Compiler.CSharp/MethodConvert/MethodConvert.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.Compiler.Optimizer;
using Neo.Cryptography.ECC;
using Neo.IO;
using Neo.SmartContract;
using Neo.VM;
using Neo.Wallets;
using scfx::Neo.SmartContract.Framework.Attributes;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Numerics;
using System.Runtime.InteropServices;

namespace Neo.Compiler
{
    internal partial class MethodConvert
    {
        #region Fields

        private readonly CompilationContext _context;
        private CallingConvention _callingConvention = CallingConvention.Cdecl;
        private bool _inline;
        private bool _internalInline;
        // _initSlot is a boolean flag that determines whether an INITSLOT instruction
        // should be added at the beginning of the method's bytecode.
        // It's used to allocate space for local variables and parameters in the Neo VM.
        // The _initSlot flag allows the compiler to avoid adding unnecessary INITSLOT
        // instructions for methods that don't need local variables or parameters.
        // It's typically set to false for inline methods or external method calls.
        // By using this flag, the compiler can efficiently manage stack space allocation
        // for method execution in the Neo VM, only allocating space when necessary.
        private bool _initSlot;
        private readonly Dictionary<IParameterSymbol, byte> _parameters = new(SymbolEqualityComparer.Default);
        private readonly List<(ILocalSymbol, byte)> _variableSymbols = new();
        private readonly Dictionary<ILocalSymbol, byte> _localVariables = new(SymbolEqualityComparer.Default);
        private readonly List<byte> _anonymousVariables = new();
        private int _localsCount;
        private readonly Stack<List<ILocalSymbol>> _blockSymbols = new();
        private readonly List<Instruction> _instructions = new();
        private readonly JumpTarget _startTarget = new();
        private readonly Dictionary<ILabelSymbol, JumpTarget> _labels = new(SymbolEqualityComparer.Default);
        private readonly Stack<JumpTarget> _continueTargets = new();
        private readonly Stack<JumpTarget> _breakTargets = new();
        private readonly JumpTarget _returnTarget = new();
        private readonly Stack<ExceptionHandling> _tryStack = new();
        private readonly Stack<byte> _exceptionStack = new();
        private readonly Stack<(SwitchLabelSyntax, JumpTarget)[]> _switchStack = new();
        private readonly Stack<bool> _checkedStack = new();

        #endregion

        #region Properties

        public IMethodSymbol Symbol { get; }
        public SyntaxNode? SyntaxNode { get; private set; }
        public IReadOnlyList<Instruction> Instructions => _instructions;
        public IReadOnlyList<(ILocalSymbol Symbol, byte SlotIndex)> Variables => _variableSymbols;
        public bool IsEmpty => _instructions.Count == 0
            || _instructions is [{ OpCode: OpCode.RET }]
            || _instructions is [{ OpCode: OpCode.INITSLOT }, { OpCode: OpCode.RET }];

        /// <summary>
        /// captured local variable/parameter symbols when converting current method
        /// </summary>
        public HashSet<ISymbol> CapturedLocalSymbols { get; } = new(SymbolEqualityComparer.Default);

        #endregion

        #region Constructors

        public MethodConvert(CompilationContext context, IMethodSymbol symbol)
        {
            this.Symbol = symbol;
            this._context = context;
            this._checkedStack.Push(context.Options.Checked);
        }
        #endregion

        #region Convert

        /// <summary>
        /// This method is responsible for converting a method into a Neo VM bytecode.
        /// </summary>
        /// <param name="model">The semantic model of the method</param>
        public void Convert(SemanticModel model)
        {
            // Step 1: Determine if the method is extern or empty
            // This checks if:
            // a) The method is marked as extern, e.g.:
            //    public static extern int ExternMethod(int arg);
            // b) The containing type (class) of the method has no declaring syntax references
            //    This can happen with partial classes or classes defined in other assemblies
            if (Symbol.IsExtern || Symbol.ContainingType.DeclaringSyntaxReferences.IsEmpty)
            {
                // Step 2a: Handle extern or empty methods
                // This path is taken for:
                // - Methods explicitly marked as extern (see example above)
                // - Methods in classes defined in other assemblies or partial classes, e.g.:
                //   public partial class MyClass
                //   {
                //       // This method might be defined in another file or assembly
                //       public void EmptyMethod();
                //   }
                if (Symbol.Name == "_initialize")
                {
                    // Special handling for _initialize method
                    // This method is used for contract initialization
                    ProcessStaticFields(model);
                    InsertStaticFieldInitialization();
                }
                else
                {
                    // Convert extern method
                    // This usually involves creating a stub or placeholder for the external implementation
                    ConvertExtern();
                }
            }
            else
            {
                // Step 2b: Handle regular methods
                // This path is taken for normal methods with implementations in the current compilation unit
                // These methods require full processing and conversion
                // Example of a regular method:
                // public class MyClass
                // {
                //     public int RegularMethod(int arg)
                //     {
                //         return arg * 2;
                //     }
                // }
                // Set syntax node if available
                if (!Symbol.DeclaringSyntaxReferences.IsEmpty)
                    SyntaxNode = Symbol.DeclaringSyntaxReferences[0].GetSyntax();

                // Step 3: Process method based on its kind
                // This handles special cases for constructors and static constructors
                // Examples:
                // public MyClass() { } // Constructor
                // static MyClass() { } // Static constructor
                InitializeFieldsBasedOnMethodKind(model);

                // Step 4: Validate method name
                // Ensures that method names starting with '_' are valid
                // Example of an invalid method name:
                // public void _invalidMethod() { } // This would throw an exception
                ValidateMethodName();

                // Step 5: Convert modifiers
                // process ModifierAttribute
                var modifiers = ConvertModifier(model).ToArray();

                // Step 6: Convert the main method body
                // This is where the actual method implementation is converted
                ConvertSource(model);

                // Step 7: Insert initialization instructions if needed
                // This includes initializing static fields and local variables
                // This might insert INITSLOT instruction to the beginning of the method
                // Example:
                // static int staticField = 10;
                // public void Method()
                // {
                //     int localVar = 5;
                //     // ... rest of the method
                // }
                InsertInitializationInstructions();

                // Step 8: Process modifiers (exit)
                // Handle any cleanup or additional instructions required by modifiers
                ProcessModifiersExit(model, modifiers);
            }

            // Step 9: Finalize the method
            // Add RET instruction to the end of the method
            // This ensures proper method termination and return instruction
            FinalizeMethod();

            // Step 10: Optimize the instructions if needed
            // Basic optimization to remove unnecessary NOP instructions
            if (_context.Options.Optimize.HasFlag(CompilationOptions.OptimizationType.Basic))
                BasicOptimizer.RemoveNops(_instructions);

            // Step 11: Set the start target
            // Mark the first instruction as the entry point of the method
            _startTarget.Instruction = _instructions[0];
        }

        public void ConvertForward(SemanticModel model, MethodConvert target)
        {
            INamedTypeSymbol type = Symbol.ContainingType;
            CreateObject(model, type, null);
            IMethodSymbol? constructor = type.InstanceConstructors.FirstOrDefault(p => p.Parameters.Length == 0)
                ?? throw new CompilationException(type, DiagnosticId.NoParameterlessConstructor, "The contract class requires a parameterless constructor.");
            CallInstanceMethod(model, constructor, true, Array.Empty<ArgumentSyntax>());
            _returnTarget.Instruction = Jump(OpCode.JMP_L, target._startTarget);
            _startTarget.Instruction = _instructions[0];
        }

        private void ProcessFieldInitializer(SemanticModel model, IFieldSymbol field, Action? preInitialize, Action? postInitialize)
        {
            AttributeData? initialValue = field.GetAttributes().FirstOrDefault(p => p.AttributeClass!.Name == nameof(InitialValueAttribute) || p.AttributeClass!.IsSubclassOf(nameof(InitialValueAttribute)));
            if (initialValue is null)
            {
                EqualsValueClauseSyntax? initializer = null;
                SyntaxNode syntaxNode;
                if (field.DeclaringSyntaxReferences.IsEmpty)
                {
                    // Special handling for string.Empty is required as it lacks an AssociatedSymbol.
                    // Without this check, the method would return prematurely, bypassing necessary processing.
                    if (field.ContainingType.ToString() == "string" && field.Name == "Empty")
                    {
                        preInitialize?.Invoke();
                        Push(string.Empty);
                        postInitialize?.Invoke();
                        return;
                    }

                    if (field.AssociatedSymbol is not IPropertySymbol property) return;
                    syntaxNode = property.DeclaringSyntaxReferences[0].GetSyntax();
                    if (syntaxNode is PropertyDeclarationSyntax syntax)
                    {
                        initializer = syntax.Initializer;
                    }
                }
                else
                {
                    VariableDeclaratorSyntax syntax = (VariableDeclaratorSyntax)field.DeclaringSyntaxReferences[0].GetSyntax();
                    syntaxNode = syntax;
                    initializer = syntax.Initializer;
                }
                if (initializer is null) return;
                model = model.Compilation.GetSemanticModel(syntaxNode.SyntaxTree);
                using (InsertSequencePoint(syntaxNode))
                {
                    preInitialize?.Invoke();
                    ConvertExpression(model, initializer.Value, syntaxNode);
                    postInitialize?.Invoke();
                }
            }
            else
            {
                preInitialize?.Invoke();
                string value = (string)initialValue.ConstructorArguments[0].Value!;
                var attributeName = initialValue.AttributeClass!.Name;
                ContractParameterType parameterType = attributeName switch
                {
                    nameof(InitialValueAttribute) => (ContractParameterType)initialValue.ConstructorArguments[1].Value!,
                    nameof(IntegerAttribute) => ContractParameterType.Integer,
                    nameof(Hash160Attribute) => ContractParameterType.Hash160,
                    nameof(PublicKeyAttribute) => ContractParameterType.PublicKey,
                    nameof(ByteArrayAttribute) => ContractParameterType.ByteArray,
                    nameof(StringAttribute) => ContractParameterType.String,
                    _ => throw new CompilationException(field, DiagnosticId.InvalidInitialValueType, $"Unsupported initial value type: {attributeName}"),
                };

                try
                {
                    switch (parameterType)
                    {
                        case ContractParameterType.String:
                            Push(value);
                            break;
                        case ContractParameterType.Integer:
                            Push(BigInteger.Parse(value));
                            break;
                        case ContractParameterType.ByteArray:
                            Push(value.HexToBytes(true));
                            break;
                        case ContractParameterType.Hash160:
                            Push((UInt160.TryParse(value, out var hash) ? hash : value.ToScriptHash(_context.Options.AddressVersion)).ToArray());
                            break;
                        case ContractParameterType.PublicKey:
                            Push(ECPoint.Parse(value, ECCurve.Secp256r1).EncodePoint(true));
                            break;
                        default:
                            throw new CompilationException(field, DiagnosticId.InvalidInitialValueType, $"Unsupported initial value type: {parameterType}");
                    }
                }
                catch (Exception ex) when (ex is not CompilationException)
                {
                    throw new CompilationException(field, DiagnosticId.InvalidInitialValue, $"Invalid initial value: {value} of type: {parameterType}");
                }
                postInitialize?.Invoke();
            }
        }


        #endregion
    }

    class MethodConvertCollection : KeyedCollection<IMethodSymbol, MethodConvert>
    {
        protected override IMethodSymbol GetKeyForItem(MethodConvert item) => item.Symbol;
    }
}

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
13	using Microsoft.CodeAnalysis;
14	using Microsoft.CodeAnalysis.CSharp.Syntax;
15	using Neo.Compiler.Optimizer;
16	using Neo.Cryptography.ECC;
17	using Neo.IO;
18	using Neo.SmartContract;
19	using Neo.VM;
20	using Neo.Wallets;
21	using scfx::Neo.SmartContract.Framework.Attributes;
22	using System;
23	using System.Collections.Generic;
24	using System.Collections.ObjectModel;
25	using System.Linq;
26	using System.Numerics;
27	using System.Runtime.InteropServices;
28
29	namespace Neo.Compiler
30	{
31	internal partial class MethodConvert
32	{
33	#region Fields
34
35	private readonly CompilationContext _context;
36	private CallingConvention _callingConvention = CallingConvention.Cdecl;	2,101✔
37	private bool _inline;
38	private bool _internalInline;
39	// _initSlot is a boolean flag that determines whether an INITSLOT instruction
40	// should be added at the beginning of the method's bytecode.
41	// It's used to allocate space for local variables and parameters in the Neo VM.
42	// The _initSlot flag allows the compiler to avoid adding unnecessary INITSLOT
43	// instructions for methods that don't need local variables or parameters.
44	// It's typically set to false for inline methods or external method calls.
45	// By using this flag, the compiler can efficiently manage stack space allocation
46	// for method execution in the Neo VM, only allocating space when necessary.
47	private bool _initSlot;
48	private readonly Dictionary<IParameterSymbol, byte> _parameters = new(SymbolEqualityComparer.Default);	2,101✔
49	private readonly List<(ILocalSymbol, byte)> _variableSymbols = new();	2,101✔
50	private readonly Dictionary<ILocalSymbol, byte> _localVariables = new(SymbolEqualityComparer.Default);	2,101✔
51	private readonly List<byte> _anonymousVariables = new();	2,101✔
52	private int _localsCount;
53	private readonly Stack<List<ILocalSymbol>> _blockSymbols = new();	2,101✔
54	private readonly List<Instruction> _instructions = new();	2,101✔
55	private readonly JumpTarget _startTarget = new();	2,101✔
56	private readonly Dictionary<ILabelSymbol, JumpTarget> _labels = new(SymbolEqualityComparer.Default);	2,101✔
57	private readonly Stack<JumpTarget> _continueTargets = new();	2,101✔
58	private readonly Stack<JumpTarget> _breakTargets = new();	2,101✔
59	private readonly JumpTarget _returnTarget = new();	2,101✔
60	private readonly Stack<ExceptionHandling> _tryStack = new();	2,101✔
61	private readonly Stack<byte> _exceptionStack = new();	2,101✔
62	private readonly Stack<(SwitchLabelSyntax, JumpTarget)[]> _switchStack = new();	2,101✔
63	private readonly Stack<bool> _checkedStack = new();	2,101✔
64
65	#endregion
66
67	#region Properties
68
69	public IMethodSymbol Symbol { get; }	46,251✔
70	public SyntaxNode? SyntaxNode { get; private set; }	7,513✔
71	public IReadOnlyList<Instruction> Instructions => _instructions;	14,465✔
72	public IReadOnlyList<(ILocalSymbol Symbol, byte SlotIndex)> Variables => _variableSymbols;	2,349✔
73	public bool IsEmpty => _instructions.Count == 0	6!
74	\|\| _instructions is [{ OpCode: OpCode.RET }]	6✔
75	\|\| _instructions is [{ OpCode: OpCode.INITSLOT }, { OpCode: OpCode.RET }];	6✔
76
77	/// <summary>
78	/// captured local variable/parameter symbols when converting current method
79	/// </summary>
80	public HashSet<ISymbol> CapturedLocalSymbols { get; } = new(SymbolEqualityComparer.Default);	2,152✔
81
82	#endregion
83
84	#region Constructors
85
86	public MethodConvert(CompilationContext context, IMethodSymbol symbol)	2,101✔
87	{	2,101✔
88	this.Symbol = symbol;	2,101✔
89	this._context = context;	2,101✔
90	this._checkedStack.Push(context.Options.Checked);	2,101✔
91	}	2,101✔
92	#endregion
93
94	#region Convert
95
96	/// <summary>
97	/// This method is responsible for converting a method into a Neo VM bytecode.
98	/// </summary>
99	/// <param name="model">The semantic model of the method</param>
100	public void Convert(SemanticModel model)
101	{	2,082✔
102	// Step 1: Determine if the method is extern or empty
103	// This checks if:
104	// a) The method is marked as extern, e.g.:
105	// public static extern int ExternMethod(int arg);
106	// b) The containing type (class) of the method has no declaring syntax references
107	// This can happen with partial classes or classes defined in other assemblies
108	if (Symbol.IsExtern \|\| Symbol.ContainingType.DeclaringSyntaxReferences.IsEmpty)	2,082✔
109	{	567✔
110	// Step 2a: Handle extern or empty methods
111	// This path is taken for:
112	// - Methods explicitly marked as extern (see example above)
113	// - Methods in classes defined in other assemblies or partial classes, e.g.:
114	// public partial class MyClass
115	// {
116	// // This method might be defined in another file or assembly
117	// public void EmptyMethod();
118	// }
119	if (Symbol.Name == "_initialize")	567✔
120	{	130✔
121	// Special handling for _initialize method
122	// This method is used for contract initialization
123	ProcessStaticFields(model);	130✔
124	InsertStaticFieldInitialization();	130✔
125	}	130✔
126	else
127	{	437✔
128	// Convert extern method
129	// This usually involves creating a stub or placeholder for the external implementation
130	ConvertExtern();	437✔
131	}	433✔
132	}	563✔
133	else
134	{	1,515✔
135	// Step 2b: Handle regular methods
136	// This path is taken for normal methods with implementations in the current compilation unit
137	// These methods require full processing and conversion
138	// Example of a regular method:
139	// public class MyClass
140	// {
141	// public int RegularMethod(int arg)
142	// {
143	// return arg * 2;
144	// }
145	// }
146	// Set syntax node if available
147	if (!Symbol.DeclaringSyntaxReferences.IsEmpty)	1,515✔
148	SyntaxNode = Symbol.DeclaringSyntaxReferences[0].GetSyntax();	1,463✔
149
150	// Step 3: Process method based on its kind
151	// This handles special cases for constructors and static constructors
152	// Examples:
153	// public MyClass() { } // Constructor
154	// static MyClass() { } // Static constructor
155	InitializeFieldsBasedOnMethodKind(model);	1,515✔
156
157	// Step 4: Validate method name
158	// Ensures that method names starting with '_' are valid
159	// Example of an invalid method name:
160	// public void _invalidMethod() { } // This would throw an exception
161	ValidateMethodName();	1,515✔
162
163	// Step 5: Convert modifiers
164	// process ModifierAttribute
165	var modifiers = ConvertModifier(model).ToArray();	1,515✔
166
167	// Step 6: Convert the main method body
168	// This is where the actual method implementation is converted
169	ConvertSource(model);	1,515✔
170
171	// Step 7: Insert initialization instructions if needed
172	// This includes initializing static fields and local variables
173	// This might insert INITSLOT instruction to the beginning of the method
174	// Example:
175	// static int staticField = 10;
176	// public void Method()
177	// {
178	// int localVar = 5;
179	// // ... rest of the method
180	// }
181	InsertInitializationInstructions();	1,511✔
182
183	// Step 8: Process modifiers (exit)
184	// Handle any cleanup or additional instructions required by modifiers
185	ProcessModifiersExit(model, modifiers);	1,511✔
186	}	1,511✔
187
188	// Step 9: Finalize the method
189	// Add RET instruction to the end of the method
190	// This ensures proper method termination and return instruction
191	FinalizeMethod();	2,074✔
192
193	// Step 10: Optimize the instructions if needed
194	// Basic optimization to remove unnecessary NOP instructions
195	if (_context.Options.Optimize.HasFlag(CompilationOptions.OptimizationType.Basic))	2,074✔
196	BasicOptimizer.RemoveNops(_instructions);	2,060✔
197
198	// Step 11: Set the start target
199	// Mark the first instruction as the entry point of the method
200	_startTarget.Instruction = _instructions[0];	2,074✔
201	}	2,074✔
202
203	public void ConvertForward(SemanticModel model, MethodConvert target)
204	{	19✔
205	INamedTypeSymbol type = Symbol.ContainingType;	19✔
206	CreateObject(model, type, null);	19✔
207	IMethodSymbol? constructor = type.InstanceConstructors.FirstOrDefault(p => p.Parameters.Length == 0)	38!
208	?? throw new CompilationException(type, DiagnosticId.NoParameterlessConstructor, "The contract class requires a parameterless constructor.");	19✔
209	CallInstanceMethod(model, constructor, true, Array.Empty<ArgumentSyntax>());	19✔
210	_returnTarget.Instruction = Jump(OpCode.JMP_L, target._startTarget);	19✔
211	_startTarget.Instruction = _instructions[0];	19✔
212	}	19✔
213
214	private void ProcessFieldInitializer(SemanticModel model, IFieldSymbol field, Action? preInitialize, Action? postInitialize)
215	{	116✔
216	AttributeData? initialValue = field.GetAttributes().FirstOrDefault(p => p.AttributeClass!.Name == nameof(InitialValueAttribute) \|\| p.AttributeClass!.IsSubclassOf(nameof(InitialValueAttribute)));	127!
217	if (initialValue is null)	116✔
218	{	107✔
219	EqualsValueClauseSyntax? initializer = null;	107✔
220	SyntaxNode syntaxNode;
221	if (field.DeclaringSyntaxReferences.IsEmpty)	107✔
222	{	33✔
223	// Special handling for string.Empty is required as it lacks an AssociatedSymbol.
224	// Without this check, the method would return prematurely, bypassing necessary processing.
225	if (field.ContainingType.ToString() == "string" && field.Name == "Empty")	33!
UNCOV 226	{	×
UNCOV 227	preInitialize?.Invoke();	×
228	Push(string.Empty);	×
229	postInitialize?.Invoke();	×
230	return;	×
231	}
232
233	if (field.AssociatedSymbol is not IPropertySymbol property) return;	35✔
234	syntaxNode = property.DeclaringSyntaxReferences[0].GetSyntax();	31✔
235	if (syntaxNode is PropertyDeclarationSyntax syntax)	31✔
236	{	29✔
237	initializer = syntax.Initializer;	29✔
238	}	29✔
239	}	31✔
240	else
241	{	74✔
242	VariableDeclaratorSyntax syntax = (VariableDeclaratorSyntax)field.DeclaringSyntaxReferences[0].GetSyntax();	74✔
243	syntaxNode = syntax;	74✔
244	initializer = syntax.Initializer;	74✔
245	}	74✔
246	if (initializer is null) return;	169✔
247	model = model.Compilation.GetSemanticModel(syntaxNode.SyntaxTree);	41✔
248	using (InsertSequencePoint(syntaxNode))	41✔
249	{	41✔
250	preInitialize?.Invoke();	41✔
251	ConvertExpression(model, initializer.Value, syntaxNode);	41✔
252	postInitialize?.Invoke();	41✔
253	}	41✔
254	}	41✔
255	else
256	{	9✔
257	preInitialize?.Invoke();	9!
258	string value = (string)initialValue.ConstructorArguments[0].Value!;	9✔
259	var attributeName = initialValue.AttributeClass!.Name;	9✔
260	ContractParameterType parameterType = attributeName switch	9!
261	{	9✔
UNCOV 262	nameof(InitialValueAttribute) => (ContractParameterType)initialValue.ConstructorArguments[1].Value!,	×
263	nameof(IntegerAttribute) => ContractParameterType.Integer,	1✔
264	nameof(Hash160Attribute) => ContractParameterType.Hash160,	3✔
265	nameof(PublicKeyAttribute) => ContractParameterType.PublicKey,	1✔
266	nameof(ByteArrayAttribute) => ContractParameterType.ByteArray,	4✔
267	nameof(StringAttribute) => ContractParameterType.String,	×
268	_ => throw new CompilationException(field, DiagnosticId.InvalidInitialValueType, $"Unsupported initial value type: {attributeName}"),	×
269	};	9✔
270
271	try
272	{	9✔
273	switch (parameterType)	9!
274	{
275	case ContractParameterType.String:
276	Push(value);	×
277	break;	×
278	case ContractParameterType.Integer:
279	Push(BigInteger.Parse(value));	1✔
280	break;	1✔
281	case ContractParameterType.ByteArray:
282	Push(value.HexToBytes(true));	4✔
283	break;	4✔
284	case ContractParameterType.Hash160:
285	Push((UInt160.TryParse(value, out var hash) ? hash : value.ToScriptHash(_context.Options.AddressVersion)).ToArray());	3!
286	break;	3✔
287	case ContractParameterType.PublicKey:
288	Push(ECPoint.Parse(value, ECCurve.Secp256r1).EncodePoint(true));	1✔
289	break;	1✔
290	default:
UNCOV 291	throw new CompilationException(field, DiagnosticId.InvalidInitialValueType, $"Unsupported initial value type: {parameterType}");	×
292	}
293	}	9✔
UNCOV 294	catch (Exception ex) when (ex is not CompilationException)	×
295	{	×
UNCOV 296	throw new CompilationException(field, DiagnosticId.InvalidInitialValue, $"Invalid initial value: {value} of type: {parameterType}");	×
297	}
298	postInitialize?.Invoke();	9✔
299	}	9✔
300	}	116✔
301
302
303	#endregion
304	}
305
306	class MethodConvertCollection : KeyedCollection<IMethodSymbol, MethodConvert>
307	{
308	protected override IMethodSymbol GetKeyForItem(MethodConvert item) => item.Symbol;	2,215✔
309	}
310	}

neo-project / neo-devpack-dotnet / 11772669734

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