private static BlockSyntax GenerateWrapingCode(List <ExpressionSyntax> assigmentExpressions, Accessor firstOutputAccessor) { BlockSyntax body; if (firstOutputAccessor.Name == Accessor.SpecialNameThis) { var assigmentStatements = assigmentExpressions.Select(x => SyntaxFactory.ExpressionStatement(x)); body = SyntaxFactory.Block(assigmentStatements); } else { var statements = new List <StatementSyntax>(); // {} var initializerSyntax = SyntaxFactoryEx.ObjectInitializerExpression(assigmentExpressions); // = new accessor.Type.Name() initializerSyntax var objectCreationSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(firstOutputAccessor.Type.Name), SyntaxFactory.ArgumentList().WithTrailingTrivia(SyntaxFactory.LineFeed), initializerSyntax)); // var result objectCreationSyntax var resultSyntax = SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var"), SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(SyntaxFactory.VariableDeclarator("result").WithInitializer(objectCreationSyntax)))); statements.Add(resultSyntax); // return resultSyntax; var returnResultSyntaxt = SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName("result")); statements.Add(returnResultSyntaxt); body = SyntaxFactory.Block(statements); } return(body); }
private static CompilationUnitSyntax GenerateSyntax(BasicData data, IEnumerable <DependecyData> contexDependecies) { var compilationUnit = SyntaxFactory.CompilationUnit(); compilationUnit = compilationUnit.AddUsings(data.Usings); var @namespace = SyntaxFactoryEx.NamespaceDeclaration(data.Namespace); var classDeclaration = SyntaxFactoryEx.InternalClassDeclaration(data.HandlerName); var typeArgumentList = new List <TypeSyntax>(); typeArgumentList.Add(SyntaxFactory.IdentifierName(data.CommandName + data.CommandTypeArguments)); if (data.ReturnType != null) { typeArgumentList.Add(data.ReturnType); } classDeclaration = classDeclaration.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.GenericName(SyntaxFactory.Identifier("IRequestHandler")).AddTypeArgumentListArguments(typeArgumentList.ToArray()))); var constructor = GenerateConstructor(data.HandlerName, contexDependecies); var handleMethod = GenerateHandleMethod(data); var members = new MemberDeclarationSyntax[] { constructor, handleMethod }; classDeclaration = classDeclaration.AddMembers(members); @namespace = @namespace.AddMembers(classDeclaration); compilationUnit = compilationUnit.AddMembers(@namespace); var code = compilationUnit.NormalizeWhitespace(); return(code); }
private static ConstructorDeclarationSyntax GenerateConstructor(string name, IEnumerable <DependecyData> contexDependecies) { var parameters = contexDependecies.Select(x => SyntaxFactoryEx.Parameter(x.Name.ToLowerFirst(), x.Type)); var constructor = SyntaxFactory.ConstructorDeclaration(SyntaxFactory.Identifier(name)) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddParameterListParameters(parameters.ToArray()) .WithBody(SyntaxFactory.Block()); //.AddBodyStatements(SyntaxFactory.Block()); return(constructor); }
private static List <ExpressionSyntax> GenerateAssigmentExpressions(IEnumerable <Match> matches) { var assigmentExpressions = new List <ExpressionSyntax>(); foreach (var match in matches) { TypeData leftType = match.LeftAccessor.Type; var left = GenerateExpression(match.LeftAccessor); var right = GenerateExpression(match.RightAccessor); if (leftType.IsCollection && leftType.Arguments.Count() == 1) { var arg = leftType.Arguments.First(); if (!arg.IsImmutable) { // x => new arg.Name(x) var lambda = SyntaxFactory.SimpleLambdaExpression(SyntaxFactoryEx.Parameter("x"), SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(arg.Name), SyntaxFactoryEx.ArgumentListWithOneArgument(SyntaxFactory.IdentifierName("x")), null)); // rightExpression.Select(lambda) right = SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, right, SyntaxFactory.IdentifierName("Select")), SyntaxFactoryEx.ArgumentListWithOneArgument(lambda)); } } if (!match.LeftAccessor.Type.IsImmutable) { if (match.LeftAccessor.Type.IsCollection && match.LeftAccessor.Type.IsInterface) { // rightExpression.ToList() right = SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, right, SyntaxFactory.IdentifierName("ToList"))); } else { if (match.LeftAccessor.Type.IsArray) { // rightExpression.ToArray() right = SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, right, SyntaxFactory.IdentifierName("ToArray"))); } else { // new LeftReferenceType(rightExpression) right = SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(match.LeftAccessor.Type.Name), SyntaxFactoryEx.ArgumentListWithOneArgument(right), null); } } } assigmentExpressions.Add(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, left, right)); } return(assigmentExpressions); }
public static CompilationUnitSyntax CreateParameterObjectClass(ParameterObject parameterObject, IEnumerable <ParameterSyntax> parameters) { var compilationUnit = SyntaxFactory.CompilationUnit(); compilationUnit = compilationUnit.AddUsings(parameterObject.Usings); var @namespace = SyntaxFactoryEx.NamespaceDeclaration(parameterObject.Namespace); var classDeclaration = SyntaxFactoryEx.InternalClassDeclaration(parameterObject.Name); var members = new List <MemberDeclarationSyntax>(); foreach (var property in parameterObject.Properties) { var propertyDeclaration = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(property.Type), property.PropertyName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); members.Add(propertyDeclaration); } var body = new List <StatementSyntax>(); foreach (var property in parameterObject.Properties) { var assignment = SyntaxFactory.ExpressionStatement ( SyntaxFactory.AssignmentExpression ( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(property.PropertyName), SyntaxFactory.IdentifierName(property.ParameterName) ) ); body.Add(assignment); } var constructor = SyntaxFactory.ConstructorDeclaration(SyntaxFactory.Identifier(parameterObject.Name)) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddParameterListParameters(parameters.ToArray()) .AddBodyStatements(body.ToArray()); members.Add(constructor); classDeclaration = classDeclaration.AddMembers(members.ToArray()); @namespace = @namespace.AddMembers(classDeclaration); compilationUnit = compilationUnit.AddMembers(@namespace); var code = compilationUnit.NormalizeWhitespace(); return(code); }
protected override SyntaxNode TryUpdateParentOfUpdatedNode(SyntaxNode parent, SyntaxNode newNameNode, SyntaxEditor editor, ISyntaxFacts syntaxFacts) { if (newNameNode.IsKind(SyntaxKind.DiscardDesignation) && parent.IsKind(SyntaxKind.DeclarationPattern, out DeclarationPatternSyntax declarationPattern) && ((CSharpParseOptions)parent.SyntaxTree.Options).LanguageVersion.IsCSharp9OrAbove()) { var trailingTrivia = declarationPattern.Type.GetTrailingTrivia() .AddRange(newNameNode.GetLeadingTrivia()) .AddRange(newNameNode.GetTrailingTrivia()); return(SyntaxFactoryEx.TypePattern(declarationPattern.Type).WithTrailingTrivia(trailingTrivia)); } return(null); }
private static MethodDeclarationSyntax GenerateHandleMethod(BasicData data) { var handleMethodReturnType = SyntaxFactory.GenericName("Task").AddTypeArgumentListArguments(data.ReturnType); if (data.ReturnType == null) { handleMethodReturnType = SyntaxFactory.GenericName("Task").AddTypeArgumentListArguments(SyntaxFactory.IdentifierName("Unit")); } var handleMethod = SyntaxFactory.MethodDeclaration(handleMethodReturnType, "Handle"); handleMethod = handleMethod.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword)); handleMethod = handleMethod.AddParameterListParameters(SyntaxFactoryEx.Parameter(data.CommandParameterNameInHandleMethod, data.CommandName + data.CommandTypeArguments), SyntaxFactoryEx.Parameter("cancellationToken", "CancellationToken")); handleMethod = handleMethod.WithBody(SyntaxFactory.Block()); return(handleMethod); }
public static CSharpSyntaxNode GenerateSyntax(CSharpSyntaxNode syntaxNode, IEnumerable <Match> matches, Accessor firstOutputAccessor) { List <ExpressionSyntax> assigmentExpressions = GenerateAssigmentExpressions(matches); switch (syntaxNode) { case ObjectCreationExpressionSyntax objectCreation: var initializerSyntax = SyntaxFactoryEx.ObjectInitializerExpression(assigmentExpressions); var updatedObjectCreation = objectCreation.WithInitializer(initializerSyntax); return(updatedObjectCreation); case BaseMethodDeclarationSyntax baseMethod: BlockSyntax body = GenerateWrapingCode(assigmentExpressions, firstOutputAccessor); var updatedMethod = baseMethod.WithBody(body).WithTrailingTrivia(baseMethod.Body.GetTrailingTrivia()); return(updatedMethod); } throw new NotImplementedException(); }
private static SyntaxNode TransformArgumentListToTuple(SemanticModel semanticModel, SeparatedSyntaxList <ArgumentSyntax> arguments) { SeparatedSyntaxList <ArgumentSyntax> processedArguments = default; for (var i = 0; i < arguments.Count; i++) { var argument = arguments[i]; var argumentTypeInfo = semanticModel.GetTypeInfo(argument.Expression); if (!Equals(argumentTypeInfo.Type, argumentTypeInfo.ConvertedType)) { var expectedType = SyntaxFactory.ParseTypeName(argumentTypeInfo.ConvertedType.ToDisplayString()); argument = argument.WithExpression(SyntaxFactory.CastExpression(expectedType, argument.Expression)); } processedArguments = processedArguments.Add(argument); } return(SyntaxFactoryEx.TupleExpression(processedArguments)); }
private static SyntaxNode TransformGenericNameToTuple(SemanticModel semanticModel, GenericNameSyntax genericName) { var implementationType = typeof(SeparatedSyntaxListWrapper <> .AutoWrapSeparatedSyntaxList <>).MakeGenericType(typeof(TupleElementSyntaxWrapper), SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper))); var tupleElements = (SeparatedSyntaxListWrapper <TupleElementSyntaxWrapper>)Activator.CreateInstance(implementationType); foreach (var typeArgument in genericName.TypeArgumentList.Arguments) { if (IsValueTuple(semanticModel, typeArgument)) { var tupleTypeSyntax = (TypeSyntax)GetReplacementNode(semanticModel, typeArgument); tupleElements = tupleElements.Add(SyntaxFactoryEx.TupleElement(tupleTypeSyntax)); } else { tupleElements = tupleElements.Add(SyntaxFactoryEx.TupleElement(typeArgument)); } } return(SyntaxFactoryEx.TupleType(tupleElements)); }
private static CompilationUnitSyntax GenerateSyntax(BasicData data) { var compilationUnit = SyntaxFactory.CompilationUnit(); compilationUnit = compilationUnit.AddUsings(data.Usings, data.Namespace); var @namespace = SyntaxFactoryEx.NamespaceDeclaration(data.Namespace); var classDeclaration = SyntaxFactoryEx.PublicClassDeclaration(data.CommandName); if (data.ReturnType != null) { classDeclaration = classDeclaration.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.GenericName(SyntaxFactory.Identifier("IRequest")).AddTypeArgumentListArguments(data.ReturnType))); } else { classDeclaration = classDeclaration.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.IdentifierName("IRequest"))); } @namespace = @namespace.AddMembers(classDeclaration); compilationUnit = compilationUnit.AddMembers(@namespace); var code = compilationUnit.NormalizeWhitespace(); return(code); }