/// <summary>
/// Retourne les conditions sur les paramètres dans une listes d'expressions.
/// </summary>
/// <param name="expressions">Liste d'expressions.</param>
/// <param name="paramètres">Les paramètres du constructeur.</param>
/// <param name="modèleSémantique">Modèle sémantique.</param>
/// <returns>La liste d'assignations.</returns>
public static IEnumerable<IfStatementSyntax> TrouveConditionsParametres(SyntaxList<StatementSyntax> expressions, ParameterListSyntax paramètres, SemanticModel modèleSémantique) =>
expressions
.OfType<IfStatementSyntax>()
.Where(e =>
(e.Condition
?.DescendantNodes()?.OfType<IdentifierNameSyntax>()
?.Any(identifiant => modèleSémantique.GetSymbolInfo(identifiant).Symbol?.Kind == SymbolKind.Parameter)
?? false)
&& (e.Statement
?.DescendantNodes()?.OfType<IdentifierNameSyntax>()
?.All(identifiant => modèleSémantique.GetSymbolInfo(identifiant).Symbol?.Kind != SymbolKind.Field)
?? false));
private void ProcessMembers(SyntaxList<MemberDeclarationSyntax> members)
{
foreach (var namespaceDeclaration in members.OfType<NamespaceDeclarationSyntax>())
{
this.ProcessUsingDirectives(namespaceDeclaration.Usings);
this.ProcessMembers(namespaceDeclaration.Members);
}
}
private static int CountNamespaces(SyntaxList<MemberDeclarationSyntax> members)
{
var result = 0;
foreach (var namespaceDeclaration in members.OfType<NamespaceDeclarationSyntax>())
{
result += 1 + CountNamespaces(namespaceDeclaration.Members);
}
return result;
}
private static SyntaxList<XmlNodeSyntax> RemoveMalformattedStandardText(SyntaxList<XmlNodeSyntax> content, SyntaxToken identifier, string preText, string postText, ref string trailingString)
{
var regex = new Regex(@"^\s*" + Regex.Escape(preText) + "[^ ]+" + Regex.Escape(postText));
var item = content.OfType<XmlTextSyntax>().FirstOrDefault();
if (item == null)
{
return content;
}
int index = -1;
foreach (var token in item.TextTokens)
{
index++;
if (token.IsKind(SyntaxKind.XmlTextLiteralNewLineToken))
{
continue;
}
else if (token.IsKind(SyntaxKind.XmlTextLiteralToken))
{
string value = token.ValueText.Trim(null);
Match match = regex.Match(value);
if (!match.Success)
{
return content;
}
else if (match.Length == value.Length)
{
// Remove the token
var tokens = item.TextTokens;
while (index >= 0)
{
tokens = tokens.RemoveAt(0);
index--;
}
var newContent = item.WithTextTokens(tokens);
return content.Replace(item, newContent);
}
else
{
// Remove the tokens before
var tokens = item.TextTokens;
while (index >= 0)
{
tokens = tokens.RemoveAt(0);
index--;
}
trailingString = value.Substring(match.Length);
var newContent = item.WithTextTokens(tokens);
return content.Replace(item, newContent);
}
}
else
{
return content;
}
}
return content;
}
ExpressionSyntax CollectCondition(ExpressionSyntax expressionSyntax, SyntaxList<SwitchLabelSyntax> labels)
{
//default
if (labels.Count == 0 || labels.OfType<DefaultSwitchLabelSyntax>().Any())
return null;
var conditionList =
labels
.OfType<CaseSwitchLabelSyntax>()
.Select(l => SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, expressionSyntax, l.Value)).ToList();
//attempt to add parentheses
//TODO: port InsertParentheses in-full rather than a make-do (but I didn't think I had the time to do a full-port)
for (int i = 0; i < conditionList.Count; ++i)
{
var cond = conditionList[i];
if (NeedsParentheses((cond.Right)))
{
conditionList[i] = cond.WithRight(SyntaxFactory.ParenthesizedExpression(cond.Right));
}
}
if (conditionList.Count == 1)
return conditionList.First();
//combine case labels
BinaryExpressionSyntax condition = conditionList[0];
for (int i = 1; i < conditionList.Count; ++i)
{
condition = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalOrExpression, condition, conditionList[i]);
}
return condition;
}
