public static async Task <Document> FixInvocationWithParameters(Document document,
IInvocation invocation,
bool generateNamedParameters,
SemanticModel semanticModel,
IMappingSourceFinder mappingSourceFinder,
CancellationToken cancellationToken)
{
var syntaxGenerator = SyntaxGenerator.GetGenerator(document);
var overloadParameterSets = invocation.GetOverloadParameterSets(semanticModel);
if (overloadParameterSets != null)
{
var mappingContext = new MappingContext(invocation.SourceNode, semanticModel);
var mappingEngine = new MappingEngine(semanticModel, syntaxGenerator);
var parametersMatch = await MethodHelper.FindBestParametersMatch(mappingSourceFinder, overloadParameterSets, mappingContext).ConfigureAwait(false);
if (parametersMatch != null)
{
var argumentList = await parametersMatch.ToArgumentListSyntaxAsync(mappingEngine, mappingContext, generateNamedParameters).ConfigureAwait(false);
return(await document.ReplaceNodes(invocation.SourceNode, invocation.WithArgumentList(argumentList), cancellationToken).ConfigureAwait(false));
}
}
return(document);
}
public static MatchedParameterList FindBestParametersMatch(IMappingSourceFinder mappingSourceFinder, IEnumerable <ImmutableArray <IParameterSymbol> > overloadParameterSets)
{
return(overloadParameterSets.Select(x => FindArgumentsMatch(x, mappingSourceFinder))
.Where(x => x.HasAnyMatch())
.OrderByDescending(x => x.IsCompletlyMatched())
.ThenByDescending(x => x.MatchedCount)
.FirstOrDefault());
}
public ObjectCreationExpressionSyntax AddInitializerWithMapping(
ObjectCreationExpressionSyntax objectCreationExpression, IMappingSourceFinder mappingSourceFinder,
ITypeSymbol createdObjectTyp,
MappingPath mappingPath = null)
{
var propertiesToSet = ObjectHelper.GetFieldsThaCanBeSetPublicly(createdObjectTyp, contextAssembly);
var assignments = MapUsingSimpleAssignment(syntaxGenerator, propertiesToSet, mappingSourceFinder, mappingPath);
var initializerExpressionSyntax = SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, new SeparatedSyntaxList <ExpressionSyntax>().AddRange(assignments)).FixInitializerExpressionFormatting(objectCreationExpression);
return(objectCreationExpression.WithInitializer(initializerExpressionSyntax));
}
private static MatchedParameterList FindArgumentsMatch(ImmutableArray <IParameterSymbol> parameters,
IMappingSourceFinder mappingSourceFinder, MappingContext mappingContext)
{
var matchedArgumentList = new MatchedParameterList();
foreach (var parameter in parameters)
{
var mappingSource = mappingSourceFinder.FindMappingSource(parameter.Name, new AnnotatedType(parameter.Type), mappingContext);
matchedArgumentList.AddMatch(parameter, mappingSource);
}
return(matchedArgumentList);
}
private static async Task <Document> ReplaceEmptyInitializationBlock(Document document,
InitializerExpressionSyntax objectInitializer, SemanticModel semanticModel,
IMappingSourceFinder mappingSourceFinder, CancellationToken cancellationToken)
{
var oldObjCreation = objectInitializer.FindContainer <ObjectCreationExpressionSyntax>();
var createdObjectType = ModelExtensions.GetTypeInfo(semanticModel, oldObjCreation).Type;
var mappingEngine = await MappingEngine.Create(document, cancellationToken, semanticModel.FindContextAssembly(objectInitializer));
var newObjectCreation = mappingEngine.AddInitializerWithMapping(oldObjCreation, mappingSourceFinder, createdObjectType);
return(await document.ReplaceNodes(oldObjCreation, newObjectCreation, cancellationToken));
}
public static async Task <MatchedParameterList> FindBestParametersMatch(IMappingSourceFinder mappingSourceFinder, IEnumerable <ImmutableArray <IParameterSymbol> > overloadParameterSets, MappingContext mappingContext)
{
var matches = new List <MatchedParameterList>();
foreach (var overloadParameterSet in overloadParameterSets)
{
var argumentMatch = await FindArgumentsMatch(overloadParameterSet, mappingSourceFinder, mappingContext).ConfigureAwait(false);
if (argumentMatch.HasAnyMatch())
{
matches.Add(argumentMatch);
}
}
return(matches
.OrderByDescending(x => x.IsCompletlyMatched())
.ThenByDescending(x => x.MatchedCount)
.FirstOrDefault());
}
public IgnorableMappingSourceFinder(IMappingSourceFinder wrappedFinder, Func <MappingElement, bool> ignore)
{
this.wrappedFinder = wrappedFinder;
this.ignore = ignore;
}
public IEnumerable <ExpressionSyntax> MapUsingSimpleAssignment(SyntaxGenerator generator,
IEnumerable <IPropertySymbol> targets, IMappingSourceFinder sourceFinder,
MappingPath mappingPath = null, SyntaxNode globalTargetAccessor = null)
{
if (mappingPath == null)
{
mappingPath = new MappingPath();
}
return(targets.Select(property => new
{
source = sourceFinder.FindMappingSource(property.Name, property.Type),
target = new MappingElement()
{
Expression = (ExpressionSyntax)CreateAccessPropertyExpression(globalTargetAccessor, property, generator),
ExpressionType = property.Type
}
})
.Where(x => x.source != null)
.Select(pair =>
{
var sourceExpression = this.MapExpression(pair.source, pair.target.ExpressionType, mappingPath.Clone()).Expression;
return (ExpressionSyntax)generator.AssignmentStatement(pair.target.Expression, sourceExpression);
}).ToList());
}
public SingleSourceMatcher(IMappingSourceFinder sourceFinder)
{
this.sourceFinder = sourceFinder;
}
private static MatchedParameterList FindArgumentsMatch(ImmutableArray <IParameterSymbol> parameters, IMappingSourceFinder mappingSourceFinder)
{
var matchedArgumentList = new MatchedParameterList();
foreach (var parameter in parameters)
{
var mappingSource = mappingSourceFinder.FindMappingSource(parameter.Name, parameter.Type);
matchedArgumentList.AddMatch(parameter, mappingSource?.Expression);
}
return(matchedArgumentList);
}
