public ExpressionResult Resolve()
{
if (_analyzedInvocation.ArgumentList.Arguments.Any())
{
var replacingInVariableResolution = _expressionResolverInstance.GetStringValueOfExpression(_document, _nextExpressionSyntax.Expression, _nodes, _semanticModel);
var stringToReplaceResolution = _expressionResolverInstance.GetStringValueOfExpression(_document, _analyzedInvocation.ArgumentList.Arguments[0].Expression, _nodes, _semanticModel);
var stringToReplaceWithResolution = _expressionResolverInstance.GetStringValueOfExpression(_document, _analyzedInvocation.ArgumentList.Arguments[1].Expression, _nodes, _semanticModel);
if (replacingInVariableResolution.IsSolved && stringToReplaceResolution.IsSolved && stringToReplaceWithResolution.IsSolved)
{
return(new ExpressionResult
{
CanBeUsedAsQuery = false,
ExpressionText = _analyzedInvocation.ToString(),
IsSolved = true,
TextResult = replacingInVariableResolution.TextResult.Replace(stringToReplaceResolution.TextResult, stringToReplaceWithResolution.TextResult)
});
}
return(new ExpressionResult
{
CanBeUsedAsQuery = false,
ExpressionText = _analyzedInvocation.ToString(),
IsSolved = false,
UnresolvableReason = "Unable to resolve all variables needed.",
});
}
return(new ExpressionResult
{
CanBeUsedAsQuery = false,
ExpressionText = _analyzedInvocation.ToString(),
IsSolved = false,
UnresolvableReason = "No argument provided to method.",
});
}
public ExpressionResult Resolve(Document document, ExpressionSyntax expressionSyntax, IEnumerable <SyntaxNode> nodes, SemanticModel semanticModel, ExpressionResolver expressionResolverInstance)
{
using (MiniProfiler.Current.Step(nameof(AddStrategy)))
{
var binaryExpressionNode = expressionSyntax as BinaryExpressionSyntax;
var leftExpression = binaryExpressionNode.Left;
var rightExpression = binaryExpressionNode.Right;
var leftExpressionValue = expressionResolverInstance.GetStringValueOfExpression(document, leftExpression, nodes, semanticModel);
var rightExpressionValue = expressionResolverInstance.GetStringValueOfExpression(document, rightExpression, nodes, semanticModel);
if (leftExpressionValue.IsSolved && rightExpressionValue.IsSolved)
{
return(new ExpressionResult
{
IsSolved = true,
CanBeUsedAsQuery = false,
ExpressionText = expressionSyntax.ToString(),
TextResult = leftExpressionValue.TextResult + rightExpressionValue.TextResult,
});
}
var result = new ExpressionResult
{
IsSolved = false,
ExpressionText = expressionSyntax.ToString(),
};
if (!leftExpressionValue.IsSolved)
{
result.TextResult += leftExpressionValue.TextResult;
result.CanBeUsedAsQuery = leftExpressionValue.CanBeUsedAsQuery;
result.UnresolvableReason = leftExpressionValue.UnresolvableReason;
result.UnresolvedPart = leftExpressionValue.UnresolvedPart;
result.UnresolvedValue = leftExpressionValue.UnresolvedValue;
result.UnresolvedFormat = "{0}" + rightExpressionValue.TextResult;
}
if (!rightExpressionValue.IsSolved)
{
result.TextResult += rightExpressionValue.TextResult;
result.CanBeUsedAsQuery = rightExpressionValue.CanBeUsedAsQuery;
result.UnresolvableReason = rightExpressionValue.UnresolvableReason;
result.UnresolvedPart = rightExpressionValue.UnresolvedPart;
result.UnresolvedValue = rightExpressionValue.UnresolvedValue;
result.UnresolvedFormat = leftExpressionValue.TextResult + "{0}";
}
if (!rightExpressionValue.IsSolved && !leftExpressionValue.IsSolved)
{
result.CanBeUsedAsQuery = false;
result.UnresolvableReason = $"{leftExpressionValue.UnresolvableReason}{rightExpressionValue.UnresolvableReason}";
}
return(result);
}
}
public ExpressionResult Resolve(Document document, ExpressionSyntax expressionSyntax, IEnumerable <SyntaxNode> nodes, SemanticModel semanticModel, ExpressionResolver expressionResolverInstance)
{
using (MiniProfiler.Current.Step(nameof(InterpolatedStringStrategy)))
{
var interpolatedNode = expressionSyntax as InterpolatedStringExpressionSyntax;
List <ExpressionResult> expressionResolverResults = new List <ExpressionResult>();
foreach (var content in interpolatedNode.Contents)
{
if (content is InterpolationSyntax)
{
var expression = (content as InterpolationSyntax).Expression;
expressionResolverResults.Add(expressionResolverInstance.GetStringValueOfExpression(document, expression, nodes, semanticModel));
}
if (content is InterpolatedStringTextSyntax)
{
expressionResolverResults.Add(new ExpressionResult
{
IsSolved = true,
CanBeUsedAsQuery = false,
ExpressionText = interpolatedNode.ToString(),
TextResult = (content as InterpolatedStringTextSyntax).TextToken.Text,
});
}
}
if (expressionResolverResults.Any(e => !e.IsSolved && e.CanBeUsedAsQuery))
{
return(new ExpressionResult
{
CanBeUsedAsQuery = !(expressionResolverResults.Count(e => !e.IsSolved && e.CanBeUsedAsQuery) > 1),//Atm, only allow for 1 variable
ExpressionText = interpolatedNode.ToString(),
IsSolved = false,
TextResult = string.Join("", expressionResolverResults.Select(e => e.TextResult)),
UnresolvableReason = expressionResolverResults.First(e => !e.IsSolved).TextResult,
UnresolvedPart = expressionResolverResults.First(e => !e.IsSolved).UnresolvedPart,
UnresolvedValue = expressionResolverResults.First(e => !e.IsSolved).UnresolvedValue,
UnresolvedFormat = string.Join("", expressionResolverResults.Select(e => e.IsSolved ? e.TextResult : "{0}")),
});
}
return(new ExpressionResult
{
CanBeUsedAsQuery = false,
ExpressionText = string.Join("", expressionResolverResults.Select(e => e.TextResult)),
IsSolved = true,
TextResult = string.Join("", expressionResolverResults.Select(e => e.TextResult)),
});
}
}
public ExpressionResult Resolve()
{
string format = "";
if (_expressionSyntax.ArgumentList.Arguments[0].Expression is LiteralExpressionSyntax)
{
format = (_expressionSyntax.ArgumentList.Arguments[0].Expression as LiteralExpressionSyntax).Token.ValueText;
}
List <string> parameters = new List <string>();
List <ExpressionResult> expressionResolverResults = new List <ExpressionResult>();
foreach (var parameter in _expressionSyntax.ArgumentList.Arguments.Skip(1))
{
expressionResolverResults.Add(_expressionResolverInstance.GetStringValueOfExpression(_document, parameter.Expression, _nodes, _semanticModel));
}
if (expressionResolverResults.Any(e => !e.IsSolved && e.CanBeUsedAsQuery))
{
return(new ExpressionResult
{
CanBeUsedAsQuery = !(expressionResolverResults.Count(e => !e.IsSolved && e.CanBeUsedAsQuery) > 1),//Atm, only allow for 1 variable
ExpressionText = _expressionSyntax.ToString(),
IsSolved = false,
TextResult = string.Format(format, expressionResolverResults.Select(e => e.TextResult).ToArray()),
UnresolvableReason = expressionResolverResults.First(e => !e.IsSolved).TextResult,
UnresolvedPart = expressionResolverResults.First(e => !e.IsSolved).UnresolvedPart,
UnresolvedValue = expressionResolverResults.First(e => !e.IsSolved).UnresolvedValue,
UnresolvedFormat = string.Join("", expressionResolverResults.Select(e => e.IsSolved ? e.TextResult : "{0}")),
});
}
return(new ExpressionResult
{
CanBeUsedAsQuery = false,
ExpressionText = _expressionSyntax.ToString(),
IsSolved = true,
TextResult = string.Format(format, expressionResolverResults.Select(e => e.TextResult).ToArray()),
});
}
public ExpressionResult Resolve(Document document, ExpressionSyntax expressionSyntax, IEnumerable <SyntaxNode> nodes, SemanticModel semanticModel, ExpressionResolver expressionResolverInstance)
{
using (MiniProfiler.Current.Step(nameof(IdentifierStrategy)))
{
var identifierNameSyntax = expressionSyntax as IdentifierNameSyntax;
var descendantTest = identifierNameSyntax.DescendantNodesAndSelf();
var variableDeclaration = nodes.OfType <VariableDeclarationSyntax>().SelectMany(e => e.Variables.Where(x => x.Identifier.Text == identifierNameSyntax.Identifier.Text)).FirstOrDefault();
if (variableDeclaration == null)//If no Variable of matching name was found, than look in properties.
{
var property = nodes.OfType <PropertyDeclarationSyntax>().FirstOrDefault(e => e.Identifier.ValueText == identifierNameSyntax.Identifier.ValueText);
if (property?.ExpressionBody != null)
{
return(expressionResolverInstance.GetStringValueOfExpression(document, property.ExpressionBody.Expression, nodes, semanticModel));
}
if (property?.AccessorList != null)
{
var getter = property.AccessorList.Accessors.FirstOrDefault(e => e.IsKind(SyntaxKind.GetAccessorDeclaration));
var getterBody = getter.Body;
if (getterBody == null)
{
return(new ExpressionResult
{
IsSolved = false,
UnresolvableReason = "Getter Body is null",
TextResult = "",
});
}
var firstReturnStatement = getterBody.Statements.FirstOrDefault(e => e.IsKind(SyntaxKind.ReturnStatement)) as ReturnStatementSyntax;
return(expressionResolverInstance.GetStringValueOfExpression(document, firstReturnStatement.Expression, nodes, semanticModel));
}
}
if (variableDeclaration?.Initializer != null)
{
return(expressionResolverInstance.GetStringValueOfExpression(document, variableDeclaration.Initializer.Value, nodes, semanticModel));
}
//Field/variable is in other document than currently analyzed
if (identifierNameSyntax.SyntaxTree.FilePath != expressionSyntax.SyntaxTree.FilePath)
{
return(expressionResolverInstance.GetStringValueOfExpression(null, identifierNameSyntax, identifierNameSyntax.SyntaxTree.GetRoot().DescendantNodes(), null));
}
//Field/variable could still be in other document, but expression is not saying this. Unsafe
if (semanticModel != null)
{
var symbol = semanticModel.GetSymbolInfo(identifierNameSyntax);
if (symbol.Symbol != null)
{
if (symbol.Symbol.Locations.Count() == 1 && identifierNameSyntax.SyntaxTree.FilePath != symbol.Symbol.Locations[0].SourceTree.FilePath)
{
return(expressionResolverInstance.GetStringValueOfExpression(null, identifierNameSyntax, symbol.Symbol.Locations[0].SourceTree.GetRoot().DescendantNodes(), null));
}
}
}
var assigmentsInDocument = nodes.OfType <AssignmentExpressionSyntax>();
var assigmentExpressions = assigmentsInDocument
.Where(e => (e.Left as IdentifierNameSyntax)?.Identifier.Text == identifierNameSyntax.Identifier.Text).Select(e => e.Right)
.Concat(
assigmentsInDocument
.Where(e => (e.Right as IdentifierNameSyntax)?.Identifier.Text == identifierNameSyntax.Identifier.Text).Select(e => e.Left)
);
foreach (var expression in assigmentExpressions)
{
var expressionResult = expressionResolverInstance.GetStringValueOfExpression(document, expression, nodes, semanticModel);
if (expressionResult.IsSolved || expressionResult.CanBeUsedAsQuery)
{
return(expressionResult);
}
}
return(new ExpressionResult
{
IsSolved = false,
UnresolvableReason = "Unable to find identifier initializer in document.",
TextResult = "",
});
}
}
