private SyntaxList <StatementSyntax> InsertRequiredDeclarations(
SyntaxList <StatementSyntax> convertedStatements, CS.CSharpSyntaxNode originaNode)
{
var descendantNodes = originaNode.DescendantNodes().ToList();
var declarationExpressions = descendantNodes.OfType <CSSyntax.DeclarationExpressionSyntax>()
.Where(e => !e.Parent.IsKind(CSSyntaxKind.ForEachVariableStatement)) //Handled inline for tuple loop
.ToList();
var isPatternExpressions = descendantNodes.OfType <CSSyntax.IsPatternExpressionSyntax>().ToList();
if (declarationExpressions.Any() || isPatternExpressions.Any())
{
convertedStatements = convertedStatements.InsertRange(0, ConvertToDeclarationStatement(declarationExpressions, isPatternExpressions));
}
return(convertedStatements);
}
private string AdjustIfEventIdentifier(string valueText, CS.CSharpSyntaxNode parent)
{
var symbol = GetSymbol(parent) as IEventSymbol;
bool isEvent = symbol.IsKind(SymbolKind.Event);
if (!isEvent)
{
return(valueText);
}
var operation = _semanticModel.GetAncestorOperationOrNull <IEventReferenceOperation>(parent);
if (operation == null || !operation.Event.Equals(symbol, SymbolEqualityComparer.IncludeNullability) || operation.Parent is IEventAssignmentOperation ||
operation.Parent is IRaiseEventOperation || operation.Parent is IInvocationOperation ||
operation.Parent is IConditionalAccessOperation cao && cao.WhenNotNull is IInvocationOperation)
{
return(valueText);
}
return(valueText + "Event");
}
public LambdaExpressionSyntax ConvertLambdaExpression(CSSyntax.AnonymousFunctionExpressionSyntax node, CS.CSharpSyntaxNode body, IEnumerable <ParameterSyntax> parameters, SyntaxTokenList modifiers)
{
var parameterList = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters.Select(p => (Microsoft.CodeAnalysis.VisualBasic.Syntax.ParameterSyntax)p.Accept(_nodesVisitor))));
LambdaHeaderSyntax header;
EndBlockStatementSyntax endBlock;
SyntaxKind multiLineExpressionKind;
SyntaxKind singleLineExpressionKind;
bool isSub = ReturnsVoid(node);
if (isSub)
{
header = SyntaxFactory.SubLambdaHeader(SyntaxFactory.List <AttributeListSyntax>(),
ConvertModifiers(modifiers, TokenContext.Local), parameterList, null);
endBlock = SyntaxFactory.EndBlockStatement(SyntaxKind.EndSubStatement,
SyntaxFactory.Token(SyntaxKind.SubKeyword));
multiLineExpressionKind = SyntaxKind.MultiLineSubLambdaExpression;
singleLineExpressionKind = SyntaxKind.SingleLineSubLambdaExpression;
}
else
{
header = CreateFunctionHeader(modifiers, parameterList, out endBlock, out multiLineExpressionKind);
singleLineExpressionKind = SyntaxKind.SingleLineFunctionLambdaExpression;
}
SyntaxList <StatementSyntax> statements;
if (body is CSSyntax.BlockSyntax block)
{
statements = ConvertStatements(block.Statements);
}
else if (body.Kind() == CSSyntaxKind.ThrowExpression)
{
var csThrowExpression = (CSSyntax.ThrowExpressionSyntax)body;
var vbThrowExpression = (ExpressionSyntax)csThrowExpression.Expression.Accept(_nodesVisitor);
var vbThrowStatement = SyntaxFactory.ThrowStatement(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), vbThrowExpression);
return(SyntaxFactory.MultiLineFunctionLambdaExpression(header,
SyntaxFactory.SingletonList <StatementSyntax>(vbThrowStatement), endBlock));
}
else
{
var stmt = GetStatementSyntax(body.Accept(_nodesVisitor),
expression => isSub ? SyntaxFactory.ExpressionStatement(expression) : SyntaxFactory.ReturnStatement(expression));
statements = InsertRequiredDeclarations(SyntaxFactory.SingletonList(stmt), body);
}
return(CreateLambdaExpression(singleLineExpressionKind, multiLineExpressionKind, header, statements, endBlock));
}
private static IEnumerable <CSSyntax.BlockSyntax> GetDeepestBlocks(CS.CSharpSyntaxNode body)
{
return(body.DescendantNodesAndSelf().OfType <CSSyntax.BlockSyntax>().Where(x => !x.DescendantNodes().OfType <CSSyntax.BlockSyntax>().Any()));
}
