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)))))));
}
