11859478724

Committed 15 Nov 2024 04:02PM UTC coverage: 74.085% (-0.1%) from 74.193%

Build # 11859478724

Build Type

push

github

Committed by

web-flow

Commit Message

fix default value (#1241)

* default value

* fix default value for property/fields

* fix unnecessary change.

* remove unnecessary

* Update src/Neo.Compiler.CSharp/MethodConvert/PropertyConvert.cs

* revert debug change

* revert debug chhange

* update artifacts

* Update tests/Neo.SmartContract.Framework.UnitTests/Services/BackedStorageTest.cs

* Update tests/Neo.SmartContract.Framework.UnitTests/Services/BackedStorageTest.cs

---------

Co-authored-by: Shargon <shargon@gmail.com>

Run Details

4869 of 7152 branches covered (68.08%)

Branch coverage included in aggregate %.

46 of 47 new or added lines in 4 files covered. (97.87%)

23 existing lines in 1 file now uncovered.

13024 of 17000 relevant lines covered (76.61%)

18072.0 hits per line

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

90.37

/src/Neo.Compiler.CSharp/MethodConvert/SourceConvert.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.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Neo.Compiler;

internal partial class MethodConvert
{
    internal static readonly Regex s_pattern = new(@"^(Neo\.SmartContract\.Framework\.SmartContract|SmartContract\.Framework\.SmartContract|Framework\.SmartContract|SmartContract|Neo\.SmartContract\.Framework\.Nep17Token|Neo\.SmartContract\.Framework\.TokenContract|Neo.SmartContract.Framework.Nep11Token<.*>)$");

    private void ConvertSource(SemanticModel model)
    {
        if (SyntaxNode is null) return;
        for (byte i = 0; i < Symbol.Parameters.Length; i++)
        {
            IParameterSymbol parameter = Symbol.Parameters[i].OriginalDefinition;
            byte index = i;
            if (NeedInstanceConstructor(Symbol)) index++;
            _parameters.Add(parameter, index);

            if (parameter.RefKind == RefKind.Out)
            {
                _context.GetOrAddCapturedStaticField(parameter);
            }
        }
        switch (SyntaxNode)
        {
            case AccessorDeclarationSyntax syntax:
                if (syntax.Body is not null)
                    ConvertStatement(model, syntax.Body);
                else if (syntax.ExpressionBody is not null)
                    ConvertExpression(model, syntax.ExpressionBody.Expression);
                else
                    ConvertNoBody(syntax);
                break;
            case ArrowExpressionClauseSyntax syntax:
                ConvertExpression(model, syntax.Expression);
                break;
            case BaseMethodDeclarationSyntax syntax:
                if (syntax.Body is null)
                {
                    ConvertExpression(model, syntax.ExpressionBody!.Expression);
                    // If the method has no return value,
                    // but the expression body has a return value, example: a+=1;
                    // drop the return value
                    // Problem:
                    //   public void Test() => a+=1; // this will push an int value to the stack
                    //   public void Test() { a+=1; } // this will not push value to the stack
                    if (syntax is MethodDeclarationSyntax methodSyntax
                        && methodSyntax.ReturnType.ToString() == "void"
                        && IsExpressionReturningValue(model, methodSyntax))
                        AddInstruction(OpCode.DROP);
                }
                else
                    ConvertStatement(model, syntax.Body);
                break;

            case SimpleLambdaExpressionSyntax syntax:
                if (syntax.Block is null)
                {
                    ConvertExpression(model, syntax.ExpressionBody!);
                }
                else
                {
                    ConvertStatement(model, syntax.Block);
                }
                break;
            case ParenthesizedLambdaExpressionSyntax syntax:
                if (syntax.Block is null)
                {
                    ConvertExpression(model, syntax.ExpressionBody!);
                }
                else
                {
                    ConvertStatement(model, syntax.Block);
                }
                break;
            case RecordDeclarationSyntax record:
                ConvertDefaultRecordConstruct(record);
                break;
            case ParameterSyntax parameter:
                ConvertRecordPropertyInitMethod(parameter);
                break;
            default:
                throw new CompilationException(SyntaxNode, DiagnosticId.SyntaxNotSupported, $"Unsupported method body:{SyntaxNode}");
        }
        // Set _initSlot to true for non-inline methods
        // This ensures that regular methods will have the INITSLOT instruction added
        _initSlot = !_inline;
    }

    private void ConvertDefaultRecordConstruct(RecordDeclarationSyntax recordDeclarationSyntax)
    {
        if (Symbol.MethodKind == MethodKind.Constructor && Symbol.ContainingType.IsRecord)
        {
            _initSlot = true;
            IFieldSymbol[] fields = Symbol.ContainingType.GetFields();
            for (byte i = 1; i <= fields.Length; i++)
            {
                AddInstruction(OpCode.LDARG0);
                Push(i - 1);
                AccessSlot(OpCode.LDARG, i);
                AddInstruction(OpCode.SETITEM);
            }
        }
    }

    private void ConvertRecordPropertyInitMethod(ParameterSyntax parameter)
    {
        IPropertySymbol property = (IPropertySymbol)Symbol.AssociatedSymbol!;
        ConvertFieldBackedProperty(property);
    }

    private static bool IsExpressionReturningValue(SemanticModel semanticModel, MethodDeclarationSyntax methodDeclaration)
    {
        // Check if it's a method declaration with an expression body
        if (methodDeclaration is { ExpressionBody: not null })
        {
            // Retrieve the expression from the expression body
            var expression = methodDeclaration.ExpressionBody.Expression;

            // Use the semantic model to get the type information of the expression
            var typeInfo = semanticModel.GetTypeInfo(expression);

            // Check if the expression's type is not void, meaning the expression has a return value
            return typeInfo.ConvertedType?.SpecialType != SpecialType.System_Void;
        }

        // For other types of BaseMethodDeclarationSyntax or cases without an expression body, default to no return value
        return false;
    }

    internal static Dictionary<IMethodSymbol, bool> _cacheNeedInstanceConstructor = new Dictionary<IMethodSymbol, bool>(SymbolEqualityComparer.Default);

    /// <summary>
    /// non-static methods needs constructors to be executed
    /// But non-static method in smart contract classes without explicit constructor
    /// does not constructors
    /// Cases we need instance constructors:
    /// 1. non-static smart contract with explicit instance constructor in itself
    /// 2. non-static ordinary method, with explicit instance constructor in itself or its base classes
    /// </summary>
    /// <param name="symbol">A method in class</param>
    /// <returns></returns>
    internal static bool NeedInstanceConstructor(IMethodSymbol symbol)
    {
        if (_cacheNeedInstanceConstructor.TryGetValue(symbol, out bool result))
            return result;
        static bool NeedInstanceConstructorInner(IMethodSymbol symbol)
        {
            if (symbol.IsStatic || symbol.MethodKind == MethodKind.AnonymousFunction)
                return false;
            INamedTypeSymbol? containingClass = symbol.ContainingType;
            if (containingClass == null)
                return false;
            // non-static methods in class
            if ((symbol.MethodKind == MethodKind.Constructor || symbol.MethodKind == MethodKind.SharedConstructor)
                && !CompilationEngine.IsDerivedFromSmartContract(containingClass))
                // is constructor, and is not smart contract
                // typically seen in framework methods
                return true;
            if (containingClass!.Constructors
                .FirstOrDefault(p => p.Parameters.Length == 0 && !p.IsStatic)?
                .DeclaringSyntaxReferences.Length > 0)
                // has explicit constructor
                return true;
            // No explicit non-static constructor in class
            // is smart contract, or is normal non-static method (whether contract or not)
            if (!s_pattern.IsMatch(containingClass?.BaseType?.ToString() ?? string.Empty))
                // class itself is not directly inheriting smart contract; can have more base classes
                return true;
            // is non-static method, directly inheriting smart contract
            if (containingClass!.GetFields().Any(f => !f.IsStatic))
                // has non-static fields
                return true;
            return false;
        }
        return _cacheNeedInstanceConstructor[symbol] = NeedInstanceConstructorInner(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	using Microsoft.CodeAnalysis;
13	using Microsoft.CodeAnalysis.CSharp.Syntax;
14	using Neo.VM;
15	using System.Collections.Generic;
16	using System.Linq;
17	using System.Text.RegularExpressions;
18
19	namespace Neo.Compiler;
20
21	internal partial class MethodConvert
22	{
23	internal static readonly Regex s_pattern = new(@"^(Neo\.SmartContract\.Framework\.SmartContract\|SmartContract\.Framework\.SmartContract\|Framework\.SmartContract\|SmartContract\|Neo\.SmartContract\.Framework\.Nep17Token\|Neo\.SmartContract\.Framework\.TokenContract\|Neo.SmartContract.Framework.Nep11Token<.*>)$");	3✔
24
25	private void ConvertSource(SemanticModel model)
26	{	1,523✔
27	if (SyntaxNode is null) return;	1,573✔
28	for (byte i = 0; i < Symbol.Parameters.Length; i++)	6,038✔
29	{	1,546✔
30	IParameterSymbol parameter = Symbol.Parameters[i].OriginalDefinition;	1,546✔
31	byte index = i;	1,546✔
32	if (NeedInstanceConstructor(Symbol)) index++;	1,599✔
33	_parameters.Add(parameter, index);	1,546✔
34
35	if (parameter.RefKind == RefKind.Out)	1,546✔
36	{	5✔
37	_context.GetOrAddCapturedStaticField(parameter);	5✔
38	}	5✔
39	}	1,546✔
40	switch (SyntaxNode)	1,473!
41	{
42	case AccessorDeclarationSyntax syntax:
43	if (syntax.Body is not null)	55!
44	ConvertStatement(model, syntax.Body);	×
45	else if (syntax.ExpressionBody is not null)	55✔
46	ConvertExpression(model, syntax.ExpressionBody.Expression);	7✔
47	else
48	ConvertNoBody(syntax);	48✔
49	break;	55✔
50	case ArrowExpressionClauseSyntax syntax:
51	ConvertExpression(model, syntax.Expression);	3✔
52	break;	3✔
53	case BaseMethodDeclarationSyntax syntax:
54	if (syntax.Body is null)	1,381✔
55	{	118✔
56	ConvertExpression(model, syntax.ExpressionBody!.Expression);	118✔
57	// If the method has no return value,
58	// but the expression body has a return value, example: a+=1;
59	// drop the return value
60	// Problem:
61	// public void Test() => a+=1; // this will push an int value to the stack
62	// public void Test() { a+=1; } // this will not push value to the stack
63	if (syntax is MethodDeclarationSyntax methodSyntax	118✔
64	&& methodSyntax.ReturnType.ToString() == "void"	118✔
65	&& IsExpressionReturningValue(model, methodSyntax))	118✔
66	AddInstruction(OpCode.DROP);	1✔
67	}	118✔
68	else
69	ConvertStatement(model, syntax.Body);	1,263✔
70	break;	1,377✔
71
72	case SimpleLambdaExpressionSyntax syntax:
73	if (syntax.Block is null)	21!
74	{	21✔
75	ConvertExpression(model, syntax.ExpressionBody!);	21✔
76	}	21✔
77	else
78	{	×
79	ConvertStatement(model, syntax.Block);	×
80	}	×
81	break;	21✔
82	case ParenthesizedLambdaExpressionSyntax syntax:
83	if (syntax.Block is null)	10✔
84	{	9✔
85	ConvertExpression(model, syntax.ExpressionBody!);	9✔
86	}	9✔
87	else
88	{	1✔
89	ConvertStatement(model, syntax.Block);	1✔
90	}	1✔
91	break;	10✔
92	case RecordDeclarationSyntax record:
93	ConvertDefaultRecordConstruct(record);	1✔
94	break;	1✔
95	case ParameterSyntax parameter:
96	ConvertRecordPropertyInitMethod(parameter);	2✔
97	break;	2✔
98	default:
99	throw new CompilationException(SyntaxNode, DiagnosticId.SyntaxNotSupported, $"Unsupported method body:{SyntaxNode}");	×
100	}
101	// Set _initSlot to true for non-inline methods
102	// This ensures that regular methods will have the INITSLOT instruction added
103	_initSlot = !_inline;	1,469✔
104	}	1,519✔
105
106	private void ConvertDefaultRecordConstruct(RecordDeclarationSyntax recordDeclarationSyntax)
107	{	1✔
108	if (Symbol.MethodKind == MethodKind.Constructor && Symbol.ContainingType.IsRecord)	1!
109	{	1✔
110	_initSlot = true;	1✔
111	IFieldSymbol[] fields = Symbol.ContainingType.GetFields();	1✔
112	for (byte i = 1; i <= fields.Length; i++)	6✔
113	{	2✔
114	AddInstruction(OpCode.LDARG0);	2✔
115	Push(i - 1);	2✔
116	AccessSlot(OpCode.LDARG, i);	2✔
117	AddInstruction(OpCode.SETITEM);	2✔
118	}	2✔
119	}	1✔
120	}	1✔
121
122	private void ConvertRecordPropertyInitMethod(ParameterSyntax parameter)
123	{	2✔
124	IPropertySymbol property = (IPropertySymbol)Symbol.AssociatedSymbol!;	2✔
125	ConvertFieldBackedProperty(property);	2✔
126	}	2✔
127
128	private static bool IsExpressionReturningValue(SemanticModel semanticModel, MethodDeclarationSyntax methodDeclaration)
129	{	4✔
130	// Check if it's a method declaration with an expression body
131	if (methodDeclaration is { ExpressionBody: not null })	4!
132	{	4✔
133	// Retrieve the expression from the expression body
134	var expression = methodDeclaration.ExpressionBody.Expression;	4✔
135
136	// Use the semantic model to get the type information of the expression
137	var typeInfo = semanticModel.GetTypeInfo(expression);	4✔
138
139	// Check if the expression's type is not void, meaning the expression has a return value
140	return typeInfo.ConvertedType?.SpecialType != SpecialType.System_Void;	4!
141	}
142
143	// For other types of BaseMethodDeclarationSyntax or cases without an expression body, default to no return value
144	return false;	×
145	}	4✔
146
147	internal static Dictionary<IMethodSymbol, bool> _cacheNeedInstanceConstructor = new Dictionary<IMethodSymbol, bool>(SymbolEqualityComparer.Default);	3✔
148
149	/// <summary>
150	/// non-static methods needs constructors to be executed
151	/// But non-static method in smart contract classes without explicit constructor
152	/// does not constructors
153	/// Cases we need instance constructors:
154	/// 1. non-static smart contract with explicit instance constructor in itself
155	/// 2. non-static ordinary method, with explicit instance constructor in itself or its base classes
156	/// </summary>
157	/// <param name="symbol">A method in class</param>
158	/// <returns></returns>
159	internal static bool NeedInstanceConstructor(IMethodSymbol symbol)
160	{	7,759✔
161	if (_cacheNeedInstanceConstructor.TryGetValue(symbol, out bool result))	7,759✔
162	return result;	6,010✔
163	static bool NeedInstanceConstructorInner(IMethodSymbol symbol)
164	{	1,749✔
165	if (symbol.IsStatic \|\| symbol.MethodKind == MethodKind.AnonymousFunction)	1,749✔
166	return false;	1,452✔
167	INamedTypeSymbol? containingClass = symbol.ContainingType;	297✔
168	if (containingClass == null)	297!
NEW 169	return false;	×
170	// non-static methods in class
171	if ((symbol.MethodKind == MethodKind.Constructor \|\| symbol.MethodKind == MethodKind.SharedConstructor)	297✔
172	&& !CompilationEngine.IsDerivedFromSmartContract(containingClass))	297✔
173	// is constructor, and is not smart contract
174	// typically seen in framework methods
175	return true;	63✔
176	if (containingClass!.Constructors	234✔
177	.FirstOrDefault(p => p.Parameters.Length == 0 && !p.IsStatic)?	355✔
178	.DeclaringSyntaxReferences.Length > 0)	234✔
179	// has explicit constructor
180	return true;	45✔
181	// No explicit non-static constructor in class
182	// is smart contract, or is normal non-static method (whether contract or not)
183	if (!s_pattern.IsMatch(containingClass?.BaseType?.ToString() ?? string.Empty))	189!
184	// class itself is not directly inheriting smart contract; can have more base classes
185	return true;	132✔
186	// is non-static method, directly inheriting smart contract
187	if (containingClass!.GetFields().Any(f => !f.IsStatic))	72✔
188	// has non-static fields
189	return true;	15✔
190	return false;	42✔
191	}	1,749✔
192	return _cacheNeedInstanceConstructor[symbol] = NeedInstanceConstructorInner(symbol);	1,749✔
193	}	7,759✔
194	}

neo-project / neo-devpack-dotnet / 11859478724

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