private static MemberDeclarationSyntax[] SetUpGenerate(ClassDeclarationSyntax @class)
{
List <MemberDeclarationSyntax> fields = new List <MemberDeclarationSyntax>();
MethodDeclarationSyntax SetUp = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void"), "SetUp")
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddAttributeLists(SyntaxFactory.SingletonList <AttributeListSyntax>(
SyntaxFactory.AttributeList(
SyntaxFactory.SingletonSeparatedList <AttributeSyntax>(
SyntaxFactory.Attribute(
SyntaxFactory.IdentifierName("SetUp"))))).ToArray()).WithBody(SyntaxFactory.Block());
if (@class.Modifiers.Any(SyntaxKind.StaticKeyword))
{
fields.Add(SetUp);
return(fields.ToArray());
}
fields.Add(GenerateField(SyntaxKind.PrivateKeyword, "_" + @class.Identifier.Text + "UnderTest", @class.Identifier.Text));
List <ConstructorDeclarationSyntax> constructors = new List <ConstructorDeclarationSyntax>();
foreach (MemberDeclarationSyntax member in @class.Members.Where(cstr => (cstr is ConstructorDeclarationSyntax)))
{
constructors.Add(member as ConstructorDeclarationSyntax);
}
string constString = "_" + @class.Identifier.Text + "UnderTest = new " + @class.Identifier.Text + "(";
if (constructors.Count > 0)
{
ConstructorDeclarationSyntax constructor = constructors.OrderBy(x => x.ParameterList.Parameters.Count).First();
ParameterSyntax[] parametrs = constructor.ParameterList.Parameters.ToArray();
foreach (ParameterSyntax param in parametrs)
{
if (param.Type.ToString()[0] == 'I')
{
fields.Add(
GenerateField(
SyntaxKind.PrivateKeyword,
"_" + param.Identifier.Text + "Dependency",
"Mock<" + param.Type.ToString() + ">"));
SetUp = SetUp.AddBodyStatements(GenerateMockClass(param.Type.ToString(), "_" + param.Identifier.Text + "Dependency"));
constString += "_" + param.Identifier.Text + "Dependency.Object, ";
}
else
{
SetUp = SetUp.AddBodyStatements(GenerateVar(param.Type.ToString(), param.Identifier.Text));
constString += param.Identifier.Text + ", ";
}
}
constString = constString.Remove(constString.Length - 2, 1);
}
constString += ");";
SetUp = SetUp.AddBodyStatements(SyntaxFactory.ParseStatement(constString));
fields.Add(SetUp);
return(fields.ToArray());
}
/// <summary>
/// Initializing of visitor
/// </summary>
public RoslynTreeBuilderVisitor(string libraryModuleName = null)
{
//Create unit
unitNode = CompilationUnit();
//Create public class "Program" (or library unit's name)
this.libraryModuleName = libraryModuleName;
string className = libraryModuleName ?? "$Program";
programClassNode = ClassDeclaration(className).AddModifiers(Token(SyntaxKind.PublicKeyword));
//Create method void Main()
mainMethodNode = MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)), "Main");
//Set Main method as static
mainMethodNode = mainMethodNode.AddModifiers(Token(SyntaxKind.StaticKeyword));
//Add to Main method empty body
mainMethodNode = mainMethodNode.AddBodyStatements();
//Set Main method as current block (push to stack)
blocks.Push(mainMethodNode);
//initialize dictionary of location annotations
LocationAnnotations = new List <SyntaxAnnotation>();
}
public Type Compile()
{
if (expressions.Count != 1)
{
throw new Exception("HAML node stack misaligned. Expected only 1 root node.");
}
FlushStringRun();
_renderMethod = _renderMethod.AddBodyStatements(SyntaxFactory.Block(expressions.Peek()));
_compilationTargetClass = _compilationTargetClass.AddMembers(_renderMethod);
_compilationUnit = _compilationUnit
.AddMembers(_compilationTargetClass);
_compilationUnit = _compilationUnit.NormalizeWhitespace(" ", true);
_compilation = _compilation.AddSyntaxTrees(CSharpSyntaxTree.Create(_compilationUnit));
MemoryStream stream = new MemoryStream();
EmitResult result = _compilation.Emit(stream);
_compilation.Emit("Output.dll");
if (!result.Success)
{
throw new HamlCompilationFailedException(result.Diagnostics);
}
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
Assembly assembly = AssemblyLoadContext.Default.LoadFromStream(stream);
return(assembly.GetType(_compilationTargetClass.Identifier.Text));
}
public static async Task <Document> RefactorAsync(
Document document,
MethodDeclarationSyntax methodDeclaration,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(methodDeclaration.ReturnType, cancellationToken);
int position = -1;
BlockSyntax body = methodDeclaration.Body;
SyntaxList <StatementSyntax> statements = body.Statements;
if (statements.Any())
{
position = statements.Last().FullSpan.End;
}
else
{
position = body.OpenBraceToken.FullSpan.End;
}
MethodDeclarationSyntax newNode = methodDeclaration
.AddBodyStatements(ReturnStatement(typeSymbol.ToDefaultExpression(semanticModel, position)));
return(await document.ReplaceNodeAsync(methodDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
public static MethodDeclarationSyntax CreateMethod(MethodGenerationData data)
{
Debug.Assert(!string.IsNullOrEmpty(data.m_MethodName), "Trying to generate a method with null or empty method name!");
Debug.Assert(!string.IsNullOrEmpty(data.m_MethodReturnType), "Trying to generate a method with null or empty return type!");
Debug.Assert(data.m_MethodBodyStatements != null && data.m_MethodBodyStatements.Count > 0, "Trying to generate a method with no body!");
MethodDeclarationSyntax syntax = SyntaxFactory
.MethodDeclaration(SyntaxFactory.ParseTypeName(data.m_MethodReturnType), data.m_MethodName)
.AddModifiers(CodeGenerationUtility.CreateProtectionLevelToken(data.m_ProtectionLevel));
switch (data.m_InheritanceKeyword)
{
case FunctionInheritanceKeyword.STATIC: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); break;
case FunctionInheritanceKeyword.OVERRIDE: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); break;
case FunctionInheritanceKeyword.VIRTUAL: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); break;
}
if (data.m_IsAsync)
{
bool canMakeAsync = false;
for (int i = 0; i < s_AcceptedAsyncReturnTypes.Length; i++)
{
if (!data.m_MethodReturnType.Contains(s_AcceptedAsyncReturnTypes[i]))
{
continue;
}
canMakeAsync = true;
break;
}
Debug.Assert(canMakeAsync, "Trying to generate async function but the return type is not supported! Please make the return type either void, Task or UniTask");
if (canMakeAsync)
{
syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
}
syntax = syntax.AddAttributeLists(AttributeGenerationService.CreateAttributeListSyntaxes(data.m_Attributes));
foreach (var param in data.m_MethodParams)
{
syntax = syntax.AddParameterListParameters(CodeGenerationUtility.CreateParameterSyntax(param.m_ParamName, param.m_ParamType));
}
foreach (var statement in data.m_MethodBodyStatements)
{
syntax = syntax.AddBodyStatements((SyntaxFactory.ParseStatement(statement)));
}
return(syntax);
}
private async Task <Document> RemoveThrowAsync(Document document, MethodDeclarationSyntax method, CancellationToken ct)
{
return(document
.WithSyntaxRoot((await document.GetSyntaxRootAsync(ct))
.ReplaceNode(method, method.AddBodyStatements(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("GC"),
SyntaxFactory.IdentifierName("SuppressFinalize")),
SyntaxFactory.ArgumentList().AddArguments(SyntaxFactory.Argument(SyntaxFactory.ThisExpression())))))
.WithAdditionalAnnotations(Formatter.Annotation))));
}
private MethodDeclarationSyntax AddReturnStatement(MethodDeclarationSyntax newMethod, SyntaxGenerator generator)
{
var getMethodInvocation =
generator.InvocationExpression(
generator.MemberAccessExpression(generator.IdentifierName(AdapterParameterName),
AdapterGetMethodName));
var returnStatement = generator.ReturnStatement(getMethodInvocation)
?.WithAdditionalAnnotations(Formatter.Annotation) as StatementSyntax;
return(returnStatement != null
? newMethod.AddBodyStatements(returnStatement)
: newMethod);
}
/// <summary>
/// Добавление выражения в начало тела метода
/// </summary>
/// <param name="method"></param>
/// <param name="expression"></param>
/// <returns></returns>
public MethodDeclarationSyntax AddExpressionToStartMethodsBody(MethodDeclarationSyntax method,
ExpressionStatementSyntax expression)
{
if (method.Body == null)
{
return(method);
}
if (method.Body.ChildNodes().Count() == 0)
{
return(method.AddBodyStatements(expression).NormalizeWhitespace());
}
BlockSyntax newBlock = method.Body.InsertNodesBefore(method.Body
.ChildNodes().ElementAt(0),
new List <SyntaxNode> {
expression
}).NormalizeWhitespace();
method = method.ReplaceNode(method.Body, newBlock);
return(method);
}
/// <summary> Modify the method found in GetOriginalMethodDeclarationSyntax(). </summary>
private static MethodDeclarationSyntax GetModifiedMethodDeclarationSyntax(MethodDeclarationSyntax method, MethodModificationData modificationData)
{
var nodes = method.DescendantNodes().ToList();
ParameterListSyntax paramListSyntax = SyntaxFactory.ParameterList();
foreach (var param in modificationData.m_NewMethodParams)
{
paramListSyntax = paramListSyntax.AddParameters(CodeGenerationUtility.CreateParameterSyntax(param.m_ParamName, param.m_ParamType));
}
method = modificationData.m_ParamModificationType == MethodParameterModificationType.REPLACE_PARAMS
? method.WithParameterList(paramListSyntax)
: method.AddParameterListParameters(paramListSyntax.Parameters.ToArray());
BlockSyntax blockSyntax = SyntaxFactory.Block();
var oldStatements = method.Body.Statements.ToList();
foreach (var statement in modificationData.m_BodyStatements)
{
if (modificationData.m_BodyModificationType == MethodBodyModificationType.ADD_OR_REPLACE_BODY)
{
if (oldStatements.Find(x => x.ToFullString().Contains(statement)) != null)
{
continue;
}
}
blockSyntax = blockSyntax.AddStatements(SyntaxFactory.ParseStatement(statement));
}
// if replacing the body, the statement in the old function with be completely replaced with the new statement
method = modificationData.m_BodyModificationType == MethodBodyModificationType.REPLACE_BODY
? method.WithBody(blockSyntax)
: method.AddBodyStatements(blockSyntax.Statements.ToArray());
return(method.NormalizeWhitespace());
}
private void ProcessNodes(IEnumerable <MyVisualSyntaxNode> nodes, ref MethodDeclarationSyntax methodDeclaration, IEnumerable <StatementSyntax> statementsToAppend = null)
{
m_helperStatementList.Clear();
m_navigator.ResetNodes();
m_builderNode.Reset();
m_builderNode.SequenceOutputs.AddRange(nodes);
m_builderNode.Navigator = m_navigator;
foreach (var node in nodes)
{
Debug.Assert(node is IMyVisualSyntaxEntryPoint);
((IMyVisualSyntaxEntryPoint)node).AddSequenceInput(m_builderNode);
}
m_builderNode.Preprocess();
m_builderNode.CollectSequenceExpressions(m_helperStatementList);
if (statementsToAppend != null)
{
m_helperStatementList.AddRange(statementsToAppend);
}
methodDeclaration = methodDeclaration.AddBodyStatements(m_helperStatementList.ToArray());
}
private static MethodDeclarationSyntax[] GenerateMethods(ClassDeclarationSyntax @class)
{
List <MethodDeclarationSyntax> testMethods = new List <MethodDeclarationSyntax>();
var methods = @class.Members.OfType <MethodDeclarationSyntax>();
foreach (var method in methods.Where(m => m.Modifiers.Any(SyntaxKind.PublicKeyword)))
{
MethodDeclarationSyntax testMethod = CreateMethodDeclaration(SyntaxKind.PublicKeyword, "void", method.Identifier.Text + "Test", "Test");
string invokeArgs = "";
//Arrange
foreach (ParameterSyntax paramSyn in method.ParameterList.Parameters)
{
if (!paramSyn.Type.ToString().StartsWith('I'))
{
testMethod = testMethod.AddBodyStatements(
CreateAssignmentStatement(
paramSyn.Type.ToString(),
paramSyn.Identifier.Text,
false,
"default"));
invokeArgs += paramSyn.Identifier.Text + ", ";
}
else
{
invokeArgs += CreateDecoratedName(paramSyn) + ".Object, ";
}
}
if (invokeArgs.Length > 0)
{
invokeArgs = invokeArgs.Remove(invokeArgs.Length - 2);
}
//Act + Assert
if (method.ReturnType.ToString() == "void")
{
testMethod = testMethod.AddBodyStatements(
CreateMethodCallStatement(
true,
"",
"",
method.Modifiers.Any(SyntaxKind.StaticKeyword) ?
@class.Identifier.Text :
$"_{@class.Identifier.Text}UnderTest",
method.Identifier.Text,
invokeArgs),
SyntaxFactory.ParseStatement("Assert.Fail(\"Autogenerated\");")); //Assert
}
else
{
testMethod = testMethod.AddBodyStatements(
CreateMethodCallStatement(
false,
method.ReturnType.ToString(),
"actual",
method.Modifiers.Any(SyntaxKind.StaticKeyword) ?
@class.Identifier.Text :
$"_{@class.Identifier.Text}UnderTest",
method.Identifier.Text,
invokeArgs),
CreateAssignmentStatement( //Assert
method.ReturnType.ToString(),
"expected",
false,
"default"),
SyntaxFactory.ParseStatement("Assert.That(actual, Is.EqualTo(expected));"),
SyntaxFactory.ParseStatement("Assert.Fail(\"Autogenerated\");"));
}
testMethods.Add(testMethod);
}
return(testMethods.ToArray());
}
private static MemberDeclarationSyntax[] GenerateSetUp(ClassDeclarationSyntax @class)
{
List <MemberDeclarationSyntax> memberDeclarations = new List <MemberDeclarationSyntax>();
MethodDeclarationSyntax setUpMethod = CreateMethodDeclaration(SyntaxKind.PublicKeyword, "void", "SetUp", "SetUp");
if (@class.Modifiers.Any(SyntaxKind.StaticKeyword))
{
setUpMethod = setUpMethod.AddBodyStatements(new StatementSyntax[0]);
memberDeclarations.Add(setUpMethod);
return(memberDeclarations.ToArray());
}
memberDeclarations.Add(CreateFieldDeclaration(SyntaxKind.PrivateKeyword, @class.Identifier.Text, $"_{@class.Identifier.Text}UnderTest"));
ParameterSyntax[] ctorParams = @class.Members.OfType <ConstructorDeclarationSyntax>()
.FirstOrDefault()?.ParameterList.Parameters.ToArray() ?? new ParameterSyntax[0];
foreach (ParameterSyntax paramSyn in ctorParams?.Where(parameter => !parameter.Type.ToString().StartsWith('I')))
{
setUpMethod = setUpMethod.AddBodyStatements(
CreateAssignmentStatement(
paramSyn.Type.ToString(),
paramSyn.Identifier.Text,
false,
"default"));
}
foreach (ParameterSyntax paramSyn in ctorParams?.Where(parameter => parameter.Type.ToString().StartsWith('I')))
{
memberDeclarations.Add(
CreateFieldDeclaration(
SyntaxKind.PrivateKeyword,
$"Mock<{paramSyn.Type.ToString()}>",
CreateDecoratedName(paramSyn)));
setUpMethod = setUpMethod.AddBodyStatements(
CreateAssignmentStatement(
"",
CreateDecoratedName(paramSyn),
true,
$"Mock<{paramSyn.Type.ToString()}>"));
}
setUpMethod = setUpMethod.AddBodyStatements(
CreateAssignmentStatement(
"",
$"_{@class.Identifier.Text}UnderTest",
true,
@class.Identifier.Text,
string.Join(
", ",
ctorParams?
.Select(
paramSyn => paramSyn.Type.ToString()
.StartsWith('I') ?
CreateDecoratedName(paramSyn) + ".Object" :
paramSyn.Identifier.Text))));
memberDeclarations.Add(setUpMethod);
return(memberDeclarations.ToArray());
}
private void CreateMethods()
{
// Generate Interface methods
if (!string.IsNullOrEmpty(m_objectBuilder.Interface))
{
var methodNodes = m_navigator.OfType <MyVisualSyntaxInterfaceMethodNode>();
foreach (var methodNode in methodNodes)
{
var methodSyntax = methodNode.GetMethodDeclaration();
ProcessNodes(new[] { methodNode }, ref methodSyntax);
m_methodDeclarations.Add(methodSyntax);
}
}
var events = m_navigator.OfType <MyVisualSyntaxEventNode>();
events.AddRange(m_navigator.OfType <MyVisualSyntaxKeyEventNode>());
// Generate Event methods
// Take all events of same name and make a method out of theire bodies.
while (events.Count > 0)
{
var firstEvent = events[0];
var eventsWithSameName = events.Where(@event => @event.ObjectBuilder.Name == firstEvent.ObjectBuilder.Name);
var methodDeclaration = MySyntaxFactory.PublicMethodDeclaration(
firstEvent.EventName,
SyntaxKind.VoidKeyword,
firstEvent.ObjectBuilder.OutputNames,
firstEvent.ObjectBuilder.OuputTypes);
ProcessNodes(eventsWithSameName, ref methodDeclaration);
// Bind with VisualScriptingProxy in constructor.
m_constructor = m_constructor.AddBodyStatements(
MySyntaxFactory.DelegateAssignment(
firstEvent.ObjectBuilder.Name,
methodDeclaration.Identifier.ToString())
);
// unBind from visualScriptingProxy in dispose method
m_disposeMethod = m_disposeMethod.AddBodyStatements(
MySyntaxFactory.DelegateRemoval(
firstEvent.ObjectBuilder.Name,
methodDeclaration.Identifier.ToString())
);
m_methodDeclarations.Add(methodDeclaration);
events.RemoveAll(@event => eventsWithSameName.Contains(@event));
}
// There can be only one method from single input node.
// Input nodes are of type Event.
var inputs = m_navigator.OfType <MyVisualSyntaxInputNode>();
var outputs = m_navigator.OfType <MyVisualSyntaxOutputNode>();
if (inputs.Count > 0)
{
Debug.Assert(inputs.Count == 1);
var input = inputs[0];
MethodDeclarationSyntax methodDeclaration = null;
if (outputs.Count > 0)
{
List <string> outputParamNames = new List <string>(outputs[0].ObjectBuilder.Inputs.Count);
List <string> outputParamTypes = new List <string>(outputs[0].ObjectBuilder.Inputs.Count);
foreach (var outputData in outputs[0].ObjectBuilder.Inputs)
{
outputParamNames.Add(outputData.Name);
outputParamTypes.Add(outputData.Type);
}
methodDeclaration = MySyntaxFactory.PublicMethodDeclaration("RunScript", SyntaxKind.BoolKeyword, input.ObjectBuilder.OutputNames, input.ObjectBuilder.OuputTypes, outputParamNames, outputParamTypes);
}
else
{
methodDeclaration = MySyntaxFactory.PublicMethodDeclaration("RunScript", SyntaxKind.BoolKeyword, input.ObjectBuilder.OutputNames, input.ObjectBuilder.OuputTypes);
}
ProcessNodes(new[] { input }, ref methodDeclaration, new[] { SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)) });
m_methodDeclarations.Add(methodDeclaration);
}
}
public static MethodDeclarationSyntax add_Statement(this MethodDeclarationSyntax methodDeclaration, StatementSyntax statement)
{
return(methodDeclaration.AddBodyStatements(statement));
}
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
node = base.VisitMethodDeclaration(node) as MethodDeclarationSyntax;
var body = node.Body;
if (body == null)
{
return(node);
}
var parentClass = node.Parent as ClassDeclarationSyntax;
if (parentClass == null)
{
return(node);
}
var parameterList = node.ParameterList;
if (parameterList == null)
{
return(node);
}
var parameters = parameterList.Parameters;
var parameterCount = parameters.Count;
if (parameterCount == 0)
{
return(node);
}
var methodName = node.Identifier.Text;
var firstParameter = parameterList.Parameters[0];
var firstParameterName = firstParameter.Identifier.Text;
if (methodName == k_ConnectSubscriber && parameterCount == 1)
{
node = node.WithBody(SyntaxFactory.Block());
// TODO: share this code with the method for finding subscriber classes below
var symbol = m_Model.GetDeclaredSymbol(parentClass) as INamedTypeSymbol;
foreach (var @interface in symbol.AllInterfaces)
{
// TODO: handle provider types with more than one level of inheritence
foreach (var baseInterface in @interface.Interfaces)
{
if (baseInterface.Name != k_IFunctionalityProvider)
{
continue;
}
var varName = string.Format(k_VariableNameTemplate, @interface.Name);
var castStatement = string.Format(k_CastStatement, varName, firstParameterName, @interface);
var assignment = string.Format(k_SetProviderStatement, varName);
node = node.AddBodyStatements(
SyntaxFactory.ParseStatement(castStatement),
SyntaxFactory.ParseStatement(assignment));
wasModified = true;
}
}
}
return(node);
}
public void Generate()
{
// standard using directives
CompilationUnitSyntax cu = SyntaxFactory.CompilationUnit()
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Collections.Generic")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Linq")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Text")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Threading.Tasks")));
NamespaceDeclarationSyntax localNamespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(directoryName));
ClassDeclarationSyntax localClass = SyntaxFactory.ClassDeclaration(Name);
foreach (var member in Declarations)
{
switch (member.DeclarationType)
{
case "method":
var currentMethod = member as Method;
//currentMethod.Type is a string parsed from the uml diagram
MethodDeclarationSyntax method = SyntaxFactory.MethodDeclaration(SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(currentMethod.Type)), currentMethod.Name);
List <SyntaxToken> mods = new List <SyntaxToken>();
foreach (var modifier in currentMethod.Modifiers)
{
mods.Add(SyntaxFactory.ParseToken(modifier));
}
method = method.AddModifiers(mods.ToArray());
SeparatedSyntaxList <ParameterSyntax> ssl = SyntaxFactory.SeparatedList <ParameterSyntax>();
foreach (var param in currentMethod.Arguments)
{
ParameterSyntax ps = SyntaxFactory.Parameter(
new SyntaxList <AttributeListSyntax>(),
new SyntaxTokenList(),
SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(param.Type)),
SyntaxFactory.Identifier(param.Name), null);
ssl = ssl.Add(ps);
}
method = method.AddParameterListParameters(ssl.ToArray());
// we add an exception to the body of an otherwise empty method
ThrowStatementSyntax notReady = SyntaxFactory.ThrowStatement(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("NotImplementedException"), SyntaxFactory.ArgumentList(), null));
method = method.AddBodyStatements(notReady);
localClass = localClass.AddMembers(method);
break;
case "field":
var currentField = member as Field;
SyntaxTokenList stl = new SyntaxTokenList();
foreach (var modifier in currentField.Modifiers)
{
stl = stl.Add(SyntaxFactory.ParseToken(modifier));
}
SeparatedSyntaxList <VariableDeclaratorSyntax> svd = SyntaxFactory.SeparatedList <VariableDeclaratorSyntax>();
svd = svd.Add(SyntaxFactory.VariableDeclarator(currentField.Name));
// currentField.Type is a string parsed from the uml diagram
VariableDeclarationSyntax variable = SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName(currentField.Type), svd);
FieldDeclarationSyntax field = SyntaxFactory.FieldDeclaration(
new SyntaxList <AttributeListSyntax>(),
stl,
variable
);
localClass = localClass.AddMembers(field);
break;
}
}
localNamespace = localNamespace.AddMembers(localClass);
cu = cu.AddMembers(localNamespace);
AdhocWorkspace cw = new AdhocWorkspace();
OptionSet options = cw.Options;
cw.Options.WithChangedOption(CSharpFormattingOptions.IndentBraces, true);
SyntaxNode formattedNode = Formatter.Format(cu, cw, options);
formattedNode.WriteTo(writer);
}
/* Update every return statements in the method declaration (if any), to return the specified symbol.*/
public SyntaxNode ChangeReturnValue(string symbolName)
{
// Create a return statement with the given symbol name.
var returnStatement = Syntax.ReturnStatement
(Syntax.ParseToken("return").WithTrailingTrivia(Syntax.Whitespace(" ")),
Syntax.ParseExpression(symbolName), Syntax.ParseToken(";"));
// Replace every return statements in the method with the created new return statement.
method = method.ReplaceNodes(
method.DescendantNodes().Where(n => n.Kind == SyntaxKind.ReturnStatement),
(n1, n2) => returnStatement);
// Get all statements in the updated method.
var statements = GetStatements();
// If the last statement is not return statement, it needs adding one.
if (statements.Last().Kind != SyntaxKind.ReturnStatement)
{
// Get the leading and trailing white space of the last statement.
var leading = statements.Last().GetLeadingTrivia();
var trailing = statements.Last().GetTrailingTrivia();
// Add a return statement to the end of the body.
method = method.AddBodyStatements(new StatementSyntax[]
{returnStatement.WithLeadingTrivia(leading).WithTrailingTrivia(trailing)});
}
return method;
}
/// <summary>
/// Добавление выражения в тело метода
/// </summary>
/// <param name="method">Метод</param>
/// <param name="expression">Добавляемое выражение</param>
/// <returns></returns>
public MethodDeclarationSyntax AddExpressionToMethodsBody(MethodDeclarationSyntax method,
ExpressionStatementSyntax expression)
{
method = method.AddBodyStatements(expression).NormalizeWhitespace();
return(method);
}
public static MethodDeclarationSyntax AddBodyStatements(this MethodDeclarationSyntax syntax, IEnumerable <StatementSyntax> parameters)
{
return(syntax.AddBodyStatements(parameters.ToArray()));
}
//访问函数，并且
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
MethodDeclarationSyntax node_raw = node;
Console.WriteLine("VisitMethodDeclaration: " + node.Identifier);
SyntaxTree SF = node.SyntaxTree;
//增加一个body
BlockSyntax Body = node.Body;
if (Body == null)
{
//处理[DllImport("CSteamworks", CallingConvention = CallingConvention.Cdecl)]
foreach (AttributeListSyntax attr in node.AttributeLists)
{
if (attr.ToString().StartsWith("[DllImport"))
{
var r = node.AttributeLists.Remove(attr);
node = node.WithAttributeLists(r);
SyntaxTrivia st = SyntaxFactory.PreprocessingMessage("\t\t//" + attr.ToString() + "\r\n");
//改为
SyntaxTriviaList s = node.GetLeadingTrivia();
if (s != null)
{
s = s.Add(st);
node = node.WithLeadingTrivia(s);
}
else
{
node = node.WithLeadingTrivia(st);
}
break;
}
}
//SyntaxNode
SyntaxList <StatementSyntax> statements = new SyntaxList <StatementSyntax>();
BinaryExpressionSyntax bes = SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, SyntaxFactory.IdentifierName("_a"),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal("X")));
//ExpressionSyntax e = SyntaxFactory.ParseExpression(string.Format("Debug.Log(\"{0}: \");", node.Identifier));
//statements.Add(e);
// StatementSyntax myStatement = SyntaxFactory.ParseStatement(@"Console.WriteLine();");
//Body.AddStatements(myStatement);
//statements.Add(bes);
//CSharpScript.Create<int>("int x = 1;");
StatementSyntax myStatement = SyntaxFactory.ParseStatement(string.Format("Debug.Log(\"****call to {0}: \");", node.Identifier));
node = node.AddBodyStatements(myStatement);
//处理带有out 修饰的参数:
SeparatedSyntaxList <ParameterSyntax> Parameters = node.ParameterList.Parameters;
if (Parameters.Count > 0)
{
foreach (ParameterSyntax param in Parameters)
{
foreach (SyntaxToken vv in param.Modifiers)
{
if (vv.ToString().Contains("out"))
{
TypeSyntax t1 = param.Type;
string t2 = param.Identifier.ToString();
StatementSyntax ss = SyntaxFactory.ParseStatement(string.Format("{0} = default({1});", t2, t1.ToString()));
node = node.AddBodyStatements(ss);
break;
}
}
foreach (AttributeListSyntax vv in param.AttributeLists)
{
if (vv.ToString().Contains("[Out]"))
{
TypeSyntax t1 = param.Type;
string t2 = param.Identifier.ToString();
StatementSyntax ss = SyntaxFactory.ParseStatement(string.Format("{0} = default({1});", t2, t1.ToString()));
node = node.AddBodyStatements(ss);
break;
}
}
}
//+ AttributeLists {[In] [Out]} Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>
}
//补充返回值:
string sr = string.Format("return {0};", BuildRetStr(node.ReturnType));
StatementSyntax ret = SyntaxFactory.ParseStatement(sr);
node = node.AddBodyStatements(ret).WithSemicolonToken(default(SyntaxToken));
//处理node的修饰符:
foreach (SyntaxToken mod in node.Modifiers)
{
if (mod.Text == "extern")
{
SyntaxTokenList n = node.Modifiers.Remove(mod);
node = node.WithModifiers(n);
break;
}
}
}
// This is new, copies the trivia (indentations, comments, etc.)
//newVariable = newVariable.WithLeadingTrivia(localDeclarationStatementSyntax.GetLeadingTrivia());
//newVariable = newVariable.WithTrailingTrivia(localDeclarationStatementSyntax.GetTrailingTrivia());
//Console.WriteLine(node.AddBodyStatements);
//StatementSyntax[] items
//SeparatedSyntaxList<ParameterSyntax> Parameters = node.ParameterListSyntax;
//if (Parameters.Count > 0)
//{
// for (int i = 0; i < Parameters.Count; ++i)
// {
// Console.WriteLine(node.Parent);
// Console.WriteLine(Parameters[i]);
// }
//}
node = node.NormalizeWhitespace();
//Console.WriteLine(node);
//将新节点替换到旧节点上:
node_raw.Parent.ReplaceNode(node_raw, node);
return(node);
}