11834815299

Committed 14 Nov 2024 09:56AM UTC coverage: 73.944% (-0.1%) from 74.058%

Build # 11834815299

Build Type

Pull #1241

github

Committed by

web-flow

Commit Message

Merge 538cb8533 into 542365a4e

Pull Request Pull Request #1241: fix default value

Run Details

4818 of 7092 branches covered (67.94%)

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.

12899 of 16868 relevant lines covered (76.47%)

17707.39 hits per line

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

59.03

/src/Neo.Compiler.CSharp/MethodConvert/Expression/ObjectCreationExpression.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;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Neo.VM;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;

namespace Neo.Compiler;

internal partial class MethodConvert
{
    private void ConvertObjectCreationExpression(SemanticModel model, BaseObjectCreationExpressionSyntax expression)
    {
        ITypeSymbol type = model.GetTypeInfo(expression).Type!;
        if (type.TypeKind == TypeKind.Delegate)
        {
            ConvertDelegateCreationExpression(model, expression);
            return;
        }
        IMethodSymbol constructor = (IMethodSymbol)model.GetSymbolInfo(expression).Symbol!;
        IReadOnlyList<ArgumentSyntax> arguments = expression.ArgumentList?.Arguments ?? (IReadOnlyList<ArgumentSyntax>)Array.Empty<ArgumentSyntax>();
        if (TryProcessSystemConstructors(model, constructor, arguments))
            return;
        bool needCreateObject = !type.DeclaringSyntaxReferences.IsEmpty && !constructor.IsExtern;
        if (needCreateObject)
        {
            // an optimization to avoid PACK + billions of SETITEM
            if (TryOptimizedObjectCreation(model, expression, type, constructor))
                return;
            CreateObject(model, type, null);
        }
        CallInstanceMethod(model, constructor, needCreateObject, arguments);
        if (expression.Initializer is not null)
        {
            ConvertObjectCreationExpressionInitializer(model, expression.Initializer);
        }
    }

    /// <summary>
    /// Handles new MyClass() { PropertyA = "A", Property2 = 2, } in a GAS-efficient way
    /// Do not initialize MyClass() by PACKing default values and then SETITEM for { PropertyA = "A", Property2 = 2, }
    /// Just PACK the final values when constructor of MyClass is not needed
    /// </summary>
    /// <param name="model"></param>
    /// <param name="expression"></param>
    /// <param name="type"></param>
    /// <param name="constructor"></param>
    /// <returns></returns>
    private bool TryOptimizedObjectCreation(SemanticModel model, BaseObjectCreationExpressionSyntax expression,
        ITypeSymbol type, IMethodSymbol constructor)
    {
        if (expression.Initializer == null || expression.Initializer.IsKind(SyntaxKind.CollectionInitializerExpression))
            return false;
        var (convert, methodCallingConvention) = GetMethodConvertAndCallingConvention(model, constructor);
        if (convert == null || convert.Instructions.Count < 2)
            return false;
        Instruction initslot = convert.Instructions[0];
        Instruction ret = convert.Instructions[1];
        if (initslot.OpCode != OpCode.INITSLOT || initslot.Operand?[0] != 0 || initslot.Operand[1] != 1
            || ret.OpCode != OpCode.RET)
            return false;
        // no constructor needed
        var members = type.GetAllMembers().Where(p => !p.IsStatic).ToArray();
        var fields = members.OfType<IFieldSymbol>().ToArray();
        Dictionary<int, ExpressionSyntax> indexToValue = new();
        foreach (ExpressionSyntax e in expression.Initializer.Expressions)
        {
            if (e is not AssignmentExpressionSyntax ae)
                throw new CompilationException(expression.Initializer, DiagnosticId.SyntaxNotSupported, $"Unsupported initializer: {expression.Initializer}");
            ISymbol symbol = model.GetSymbolInfo(ae.Left).Symbol!;
            if (symbol is not IFieldSymbol field)
                return false;
            int index = Array.IndexOf(field.ContainingType.GetFields(), field);
            indexToValue.Add(index, ae.Right);
        }
        var virtualMethods = members.OfType<IMethodSymbol>().Where(p => p.IsVirtualMethod()).ToArray();
        int needVirtualMethodTable = 0;
        if (!type.IsRecord && virtualMethods.Length > 0)
        {
            needVirtualMethodTable += 1;
            byte vTableIndex = _context.AddVTable(type);
            AccessSlot(OpCode.LDSFLD, vTableIndex);
        }
        for (int i = fields.Length - 1; i >= 0; --i)
            if (indexToValue.TryGetValue(i, out ExpressionSyntax? right))
                ConvertExpression(model, right);
            else
                PushDefault(fields[i].Type);
        Push(fields.Length + needVirtualMethodTable);
        AddInstruction(type.IsValueType || type.IsRecord ? OpCode.PACKSTRUCT : OpCode.PACK);
        return true;
    }

    private void ConvertObjectCreationExpressionInitializer(SemanticModel model, InitializerExpressionSyntax initializer)
    {
        // Handle different types of initializer expressions:
        //
        // ObjectInitializerExpression:
        // Example: new Person { Name = "John", Age = 30 }
        // Used for initializing properties of an object.
        //
        // CollectionInitializerExpression:
        // Example: new List<int> { 1, 2, 3 }
        // Used for initializing collections like lists or sets.
        //
        // ArrayInitializerExpression:
        // Example: new int[] { 1, 2, 3 }
        // Used for initializing arrays.
        //
        // ComplexElementInitializerExpression:
        // Example: new Dictionary<string, int> { { "one", 1 }, { "two", 2 } }
        // Used for initializing complex elements like dictionary entries.
        //
        // NullLiteralExpression:
        // Example: new Person { Name = null }
        // Used when explicitly setting a property to null in an initializer.

        if (initializer.IsKind(SyntaxKind.CollectionInitializerExpression))
        {
            ITypeSymbol type;
            if (initializer.Expressions.Count > 0)
            {
                var firstExpression = initializer.Expressions[0];
                var typeInfo = model.GetTypeInfo(firstExpression);
                type = typeInfo.Type!;
            }
            else
            {
                // Handle empty collection case if necessary
                throw new CompilationException(initializer, DiagnosticId.SyntaxNotSupported, "Cannot determine item type from an empty collection initializer.");
            }

            AddInstruction(OpCode.DROP);
            if (type.SpecialType == SpecialType.System_Byte)
            {
                var values = initializer.Expressions.Select(p => model.GetConstantValue(p)).ToArray();
                if (values.Any(p => !p.HasValue))
                {
                    Push(values.Length);
                    AddInstruction(OpCode.NEWBUFFER);
                    for (var i = 0; i < initializer.Expressions.Count; i++)
                    {
                        AddInstruction(OpCode.DUP);
                        Push(i);
                        ConvertExpression(model, initializer.Expressions[i]);
                        AddInstruction(OpCode.SETITEM);
                    }
                }
                else
                {
                    var data = values.Select(p => (byte)System.Convert.ChangeType(p.Value, typeof(byte))!).ToArray();
                    Push(data);
                    ChangeType(VM.Types.StackItemType.Buffer);
                }
            }
            else
            {
                for (var i = initializer.Expressions.Count - 1; i >= 0; i--)
                    ConvertExpression(model, initializer.Expressions[i]);
                Push(initializer.Expressions.Count);
                AddInstruction(OpCode.PACK);
            }
            return;
        }

        foreach (ExpressionSyntax e in initializer.Expressions)
        {
            if (e is not AssignmentExpressionSyntax ae)
                throw new CompilationException(initializer, DiagnosticId.SyntaxNotSupported, $"Unsupported initializer: {initializer}");
            ISymbol symbol = model.GetSymbolInfo(ae.Left).Symbol!;
            switch (symbol)
            {
                case IFieldSymbol field:
                    AddInstruction(OpCode.DUP);
                    int index = Array.IndexOf(field.ContainingType.GetFields(), field);
                    Push(index);
                    ConvertExpression(model, ae.Right);
                    AddInstruction(OpCode.SETITEM);
                    break;
                case IPropertySymbol property:
                    // Special handling for Map and List initialization is required due to their unique initialization syntax and behavior.
                    // Map and List properties are not defined explicitly like regular types

                    // Examples:
                    // Map: new Map<string, int> { ["key"] = 42 };
                    //      This is equivalent to: map["key"] = 42;
                    // Regular: new MyClass { Property = value };
                    //      This uses the standard property setter.
                    if (property.ContainingType.Name is "Map")
                    {
                        // Duplicate the object reference for Map and List
                        AddInstruction(OpCode.DUP);

                        if (ae.Left is ImplicitElementAccessSyntax elementAccess)
                        {
                            ConvertExpression(model, elementAccess.ArgumentList.Arguments[0].Expression);
                        }
                        else
                        {
                            ConvertExpression(model, ae.Left);
                        }
                        // Convert the value to be assigned (for both Map and List)
                        ConvertExpression(model, ae.Right);
                        AddInstruction(OpCode.SETITEM);
                    }
                    else
                    {
                        // For regular properties:
                        ConvertExpression(model, ae.Right);
                        AddInstruction(OpCode.OVER);
                        CallMethodWithConvention(model, property.SetMethod!, CallingConvention.Cdecl);
                    }
                    break;
                default:
                    throw new CompilationException(ae.Left, DiagnosticId.SyntaxNotSupported, $"Unsupported symbol: {symbol}");
            }
        }
    }

    private void ConvertDelegateCreationExpression(SemanticModel model, BaseObjectCreationExpressionSyntax expression)
    {
        if (expression.ArgumentList!.Arguments.Count != 1)
            throw new CompilationException(expression, DiagnosticId.SyntaxNotSupported, $"Unsupported delegate: {expression}");
        IMethodSymbol symbol = (IMethodSymbol)model.GetSymbolInfo(expression.ArgumentList.Arguments[0].Expression).Symbol!;
        if (!symbol.IsStatic)
            throw new CompilationException(expression, DiagnosticId.NonStaticDelegate, $"Unsupported delegate: {symbol}");
        InvokeMethod(model, 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;
15	using Microsoft.CodeAnalysis.CSharp.Syntax;
16	using Neo.VM;
17	using System;
18	using System.Collections.Generic;
19	using System.Linq;
20	using System.Runtime.InteropServices;
21
22	namespace Neo.Compiler;
23
24	internal partial class MethodConvert
25	{
26	private void ConvertObjectCreationExpression(SemanticModel model, BaseObjectCreationExpressionSyntax expression)
27	{	152✔
28	ITypeSymbol type = model.GetTypeInfo(expression).Type!;	152✔
29	if (type.TypeKind == TypeKind.Delegate)	152✔
30	{	7✔
31	ConvertDelegateCreationExpression(model, expression);	7✔
32	return;	7✔
33	}
34	IMethodSymbol constructor = (IMethodSymbol)model.GetSymbolInfo(expression).Symbol!;	145✔
35	IReadOnlyList<ArgumentSyntax> arguments = expression.ArgumentList?.Arguments ?? (IReadOnlyList<ArgumentSyntax>)Array.Empty<ArgumentSyntax>();	145✔
36	if (TryProcessSystemConstructors(model, constructor, arguments))	145✔
37	return;	4✔
38	bool needCreateObject = !type.DeclaringSyntaxReferences.IsEmpty && !constructor.IsExtern;	141✔
39	if (needCreateObject)	141✔
40	{	42✔
41	// an optimization to avoid PACK + billions of SETITEM
42	if (TryOptimizedObjectCreation(model, expression, type, constructor))	42✔
UNCOV 43	return;	×
44	CreateObject(model, type, null);	42✔
45	}	42✔
46	CallInstanceMethod(model, constructor, needCreateObject, arguments);	141✔
47	if (expression.Initializer is not null)	140✔
48	{	20✔
49	ConvertObjectCreationExpressionInitializer(model, expression.Initializer);	20✔
50	}	20✔
51	}	151✔
52
53	/// <summary>
54	/// Handles new MyClass() { PropertyA = "A", Property2 = 2, } in a GAS-efficient way
55	/// Do not initialize MyClass() by PACKing default values and then SETITEM for { PropertyA = "A", Property2 = 2, }
56	/// Just PACK the final values when constructor of MyClass is not needed
57	/// </summary>
58	/// <param name="model"></param>
59	/// <param name="expression"></param>
60	/// <param name="type"></param>
61	/// <param name="constructor"></param>
62	/// <returns></returns>
63	private bool TryOptimizedObjectCreation(SemanticModel model, BaseObjectCreationExpressionSyntax expression,
64	ITypeSymbol type, IMethodSymbol constructor)
65	{	42✔
66	if (expression.Initializer == null \|\| expression.Initializer.IsKind(SyntaxKind.CollectionInitializerExpression))	42✔
67	return false;	26✔
68	var (convert, methodCallingConvention) = GetMethodConvertAndCallingConvention(model, constructor);	16✔
69	if (convert == null \|\| convert.Instructions.Count < 2)	16!
70	return false;	×
71	Instruction initslot = convert.Instructions[0];	16✔
72	Instruction ret = convert.Instructions[1];	16✔
73	if (initslot.OpCode != OpCode.INITSLOT \|\| initslot.Operand?[0] != 0 \|\| initslot.Operand[1] != 1	16!
74	\|\| ret.OpCode != OpCode.RET)	16✔
75	return false;	16✔
76	// no constructor needed
UNCOV 77	var members = type.GetAllMembers().Where(p => !p.IsStatic).ToArray();	×
UNCOV 78	var fields = members.OfType<IFieldSymbol>().ToArray();	×
UNCOV 79	Dictionary<int, ExpressionSyntax> indexToValue = new();	×
UNCOV 80	foreach (ExpressionSyntax e in expression.Initializer.Expressions)	×
UNCOV 81	{	×
UNCOV 82	if (e is not AssignmentExpressionSyntax ae)	×
83	throw new CompilationException(expression.Initializer, DiagnosticId.SyntaxNotSupported, $"Unsupported initializer: {expression.Initializer}");	×
UNCOV 84	ISymbol symbol = model.GetSymbolInfo(ae.Left).Symbol!;	×
UNCOV 85	if (symbol is not IFieldSymbol field)	×
UNCOV 86	return false;	×
UNCOV 87	int index = Array.IndexOf(field.ContainingType.GetFields(), field);	×
UNCOV 88	indexToValue.Add(index, ae.Right);	×
UNCOV 89	}	×
UNCOV 90	var virtualMethods = members.OfType<IMethodSymbol>().Where(p => p.IsVirtualMethod()).ToArray();	×
UNCOV 91	int needVirtualMethodTable = 0;	×
UNCOV 92	if (!type.IsRecord && virtualMethods.Length > 0)	×
93	{	×
94	needVirtualMethodTable += 1;	×
95	byte vTableIndex = _context.AddVTable(type);	×
96	AccessSlot(OpCode.LDSFLD, vTableIndex);	×
97	}	×
UNCOV 98	for (int i = fields.Length - 1; i >= 0; --i)	×
UNCOV 99	if (indexToValue.TryGetValue(i, out ExpressionSyntax? right))	×
UNCOV 100	ConvertExpression(model, right);	×
101	else
UNCOV 102	PushDefault(fields[i].Type);	×
UNCOV 103	Push(fields.Length + needVirtualMethodTable);	×
UNCOV 104	AddInstruction(type.IsValueType \|\| type.IsRecord ? OpCode.PACKSTRUCT : OpCode.PACK);	×
UNCOV 105	return true;	×
106	}	42✔
107
108	private void ConvertObjectCreationExpressionInitializer(SemanticModel model, InitializerExpressionSyntax initializer)
109	{	22✔
110	// Handle different types of initializer expressions:
111	//
112	// ObjectInitializerExpression:
113	// Example: new Person { Name = "John", Age = 30 }
114	// Used for initializing properties of an object.
115	//
116	// CollectionInitializerExpression:
117	// Example: new List<int> { 1, 2, 3 }
118	// Used for initializing collections like lists or sets.
119	//
120	// ArrayInitializerExpression:
121	// Example: new int[] { 1, 2, 3 }
122	// Used for initializing arrays.
123	//
124	// ComplexElementInitializerExpression:
125	// Example: new Dictionary<string, int> { { "one", 1 }, { "two", 2 } }
126	// Used for initializing complex elements like dictionary entries.
127	//
128	// NullLiteralExpression:
129	// Example: new Person { Name = null }
130	// Used when explicitly setting a property to null in an initializer.
131
132	if (initializer.IsKind(SyntaxKind.CollectionInitializerExpression))	22✔
133	{	1✔
134	ITypeSymbol type;
135	if (initializer.Expressions.Count > 0)	1!
136	{	1✔
137	var firstExpression = initializer.Expressions[0];	1✔
138	var typeInfo = model.GetTypeInfo(firstExpression);	1✔
139	type = typeInfo.Type!;	1✔
140	}	1✔
141	else
142	{	×
143	// Handle empty collection case if necessary
144	throw new CompilationException(initializer, DiagnosticId.SyntaxNotSupported, "Cannot determine item type from an empty collection initializer.");	×
145	}
146
147	AddInstruction(OpCode.DROP);	1✔
148	if (type.SpecialType == SpecialType.System_Byte)	1!
149	{	×
150	var values = initializer.Expressions.Select(p => model.GetConstantValue(p)).ToArray();	×
151	if (values.Any(p => !p.HasValue))	×
152	{	×
153	Push(values.Length);	×
154	AddInstruction(OpCode.NEWBUFFER);	×
155	for (var i = 0; i < initializer.Expressions.Count; i++)	×
156	{	×
157	AddInstruction(OpCode.DUP);	×
158	Push(i);	×
159	ConvertExpression(model, initializer.Expressions[i]);	×
160	AddInstruction(OpCode.SETITEM);	×
161	}	×
162	}	×
163	else
164	{	×
165	var data = values.Select(p => (byte)System.Convert.ChangeType(p.Value, typeof(byte))!).ToArray();	×
166	Push(data);	×
167	ChangeType(VM.Types.StackItemType.Buffer);	×
168	}	×
169	}	×
170	else
171	{	1✔
172	for (var i = initializer.Expressions.Count - 1; i >= 0; i--)	12✔
173	ConvertExpression(model, initializer.Expressions[i]);	5✔
174	Push(initializer.Expressions.Count);	1✔
175	AddInstruction(OpCode.PACK);	1✔
176	}	1✔
177	return;	1✔
178	}
179
180	foreach (ExpressionSyntax e in initializer.Expressions)	137✔
181	{	37✔
182	if (e is not AssignmentExpressionSyntax ae)	37!
183	throw new CompilationException(initializer, DiagnosticId.SyntaxNotSupported, $"Unsupported initializer: {initializer}");	×
184	ISymbol symbol = model.GetSymbolInfo(ae.Left).Symbol!;	37✔
185	switch (symbol)	37!
186	{
187	case IFieldSymbol field:
188	AddInstruction(OpCode.DUP);	12✔
189	int index = Array.IndexOf(field.ContainingType.GetFields(), field);	12✔
190	Push(index);	12✔
191	ConvertExpression(model, ae.Right);	12✔
192	AddInstruction(OpCode.SETITEM);	12✔
193	break;	12✔
194	case IPropertySymbol property:
195	// Special handling for Map and List initialization is required due to their unique initialization syntax and behavior.
196	// Map and List properties are not defined explicitly like regular types
197
198	// Examples:
199	// Map: new Map<string, int> { ["key"] = 42 };
200	// This is equivalent to: map["key"] = 42;
201	// Regular: new MyClass { Property = value };
202	// This uses the standard property setter.
203	if (property.ContainingType.Name is "Map")	25✔
204	{	3✔
205	// Duplicate the object reference for Map and List
206	AddInstruction(OpCode.DUP);	3✔
207
208	if (ae.Left is ImplicitElementAccessSyntax elementAccess)	3!
209	{	3✔
210	ConvertExpression(model, elementAccess.ArgumentList.Arguments[0].Expression);	3✔
211	}	3✔
212	else
213	{	×
214	ConvertExpression(model, ae.Left);	×
215	}	×
216	// Convert the value to be assigned (for both Map and List)
217	ConvertExpression(model, ae.Right);	3✔
218	AddInstruction(OpCode.SETITEM);	3✔
219	}	3✔
220	else
221	{	22✔
222	// For regular properties:
223	ConvertExpression(model, ae.Right);	22✔
224	AddInstruction(OpCode.OVER);	22✔
225	CallMethodWithConvention(model, property.SetMethod!, CallingConvention.Cdecl);	22✔
226	}	22✔
227	break;	25✔
228	default:
229	throw new CompilationException(ae.Left, DiagnosticId.SyntaxNotSupported, $"Unsupported symbol: {symbol}");	×
230	}
231	}	37✔
232	}	22✔
233
234	private void ConvertDelegateCreationExpression(SemanticModel model, BaseObjectCreationExpressionSyntax expression)
235	{	7✔
236	if (expression.ArgumentList!.Arguments.Count != 1)	7!
237	throw new CompilationException(expression, DiagnosticId.SyntaxNotSupported, $"Unsupported delegate: {expression}");	×
238	IMethodSymbol symbol = (IMethodSymbol)model.GetSymbolInfo(expression.ArgumentList.Arguments[0].Expression).Symbol!;	7✔
239	if (!symbol.IsStatic)	7!
240	throw new CompilationException(expression, DiagnosticId.NonStaticDelegate, $"Unsupported delegate: {symbol}");	×
241	InvokeMethod(model, symbol);	7✔
242	}	7✔
243	}

neo-project / neo-devpack-dotnet / 11834815299

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