private ArgumentListSyntax GetReferenceEqualsToGivenArgument(SyntaxToken token, ExpressionSyntax sameAs) { return(SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.SimpleLambdaExpression(SyntaxFactory.Parameter(token), SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("ReferenceEquals"), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName(token)), SyntaxFactory.Argument(sameAs) })) )))))); }
protected virtual MappingElement TryToCreateMappingExpression(MappingElement source, ITypeSymbol targetType, MappingPath mappingPath, MappingContext mappingContext) { //TODO: If source expression is method or constructor invocation then we should extract local variable and use it im mappings as a reference var namedTargetType = targetType as INamedTypeSymbol; if (namedTargetType != null) { var directlyMappingConstructor = namedTargetType.Constructors.FirstOrDefault(c => c.Parameters.Length == 1 && c.Parameters[0].Type.Equals(source.ExpressionType)); if (directlyMappingConstructor != null) { var constructorParameters = SyntaxFactory.ArgumentList().AddArguments(SyntaxFactory.Argument(source.Expression)); var creationExpression = syntaxGenerator.ObjectCreationExpression(targetType, constructorParameters.Arguments); return(new MappingElement() { ExpressionType = targetType, Expression = (ExpressionSyntax)creationExpression }); } } if (MappingHelper.IsMappingBetweenCollections(targetType, source.ExpressionType)) { return(new MappingElement() { ExpressionType = targetType, Expression = MapCollections(source.Expression, source.ExpressionType, targetType, mappingPath.Clone(), mappingContext) as ExpressionSyntax }); } var subMappingSourceFinder = new ObjectMembersMappingSourceFinder(source.ExpressionType, source.Expression, syntaxGenerator); if (namedTargetType != null) { //maybe there is constructor that accepts parameter matching source properties var constructorOverloadParameterSets = namedTargetType.Constructors.Select(x => x.Parameters); var matchedOverload = MethodHelper.FindBestParametersMatch(subMappingSourceFinder, constructorOverloadParameterSets, mappingContext); if (matchedOverload != null) { var creationExpression = ((ObjectCreationExpressionSyntax)syntaxGenerator.ObjectCreationExpression(targetType, matchedOverload.ToArgumentListSyntax(this, mappingContext).Arguments)); var matchedSources = matchedOverload.GetMatchedSources(); var restSourceFinder = new IgnorableMappingSourceFinder(subMappingSourceFinder, foundElement => { return(matchedSources.Any(x => x.Expression.IsEquivalentTo(foundElement.Expression))); }); var mappingMatcher = new SingleSourceMatcher(restSourceFinder); return(new MappingElement() { ExpressionType = targetType, Expression = AddInitializerWithMapping(creationExpression, mappingMatcher, targetType, mappingContext, mappingPath) }); } } var objectCreationExpressionSyntax = ((ObjectCreationExpressionSyntax)syntaxGenerator.ObjectCreationExpression(targetType)); var subMappingMatcher = new SingleSourceMatcher(subMappingSourceFinder); return(new MappingElement() { ExpressionType = targetType, Expression = AddInitializerWithMapping(objectCreationExpressionSyntax, subMappingMatcher, targetType, mappingContext, mappingPath) }); }
private static ExpressionSyntax GetSimplificationFromInvocations(ExpressionSyntax expression1, ExpressionSyntax expression2, ExpressionSyntax condition, ExpressionSyntax compared, SemanticModel semanticModel, SyntaxAnnotation annotation, bool isNullCoalescing) { var methodCall1 = expression1 as InvocationExpressionSyntax; var methodCall2 = expression2 as InvocationExpressionSyntax; if (methodCall1 == null || methodCall2 == null) { return(null); } var methodSymbol1 = semanticModel.GetSymbolInfo(methodCall1).Symbol; var methodSymbol2 = semanticModel.GetSymbolInfo(methodCall2).Symbol; if (methodSymbol1 == null || methodSymbol2 == null || !methodSymbol1.Equals(methodSymbol2)) { return(null); } var newArgumentList = SyntaxFactory.ArgumentList(); for (int i = 0; i < methodCall1.ArgumentList.Arguments.Count; i++) { var arg1 = methodCall1.ArgumentList.Arguments[i]; var arg2 = methodCall2.ArgumentList.Arguments[i]; var expr1 = arg1.Expression.RemoveParentheses(); var expr2 = arg2.Expression.RemoveParentheses(); if (!EquivalenceChecker.AreEquivalent(expr1, expr2)) { ExpressionSyntax createdExpression; if (isNullCoalescing) { var arg1IsCompared = EquivalenceChecker.AreEquivalent(expr1, compared); var expression = arg1IsCompared ? expr2 : expr1; createdExpression = SyntaxFactory.BinaryExpression(SyntaxKind.CoalesceExpression, compared, expression); } else { createdExpression = SyntaxFactory.ConditionalExpression(condition, expr1, expr2); } newArgumentList = newArgumentList.AddArguments( SyntaxFactory.Argument( arg1.NameColon, arg1.RefOrOutKeyword, createdExpression.WithAdditionalAnnotations(annotation))); } else { newArgumentList = newArgumentList.AddArguments(arg1.WithExpression(arg1.Expression.RemoveParentheses())); } } return(methodCall1.WithArgumentList(newArgumentList)); }
private MemberDeclarationSyntax GenerateHelperClassContents(HelperDefinition helperDefinition) { return(SyntaxFactory.ClassDeclaration(helperDefinition.Name) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword))) .WithBaseList(SyntaxFactory.BaseList(SyntaxFactory.SeparatedList <BaseTypeSyntax>(new [] { SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("DotVVM.Framework.Testing.SeleniumHelpers.SeleniumHelperBase")) }))) .WithMembers(SyntaxFactory.List(helperDefinition.Members)) .AddMembers( SyntaxFactory.ConstructorDeclaration(helperDefinition.Name) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(new [] { SyntaxFactory.Parameter(SyntaxFactory.Identifier("webDriver")) .WithType(SyntaxFactory.ParseTypeName("OpenQA.Selenium.IWebDriver")), SyntaxFactory.Parameter(SyntaxFactory.Identifier("parentHelper")) .WithType(SyntaxFactory.ParseTypeName("DotVVM.Framework.Testing.SeleniumHelpers.SeleniumHelperBase")) .WithDefault(SyntaxFactory.EqualsValueClause(SyntaxFactory.IdentifierName("null"))), SyntaxFactory.Parameter(SyntaxFactory.Identifier("selectorPrefix")) .WithType(SyntaxFactory.ParseTypeName("System.String")) .WithDefault(SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("")))) }))) .WithInitializer(SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new [] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName("webDriver")), SyntaxFactory.Argument(SyntaxFactory.IdentifierName("parentHelper")), SyntaxFactory.Argument(SyntaxFactory.IdentifierName("selectorPrefix")) })))) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword))) .WithBody(SyntaxFactory.Block(helperDefinition.ConstructorStatements)) ) .AddMembers( helperDefinition.Children.Select(GenerateHelperClassContents).ToArray() )); }
public static Microsoft.CodeAnalysis.VisualBasic.Syntax.ThrowStatementSyntax GetNotImplementedThrowStatement() { return(SyntaxFactory.ThrowStatement(SyntaxFactory.ObjectCreationExpression( SyntaxFactory.QualifiedName(SyntaxFactory.IdentifierName(@"System"), SyntaxFactory.IdentifierName(@"NotImplementedException"))) .WithArgumentList(SyntaxFactory.ArgumentList()))); }
public void Process(DocumentEditor editor) { foreach (var node in editor.OriginalRoot.DescendantNodes() .OfType <AttributeSyntax>() .Where(attribute => attribute.Name is IdentifierNameSyntax && ((IdentifierNameSyntax)attribute.Name).Identifier.Text == "ExpectedException")) { var typeofExpression = (TypeOfExpressionSyntax)node.ArgumentList.Arguments.FirstOrDefault()?.Expression; var expectedExceptionType = (NameSyntax)typeofExpression?.Type; if (expectedExceptionType == null) { expectedExceptionType = SyntaxFactory.IdentifierName("Exception"); } var parentMethod = (MethodDeclarationSyntax)node.Parent.Parent; var lastStatement = parentMethod.Body.DescendantNodes().OfType <StatementSyntax>().Last(); var assertThrowsStatement = GetAssertThrows(lastStatement.GetLeadingTrivia(), expectedExceptionType) .WithOperatorToken(SyntaxFactory.Token(SyntaxKind.DotToken)); var expression = SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression(assertThrowsStatement) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.ParenthesizedLambdaExpression( SyntaxFactory.Block( SyntaxFactory.SingletonList( lastStatement .WithLeadingTrivia(SyntaxTriviaList.Empty) .WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.Space)))) .WithOpenBraceToken( SyntaxFactory.Token( SyntaxFactory.TriviaList(), SyntaxKind.OpenBraceToken, SyntaxFactory.TriviaList(SyntaxFactory.Space))) .WithCloseBraceToken( SyntaxFactory.Token(SyntaxKind.CloseBraceToken))) .WithParameterList( SyntaxFactory.ParameterList() .WithOpenParenToken( SyntaxFactory.Token(SyntaxKind.OpenParenToken)) .WithCloseParenToken( SyntaxFactory.Token( SyntaxFactory.TriviaList(), SyntaxKind.CloseParenToken, SyntaxFactory.TriviaList(SyntaxFactory.Space)))) .WithArrowToken( SyntaxFactory.Token( SyntaxFactory.TriviaList(), SyntaxKind.EqualsGreaterThanToken, SyntaxFactory.TriviaList(SyntaxFactory.Space)))))) .WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken)) .WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken)))) .WithSemicolonToken(SyntaxFactory.Token( SyntaxFactory.TriviaList(), SyntaxKind.SemicolonToken, SyntaxFactory.TriviaList())) .WithTrailingTrivia(lastStatement.GetTrailingTrivia()); editor.RemoveNode(node); editor.ReplaceNode(lastStatement, expression); } }
public static ClassDeclarationSyntax AddWith(TransformationContext context, ClassDeclarationSyntax partialClass, TypeSyntax returnType, List <FieldDeclarationSyntax> fields) { //var withParms = fields.Where(f => f.Declaration.Variables.Count > 0) // .Select(f => (Id: f.Declaration.Variables[0].Identifier, Type: SyntaxFactory.GenericName( // SyntaxFactory.Identifier("WithOpt")) // .WithTypeArgumentList( // SyntaxFactory.TypeArgumentList( // SyntaxFactory.SingletonSeparatedList<TypeSyntax>(f.Declaration.Type))))) // .Select(f => // SyntaxFactory.Parameter(MakeFirstCharUpper(f.Id)) // .WithType(f.Type) // .WithDefault(SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(f.Type)))) // .ToArray(); //var withMethod = SyntaxFactory.MethodDeclaration(returnType, "With") // .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList<ParameterSyntax>(withParms))) // .WithModifiers(SyntaxFactory.TokenList( // SyntaxFactory.Token(SyntaxKind.PublicKeyword))) // .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) // .WithExpressionBody( // SyntaxFactory.ArrowExpressionClause( // SyntaxFactory.ObjectCreationExpression( // returnType, // SyntaxFactory.ArgumentList( // SyntaxFactory.SeparatedList<ArgumentSyntax>( // withParms.Select(wa => // SyntaxFactory.Argument( // SyntaxFactory.InvocationExpression( // SyntaxFactory.MemberAccessExpression( // SyntaxKind.SimpleMemberAccessExpression, // SyntaxFactory.IdentifierName(wa.Identifier), // SyntaxFactory.IdentifierName("IfNone"))) // .WithArgumentList( // SyntaxFactory.ArgumentList( // SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>( // SyntaxFactory.Argument( // SyntaxFactory.MemberAccessExpression( // SyntaxKind.SimpleMemberAccessExpression, // SyntaxFactory.ThisExpression(), // SyntaxFactory.IdentifierName(wa.Identifier)))))))))), // null))); var withParms = fields.Where(f => f.Declaration.Variables.Count > 0) .Select(f => (Field: f, Type: context.SemanticModel.GetTypeInfo(f.Declaration.Type))) .Select(f => (Id: f.Field.Declaration.Variables[0].Identifier, Type: f.Field.Declaration.Type, Info: f.Type)) .Select(f => (f.Id, f.Type, f.Info, IsGeneric: !f.Info.Type.IsValueType && !f.Info.Type.IsReferenceType, ParamType: f.Info.Type.IsValueType ? SyntaxFactory.NullableType(f.Type) : f.Type)) .Select(f => SyntaxFactory.Parameter(MakeFirstCharUpper(f.Id)) .WithType(f.ParamType) .WithDefault( f.IsGeneric ? SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(f.Type)) : SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)))) .ToArray(); var withMethod = SyntaxFactory.MethodDeclaration(returnType, "With") .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(withParms))) .WithModifiers(SyntaxFactory.TokenList( SyntaxFactory.Token(SyntaxKind.PublicKeyword))) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxFactory.ObjectCreationExpression( returnType, SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( withParms.Select(wa => SyntaxFactory.Argument( SyntaxFactory.BinaryExpression( SyntaxKind.CoalesceExpression, SyntaxFactory.IdentifierName(wa.Identifier), SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(wa.Identifier))))))), null))); partialClass = partialClass.AddMembers(withMethod); return(partialClass); }
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node) { var symbol = _semanticModel.GetSymbolInfo(node).Symbol as IMethodSymbol; var innerInvocation = base.VisitInvocationExpression(node) as InvocationExpressionSyntax; var invocationMember = innerInvocation.Expression as MemberAccessExpressionSyntax; if (AssertRecognizer.IsTrueMethod(symbol) || AssertRecognizer.TrueMethod(symbol)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("True"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 2))); } if (AssertRecognizer.IsFalseMethod(symbol) || AssertRecognizer.FalseMethod(symbol)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("False"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 2))); } if (AssertRecognizer.AreEqualMethod(symbol) && innerInvocation.ArgumentList.Arguments.Count == 2) { return(innerInvocation.WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("Equal")))); } if (AssertRecognizer.AreNotEqualMethod(symbol) && innerInvocation.ArgumentList.Arguments.Count == 2) { return(innerInvocation.WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("NotEqual")))); } if (AssertRecognizer.IsNullMethod(symbol)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("Null"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 1))); } if (AssertRecognizer.IsNotNullMethod(symbol)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("NotNull"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 1))); } if (AssertRecognizer.NullMethod(symbol)) { return(innerInvocation .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 1))); } if (AssertRecognizer.NotNullMethod(symbol)) { return(innerInvocation .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 1))); } if (AssertRecognizer.AreSameMethod(symbol)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("Same"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 2))); } if (AssertRecognizer.AreNotSameMethod(symbol)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("NotSame"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 2))); } if (AssertRecognizer.IsEmptyMethod(symbol) && symbol is IMethodSymbol isEmptyMethodSymbol) { if (NetStandardRecognizer.IsIEnumerableParameter(isEmptyMethodSymbol.Parameters.First().Type)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("Empty"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 1))); } if (NetStandardRecognizer.IsStringParameter(isEmptyMethodSymbol.Parameters.First().Type)) { var args = CutArgs(innerInvocation.ArgumentList, 1).Arguments .Insert(0, SyntaxFactory.Argument(GetStringEmpty())); var invocation = innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("Equal"))) .WithArgumentList(SyntaxFactory.ArgumentList(args)); return(invocation); } } if (AssertRecognizer.IsNotEmptyMethod(symbol) && symbol is IMethodSymbol isNotEmptyMethodSymbol) { if (NetStandardRecognizer.IsIEnumerableParameter(isNotEmptyMethodSymbol.Parameters.First().Type)) { return(innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("NotEmpty"))) .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 1))); } if (NetStandardRecognizer.IsStringParameter(isNotEmptyMethodSymbol.Parameters.First().Type)) { var args = CutArgs(innerInvocation.ArgumentList, 1).Arguments .Insert(0, SyntaxFactory.Argument(GetStringEmpty())); var invocation = innerInvocation .WithExpression(invocationMember.WithName(SyntaxFactory.IdentifierName("NotEqual"))) .WithArgumentList(SyntaxFactory.ArgumentList(args)); return(invocation); } } if (AssertRecognizer.ContainsMethod(symbol)) { return(innerInvocation .WithArgumentList(CutArgs(innerInvocation.ArgumentList, 2))); } if (AssertRecognizer.ZeroMethod(symbol)) { return(WithRenameWithFirstParamter(innerInvocation, invocationMember, "Equal", GetZero())); } if (AssertRecognizer.NotZeroMethod(symbol)) { return(WithRenameWithFirstParamter(innerInvocation, invocationMember, "NotEqual", GetZero())); } if (AssertRecognizer.PassMethod(symbol)) { return(WithRenameWithFirstParamter(innerInvocation, invocationMember, "True", GetTrue())); } if (AssertRecognizer.FailMethod(symbol)) { return(WithRenameWithFirstParamter(innerInvocation, invocationMember, "True", GetFalse())); } if (AssertRecognizer.ThrowsMethod(symbol)) { return(WrapInAction(innerInvocation.ArgumentList.Arguments.First().Expression, innerInvocation)); } if (AssertRecognizer.DoesNotThrowMethod(symbol)) { return(GetInnerLambda(innerInvocation.ArgumentList.Arguments.First().Expression, innerInvocation)); } if (AssertRecognizer.ThrowsAsyncMethod(symbol)) { return(SyntaxFactory.AwaitExpression(innerInvocation.WithArgumentList(CutArgs(innerInvocation.ArgumentList, 1)))); } if (AssertRecognizer.DoesNotThrowAsyncMethod(symbol)) { return(GetInnerLambda(innerInvocation.ArgumentList.Arguments.First().Expression, innerInvocation)); } if (AssertRecognizer.IsInstanceOfMethod(symbol)) { return(RewriteInstanceOf(innerInvocation, invocationMember)); } if (AssertRecognizer.IsNotInstanceOfMethod(symbol)) { return(RewriteNotInstanceOf(innerInvocation, invocationMember)); } if (AssertRecognizer.IsAssignableFromMethod(symbol)) { return(RewriteIsAssignableFromMethod(innerInvocation, invocationMember, "True")); } if (AssertRecognizer.IsNotAssignableFromMethod(symbol)) { return(RewriteIsAssignableFromMethod(innerInvocation, invocationMember, "False")); } if (AssertRecognizer.ThatNotGenericMethod(symbol)) { return(RewriteNonGenericThat(innerInvocation, invocationMember, symbol)); } if (AssertRecognizer.ThatMethod(symbol)) { return(RewriteThat(innerInvocation)); } return(innerInvocation); }
private ArgumentListSyntax CutArgs(ArgumentListSyntax args, int take) => SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(args.Arguments.Take(take)));
protected override void GenerateCore() { var valueParameterName = SyntaxFactory.IdentifierName("value"); foreach (var field in this.generator.applyToMetaType.LocalFields) { var withPropertyMethod = SyntaxFactory.MethodDeclaration( GetFullyQualifiedSymbolName(this.generator.applyToSymbol), WithPropertyMethodPrefix + field.Name.ToPascalCase()) .WithAdditionalAnnotations() .AddModifiers( SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddParameterListParameters( SyntaxFactory.Parameter(valueParameterName.Identifier) .WithType(GetFullyQualifiedSymbolName(field.Type))) .WithBody(SyntaxFactory.Block( SyntaxFactory.IfStatement( SyntaxFactory.BinaryExpression( SyntaxKind.EqualsExpression, valueParameterName, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), field.NameAsField)), SyntaxFactory.Block( SyntaxFactory.ReturnStatement(SyntaxFactory.ThisExpression()))), SyntaxFactory.ReturnStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), WithMethodName), SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.NameColon(field.Name), NoneToken, Syntax.OptionalFor(valueParameterName)))))))); this.innerMembers.Add(withPropertyMethod); } foreach (var field in this.generator.applyToMetaType.InheritedFields) { string withMethodName = WithPropertyMethodPrefix + field.Name.ToPascalCase(); var withPropertyMethod = SyntaxFactory.MethodDeclaration( GetFullyQualifiedSymbolName(this.generator.applyToSymbol), withMethodName) .AddModifiers( SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddParameterListParameters( SyntaxFactory.Parameter(valueParameterName.Identifier) .WithType(GetFullyQualifiedSymbolName(field.Type))) .WithBody(SyntaxFactory.Block( SyntaxFactory.ReturnStatement( SyntaxFactory.CastExpression( GetFullyQualifiedSymbolName(this.generator.applyToSymbol), SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.BaseExpression(), SyntaxFactory.IdentifierName(withMethodName)), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(valueParameterName)))))))); this.innerMembers.Add(withPropertyMethod); } }
public override sealed async Task RegisterCodeFixesAsync(CodeFixContext context) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var syntaxNode = root.FindNode(diagnosticSpan); var method = syntaxNode.FirstAncestorOrSelf <MethodDeclarationSyntax>(); if (method.Body.CloseBraceToken.IsMissing || method.Body.OpenBraceToken.IsMissing) { return; } context.RegisterCodeFix( CodeAction.Create( TitleComment, c => { var newMethodBody = method.Body; newMethodBody = newMethodBody .WithOpenBraceToken(newMethodBody.OpenBraceToken .WithTrailingTrivia(SyntaxFactory.TriviaList() .Add(SyntaxFactory.EndOfLine(Environment.NewLine)))); newMethodBody = newMethodBody .WithCloseBraceToken(newMethodBody.CloseBraceToken .WithLeadingTrivia(SyntaxFactory.TriviaList() .Add(SyntaxFactory.Comment("// Method intentionally left empty.")) .Add(SyntaxFactory.EndOfLine(Environment.NewLine)))); var newRoot = root.ReplaceNode( method.Body, newMethodBody.WithTriviaFrom(method.Body).WithAdditionalAnnotations(Formatter.Annotation)); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }, TitleComment), context.Diagnostics); var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); const string LiteralNotSupportedException = "NotSupportedException"; const string LiteralSystem = "System"; var systemNeedsToBeAdded = NamespaceNeedsToBeAdded(method, semanticModel, LiteralNotSupportedException, LiteralSystem); var memberAccessRoot = systemNeedsToBeAdded ? (NameSyntax)SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName(LiteralSystem), SyntaxFactory.IdentifierName(LiteralNotSupportedException)) : SyntaxFactory.IdentifierName(LiteralNotSupportedException); context.RegisterCodeFix( CodeAction.Create( TitleThrow, c => { var newRoot = root.ReplaceNode(method.Body, method.Body.WithStatements( SyntaxFactory.List( new StatementSyntax[] { SyntaxFactory.ThrowStatement( SyntaxFactory.ObjectCreationExpression( memberAccessRoot, SyntaxFactory.ArgumentList(), null)) })) .WithTriviaFrom(method.Body) .WithAdditionalAnnotations(Formatter.Annotation)); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }, TitleThrow), context.Diagnostics); }
private static async Task RegisterCodeFixesForMethodsAsync(CodeFixContext context, SyntaxNode root, MethodDeclarationSyntax method) { context.RegisterCodeFix( CodeAction.Create( TitleComment, c => { var newMethodBody = method.Body; newMethodBody = newMethodBody .WithOpenBraceToken(newMethodBody.OpenBraceToken .WithTrailingTrivia(SyntaxFactory.TriviaList() .Add(SyntaxFactory.EndOfLine(Environment.NewLine)))); newMethodBody = newMethodBody .WithCloseBraceToken(newMethodBody.CloseBraceToken .WithLeadingTrivia(SyntaxFactory.TriviaList() .Add(SyntaxFactory.Comment("// Method intentionally left empty.")) .Add(SyntaxFactory.EndOfLine(Environment.NewLine)))); var newRoot = root.ReplaceNode( method.Body, newMethodBody.WithTriviaFrom(method.Body).WithAdditionalAnnotations(Formatter.Annotation)); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }, TitleComment), context.Diagnostics); var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); var systemNeedsToBeAdded = NamespaceNeedsToBeAdded(method, semanticModel); var memberAccessRoot = systemNeedsToBeAdded ? (NameSyntax)SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName(LiteralSystem), SyntaxFactory.IdentifierName(LiteralNotSupportedException)) : SyntaxFactory.IdentifierName(LiteralNotSupportedException); context.RegisterCodeFix( CodeAction.Create( TitleThrow, c => { var newRoot = root.ReplaceNode(method.Body, method.Body.WithStatements( SyntaxFactory.List( new StatementSyntax[] { SyntaxFactory.ThrowStatement( SyntaxFactory.ObjectCreationExpression( memberAccessRoot, SyntaxFactory.ArgumentList(), null)) })) .WithTriviaFrom(method.Body) .WithAdditionalAnnotations(Formatter.Annotation)); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }, TitleThrow), context.Diagnostics); }
private static ArgumentListSyntax GenerateArgumentList(IList <SyntaxNode> arguments) { return(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments.Select(ArgumentGenerator.GenerateArgument)))); }
private ArgumentListSyntax GetLambdaAsArgument(SyntaxToken token, ExpressionSyntax lambdaArgument) { return(SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(lambdaArgument)))); }
public static ArgumentListSyntax GenerateArgumentList(IList <SyntaxNode> arguments) => SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList(arguments.Select(GenerateArgument)) );
static ArgumentListSyntax ArgumentList(params ExpressionSyntax [] argumentExpressions) => SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList( argumentExpressions.Select(SyntaxFactory.Argument)));
static ITypeSymbol CreateClass(MonoDevelop.Projects.Project project, Stetic.ActionGroupComponent group, string name, string namspace, string folder) { string fullName = namspace.Length > 0 ? namspace + "." + name : name; var type = SyntaxFactory.ClassDeclaration(name) .AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("Gtk.ActionGroup"))); // Generate the constructor. It contains the call that builds the widget. var ctor = SyntaxFactory.ConstructorDeclaration( new SyntaxList <AttributeListSyntax> (), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), SyntaxFactory.Identifier(name), SyntaxFactory.ParameterList(), SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseKeyword, SyntaxFactory.ArgumentList(new SeparatedSyntaxList <ArgumentSyntax> { SyntaxFactory.Argument(SyntaxFactory.ParseExpression(fullName)) })), SyntaxFactory.Block( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression("Stetic.Gui.Build"), SyntaxFactory.ArgumentList( new SeparatedSyntaxList <ArgumentSyntax> { SyntaxFactory.Argument(SyntaxFactory.ThisExpression()), SyntaxFactory.Argument(SyntaxFactory.ParseExpression(fullName)) } ) ) ) ) ); type = type.AddMembers(ctor); // Add signal handlers foreach (Stetic.ActionComponent action in group.GetActions()) { foreach (Stetic.Signal signal in action.GetSignals()) { var parameters = new SeparatedSyntaxList <ParameterSyntax> (); foreach (var p in signal.SignalDescriptor.HandlerParameters) { parameters = parameters.Add(SyntaxFactory.Parameter(new SyntaxList <AttributeListSyntax> (), SyntaxFactory.TokenList(), SyntaxFactory.ParseTypeName(p.TypeName), SyntaxFactory.Identifier(p.Name), null)); } var met = SyntaxFactory.MethodDeclaration( new SyntaxList <AttributeListSyntax> (), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)), SyntaxFactory.ParseTypeName(signal.SignalDescriptor.HandlerReturnTypeName), null, SyntaxFactory.Identifier(signal.Handler), null, SyntaxFactory.ParameterList(parameters), new SyntaxList <TypeParameterConstraintClauseSyntax> (), SyntaxFactory.Block(), null ); type = type.AddMembers(met); } } // Create the class return(CodeGenerationService.AddType((DotNetProject)project, folder, namspace, type)); }
protected void GenerateForClass(NodeTypeInfo nodeTypeInfo, SemanticModel semanticModel) { var outputFile = (CodeFileCSharp)this.outputStream.CreateCodeFile($"{ nodeTypeInfo.DeclaredType.Name}.cs"); var unit = SyntaxFactory.CompilationUnit(); unit = unit.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Collections.Generic"))); unit = unit.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Linq"))); var nsContainer = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(this.Settings.OutputNamespace)); var nodeClass = SyntaxFactory.ClassDeclaration(nodeTypeInfo.DeclaredType.Name); nodeClass = nodeClass.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); if (nodeTypeInfo.DeclaredType.IsAbstract) { nodeClass = nodeClass.AddModifiers(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } nodeClass = nodeClass.AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); if (!string.IsNullOrEmpty(nodeTypeInfo.BaseTypeString)) { nodeClass = nodeClass .WithBaseList( SyntaxFactory .BaseList( SyntaxFactory.Token(SyntaxKind.ColonToken), SyntaxFactory.SeparatedList( new BaseTypeSyntax[] { SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(nodeTypeInfo.BaseTypeString)) }))); } foreach (var member in nodeTypeInfo.Members.Where(m => !m.IsInherited && !m.IsCollection)) { nodeClass = nodeClass.AddMembers( SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration( SyntaxFactory.ParseTypeName(member.FullySpecifiedOutputTypeString), SyntaxFactory.SeparatedList(new VariableDeclaratorSyntax[] { SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(member.DestinationFieldName)) })))); } var constructor = SyntaxFactory.ConstructorDeclaration(nodeTypeInfo.DeclaredType.Name); constructor = constructor.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); List<StatementSyntax> statements = new List<StatementSyntax>(); foreach (var member in nodeTypeInfo.Members.Where(m => !m.IsInherited && m.IsCollection)) { ExpressionSyntax right = null; if (member.ItemTypeInheritsFromSourceNodeType) { right = SyntaxFactory.ObjectCreationExpression( SyntaxFactory.ParseTypeName(member.CollectionTypeString), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new ArgumentSyntax[] { SyntaxFactory.Argument(SyntaxFactory.ThisExpression()) })), null); } else { right = SyntaxFactory.ObjectCreationExpression( SyntaxFactory.ParseTypeName(member.CollectionTypeString), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>()), null); } statements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.OriginalField.Name)), right))); } constructor = constructor.WithBody(SyntaxFactory.Block(statements)); nodeClass = nodeClass.AddMembers(constructor); foreach (var member in nodeTypeInfo.Members.Where(m => !m.IsInherited)) { if (member.IsCollection) { nodeClass = nodeClass.AddMembers( SyntaxFactory .PropertyDeclaration( SyntaxFactory.ParseTypeName(member.CollectionTypeString), member.OriginalField.Name) .WithAccessorList( SyntaxFactory.AccessorList( SyntaxFactory.List<AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[] { SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) }))) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))); } else { List<StatementSyntax> setterStatements = new List<StatementSyntax>(); if (member.TypeInheritsFromSourceNodeType) { setterStatements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName("SetAsParentFor")), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList(new ArgumentSyntax[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.DestinationFieldName))), SyntaxFactory.Argument(SyntaxFactory.IdentifierName("value")) }))))); } else { if (!string.IsNullOrEmpty(this.Settings.AllowedModificationCheckMethodName)) { setterStatements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(this.Settings.AllowedModificationCheckMethodName)), SyntaxFactory.ArgumentList()))); } } setterStatements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.DestinationFieldName)), SyntaxFactory.IdentifierName("value") ))); nodeClass = nodeClass.AddMembers( SyntaxFactory .PropertyDeclaration( SyntaxFactory.ParseTypeName(member.FullySpecifiedOutputTypeString), member.OriginalField.Name) .WithAccessorList( SyntaxFactory.AccessorList( SyntaxFactory.List<AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[] { SyntaxFactory.AccessorDeclaration( SyntaxKind.GetAccessorDeclaration, SyntaxFactory.Block(new StatementSyntax[] { SyntaxFactory.ReturnStatement( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.DestinationFieldName))) })), SyntaxFactory.AccessorDeclaration( SyntaxKind.SetAccessorDeclaration, SyntaxFactory.Block(setterStatements)) }))) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))); } } if (!nodeTypeInfo.DeclaredType.IsAbstract) { var toLtsModelNodeMethodName = "ToLtsModelNode"; string resultVarName = "result"; List<StatementSyntax> methodStatements = new List<StatementSyntax>(); methodStatements.Add( SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.VariableDeclaration( SyntaxFactory.ParseTypeName("var"), SyntaxFactory.SeparatedList(new VariableDeclaratorSyntax[] { SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier(resultVarName), null, SyntaxFactory.EqualsValueClause( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.ParseTypeName(nodeTypeInfo.DeclaredType.ToMinimalDisplayString(semanticModel, 0, SymbolDisplayFormat.MinimallyQualifiedFormat)), SyntaxFactory.ArgumentList(), null))) })))); foreach (var member in nodeTypeInfo.Members) { if (member.IsCollection) { if (member.ItemTypeInheritsFromSourceNodeType) { //// Makes an assumption that source collection is List. Should be changed. var lambdaParameterName = "i"; methodStatements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(resultVarName), SyntaxFactory.IdentifierName(member.OriginalField.Name)), SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.OriginalField.Name)), SyntaxFactory.IdentifierName("Select")), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList( new ArgumentSyntax[] { SyntaxFactory.Argument( SyntaxFactory.ParenthesizedLambdaExpression( SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList<ParameterSyntax>() .Add(SyntaxFactory.Parameter(SyntaxFactory.Identifier(lambdaParameterName)))), SyntaxFactory.CastExpression( SyntaxFactory.ParseTypeName(member.ItemType.ToMinimalDisplayString(semanticModel, 0, SymbolDisplayFormat.MinimallyQualifiedFormat)), SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(lambdaParameterName), SyntaxFactory.IdentifierName(toLtsModelNodeMethodName)))))) }))), SyntaxFactory.IdentifierName("ToList")))))); } else { //// Makes an assumption that collection can be constructed with IEnumerable as an argument to populate it. Not very nice. methodStatements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(resultVarName), SyntaxFactory.IdentifierName(member.OriginalField.Name)), SyntaxFactory.ObjectCreationExpression( SyntaxFactory.ParseTypeName(member.OriginalField.Type.ToMinimalDisplayString(semanticModel, 0, SymbolDisplayFormat.MinimallyQualifiedFormat)), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList(new ArgumentSyntax[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.OriginalField.Name))) })), null)))); } } else { if (member.TypeInheritsFromSourceNodeType) { methodStatements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(resultVarName), SyntaxFactory.IdentifierName(member.OriginalField.Name)), SyntaxFactory.CastExpression( SyntaxFactory.ParseTypeName(member.OriginalField.Type.ToMinimalDisplayString(semanticModel, 0, SymbolDisplayFormat.MinimallyQualifiedFormat)), SyntaxFactory.InvocationExpression( SyntaxFactory.ConditionalAccessExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.OriginalField.Name)), SyntaxFactory.MemberBindingExpression( SyntaxFactory.IdentifierName(toLtsModelNodeMethodName)) )))))); } else { methodStatements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(resultVarName), SyntaxFactory.IdentifierName(member.OriginalField.Name)), SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(member.OriginalField.Name))))); } } } methodStatements.Add(SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(resultVarName))); ////initializerExpressions = initializerExpressions.Select(e => e.WithLeadingTrivia(SyntaxFactory.Whitespace("\n"))).ToList(); nodeClass = nodeClass.AddMembers( SyntaxFactory.MethodDeclaration( SyntaxFactory.ParseTypeName(this.Settings.SourceNodeBaseType), toLtsModelNodeMethodName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.OverrideKeyword)) .WithBody(SyntaxFactory.Block(methodStatements)) ); } nsContainer = nsContainer.AddMembers(nodeClass); unit = unit.AddMembers(nsContainer); outputFile.SyntaxTree = unit.SyntaxTree; }
public static ClassDeclarationSyntax AddLens(ClassDeclarationSyntax partialClass, TypeSyntax returnType, FieldDeclarationSyntax field) { var lfield = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration( SyntaxFactory.GenericName(SyntaxFactory.Identifier("Lens")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList <TypeSyntax>(new[] { returnType, field.Declaration.Type })))) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator(MakeFirstCharLower(field.Declaration.Variables[0].Identifier)) .WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.GenericName("Lens") .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SeparatedList <TypeSyntax>(new[] { returnType, field.Declaration.Type }))), SyntaxFactory.IdentifierName("New"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.SimpleLambdaExpression( SyntaxFactory.Parameter( SyntaxFactory.Identifier("_x")), SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_x"), SyntaxFactory.IdentifierName(field.Declaration.Variables[0].Identifier.ToString())))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument( SyntaxFactory.SimpleLambdaExpression( SyntaxFactory.Parameter( SyntaxFactory.Identifier("_x")), SyntaxFactory.SimpleLambdaExpression( SyntaxFactory.Parameter( SyntaxFactory.Identifier("_y")), SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_y"), SyntaxFactory.IdentifierName("With"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.Argument( SyntaxFactory.IdentifierName("_x")) .WithNameColon( SyntaxFactory.NameColon(field.Declaration.Variables[0].Identifier.ToString())))))))) })))))))); lfield = lfield.WithModifiers( SyntaxFactory.TokenList( SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))); return(partialClass.AddMembers(lfield)); }
/// <summary> /// Rewrites the expression with a create remote machine expression. /// </summary> /// <param name="node">InvocationExpressionSyntax</param> /// <returns>SyntaxNode</returns> private SyntaxNode RewriteStatement(InvocationExpressionSyntax node) { var arguments = new List <ArgumentSyntax>(node.ArgumentList.Arguments); var machineIdentifier = arguments[0].ToString(); SyntaxNode models = null; var parent = node.FirstAncestorOrSelf <ExpressionStatementSyntax>(); if (parent != null) { models = base.GetNextStatement(parent); if (models != null && (models is LocalDeclarationStatementSyntax) && (models as LocalDeclarationStatementSyntax).Declaration. Type.ToString().Equals("models")) { if (!Configuration.RunStaticAnalysis && !Configuration.RunDynamicAnalysis) { machineIdentifier = (models as LocalDeclarationStatementSyntax). Declaration.Variables[0].Identifier.ValueText; } } else { models = null; } } arguments[0] = SyntaxFactory.Argument(SyntaxFactory.TypeOfExpression( SyntaxFactory.IdentifierName(machineIdentifier))); var text = ""; if (base.IsMonitor(machineIdentifier)) { if (!Configuration.RunStaticAnalysis && !Configuration.RunDynamicAnalysis) { this.ToRemove.Add(node); if (models != null) { this.ToRemove.Add(models); } return(node); } text += "this.CreateMonitor"; } else if (Configuration.CompileForDistribution) { text += "this.CreateRemoteMachine"; } else { text += "this.CreateMachine"; } var rewritten = node. WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))). WithExpression(SyntaxFactory.IdentifierName(text)). WithTriviaFrom(node); if (models != null) { node = node.WithoutTrailingTrivia(); this.ToReplace.Add(models); } return(rewritten); }
/// <summary> /// Gets the syntax for the creation of an anonymous type. /// </summary> /// <param name="tableElement">The description of a table.</param> /// <returns>A set of expression that enlists the table in a transaction.</returns> public static List <StatementSyntax> GetSyntax(TableElement tableElement) { // Validate the argument. if (tableElement == null) { throw new ArgumentNullException(nameof(tableElement)); } // This is used to collect the statements. List <StatementSyntax> statements = new List <StatementSyntax>(); // transaction.EnlistVolatile(this.domain.Accounts, EnlistmentOptions.None); statements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("transaction"), SyntaxFactory.IdentifierName("EnlistVolatile"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())), SyntaxFactory.IdentifierName(tableElement.Name.ToPlural()))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("EnlistmentOptions"), SyntaxFactory.IdentifierName("None"))), }))))); // Enlist each of the unique key indices in this transaction. foreach (UniqueKeyElement uniqueKeyElement in tableElement.UniqueKeys) { // transaction.EnlistVolatile(this.domain.Accounts.AccountExternalKey, EnlistmentOptions.None); statements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("transaction"), SyntaxFactory.IdentifierName("EnlistVolatile"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())), SyntaxFactory.IdentifierName(uniqueKeyElement.Table.Name.ToPlural())), SyntaxFactory.IdentifierName(uniqueKeyElement.Name))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("EnlistmentOptions"), SyntaxFactory.IdentifierName("None"))), }))))); } // Enlist each of the foreign key indices in this transaction. foreach (ForeignKeyElement foreignKeyElement in tableElement.ParentKeys) { // transaction.EnlistVolatile(this.domain.Accounts.EntityAccountKey, EnlistmentOptions.None); statements.Add( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("transaction"), SyntaxFactory.IdentifierName("EnlistVolatile"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())), SyntaxFactory.IdentifierName(foreignKeyElement.Table.Name.ToPlural())), SyntaxFactory.IdentifierName(foreignKeyElement.Name))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("EnlistmentOptions"), SyntaxFactory.IdentifierName("None"))), }))))); } // This set of statement will enlist the indices and tables in the current transaction and acquire an exclusive lock. return(statements); }
/// <summary> /// Creates an argument that creates a lambda expression for extracting the key from a class. /// </summary> /// <param name="uniqueKeyElement">The unique key element.</param> /// <param name="isAnonymous">Indicates we should create an anonymous key for Entity Framework.</param> /// <returns>An argument that extracts a key from an object.</returns> public static ExpressionSyntax GetUniqueKey(UniqueKeyElement uniqueKeyElement, bool isAnonymous = false) { // Validate the parameter if (uniqueKeyElement == null) { throw new ArgumentNullException(nameof(uniqueKeyElement)); } // Used as a variable when constructing the lambda expression. string abbreviation = uniqueKeyElement.Table.Name[0].ToString(CultureInfo.InvariantCulture).ToLowerInvariant(); // This will create an expression for extracting the key from record. CSharpSyntaxNode syntaxNode = null; if (uniqueKeyElement.Columns.Count == 1) { // A simple key can be used like a value type. syntaxNode = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(abbreviation), SyntaxFactory.IdentifierName(uniqueKeyElement.Columns[0].Column.Name)); } else { // A Compound key must be constructed from an anomymous type. List <SyntaxNodeOrToken> keyElements = new List <SyntaxNodeOrToken>(); foreach (ColumnReferenceElement columnReferenceElement in uniqueKeyElement.Columns) { if (keyElements.Count != 0) { keyElements.Add(SyntaxFactory.Token(SyntaxKind.CommaToken)); } if (isAnonymous) { keyElements.Add( SyntaxFactory.AnonymousObjectMemberDeclarator( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(abbreviation), SyntaxFactory.IdentifierName(columnReferenceElement.Column.Name)))); } else { keyElements.Add( SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(abbreviation), SyntaxFactory.IdentifierName(columnReferenceElement.Column.Name)))); } } if (isAnonymous) { // b => b.BuyerId or b => new { b.BuyerId, b.ExternalId0 } syntaxNode = SyntaxFactory.AnonymousObjectCreationExpression( SyntaxFactory.SeparatedList <AnonymousObjectMemberDeclaratorSyntax>(keyElements.ToArray())); } else { // b => b.BuyerId or p => ValueTuple.Create(p.Name, p.CountryCode) syntaxNode = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("ValueTuple"), SyntaxFactory.IdentifierName("Create"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>(keyElements.ToArray()))); } } // this.BuyerKey = new SimpleUniqueKeyIndex<Buyer>("BuyerKey").HasIndex(b => b.BuyerId); return(SyntaxFactory.SimpleLambdaExpression(SyntaxFactory.Parameter(SyntaxFactory.Identifier(abbreviation)), syntaxNode)); }
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node) { if (this.lambdaStack.Any()) { return(node); } if (node.Expression.Kind() == SyntaxKind.IdentifierName) { if ((node.Expression as IdentifierNameSyntax)?.Identifier.Text == "nameof") { return(node); } } var originalNodeStart = node.SpanStart + this.displacement; var explicitExtensionMethodCall = false; var result = this.semanticModel.GetSpeculativeSymbolInfo(node.SpanStart + displacement, node, SpeculativeBindingOption.BindAsExpression); if (result.Symbol == null) { var newNode = node.WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(node.ArgumentList.Arguments .Where(c => this.GetArgumentType(c) != this.cancellationTokenSymbol)))); var visited = this.Visit(node.Expression); if (visited is MemberAccessExpressionSyntax) { var memberAccess = (MemberAccessExpressionSyntax)visited; if (memberAccess.Name.Identifier.Text.EndsWith("Async")) { var newExp = memberAccess.WithName(SyntaxFactory.IdentifierName(Regex.Replace(memberAccess.Name.Identifier.Text, "Async$", ""))); newNode = newExp == null ? null : newNode.WithExpression(newExp); } else { newNode = null; } } else if (visited is IdentifierNameSyntax) { var identifier = (IdentifierNameSyntax)visited; if (identifier.Identifier.Text.EndsWith("Async")) { var newExp = identifier.WithIdentifier(SyntaxFactory.Identifier(Regex.Replace(identifier.Identifier.Text, "Async$", ""))); newNode = newExp == null ? null : newNode.WithExpression(newExp); } else { newNode = null; } } else { newNode = null; } IMethodSymbol syncMethod; if (newNode != null && (syncMethod = (IMethodSymbol)(this.semanticModel.ParentModel ?? this.semanticModel).GetSpeculativeSymbolInfo(node.SpanStart, newNode, SpeculativeBindingOption.BindAsExpression).Symbol) != null) { if (syncMethod.HasRewriteAsyncApplied()) { var retval = node .WithExpression((ExpressionSyntax)visited) .WithArgumentList((ArgumentListSyntax)this.VisitArgumentList(node.ArgumentList)); var defaultExpression = SyntaxFactory.DefaultExpression(SyntaxFactory.ParseTypeName($"Task<" + syncMethod.ReturnType + ">")); var actualNode = this.semanticModel.SyntaxTree.GetRoot().FindNode(new TextSpan(originalNodeStart, node.Span.Length)); this.displacement += -this.methodSyntax.SpanStart - (node.FullSpan.Length - defaultExpression.FullSpan.Length); this.methodSyntax = this.methodSyntax.ReplaceNode(actualNode, defaultExpression); this.displacement += this.methodSyntax.SpanStart; return(retval); } } return(node .WithExpression((ExpressionSyntax)this.Visit(node.Expression)) .WithArgumentList((ArgumentListSyntax)this.VisitArgumentList(node.ArgumentList))); } var methodSymbol = (IMethodSymbol)result.Symbol; var methodParameters = (methodSymbol.ReducedFrom ?? methodSymbol).ExtensionMethodNormalizingParameters().ToArray(); IMethodSymbol candidate; int cancellationTokenPos; if (methodSymbol.HasRewriteAsyncApplied()) { candidate = methodSymbol; cancellationTokenPos = methodParameters.TakeWhile(p => !p.IsOptional && !p.IsParams).Count(); } else { if (this.excludeTypes.Contains(methodSymbol.ContainingType)) { return(node .WithExpression((ExpressionSyntax)this.Visit(node.Expression)) .WithArgumentList((ArgumentListSyntax)this.VisitArgumentList(node.ArgumentList))); } var expectedParameterTypes = new List <ITypeSymbol>(); expectedParameterTypes.AddRange(methodParameters.TakeWhile(c => !(c.HasExplicitDefaultValue || c.IsParams)).Select(c => c.Type)); expectedParameterTypes.Add(this.cancellationTokenSymbol); expectedParameterTypes.AddRange(methodParameters.SkipWhile(c => !(c.HasExplicitDefaultValue || c.IsParams)).Select(c => c.Type)); var asyncCandidates1 = methodSymbol .ContainingType .GetMembers() .Where(c => Regex.IsMatch(c.Name, methodSymbol.Name + "Async" + @"(`[0-9])?")) .OfType <IMethodSymbol>() .ToList(); candidate = asyncCandidates1.FirstOrDefault(c => c.ExtensionMethodNormalizingParameters().Select(d => d.Type).SequenceEqual(expectedParameterTypes, TypeSymbolExtensions.EqualsToIgnoreGenericParametersEqualityComparer.Default)) ?? asyncCandidates1.FirstOrDefault(c => c.ExtensionMethodNormalizingParameters().Select(d => d.Type).SequenceEqual(methodParameters.Select(e => e.Type), TypeSymbolExtensions.EqualsToIgnoreGenericParametersEqualityComparer.Default)); if (candidate == null) { var asyncCandidates2 = this.extensionMethodLookup.GetExtensionMethods(methodSymbol.Name + "Async", this.GetInvocationTargetType(originalNodeStart, node, methodSymbol)).ToList(); candidate = asyncCandidates2.FirstOrDefault(c => c.ExtensionMethodNormalizingParameters().Select(d => d.Type).SequenceEqual(expectedParameterTypes, TypeSymbolExtensions.EqualsToIgnoreGenericParametersEqualityComparer.Default)) ?? asyncCandidates2.FirstOrDefault(c => c.ExtensionMethodNormalizingParameters().Select(d => d.Type).SequenceEqual(methodParameters.Select(e => e.Type), TypeSymbolExtensions.EqualsToIgnoreGenericParametersEqualityComparer.Default)); if (candidate != null) { explicitExtensionMethodCall = true; } else { return(node .WithExpression((ExpressionSyntax)this.Visit(node.Expression)) .WithArgumentList((ArgumentListSyntax)this.VisitArgumentList(node.ArgumentList))); } } if (candidate.ExtensionMethodNormalizingParameters().Any(c => c.Type == this.cancellationTokenSymbol)) { cancellationTokenPos = candidate.ExtensionMethodNormalizingParameters().Count(c => c.Type != this.cancellationTokenSymbol); } else { cancellationTokenPos = -1; } } node = node .WithExpression((ExpressionSyntax)this.Visit(node.Expression)) .WithArgumentList((ArgumentListSyntax)this.VisitArgumentList(node.ArgumentList)); return(this.InspectExpression(node, cancellationTokenPos, candidate, explicitExtensionMethodCall)); }
/// <summary> /// Gets the syntax for the creation of an anonymous type. /// </summary> /// <param name="tableElement">The description of a table.</param> /// <param name="bodyStatements">The statements that appear in the body of the using block.</param> /// <returns>An expression that builds an anonymous type from a table description.</returns> public static List <StatementSyntax> GetSyntax(TableElement tableElement, IEnumerable <StatementSyntax> bodyStatements) { // Validate the argument. if (tableElement == null) { throw new ArgumentNullException(nameof(tableElement)); } // This is used to collect the statements. List <StatementSyntax> statements = new List <StatementSyntax>(); // using (TransactionScope transactionScope = new TransactionScope()) UsingStatementSyntax usingStatement = SyntaxFactory.UsingStatement( SyntaxFactory.Block(bodyStatements)) .WithDeclaration( SyntaxFactory.VariableDeclaration( SyntaxFactory.IdentifierName("var")) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("transactionScope")) .WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName("TransactionScope")) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("TransactionScopeOption"), SyntaxFactory.IdentifierName("RequiresNew"))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName("transactionTimeout"))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("TransactionScopeAsyncFlowOption"), SyntaxFactory.IdentifierName("Enabled"))), })))))))); // using (var disposables = new DisposableList()) usingStatement = SyntaxFactory.UsingStatement(usingStatement) .WithDeclaration( SyntaxFactory.VariableDeclaration( SyntaxFactory.IdentifierName("var")) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("disposables")) .WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName("DisposableList")) .WithArgumentList( SyntaxFactory.ArgumentList())))))); // using (await this.domain.Accounts.Lock.WriteLockAsync()) // using (await this.domain.Accounts.AccountExternalKey.Lock.WriteLockAsync()) // using (await this.domain.Accounts.AccountKey.Lock.WriteLockAsync()) // using (await this.domain.Accounts.EntityAccountKey.Lock.WriteLockAsync()) foreach (ForeignKeyElement foreignKeyElement in tableElement.ParentKeys.AsEnumerable().Reverse()) { // using (await this.Accounts.EntityAccountKey.Lock.WriteLockAsync()) usingStatement = SyntaxFactory.UsingStatement(usingStatement) .WithExpression( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())), SyntaxFactory.IdentifierName(foreignKeyElement.Table.Name.ToPlural())), SyntaxFactory.IdentifierName(foreignKeyElement.Name)), SyntaxFactory.IdentifierName("Lock")), SyntaxFactory.IdentifierName("WriteLockAsync"))))); } // Lock each of the unique key indices foreach (UniqueKeyElement uniqueKeyElement in tableElement.UniqueKeys.AsEnumerable().Reverse()) { // using (await this.domain.Accounts.AccountKey.Lock.WriteLockAsync()) usingStatement = SyntaxFactory.UsingStatement(usingStatement) .WithExpression( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())), SyntaxFactory.IdentifierName(uniqueKeyElement.Table.Name.ToPlural())), SyntaxFactory.IdentifierName(uniqueKeyElement.Name)), SyntaxFactory.IdentifierName("Lock")), SyntaxFactory.IdentifierName("WriteLockAsync"))))); } // Finally, lock the table. // using (await this.domain.Accounts.Lock.WriteLockAsync()) usingStatement = SyntaxFactory.UsingStatement(usingStatement) .WithExpression( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())), SyntaxFactory.IdentifierName(tableElement.Name.ToPlural())), SyntaxFactory.IdentifierName("Lock")), SyntaxFactory.IdentifierName("WriteLockAsync"))))); // This puts all the other 'using' statements into a big block with the transaction as the first item. This order also insures that // the transaction is also the last to be disposed. // using (await this.Accounts.Lock.WriteLockAsync()) // using (await this.Accounts.AccountExternalKey.Lock.WriteLockAsync()) // using (await this.ManagedAccounts.AccountExternalKey.Lock.WriteLockAsync()) // using (var disposables = new DisposableList()) // using (var transactionScope = new TransactionScope()) // { // <LoadDomain> // } statements.Add(usingStatement); // This set of statement will enlist the indices and tables in the current transaction and acquire an exclusive lock. return(statements); }
private BlockSyntax CreateMethodBody(SemanticModel model, INamedTypeSymbol typeSymbol, IMethodSymbol methodSymbol) { var currentDeclarator = SyntaxFactory.VariableDeclarator("current"); var variableCurrent = SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(methodSymbol.Parameters.First().Type.Name), new SeparatedSyntaxList <VariableDeclaratorSyntax>().Add(currentDeclarator)); var allVisitMethods = GetVisitMethods(typeSymbol, true).ToList(); var thisKeyword = SyntaxFactory.Token(SyntaxKind.ThisKeyword); var expressionParam = SyntaxFactory.IdentifierName("expression"); var tryGetValue = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("TryGetCurrent"), SyntaxFactory.ArgumentList().AddArguments(SyntaxFactory.Argument(expressionParam), SyntaxFactory.Argument(SyntaxFactory.IdentifierName(currentDeclarator.Identifier.Text)).WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)))); var ifTryGetValue = SyntaxFactory .IfStatement(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, tryGetValue), SyntaxFactory.Block(SyntaxFactory.ReturnStatement(expressionParam))); var properties = GetProperties((INamedTypeSymbol)methodSymbol.Parameters.First().Type).Where(c => c.Name != "CanReduce").ToList(); var simpleProperties = properties .Where(c => !IsOfType(c.Type, "Expression") && !IsOfType(c.Type, "IReadOnlyList") && allVisitMethods.All(d => d.Parameters[0].Type.Name != c.Type.Name)) .ToList(); var expressionProperties = properties .Where(c => IsOfType(c.Type, "Expression") || (!IsOfType(c.Type, "IReadOnlyList") && allVisitMethods.Any(d => d.Parameters[0].Type.Name == c.Type.Name))) .ToList(); var collectionProperties = properties .Where(c => IsOfType(c.Type, "IReadOnlyList")) .ToList(); var result = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("this"), SyntaxFactory.IdentifierName("result")); var currentObject = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("this"), SyntaxFactory.IdentifierName("currentObject")); var simplePropertyChecks = simpleProperties.Select(c => { var type = c.Type; var fullname = type.ToDisplayString(new SymbolDisplayFormat(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces)); if (type.IsValueType || fullname == "System.Type" || fullname == "System.Reflection.FieldInfo" || fullname == "System.Reflection.MethodInfo" || fullname == "System.Reflection.PropertyInfo") { return((ExpressionSyntax)SyntaxFactory.BinaryExpression ( SyntaxKind.EqualsExpression, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("current"), SyntaxFactory.IdentifierName(c.Name)), SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("expression"), SyntaxFactory.IdentifierName(c.Name)) )); } else { return(SyntaxFactory.InvocationExpression ( SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("object"), SyntaxFactory.IdentifierName("Equals")), SyntaxFactory.ArgumentList().AddArguments ( SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("current"), SyntaxFactory.IdentifierName(c.Name))), SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("expression"), SyntaxFactory.IdentifierName(c.Name))) ) )); } }) .Select(c => SyntaxFactory.AssignmentExpression(SyntaxKind.AndAssignmentExpression, result, c)) .Select(c => SyntaxFactory.IfStatement(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, SyntaxFactory.ParenthesizedExpression(c)), SyntaxFactory.Block(SyntaxFactory.ReturnStatement(expressionParam)))) .ToArray <StatementSyntax>(); var visitMethod = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("this"), SyntaxFactory.IdentifierName("Visit")); var expressionPropertyChecks = expressionProperties.Select(c => new StatementSyntax[] { SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, currentObject, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("current"), SyntaxFactory.IdentifierName(c.Name)))), SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(allVisitMethods.FirstOrDefault(d => d.Parameters[0].Type.Name == c.Type.Name) == null ? visitMethod : SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("this"), SyntaxFactory.IdentifierName(allVisitMethods.FirstOrDefault(d => d.Parameters[0].Type.Name == c.Type.Name).Name)), SyntaxFactory.ArgumentList().AddArguments(SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("expression"), SyntaxFactory.IdentifierName(c.Name)))))), SyntaxFactory.IfStatement(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, result), SyntaxFactory.Block(SyntaxFactory.ReturnStatement(expressionParam))), }) .SelectMany(c => c) .ToArray(); var collectionPropertyChecks = collectionProperties.Select(c => { var readonlyInterface = c.Type.AllInterfaces.Concat(new [] { c.Type }).Single(d => d.Name == "IReadOnlyList"); var type = ((INamedTypeSymbol)readonlyInterface).TypeArguments[0]; var visitMethodToCall = allVisitMethods.FirstOrDefault(d => d.Parameters[0].Type.AllInterfaces.Concat(new[] { d.Parameters[0].Type as INamedTypeSymbol }).Any(e => e.Name == "IReadOnlyList" && e.TypeArguments[0].Name == type.Name)); if (visitMethodToCall == null) { if (IsOfType(type, "Expression")) { visitMethodToCall = allVisitMethods.FirstOrDefault(d => d.Parameters[0].Type.AllInterfaces.Concat(new[] { d.Parameters[0].Type as INamedTypeSymbol }).Any(e => e.Name == "IReadOnlyList" && e.TypeArguments[0].Name == nameof(Expression))); } else { visitMethodToCall = allVisitMethods.Where(d => d.Name.EndsWith("ObjectList")).FirstOrDefault(d => d.Parameters[0].Type.AllInterfaces.Concat(new[] { d.Parameters[0].Type as INamedTypeSymbol }).Any(e => e.Name == "IReadOnlyList" && e.TypeArguments[0].Name == "T")); } } var visitMethodMethodToCallExpr = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("this"), SyntaxFactory.IdentifierName(visitMethodToCall.Name)); return(new StatementSyntax[] { SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, currentObject, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("current"), SyntaxFactory.IdentifierName(c.Name)))), SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(visitMethodMethodToCallExpr, SyntaxFactory.ArgumentList().AddArguments(SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("expression"), SyntaxFactory.IdentifierName(c.Name)))))), SyntaxFactory.IfStatement(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, result), SyntaxFactory.Block(SyntaxFactory.ReturnStatement(expressionParam))) }); }) .SelectMany(c => c) .ToArray(); return(SyntaxFactory .Block() .AddStatements(SyntaxFactory.LocalDeclarationStatement(variableCurrent)) .AddStatements(ifTryGetValue) .AddStatements(simplePropertyChecks) .AddStatements(expressionPropertyChecks) .AddStatements(collectionPropertyChecks) .AddStatements(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, currentObject, SyntaxFactory.IdentifierName("current")))) .AddStatements(SyntaxFactory.ReturnStatement(expressionParam))); }
public override ExpressionSyntax Visit(ConversionContext context, ObjectCreationExpr newExpr) { var anonBody = newExpr.getAnonymousClassBody().ToList <BodyDeclaration>(); if (anonBody != null && anonBody.Count > 0) { return(VisitAnonymousClassCreationExpression(context, newExpr, anonBody)); } var scope = newExpr.getScope(); ExpressionSyntax scopeSyntax = null; if (scope != null) { scopeSyntax = ExpressionVisitor.VisitExpression(context, scope); } // TODO: what to do with scope? var type = newExpr.getType(); var typeSyntax = TypeHelper.GetSyntaxFromType(type); var args = newExpr.getArgs().ToList <Expression>(); if (args == null || args.Count == 0) { return(SyntaxFactory.ObjectCreationExpression(typeSyntax).WithArgumentList(SyntaxFactory.ArgumentList())); } var argSyntaxes = new List <ArgumentSyntax>(); foreach (var arg in args) { var argSyntax = ExpressionVisitor.VisitExpression(context, arg); argSyntaxes.Add(SyntaxFactory.Argument(argSyntax)); } return(SyntaxFactory.ObjectCreationExpression(typeSyntax, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(argSyntaxes, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), argSyntaxes.Count - 1))), null)); }
private static BlockSyntax CallNativePointerOverload(MethodDeclarationSyntax nativePointerOverload, GeneratorFlags flags, IReadOnlyDictionary <ParameterSyntax, FriendlyFlags> parametersToFriendlyTransform) { Func <ParameterSyntax, IdentifierNameSyntax> getLocalSubstituteName = p => SyntaxFactory.IdentifierName(p.Identifier.ValueText + "Local"); var invocationArguments = new Dictionary <ParameterSyntax, ArgumentSyntax>(); foreach (var p in nativePointerOverload.ParameterList.Parameters) { var refOrOut = p.Modifiers.FirstOrDefault(m => m.IsKind(SyntaxKind.RefKeyword) || m.IsKind(SyntaxKind.OutKeyword)); invocationArguments[p] = SyntaxFactory .Argument(SyntaxFactory.IdentifierName(p.Identifier)) .WithRefOrOutKeyword(refOrOut); } var prelude = new List <StatementSyntax>(); var postlude = new List <StatementSyntax>(); var fixedStatements = new List <FixedStatementSyntax>(); foreach (var parameter in nativePointerOverload.ParameterList.Parameters.Where(p => p.Type is PointerTypeSyntax)) { var parameterName = SyntaxFactory.IdentifierName(parameter.Identifier); var localVarName = getLocalSubstituteName(parameter); FriendlyFlags friendlyFlags; if (flags.HasFlag(GeneratorFlags.NativePointerToFriendly) && parametersToFriendlyTransform.TryGetValue(parameter, out friendlyFlags)) { if (friendlyFlags.HasFlag(FriendlyFlags.Array)) { var fixedArrayDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause(parameterName)); fixedStatements.Add(SyntaxFactory.FixedStatement( SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedArrayDecl), SyntaxFactory.Block())); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } else { if (friendlyFlags.HasFlag(FriendlyFlags.Optional)) { var nullableType = (PointerTypeSyntax)parameter.Type; var hasValueExpression = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(Nullable <int> .HasValue))); var valueExpression = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(Nullable <int> .Value))); var defaultExpression = SyntaxFactory.DefaultExpression(nullableType.ElementType); var varStatement = SyntaxFactory.VariableDeclaration(nullableType.ElementType).AddVariables( SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause( SyntaxFactory.ConditionalExpression( hasValueExpression, valueExpression, defaultExpression)))); prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement)); if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { // someParam = someParamLocal; var assignBackToParameter = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, parameterName, localVarName); var conditionalStatement = SyntaxFactory.IfStatement( hasValueExpression, SyntaxFactory.ExpressionStatement(assignBackToParameter)); postlude.Add(conditionalStatement); } invocationArguments[parameter] = invocationArguments[parameter].WithExpression( SyntaxFactory.ConditionalExpression( hasValueExpression, SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, localVarName), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); } else if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { var fixedDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause( SyntaxFactory.PrefixUnaryExpression( SyntaxKind.AddressOfExpression, parameterName))); fixedStatements.Add(SyntaxFactory.FixedStatement( SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedDecl), SyntaxFactory.Block())); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } else { invocationArguments[parameter] = invocationArguments[parameter] .WithExpression(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, parameterName)); } } } else if (flags.HasFlag(GeneratorFlags.NativePointerToIntPtr)) { var varStatement = SyntaxFactory.VariableDeclaration(parameter.Type); var declarator = SyntaxFactory.VariableDeclarator(localVarName.Identifier); if (parameter.Modifiers.Any(m => m.IsKind(SyntaxKind.OutKeyword))) { var assignment = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, parameterName, SyntaxFactory.ObjectCreationExpression( IntPtrTypeSyntax, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(localVarName))), null)); postlude.Add(SyntaxFactory.ExpressionStatement(assignment)); } else { var voidStarPointer = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(IntPtr.ToPointer))), SyntaxFactory.ArgumentList()); var typedPointer = parameter.Type.Equals(VoidStar) ? (ExpressionSyntax)voidStarPointer : SyntaxFactory.CastExpression(parameter.Type, voidStarPointer); declarator = declarator.WithInitializer(SyntaxFactory.EqualsValueClause(typedPointer)); } varStatement = varStatement.AddVariables(declarator); prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement)); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } } var invocationExpression = SyntaxFactory.InvocationExpression( SyntaxFactory.IdentifierName(nativePointerOverload.Identifier.ValueText), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList( from p in nativePointerOverload.ParameterList.Parameters select invocationArguments[p]))); IdentifierNameSyntax resultVariableName = null; StatementSyntax invocationStatement; if (nativePointerOverload.ReturnType != null && (nativePointerOverload.ReturnType as PredefinedTypeSyntax)?.Keyword.Kind() != SyntaxKind.VoidKeyword) { resultVariableName = SyntaxFactory.IdentifierName("result"); // TODO: ensure this is unique. invocationStatement = SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.VariableDeclaration(nativePointerOverload.ReturnType) .AddVariables( SyntaxFactory.VariableDeclarator(resultVariableName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause(invocationExpression)))); } else { invocationStatement = SyntaxFactory.ExpressionStatement(invocationExpression); } var block = SyntaxFactory.Block() .AddStatements(prelude.ToArray()) .AddStatements(invocationStatement) .AddStatements(postlude.ToArray()); if (resultVariableName != null) { ExpressionSyntax returnedValue = nativePointerOverload.ReturnType is PointerTypeSyntax ? (ExpressionSyntax)SyntaxFactory.ObjectCreationExpression( IntPtrTypeSyntax, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(resultVariableName))), null) : resultVariableName; block = block.AddStatements(SyntaxFactory.ReturnStatement(returnedValue)); } if (fixedStatements.Count > 0) { StatementSyntax outermost = block; foreach (var statement in fixedStatements) { outermost = statement.WithStatement(outermost); } block = SyntaxFactory.Block(outermost); } return(block); }
private static ExpressionSyntax VisitAnonymousClassCreationExpression(ConversionContext context, ObjectCreationExpr newExpr, List <BodyDeclaration> anonBody) { string baseTypeName = TypeHelper.ConvertType(newExpr.getType().getName()); string anonTypeName = string.Empty; for (int i = 0; i <= 100; i++) { if (i == 100) { throw new InvalidOperationException("Too many anonymous types"); } anonTypeName = string.Format("Anonymous{0}{1}", baseTypeName, i == 0 ? string.Empty : i.ToString()); if (!context.UsedAnonymousTypeNames.Contains(anonTypeName)) { context.UsedAnonymousTypeNames.Add(anonTypeName); break; // go with this one } } var classSyntax = SyntaxFactory.ClassDeclaration(anonTypeName) .AddModifiers( SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.SealedKeyword)) .WithBaseList(SyntaxFactory.BaseList(SyntaxFactory.SeparatedList(new List <BaseTypeSyntax> { SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(baseTypeName)) }))); var parentField = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName(context.LastTypeName)).AddVariables(SyntaxFactory.VariableDeclarator("parent"))) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); var ctorSyntax = SyntaxFactory.ConstructorDeclaration(anonTypeName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .AddParameterListParameters(SyntaxFactory.Parameter(SyntaxFactory.ParseToken("parent")).WithType(SyntaxFactory.ParseTypeName(context.LastTypeName))) .AddBodyStatements(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName("parent")), SyntaxFactory.IdentifierName("parent")))); classSyntax = classSyntax.AddMembers(ctorSyntax, parentField); foreach (var member in anonBody) { var memberSyntax = BodyDeclarationVisitor.VisitBodyDeclarationForClass(context, classSyntax, member); if (memberSyntax != null) { classSyntax = classSyntax.AddMembers(memberSyntax); } } context.PendingAnonymousTypes.Enqueue(classSyntax); var args = newExpr.getArgs().ToList <Expression>(); if (args == null || args.Count == 0) { return(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(anonTypeName)) .AddArgumentListArguments(SyntaxFactory.Argument(SyntaxFactory.ThisExpression()))); } var argSyntaxes = new List <ArgumentSyntax>(); argSyntaxes.Add(SyntaxFactory.Argument(SyntaxFactory.ThisExpression())); foreach (var arg in args) { var argSyntax = ExpressionVisitor.VisitExpression(context, arg); argSyntaxes.Add(SyntaxFactory.Argument(argSyntax)); } return(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(anonTypeName), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(argSyntaxes, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), argSyntaxes.Count - 1))), null)); }
private static async Task <Document> CreateMappingLambda(Document document, InvocationExpressionSyntax invocation, CancellationToken cancellationToken) { var semanticModel = await document.GetSemanticModelAsync(cancellationToken); var syntaxGenerator = SyntaxGenerator.GetGenerator(document); var methodInvocationSymbol = semanticModel.GetSymbolInfo(invocation.Expression); var mappingOverload = methodInvocationSymbol.CandidateSymbols.OfType <IMethodSymbol>().FirstOrDefault(IsMappingMethod); if (mappingOverload == null) { return(document); } var parameterType = ((INamedTypeSymbol)mappingOverload.Parameters[0].Type); var sourceElementType = parameterType.TypeArguments[0]; var targetElementType = GetExpressionType(semanticModel, invocation); if (targetElementType == null) { return(document); } var mappingEngine = new MappingEngine(semanticModel, syntaxGenerator); var sourceListElementType = new AnnotatedType(sourceElementType); var mappingLambda = mappingEngine.CreateMappingLambda("x", sourceListElementType, targetElementType, new MappingPath(), new MappingContext(invocation, semanticModel)); return(await document.ReplaceNodes(invocation, invocation.WithArgumentList(SyntaxFactory.ArgumentList().AddArguments(SyntaxFactory.Argument((ExpressionSyntax)mappingLambda))), cancellationToken)); }
private ArgumentListSyntax GetEqualsNullArgument(SyntaxToken token) { return(SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(SyntaxFactory.SimpleLambdaExpression(SyntaxFactory.Parameter(token), SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, SyntaxFactory.IdentifierName(token), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))))))); }