private BoundExpression VisitInternal(BoundExpression node)
{
BoundExpression result;
_recursionDepth++;
#if DEBUG
int saveRecursionDepth = _recursionDepth;
#endif
if (_recursionDepth > 1)
{
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
result = VisitExpressionWithoutStackGuard(node);
}
else
{
result = VisitExpressionWithStackGuard(node);
}
#if DEBUG
Debug.Assert(saveRecursionDepth == _recursionDepth);
#endif
_recursionDepth--;
return(result);
}
internal StatementSyntax ParseStatement()
{
_recursionDepth++;
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
var result = ParseStatementCore();
_recursionDepth--;
return(result);
}
private BoundExpression VisitExpressionWithStackGuard(BoundExpression node)
{
try
{
return(VisitExpressionWithoutStackGuard(node));
}
catch (Exception ex) when(StackGuard.IsInsufficientExecutionStackException(ex))
{
throw new BoundTreeVisitor.CancelledByStackGuardException(ex, node);
}
}
internal TNode ParseWithStackGuard <TNode>(Func <TNode> parserFunc, Func <TNode> createEmptyNodeFunc) where TNode : SyntaxNode
{
try
{
return(parserFunc());
}
catch (Exception ex) when(StackGuard.IsInsufficientExecutionStackException(ex))
{
return(createEmptyNodeFunc());
}
}
public new void Visit([DisallowNull] DotSyntax syntax)
{
if (syntax == null)
{
throw new ArgumentNullException(nameof(syntax));
}
RecursionDepth++;
StackGuard.EnsureSufficientExecutionStack(RecursionDepth);
syntax.Accept(this);
RecursionDepth--;
}
/// <summary>
/// Asserts that no unexpected nodes survived local rewriting.
/// </summary>
public static void Validate(BoundNode node)
{
try
{
new LocalRewritingValidator().Visit(node);
}
catch (Exception ex) when(StackGuard.IsInsufficientExecutionStackException(ex))
{
// Intentionally ignored to let the overflow get caught in a more crucial visitor
}
}
/// <summary>
/// Called when the syntax walker visits a node.
/// </summary>
/// <param name="node"></param>
public override void Visit(LuaSyntaxNode node)
{
if (node != null)
{
_recursionDepth++;
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
node.Accept(this);
_recursionDepth--;
}
}
public override TResult?Visit(IOperation?operation, TArgument argument)
{
if (operation != null)
{
_recursionDepth++;
try {
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
return(operation.Accept(this, argument));
} finally {
_recursionDepth--;
}
}
return(default);
private void CollectCaptures(RegexNode node, RegexOptions options)
{
try
{
_recursionDepth++;
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
CollectCapturesWorker(node, options);
}
finally
{
_recursionDepth--;
}
}
public override void Visit(IOperation operation)
{
if (operation != null)
{
_recursionDepth++;
try
{
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
operation.Accept(this);
}
finally
{
_recursionDepth--;
}
}
}
public override SyntaxNode Visit(SyntaxNode node)
{
if (node != null)
{
_recursionDepth++;
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
var result = ((CSharpSyntaxNode)node).Accept(this);
_recursionDepth--;
return(result);
}
else
{
return(null);
}
}
public override SyntaxNode?Visit(SyntaxNode?node)
{
if (node != null)
{
_recursionDepth++;
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
var result = ((LuaSyntaxNode)node).Accept(this);
_recursionDepth--;
// https://github.com/dotnet/roslyn/issues/47682
return(result !);
}
else
{
return(null);
}
}
private StatementSyntax ParseStatementCore()
{
_cancellationToken.ThrowIfCancellationRequested();
if (IsIncremental && CurrentNode is Syntax.StatementSyntax)
{
return((StatementSyntax)EatNode());
}
try
{
_recursionDepth++;
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
switch (CurrentToken.Kind)
{
case SyntaxKind.LocalKeyword:
if (PeekToken(1).Kind is SyntaxKind.FunctionKeyword)
{
return(ParseLocalFunctionDeclarationStatement());
}
else
{
return(ParseLocalVariableDeclarationStatement());
}
case SyntaxKind.ForKeyword:
if (PeekToken(2).Kind == SyntaxKind.EqualsToken)
{
return(ParseNumericForStatement());
}
else
{
return(ParseGenericForStatement());
}
case SyntaxKind.IfKeyword:
return(ParseIfStatement());
case SyntaxKind.RepeatKeyword:
return(ParseRepeatUntilStatement());
case SyntaxKind.WhileKeyword:
return(ParseWhileStatement());
case SyntaxKind.DoKeyword:
return(ParseDoStatement());
case SyntaxKind.GotoKeyword:
return(ParseGotoStatement());
case SyntaxKind.BreakKeyword:
return(ParseBreakStatement());
case SyntaxKind.ContinueKeyword:
return(ParseContinueStatement());
case SyntaxKind.ColonColonToken:
return(ParseGotoLabelStatement());
case SyntaxKind.FunctionKeyword:
return(ParseFunctionDeclarationStatement());
case SyntaxKind.ReturnKeyword:
return(ParseReturnStatement());
case SyntaxKind.SemicolonToken when Options.SyntaxOptions.AcceptEmptyStatements:
return(SyntaxFactory.EmtpyStatement(EatToken(SyntaxKind.SemicolonToken)));
default:
{
if (CurrentToken.ContextualKind == SyntaxKind.ContinueKeyword)
{
return(ParseContinueStatement());
}
var expression = ParsePrefixOrVariableExpression();
if (expression.Kind is SyntaxKind.BadExpression)
{
var semicolon = TryMatchSemicolon();
return(SyntaxFactory.BadStatement((BadExpressionSyntax)expression, semicolon));
}
if (CurrentToken.Kind is SyntaxKind.CommaToken or SyntaxKind.EqualsToken)
{
return(ParseAssignmentStatement(expression));
}
else if (SyntaxFacts.IsCompoundAssignmentOperatorToken(CurrentToken.Kind))
{
return(ParseCompoundAssignment(expression));
}
else
{
var semicolonToken = TryMatchSemicolon();
var node = SyntaxFactory.ExpressionStatement(expression, semicolonToken);
if (expression.Kind is not(SyntaxKind.FunctionCallExpression or SyntaxKind.MethodCallExpression))
{
node = AddError(node, ErrorCode.ERR_NonFunctionCallBeingUsedAsStatement);
}
return(node);
}
}
