public override SyntaxNode VisitBlock(BlockSyntax node)
{
if (node.FirstAncestorOrSelf <MethodDeclarationSyntax>() != null && node.FirstAncestorOrSelf <MethodDeclarationSyntax>().Identifier.Text == "MapToModel")
{
return(node.ReplaceToken(node.OpenBraceToken, SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.OpenBraceToken, this.GenerateCommentsTrivia())));
}
return(base.VisitBlock(node));
}
public override SyntaxNode VisitBlock(BlockSyntax node)
{
var containingMethod = node.FirstAncestorOrSelf <MethodDeclarationSyntax>();
if (containingMethod != null && containingMethod.Identifier.ToString() == "MapToModel" &&
containingMethod.FirstAncestorOrSelf <ClassDeclarationSyntax>().Identifier.ToString().Contains("Mapper"))
{
if (node.Statements.Count == 0)
{
node = node.WithOpenBraceToken(GetOpenBraceTokenWithEmptyCustomCode());
}
else if (node.Statements.Count == 1)
{
var newStatement = AddLeadingTriviaComment(AddTrailingTriviaComment(node.Statements.Single()));
node = node.WithStatements(node.Statements.RemoveAt(0).Add(newStatement));
}
else
{
var firstStatement = AddLeadingTriviaComment(node.Statements.First());
var lastStatement = AddTrailingTriviaComment(node.Statements.Last());
var lastStatementIndex = node.Statements.Count - 1;
node = node.WithStatements(node.Statements.RemoveAt(lastStatementIndex).RemoveAt(0).Insert(0, firstStatement).Add(lastStatement));
}
}
return(base.VisitBlock(node));
}
public static void ProcessRightOfAssignmentToField(
ISymbol variable,
BlockSyntax block,
SemanticModel semanticModel,
CancellationToken cancellationToken,
RefCounterStatus status)
{
List <AssignmentExpressionSyntax> rc = new List <AssignmentExpressionSyntax>();
block?.TryGetAssignment(variable, semanticModel, cancellationToken, rc);
int count = 0;
ISymbol field = null;
Location loc = Location.None;
foreach (AssignmentExpressionSyntax assignment in rc)
{
var classDef = block.FirstAncestor <ClassDeclarationSyntax>();
var classSymbol = CSharpExtensions.GetDeclaredSymbol(semanticModel, classDef, cancellationToken);
if (IsRightOfAssignmentToField(semanticModel, cancellationToken, assignment.Left, out field))
{
count++;
loc = assignment.GetLocation();
if (!field.ContainingType.Equals(classSymbol))
{
status.Skip("assigned to field/property of other class", loc);
}
if (LoopUtils.HasLoopBetween(assignment, block))
{
status.Skip("loop between assignment to field/property and var block", loc);
}
}
}
if (count == 1)
{
status.ReleaseReference("assign to class field/property", loc);
var methodBlock = block?.FirstAncestorOrSelf <BlockSyntax>();
if (methodBlock == null)
{
return;
}
if (RightSideOfAssignmentCount(field, methodBlock, semanticModel, cancellationToken) > 0)
{
status.Skip("var assigned to field/property, which is assigned to others", loc);
}
ChangeReferenceMethodUtils.ProcessIncDelRefInvocation(field, methodBlock, semanticModel, cancellationToken, status);
ReturnUtils.ProcessReturnStatement(field, methodBlock, semanticModel, cancellationToken, status);
}
else if (count > 1)
{
status.Skip("multiple assign to field/property", loc);
}
}
public override SyntaxNode VisitBlock(BlockSyntax node)
{
if (node.FirstAncestorOrSelf <MethodDeclarationSyntax>() != null && node.FirstAncestorOrSelf <MethodDeclarationSyntax>().Identifier.Text == "MapToModel")
{
var statements = node.Statements;
foreach (var prop in _metadata.Properties.Where(p => !p.IsRelation))
{
var st = SyntaxExtenders.AssignmentStatement("model." + prop.Name, "dto." + prop.Name);
statements = statements.Add(st);
}
if (!string.IsNullOrWhiteSpace(this._metadata.BaseClassDtoName))
{
var mapperField = this.GenerateMapperFieldName(this._metadata.BaseClassDtoName);
var st = SyntaxExtenders.InvocationStatement($"this.{mapperField}.MapToModel", "dto", "model");
statements = statements.Add(st);
}
return(node.WithStatements(statements));
}
return(base.VisitBlock(node));
}
