Skip to content

Commit ed4942a

Browse files
Jim8yJim8y
authored
[Compiler] Further Split long expression files (#884)
* add comments to expression * change namespace style * remove * update neo to latest * adapt to latest neo version * dotnet format * Apply suggestions from code review Clean empty lines * remove comments * update neo * Update BinaryExpression.cs * Update src/Neo.Compiler.CSharp/MethodConvert/Expression/CastExpression.cs * Update src/Neo.Compiler.CSharp/MethodConvert/Expression/CastExpression.cs * merge master --------- Co-authored-by: Shargon <[email protected]>
1 parent 2263f94 commit ed4942a

9 files changed

+1003
-902
lines changed

‎neo‎

‎neo-devpack-dotnet.sln‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.SmartContract.Testing",
3636
EndProject
3737
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.SmartContract.Testing.UnitTests", "tests\Neo.SmartContract.Testing.UnitTests\Neo.SmartContract.Testing.UnitTests.csproj", "{B772B8A9-9362-4C6F-A6D3-2A4138439B2C}"
3838
EndProject
39+
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Neo.Extensions", "neo\src\Neo.Extensions\Neo.Extensions.csproj", "{E5EFB018-810D-4297-8921-940FA0B1ED97}"
40+
EndProject
41+
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Neo.IO", "neo\src\Neo.IO\Neo.IO.csproj", "{C2B7927F-AAA5-432A-8E76-B5080BD7EFB9}"
42+
EndProject
3943
Global
4044
GlobalSection(SolutionConfigurationPlatforms) = preSolution
4145
Debug|Any CPU = Debug|Any CPU
@@ -98,6 +102,14 @@ Global
98102
{B772B8A9-9362-4C6F-A6D3-2A4138439B2C}.Debug|Any CPU.Build.0 = Debug|Any CPU
99103
{B772B8A9-9362-4C6F-A6D3-2A4138439B2C}.Release|Any CPU.ActiveCfg = Release|Any CPU
100104
{B772B8A9-9362-4C6F-A6D3-2A4138439B2C}.Release|Any CPU.Build.0 = Release|Any CPU
105+
{E5EFB018-810D-4297-8921-940FA0B1ED97}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
106+
{E5EFB018-810D-4297-8921-940FA0B1ED97}.Debug|Any CPU.Build.0 = Debug|Any CPU
107+
{E5EFB018-810D-4297-8921-940FA0B1ED97}.Release|Any CPU.ActiveCfg = Release|Any CPU
108+
{E5EFB018-810D-4297-8921-940FA0B1ED97}.Release|Any CPU.Build.0 = Release|Any CPU
109+
{C2B7927F-AAA5-432A-8E76-B5080BD7EFB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
110+
{C2B7927F-AAA5-432A-8E76-B5080BD7EFB9}.Debug|Any CPU.Build.0 = Debug|Any CPU
111+
{C2B7927F-AAA5-432A-8E76-B5080BD7EFB9}.Release|Any CPU.ActiveCfg = Release|Any CPU
112+
{C2B7927F-AAA5-432A-8E76-B5080BD7EFB9}.Release|Any CPU.Build.0 = Release|Any CPU
101113
EndGlobalSection
102114
GlobalSection(SolutionProperties) = preSolution
103115
HideSolutionNode = FALSE
@@ -117,6 +129,8 @@ Global
117129
{D6D53889-5A10-46A4-BA66-E78B56EC1881} = {49D5873D-7B38-48A5-B853-85146F032091}
118130
{648DCE6F-A0BA-4032-951B-20CF5BBFD998} = {79389FC0-C621-4CEA-AD2B-6074C32E7BCA}
119131
{B772B8A9-9362-4C6F-A6D3-2A4138439B2C} = {D5266066-0AFD-44D5-A83E-2F73668A63C8}
132+
{E5EFB018-810D-4297-8921-940FA0B1ED97} = {49D5873D-7B38-48A5-B853-85146F032091}
133+
{C2B7927F-AAA5-432A-8E76-B5080BD7EFB9} = {49D5873D-7B38-48A5-B853-85146F032091}
120134
EndGlobalSection
121135
GlobalSection(ExtensibilityGlobals) = postSolution
122136
SolutionGuid = {6DA935E1-C674-4364-B087-F1B511B79215}

‎src/Neo.Compiler.CSharp/MethodConvert/Expression/AssignmentExpression.CoalesceAssignment.cs‎

Lines changed: 300 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,300 @@
1+
// Copyright (C) 2015-2023 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.Runtime.InteropServices;
19+
20+
namespace Neo.Compiler;
21+
22+
partial class MethodConvert
23+
{
24+
private void ConvertCoalesceAssignmentExpression(SemanticModel model, AssignmentExpressionSyntax expression)
25+
{
26+
switch (expression.Left)
27+
{
28+
case ElementAccessExpressionSyntax left:
29+
ConvertElementAccessCoalesceAssignment(model, left, expression.Right);
30+
break;
31+
case IdentifierNameSyntax left:
32+
ConvertIdentifierNameCoalesceAssignment(model, left, expression.Right);
33+
break;
34+
case MemberAccessExpressionSyntax left:
35+
ConvertMemberAccessCoalesceAssignment(model, left, expression.Right);
36+
break;
37+
default:
38+
throw new CompilationException(expression, DiagnosticId.SyntaxNotSupported, $"Unsupported coalesce assignment: {expression}");
39+
}
40+
}
41+
42+
private void ConvertElementAccessCoalesceAssignment(SemanticModel model, ElementAccessExpressionSyntax left, ExpressionSyntax right)
43+
{
44+
if (left.ArgumentList.Arguments.Count != 1)
45+
throw new CompilationException(left.ArgumentList, DiagnosticId.MultidimensionalArray, $"Unsupported array rank: {left.ArgumentList.Arguments}");
46+
JumpTarget assignmentTarget = new();
47+
JumpTarget endTarget = new();
48+
if (model.GetSymbolInfo(left).Symbol is IPropertySymbol property)
49+
{
50+
ConvertExpression(model, left.Expression);
51+
ConvertExpression(model, left.ArgumentList.Arguments[0].Expression);
52+
AddInstruction(OpCode.OVER);
53+
AddInstruction(OpCode.OVER);
54+
Call(model, property.GetMethod!, CallingConvention.StdCall);
55+
AddInstruction(OpCode.DUP);
56+
AddInstruction(OpCode.ISNULL);
57+
Jump(OpCode.JMPIF_L, assignmentTarget);
58+
AddInstruction(OpCode.NIP);
59+
AddInstruction(OpCode.NIP);
60+
Jump(OpCode.JMP_L, endTarget);
61+
assignmentTarget.Instruction = AddInstruction(OpCode.DROP);
62+
ConvertExpression(model, right);
63+
AddInstruction(OpCode.DUP);
64+
AddInstruction(OpCode.REVERSE4);
65+
Call(model, property.SetMethod!, CallingConvention.Cdecl);
66+
}
67+
else
68+
{
69+
ConvertExpression(model, left.Expression);
70+
ConvertExpression(model, left.ArgumentList.Arguments[0].Expression);
71+
AddInstruction(OpCode.OVER);
72+
AddInstruction(OpCode.OVER);
73+
AddInstruction(OpCode.PICKITEM);
74+
AddInstruction(OpCode.ISNULL);
75+
Jump(OpCode.JMPIF_L, assignmentTarget);
76+
AddInstruction(OpCode.PICKITEM);
77+
Jump(OpCode.JMP_L, endTarget);
78+
assignmentTarget.Instruction = AddInstruction(OpCode.NOP);
79+
ConvertExpression(model, right);
80+
AddInstruction(OpCode.DUP);
81+
AddInstruction(OpCode.REVERSE4);
82+
AddInstruction(OpCode.REVERSE3);
83+
AddInstruction(OpCode.SETITEM);
84+
}
85+
endTarget.Instruction = AddInstruction(OpCode.NOP);
86+
}
87+
88+
private void ConvertIdentifierNameCoalesceAssignment(SemanticModel model, IdentifierNameSyntax left, ExpressionSyntax right)
89+
{
90+
ISymbol symbol = model.GetSymbolInfo(left).Symbol!;
91+
switch (symbol)
92+
{
93+
case IFieldSymbol field:
94+
ConvertFieldIdentifierNameCoalesceAssignment(model, field, right);
95+
break;
96+
case ILocalSymbol local:
97+
ConvertLocalIdentifierNameCoalesceAssignment(model, local, right);
98+
break;
99+
case IParameterSymbol parameter:
100+
ConvertParameterIdentifierNameCoalesceAssignment(model, parameter, right);
101+
break;
102+
case IPropertySymbol property:
103+
ConvertPropertyIdentifierNameCoalesceAssignment(model, property, right);
104+
break;
105+
default:
106+
throw new CompilationException(left, DiagnosticId.SyntaxNotSupported, $"Unsupported symbol: {symbol}");
107+
}
108+
}
109+
110+
private void ConvertMemberAccessCoalesceAssignment(SemanticModel model, MemberAccessExpressionSyntax left, ExpressionSyntax right)
111+
{
112+
ISymbol symbol = model.GetSymbolInfo(left).Symbol!;
113+
switch (symbol)
114+
{
115+
case IFieldSymbol field:
116+
ConvertFieldMemberAccessCoalesceAssignment(model, left, right, field);
117+
break;
118+
case IPropertySymbol property:
119+
ConvertPropertyMemberAccessCoalesceAssignment(model, left, right, property);
120+
break;
121+
default:
122+
throw new CompilationException(left, DiagnosticId.SyntaxNotSupported, $"Unsupported symbol: {symbol}");
123+
}
124+
}
125+
126+
private void ConvertFieldIdentifierNameCoalesceAssignment(SemanticModel model, IFieldSymbol left, ExpressionSyntax right)
127+
{
128+
JumpTarget assignmentTarget = new();
129+
JumpTarget endTarget = new();
130+
if (left.IsStatic)
131+
{
132+
byte index = context.AddStaticField(left);
133+
AccessSlot(OpCode.LDSFLD, index);
134+
AddInstruction(OpCode.ISNULL);
135+
Jump(OpCode.JMPIF_L, assignmentTarget);
136+
AccessSlot(OpCode.LDSFLD, index);
137+
Jump(OpCode.JMP_L, endTarget);
138+
assignmentTarget.Instruction = AddInstruction(OpCode.NOP);
139+
ConvertExpression(model, right);
140+
AddInstruction(OpCode.DUP);
141+
AccessSlot(OpCode.STSFLD, index);
142+
}
143+
else
144+
{
145+
int index = Array.IndexOf(left.ContainingType.GetFields(), left);
146+
AddInstruction(OpCode.LDARG0);
147+
Push(index);
148+
AddInstruction(OpCode.OVER);
149+
AddInstruction(OpCode.OVER);
150+
AddInstruction(OpCode.PICKITEM);
151+
AddInstruction(OpCode.ISNULL);
152+
Jump(OpCode.JMPIF_L, assignmentTarget);
153+
AddInstruction(OpCode.PICKITEM);
154+
Jump(OpCode.JMP_L, endTarget);
155+
assignmentTarget.Instruction = AddInstruction(OpCode.NOP);
156+
ConvertExpression(model, right);
157+
AddInstruction(OpCode.DUP);
158+
AddInstruction(OpCode.REVERSE4);
159+
AddInstruction(OpCode.REVERSE3);
160+
AddInstruction(OpCode.SETITEM);
161+
}
162+
endTarget.Instruction = AddInstruction(OpCode.NOP);
163+
}
164+
165+
private void ConvertLocalIdentifierNameCoalesceAssignment(SemanticModel model, ILocalSymbol left, ExpressionSyntax right)
166+
{
167+
JumpTarget assignmentTarget = new();
168+
JumpTarget endTarget = new();
169+
byte index = _localVariables[left];
170+
AccessSlot(OpCode.LDLOC, index);
171+
AddInstruction(OpCode.ISNULL);
172+
Jump(OpCode.JMPIF_L, assignmentTarget);
173+
AccessSlot(OpCode.LDLOC, index);
174+
Jump(OpCode.JMP_L, endTarget);
175+
assignmentTarget.Instruction = AddInstruction(OpCode.NOP);
176+
ConvertExpression(model, right);
177+
AddInstruction(OpCode.DUP);
178+
AccessSlot(OpCode.STLOC, index);
179+
endTarget.Instruction = AddInstruction(OpCode.NOP);
180+
}
181+
182+
private void ConvertParameterIdentifierNameCoalesceAssignment(SemanticModel model, IParameterSymbol left, ExpressionSyntax right)
183+
{
184+
JumpTarget assignmentTarget = new();
185+
JumpTarget endTarget = new();
186+
byte index = _parameters[left];
187+
AccessSlot(OpCode.LDARG, index);
188+
AddInstruction(OpCode.ISNULL);
189+
Jump(OpCode.JMPIF_L, assignmentTarget);
190+
AccessSlot(OpCode.LDARG, index);
191+
Jump(OpCode.JMP_L, endTarget);
192+
assignmentTarget.Instruction = AddInstruction(OpCode.NOP);
193+
ConvertExpression(model, right);
194+
AddInstruction(OpCode.DUP);
195+
AccessSlot(OpCode.STARG, index);
196+
endTarget.Instruction = AddInstruction(OpCode.NOP);
197+
}
198+
199+
private void ConvertPropertyIdentifierNameCoalesceAssignment(SemanticModel model, IPropertySymbol left, ExpressionSyntax right)
200+
{
201+
JumpTarget endTarget = new();
202+
if (left.IsStatic)
203+
{
204+
Call(model, left.GetMethod!);
205+
AddInstruction(OpCode.DUP);
206+
AddInstruction(OpCode.ISNULL);
207+
Jump(OpCode.JMPIFNOT_L, endTarget);
208+
AddInstruction(OpCode.DROP);
209+
ConvertExpression(model, right);
210+
AddInstruction(OpCode.DUP);
211+
Call(model, left.SetMethod!);
212+
}
213+
else
214+
{
215+
AddInstruction(OpCode.LDARG0);
216+
Call(model, left.GetMethod!);
217+
AddInstruction(OpCode.DUP);
218+
AddInstruction(OpCode.ISNULL);
219+
Jump(OpCode.JMPIFNOT_L, endTarget);
220+
AddInstruction(OpCode.DROP);
221+
AddInstruction(OpCode.LDARG0);
222+
ConvertExpression(model, right);
223+
AddInstruction(OpCode.TUCK);
224+
Call(model, left.SetMethod!, CallingConvention.StdCall);
225+
}
226+
endTarget.Instruction = AddInstruction(OpCode.NOP);
227+
}
228+
229+
private void ConvertFieldMemberAccessCoalesceAssignment(SemanticModel model, MemberAccessExpressionSyntax left, ExpressionSyntax right, IFieldSymbol field)
230+
{
231+
JumpTarget assignmentTarget = new();
232+
JumpTarget endTarget = new();
233+
if (field.IsStatic)
234+
{
235+
byte index = context.AddStaticField(field);
236+
AccessSlot(OpCode.LDSFLD, index);
237+
AddInstruction(OpCode.ISNULL);
238+
Jump(OpCode.JMPIF_L, assignmentTarget);
239+
AccessSlot(OpCode.LDSFLD, index);
240+
Jump(OpCode.JMP_L, endTarget);
241+
assignmentTarget.Instruction = AddInstruction(OpCode.NOP);
242+
ConvertExpression(model, right);
243+
AddInstruction(OpCode.DUP);
244+
AccessSlot(OpCode.STSFLD, index);
245+
}
246+
else
247+
{
248+
int index = Array.IndexOf(field.ContainingType.GetFields(), field);
249+
ConvertExpression(model, left.Expression);
250+
Push(index);
251+
AddInstruction(OpCode.OVER);
252+
AddInstruction(OpCode.OVER);
253+
AddInstruction(OpCode.PICKITEM);
254+
AddInstruction(OpCode.ISNULL);
255+
Jump(OpCode.JMPIF_L, assignmentTarget);
256+
AddInstruction(OpCode.PICKITEM);
257+
Jump(OpCode.JMP_L, endTarget);
258+
assignmentTarget.Instruction = AddInstruction(OpCode.NOP);
259+
ConvertExpression(model, right);
260+
AddInstruction(OpCode.DUP);
261+
AddInstruction(OpCode.REVERSE4);
262+
AddInstruction(OpCode.REVERSE3);
263+
AddInstruction(OpCode.SETITEM);
264+
}
265+
endTarget.Instruction = AddInstruction(OpCode.NOP);
266+
}
267+
268+
private void ConvertPropertyMemberAccessCoalesceAssignment(SemanticModel model, MemberAccessExpressionSyntax left, ExpressionSyntax right, IPropertySymbol property)
269+
{
270+
JumpTarget endTarget = new();
271+
if (property.IsStatic)
272+
{
273+
Call(model, property.GetMethod!);
274+
AddInstruction(OpCode.DUP);
275+
AddInstruction(OpCode.ISNULL);
276+
Jump(OpCode.JMPIFNOT_L, endTarget);
277+
AddInstruction(OpCode.DROP);
278+
ConvertExpression(model, right);
279+
AddInstruction(OpCode.DUP);
280+
Call(model, property.SetMethod!);
281+
}
282+
else
283+
{
284+
JumpTarget assignmentTarget = new();
285+
ConvertExpression(model, left.Expression);
286+
AddInstruction(OpCode.DUP);
287+
Call(model, property.GetMethod!);
288+
AddInstruction(OpCode.DUP);
289+
AddInstruction(OpCode.ISNULL);
290+
Jump(OpCode.JMPIF_L, assignmentTarget);
291+
AddInstruction(OpCode.NIP);
292+
Jump(OpCode.JMP_L, endTarget);
293+
assignmentTarget.Instruction = AddInstruction(OpCode.DROP);
294+
ConvertExpression(model, right);
295+
AddInstruction(OpCode.TUCK);
296+
Call(model, property.SetMethod!, CallingConvention.StdCall);
297+
}
298+
endTarget.Instruction = AddInstruction(OpCode.NOP);
299+
}
300+
}

0 commit comments

Comments
 (0)