public static WhileStatementSyntax AddBraces(WhileStatementSyntax whileStatement) { Debug.Assert(whileStatement != null && NeedsBraces(whileStatement)); return whileStatement .WithStatement(SyntaxFactory.Block(whileStatement.Statement)) .WithAdditionalAnnotations(Formatter.Annotation); }
public BoundWhileStatement BindWhile(WhileStatementSyntax node) { Debug.Assert(node != null); var condition = BindBooleanExpression(node.Condition); var loopContext = this.containingMethod.BlockMap.GetValueOrDefault(node); Debug.Assert(loopContext != null); var analyzer = new SemanticAnalyzer(this.containingMethod, loopContext, this.diagnostics); var body = analyzer.BindStatement(node.Statement); return new BoundWhileStatement(node, condition, body, loopContext.GetBreakLabel(), loopContext.GetContinueLabel()); }
public static void Go(OutputWriter writer, WhileStatementSyntax whileStatement) { var info = new LoopInfo(whileStatement); writer.WriteIndent(); writer.Write("while ("); Core.Write(writer, whileStatement.Condition); writer.Write(")\r\n"); writer.OpenBrace(); Core.WriteStatementAsBlock(writer, whileStatement.Statement, false); writer.CloseBrace(); }
private void BuildWhileStatement(WhileStatementSyntax whileStatement) { var afterBlock = currentBlock; var loopTempBlock = CreateTemporaryBlock(); BreakTarget.Push(afterBlock); ContinueTargets.Push(loopTempBlock); var bodyBlock = CreateBlock(loopTempBlock); currentBlock = bodyBlock; BuildStatement(whileStatement.Statement); BreakTarget.Pop(); ContinueTargets.Pop(); currentBlock = CreateBinaryBranchBlock(whileStatement, currentBlock, afterBlock); BuildExpression(whileStatement.Condition); loopTempBlock.SuccessorBlock = currentBlock; currentBlock = CreateBlock(currentBlock); }
public override BoundNode VisitWhileStatement(BoundWhileStatement node) { Debug.Assert(node != null); var rewrittenCondition = (BoundExpression)Visit(node.Condition); var rewrittenBody = (BoundStatement)Visit(node.Body); TextSpan conditionSequencePointSpan = default(TextSpan); if (this.generateDebugInfo) { if (!node.WasCompilerGenerated) { WhileStatementSyntax whileSyntax = (WhileStatementSyntax)node.Syntax; conditionSequencePointSpan = TextSpan.FromBounds( whileSyntax.WhileKeyword.Span.Start, whileSyntax.CloseParenToken.Span.End); } } return(RewriteWhileStatement(node.Syntax, rewrittenCondition, conditionSequencePointSpan, rewrittenBody, node.BreakLabel, node.ContinueLabel, node.HasErrors)); }
private SyntaxNode normalizeBlockedCode(SyntaxNode node) { IfStatementSyntax ifStatement = node as IfStatementSyntax; if (ifStatement != null) { return(ifStatement.ChildNodes().First()); } ForStatementSyntax forStatement = node as ForStatementSyntax; if (forStatement != null) { return(forStatement.ChildNodes().First()); } WhileStatementSyntax whileStatement = node as WhileStatementSyntax; if (whileStatement != null) { return(whileStatement.ChildNodes().First()); } return(node); }
public static void ComputeRefactorings(RefactoringContext context, WhileStatementSyntax whileStatement) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceWhileStatementWithDoStatement) && (whileStatement.WhileKeyword.Span.Contains(context.Span))) { context.RegisterRefactoring( "Replace while with do", cancellationToken => { return(ReplaceWhileWithDoRefactoring.RefactorAsync( context.Document, whileStatement, cancellationToken)); }); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceWhileWithFor) && context.Span.IsBetweenSpans(whileStatement)) { ReplaceWhileWithForRefactoring.ComputeRefactoring(context, whileStatement); } }
internal static void ConvertIfToWhile() { //get current block BlockSyntax block = Root.DescendantNodes().OfType <BlockSyntax>().Where(n => n.HasAnnotation(CurrentBlock)).Single(); if (!(block.Parent is IfStatementSyntax)) { return; } //get if statement IfStatementSyntax ifStatement = block.Parent as IfStatementSyntax; //change it to a while WhileStatementSyntax whileStatement = SyntaxFactory.WhileStatement(ifStatement.Condition, ifStatement.Statement); //do the replacement Root = Root.ReplaceNode(ifStatement, whileStatement); BlockSyntax prevBlock = GetPreviousBlock(); CurrentBlock = prevBlock.GetAnnotations("Block").Single(); }
public static async Task <Document> RefactorAsync( Document document, BinaryExpressionSyntax condition, ExpressionSyntax expression, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var whileStatement = (WhileStatementSyntax)condition.Parent; WhileStatementSyntax newWhileStatement = whileStatement.ReplaceNode( expression.Parent, ExtractExpressionFromConditionRefactoring.GetNewCondition(condition, expression)); newWhileStatement = newWhileStatement.WithFormatterAnnotation(); root = root.ReplaceNode( whileStatement, ExtractExpressionToNestedIf(expression, whileStatement, newWhileStatement)); return(document.WithSyntaxRoot(root)); }
private static Task <Document> RefactorAsync( Document document, WhileStatementSyntax whileStatement, List <LocalDeclarationStatementSyntax> localDeclarations, CancellationToken cancellationToken) { IEnumerable <VariableDeclarationSyntax> declarations = localDeclarations .Select(f => f.Declaration); TypeSyntax type = declarations.First().Type.TrimTrivia(); SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declarations .SelectMany(f => f.Variables) .Select(f => f.TrimTrivia()) .ToSeparatedSyntaxList(); VariableDeclarationSyntax declaration = VariableDeclaration(type, variables); ForStatementSyntax forStatement = SyntaxRefactorings.ConvertWhileStatementToForStatement(whileStatement, declaration); return(RefactorAsync(document, whileStatement, forStatement, localDeclarations, cancellationToken)); }
public static async Task <Document> RefactorAsync( Document document, WhileStatementSyntax whileStatement, CancellationToken cancellationToken) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(whileStatement); if (statementsInfo.Success) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); int index = FindLocalDeclarationStatementIndex( whileStatement, statementsInfo.Statements, startIndex: 0, count: statementsInfo.IndexOf(whileStatement), mustBeReferencedInsideWhileStatement: true, semanticModel: semanticModel, cancellationToken: cancellationToken); if (index >= 0) { List <LocalDeclarationStatementSyntax> localDeclarations = statementsInfo .Statements .Skip(index) .Take(statementsInfo.IndexOf(whileStatement) - 1) .Cast <LocalDeclarationStatementSyntax>() .ToList(); return(await RefactorAsync(document, whileStatement, localDeclarations, cancellationToken).ConfigureAwait(false)); } } return(await document.ReplaceNodeAsync( whileStatement, SyntaxRefactorings.ConvertWhileStatementToForStatement(whileStatement), cancellationToken).ConfigureAwait(false)); }
public override void VisitWhileStatement(WhileStatementSyntax node) { ContinueInfo ci = new ContinueInfo(); ci.Init(node.Statement); m_ContinueInfoStack.Push(ci); CodeBuilder.AppendFormat("{0}while ", GetIndentString()); VisitExpressionSyntax(node.Condition); CodeBuilder.AppendLine(" do"); if (ci.HaveContinue) { if (ci.HaveBreak) { CodeBuilder.AppendFormat("{0}local {1} = false", GetIndentString(), ci.BreakFlagVarName); CodeBuilder.AppendLine(); } CodeBuilder.AppendFormat("{0}repeat", GetIndentString()); CodeBuilder.AppendLine(); } ++m_Indent; node.Statement.Accept(this); --m_Indent; if (ci.HaveContinue) { CodeBuilder.AppendFormat("{0}until true;", GetIndentString()); CodeBuilder.AppendLine(); if (ci.HaveBreak) { CodeBuilder.AppendFormat("{0}if {1} then break; end;", GetIndentString(), ci.BreakFlagVarName); CodeBuilder.AppendLine(); } } CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); m_ContinueInfoStack.Pop(); }
private static Task <Document> RefactorAsync <TNode>( Document document, WhileStatementSyntax whileStatement, ForStatementSyntax forStatement, List <TNode> list, CancellationToken cancellationToken) where TNode : StatementSyntax { forStatement = forStatement .TrimLeadingTrivia() .PrependToLeadingTrivia(list[0].GetLeadingTrivia()); StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(whileStatement); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(list[0]); IEnumerable <StatementSyntax> newStatements = statements.Take(index) .Concat(new ForStatementSyntax[] { forStatement }) .Concat(statements.Skip(index + list.Count + 1)); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
private static Task <Document> RefactorAsync <TNode>( Document document, WhileStatementSyntax whileStatement, ForStatementSyntax forStatement, List <TNode> list, CancellationToken cancellationToken) where TNode : StatementSyntax { forStatement = forStatement .TrimLeadingTrivia() .PrependToLeadingTrivia(list[0].GetLeadingTrivia()); StatementContainer container = StatementContainer.Create(whileStatement); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(list[0]); IEnumerable <StatementSyntax> newStatements = statements.Take(index) .Concat(new ForStatementSyntax[] { forStatement }) .Concat(statements.Skip(index + list.Count + 1)); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
public override void VisitWhileStatement(WhileStatementSyntax node) { var topOfLoop = GetNextState(); GotoState(topOfLoop); CurrentState = topOfLoop; var afterWhileStatement = GetNextState(); var bodyState = NewState(); var newWhileStatement = Js.While( (JsExpression)node.Condition.Accept(Transformer), GotoStateBlock(bodyState)); CurrentState.Add(newWhileStatement); GotoState(afterWhileStatement); CurrentState = bodyState; AcceptStatement(node.Statement, afterWhileStatement, topOfLoop); GotoState(topOfLoop); CurrentState = afterWhileStatement; }
public override void VisitWhileStatement(WhileStatementSyntax node) { if (!YieldChecker.HasSpecialStatement(node)) { currentState.Add(StateMachineThisFixer.Fix(node)); } else { MaybeCreateNewState(); var nextState = GetNextState(node); var iterationState = currentState; iterationState.NextState = nextState; iterationState.BreakState = nextState; node = node.WithStatement(SyntaxFactory.Block(CaptureState(node.Statement, iterationState, nextState))); iterationState.Statements.Add(node); Close(iterationState); currentState = nextState; } }
public static Task <Document> RefactorAsync( Document document, DoStatementSyntax doStatement, CancellationToken cancellationToken = default) { SyntaxTriviaList trailingTrivia = doStatement.Statement .GetTrailingTrivia() .EmptyIfWhitespace() .AddRange(doStatement.CloseParenToken.TrailingTrivia.EmptyIfWhitespace()) .AddRange(doStatement.SemicolonToken.LeadingTrivia.EmptyIfWhitespace()) .AddRange(doStatement.SemicolonToken.TrailingTrivia); WhileStatementSyntax newNode = WhileStatement( doStatement.WhileKeyword.WithLeadingTrivia(doStatement.DoKeyword.LeadingTrivia), doStatement.OpenParenToken, doStatement.Condition, doStatement.CloseParenToken.WithTrailingTrivia(doStatement.DoKeyword.TrailingTrivia), doStatement.Statement.WithTrailingTrivia(trailingTrivia)); newNode = newNode.WithFormatterAnnotation(); return(document.ReplaceNodeAsync(doStatement, newNode, cancellationToken)); }
public static async Task <Document> RefactorAsync( Document document, WhileStatementSyntax whileStatement, CancellationToken cancellationToken = default(CancellationToken)) { DoStatementSyntax doStatement = DoStatement( Token( whileStatement.WhileKeyword.LeadingTrivia, SyntaxKind.DoKeyword, whileStatement.CloseParenToken.TrailingTrivia), whileStatement.Statement.WithoutTrailingTrivia(), WhileKeyword(), whileStatement.OpenParenToken, whileStatement.Condition, whileStatement.CloseParenToken.WithoutTrailingTrivia(), SemicolonToken()); doStatement = doStatement .WithTriviaFrom(whileStatement) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(whileStatement, doStatement, cancellationToken).ConfigureAwait(false)); }
public static void Go(HaxeWriter writer, WhileStatementSyntax whileStatement) { writer.WriteIndent(); writer.Write("while ("); Core.Write(writer, whileStatement.Condition); writer.Write(")\r\n"); writer.WriteOpenBrace(); if (whileStatement.Statement is BlockSyntax) { foreach (var statement in whileStatement.Statement.As <BlockSyntax>().Statements) { Core.Write(writer, statement); } } else { Core.Write(writer, whileStatement.Statement); } writer.WriteCloseBrace(); }
bool IsInConditionExpression(StatementSyntax statement, ISymbol symbol) { if (statement.Kind == SyntaxKind.IfStatement) { IfStatementSyntax ifStatement = (IfStatementSyntax)statement; return(this.model.AnalyzeExpressionDataFlow(ifStatement.Condition).WrittenInside.Contains(symbol)); } else if (statement.Kind == SyntaxKind.WhileStatement) { WhileStatementSyntax whileStatement = (WhileStatementSyntax)statement; return(this.model.AnalyzeExpressionDataFlow(whileStatement.Condition).WrittenInside.Contains(symbol)); } else if (statement.Kind == SyntaxKind.DoStatement) { DoStatementSyntax doStatement = (DoStatementSyntax)statement; return(this.model.AnalyzeExpressionDataFlow(doStatement.Condition).WrittenInside.Contains(symbol)); } else if (statement.Kind == SyntaxKind.ForStatement) { ForStatementSyntax forStatement = (ForStatementSyntax)statement; if (this.model.AnalyzeExpressionDataFlow(forStatement.Condition).WrittenInside.Contains(symbol)) { return(true); } if (forStatement.Initializers.Any(n => this.model.AnalyzeExpressionDataFlow(n).WrittenInside.Contains(symbol))) { return(true); } if (forStatement.Incrementors.Any(n => this.model.AnalyzeExpressionDataFlow(n).WrittenInside.Contains(symbol))) { return(true); } } return(false); }
private bool TryCompileWhile(WhileStatementSyntax whileSyntax, BasicBlockBuilder builder, out BasicBlockBuilder newBuilder) { newBuilder = builder; // Default failure case Debug.Assert(_methodInProgress != null); // Create a new basic block which will be the backwards branch target var conditionBuilder = builder.CreateSuccessorBlock(); var conditionBlockIndex = conditionBuilder.Index; // Compile the condition var conditionValue = ExpressionCompiler.TryCompileExpression(whileSyntax.ConditionSyntax, SimpleType.Bool, _methodInProgress, conditionBuilder, this, _diagnostics); if (conditionValue == -1) { return(false); } // Then compile the body. // The return guarantee is not propagated up as we don't know whether the loop will ever be entered. // TODO: Recognizing compile-time constant condition var bodyBuilder = conditionBuilder.CreateBranch((ushort)conditionValue); if (!TryCompileBlock(whileSyntax.BodySyntax, bodyBuilder, out bodyBuilder, out var _)) { return(false); } // Create the backwards branch bodyBuilder.SetSuccessor(conditionBlockIndex); // Create the exit branch newBuilder = conditionBuilder.CreateSuccessorBlock(); return(true); }
public sealed override void VisitWhileStatement(WhileStatementSyntax whileSyntax) { var outEdge = this.Context.CurrentNode.GetSingleEdge(); this.Context.CurrentNode.OutgoingEdges.Clear(); var condition = this.Context.ReenqueueCurrentNode(whileSyntax.Condition, createDisplayNode: true); condition.Flags |= FlowNodeFlags.LoopCondition; var statement = this.Context.EnqueueNode(whileSyntax.Statement); statement.Flags |= FlowNodeFlags.LoopBody; condition.AddEdge(statement, ExpressionFactory.True); statement.AddEdge(condition); this.Context.CurrentNode.OutgoingEdges.Add(outEdge.WithValueCondition(ExpressionFactory.False)); // TODO: Handle in a more sophisticated way, not causing "while (boolVar)" to create a helper variable if (condition.VariableModel == null) { condition.VariableModel = this.Context.TryCreateTemporaryVariableModel(whileSyntax.Condition); } return; }
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken); WhileStatementSyntax whileStatement = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <WhileStatementSyntax>(); if (whileStatement == null) { return; } if (whileStatement.Condition != null && whileStatement.Condition.Span.Contains(context.Span) && context.Document.SupportsSemanticModel) { SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken); AddBooleanComparisonRefactoring.Refactor(whileStatement.Condition, context, semanticModel); } FormatBinaryExpressionRefactoring.Refactor(context, whileStatement); }
/// <summary> /// Handles the given while statement. /// </summary> /// <param name="stmt">Statement</param> /// <param name="successor">Successor</param> private void HandleWhileStatement(WhileStatementSyntax stmt, ControlFlowGraphNode successor) { this.SyntaxNodes.Add(stmt.Condition); this.IsLoopHeadNode = true; if (successor != null) { this.ISuccessors.Add(successor); successor.IPredecessors.Add(this); this.LoopExitNode = successor; } var whileNode = new ControlFlowGraphNode(this.Summary); this.ISuccessors.Add(whileNode); whileNode.IPredecessors.Add(this); if (stmt.Statement is BlockSyntax) { whileNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, this); } else { whileNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, this); } }
private BoundStatement BindWhile(WhileStatementSyntax node, DiagnosticBag diagnostics) { Debug.Assert(node != null); var loopBinder = this.GetBinder(node); Debug.Assert(loopBinder != null); return loopBinder.WrapWithVariablesIfAny(node, loopBinder.BindWhileParts(diagnostics, loopBinder)); }
public override SyntaxNode VisitWhileStatement(WhileStatementSyntax node) { this.loopLevel++; var statement = base.VisitWhileStatement (node .WithStatement (GetLoopBlock (node.Statement))) .WithAdditionalAnnotations (this.isLoop); this.loopLevel--; return statement; }
public override void VisitWhileStatement(WhileStatementSyntax node) { Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda); var patternBinder = new PatternVariableBinder(node, _enclosing); var whileBinder = new WhileBinder(patternBinder, node); AddToMap(node, whileBinder); Visit(node.Condition, whileBinder); VisitPossibleEmbeddedStatement(node.Statement, whileBinder); }
public override void VisitWhileStatement(WhileStatementSyntax node) { base.VisitWhileStatement(node); _counter++; }
public override void VisitWhileStatement(WhileStatementSyntax node) { this.VisitWhileStatementDeclarations(node); base.VisitWhileStatement(node); }
public override void VisitWhileStatement(WhileStatementSyntax node) => this.counter.CheckNesting(node.WhileKeyword, () => base.VisitWhileStatement(node));
public override SyntaxNode VisitWhileStatement(WhileStatementSyntax node) { _output.Write(node.WhileKeyword, "while ("); this.VisitExpression(node.Condition); _output.TrivialWriteLine(") {"); _output.IncreaseIndent(); this.Visit(node.Statement); this.AppendCompensateSemicolon(node.Statement); _output.DecreaseIndent(); _output.TrivialWrite('}'); return node; }
public WhileStatementInterpreter(StatementInterpreterHandler statementInterpreterHandler, WhileStatementSyntax whileStatementSyntax) { this.statementInterpreterHandler = statementInterpreterHandler; this.whileStatementSyntax = whileStatementSyntax; }
public override void VisitWhileStatement(WhileStatementSyntax node) { _builder.Add(node); base.VisitWhileStatement(node); }
public override SyntaxNode VisitWhileStatement(WhileStatementSyntax node) { SyntaxNode rewrittenNode = null; if (node.Statement != null) rewrittenNode = RewriteWithBlockIfRequired(node, node.Statement); return base.VisitWhileStatement((WhileStatementSyntax)rewrittenNode ?? node); }
public BoundWhileStatement BindWhile(WhileStatementSyntax node, DiagnosticBag diagnostics) { Debug.Assert(node != null); var condition = BindBooleanExpression(node.Condition, diagnostics); var loopBinder = this.GetBinder(node); Debug.Assert(loopBinder != null); var body = loopBinder.BindPossibleEmbeddedStatement(node.Statement, diagnostics); return new BoundWhileStatement(node, condition, body, loopBinder.BreakLabel, loopBinder.ContinueLabel); }
public override void VisitWhileStatement(WhileStatementSyntax node) { var saveCurrentScope = currentScope; currentScope = new DeclarationScope(currentScope); Visit(node.Condition); VisitPossibleEmbeddedStatement(node.Statement); Debug.Assert(currentScope.Parent == saveCurrentScope); currentScope = saveCurrentScope; }
private IEnumerable<ITypeSymbol> InferTypeInWhileStatement(WhileStatementSyntax whileStatement, SyntaxToken? previousToken = null) { // If we're position based, then we have to be after the "while(" if (previousToken.HasValue && previousToken.Value != whileStatement.OpenParenToken) { return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); } return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Boolean)); }
override public void VisitWhileStatement(WhileStatementSyntax node) { Complexity++; base.VisitWhileStatement(node); }
/// <summary> /// /// </summary> /// <param name="node"></param> /// <remarks> /// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the /// tree by visiting the node. /// </remarks> public override void VisitWhileStatement(WhileStatementSyntax node) { this.VisitStatement(node); }
protected override SyntaxNode VisitWhileStatement(WhileStatementSyntax node) { node = node.Update (node.WhileKeyword, node.OpenParenToken, node.Condition, node.CloseParenToken, GetLoopBlock (node.Statement)); return base.VisitWhileStatement ((WhileStatementSyntax)node.WithAdditionalAnnotations (this.isLoop)); }
public override void VisitWhileStatement(WhileStatementSyntax node) { var token = CreateBlock($"while ({node.Condition})", SDNodeRole.WhileLoop); _tokenList.Add(token); VisitChildren(token.Statements, node.Statement); }
public override void VisitWhileStatement(WhileStatementSyntax node) { Emit("while ({0})", node.Condition.ToString()); using (IndentedBracketScope(node.Statement)) Visit(node.Statement); }
protected override void VisitWhileStatement(WhileStatementSyntax node) { Consider(node.Condition); base.VisitWhileStatement(node); }
public override void VisitWhileStatement(WhileStatementSyntax node) { Visit(node.Condition); }
private bool AnalyzeWhileStatement(WhileStatementSyntax whileStatement) => !whileStatement.Statement.IsKind(SyntaxKind.Block);
public BoundWhileStatement BindWhile(WhileStatementSyntax node, DiagnosticBag diagnostics) { Debug.Assert(node != null); var loopBinder = this.GetBinder(node); Debug.Assert(loopBinder != null); return loopBinder.BindWhileParts(diagnostics, loopBinder); }
public virtual void VisitWhileStatement(WhileStatementSyntax node) { DefaultVisit(node); }
public override SyntaxNode VisitWhileStatement(WhileStatementSyntax node) { node = (WhileStatementSyntax)base.VisitWhileStatement(node); if (!node.Statement.IsKind(SyntaxKind.Block)) { this.addedAnnotations = true; node = node.WithStatement(SyntaxFactory.Block(node.Statement)); } return node; }
private static async Task <Document> RefactorAsync( Document document, ForEachStatementSyntax forEachStatement, CancellationToken cancellationToken) { int position = forEachStatement.SpanStart; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string name = NameGenerator.Default.EnsureUniqueLocalName(DefaultNames.EnumeratorVariable, semanticModel, position, cancellationToken: cancellationToken); InvocationExpressionSyntax expression = SimpleMemberInvocationExpression(forEachStatement.Expression, IdentifierName(WellKnownMemberNames.GetEnumeratorMethodName)); VariableDeclarationSyntax variableDeclaration = VariableDeclaration(VarType(), Identifier(name).WithRenameAnnotation(), expression); MemberAccessExpressionSyntax currentExpression = SimpleMemberAccessExpression(IdentifierName(name), IdentifierName("Current")); ILocalSymbol localSymbol = semanticModel.GetDeclaredSymbol(forEachStatement, cancellationToken); StatementSyntax statement = forEachStatement.Statement; StatementSyntax newStatement = statement.ReplaceNodes( statement .DescendantNodes() .Where(node => node.Kind() == SyntaxKind.IdentifierName && localSymbol.Equals(semanticModel.GetSymbol(node, cancellationToken))), (node, _) => currentExpression.WithTriviaFrom(node)); WhileStatementSyntax whileStatement = WhileStatement( SimpleMemberInvocationExpression(IdentifierName(name), IdentifierName("MoveNext")), newStatement); if (semanticModel .GetSpeculativeMethodSymbol(position, expression)? .ReturnType .Implements(SpecialType.System_IDisposable, allInterfaces: true) == true) { UsingStatementSyntax usingStatement = UsingStatement( variableDeclaration, default(ExpressionSyntax), Block(whileStatement)); usingStatement = usingStatement .WithLeadingTrivia(forEachStatement.GetLeadingTrivia()) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(forEachStatement, usingStatement, cancellationToken).ConfigureAwait(false)); } else { LocalDeclarationStatementSyntax localDeclaration = LocalDeclarationStatement(variableDeclaration) .WithLeadingTrivia(forEachStatement.GetLeadingTrivia()) .WithFormatterAnnotation(); var newStatements = new StatementSyntax[] { localDeclaration, whileStatement.WithFormatterAnnotation() }; if (forEachStatement.IsEmbedded()) { BlockSyntax block = Block(newStatements).WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(forEachStatement, block, cancellationToken).ConfigureAwait(false)); } return(await document.ReplaceNodeAsync(forEachStatement, newStatements, cancellationToken).ConfigureAwait(false)); } }
public override void VisitWhileStatement(WhileStatementSyntax node) { Visit(node.Condition); }
private static bool AreEquivalentActiveStatements(WhileStatementSyntax oldNode, WhileStatementSyntax newNode) { // only check the condition, edits in the body are allowed: return AreEquivalentIgnoringLambdaBodies(oldNode.Condition, newNode.Condition); }
public override void VisitWhileStatement(WhileStatementSyntax node) { if (!YieldChecker.HasSpecialStatement(node)) { currentState.Add(StateMachineThisFixer.Fix(node)); } else { MaybeCreateNewState(); var nextState = GetNextState(node); var iterationState = currentState; iterationState.NextState = nextState; iterationState.BreakState = nextState; node = node.WithStatement(SyntaxFactory.Block(CaptureState(node.Statement, iterationState, nextState))); iterationState.Statements.Add(node); Close(iterationState); currentState = nextState; } }
public override void VisitWhileStatement(WhileStatementSyntax node) { Debug.Assert((object)_method == _enclosing.ContainingMemberOrLambda); var whileBinder = new WhileBinder(_enclosing, node); AddToMap(node, whileBinder); VisitPossibleEmbeddedStatement(node.Statement, whileBinder); }
private void HighlightWhileStatement(WhileStatementSyntax statement, List <TextSpan> spans) { spans.Add(statement.WhileKeyword.Span); }
private static int FindLocalDeclarationStatementIndex( WhileStatementSyntax whileStatement, SyntaxList <StatementSyntax> statements, int startIndex, int count, bool mustBeReferencedInsideWhileStatement, SemanticModel semanticModel, CancellationToken cancellationToken = default) { int resultIndex = -1; int whileStatementIndex = -1; ITypeSymbol typeSymbol = null; for (int i = count - 1; i >= startIndex; i--) { StatementSyntax statement = statements[i]; if (!(statement is LocalDeclarationStatementSyntax localDeclaration)) { return(resultIndex); } VariableDeclarationSyntax declaration = localDeclaration.Declaration; foreach (VariableDeclaratorSyntax variable in declaration.Variables) { var symbol = (ILocalSymbol)semanticModel.GetDeclaredSymbol(variable, cancellationToken); if (symbol == null) { continue; } if (symbol.Type.IsErrorType()) { continue; } if (typeSymbol == null) { typeSymbol = symbol.Type; } else if (!SymbolEqualityComparer.Default.Equals(typeSymbol, symbol.Type)) { return(resultIndex); } ContainsLocalOrParameterReferenceWalker walker = null; try { walker = ContainsLocalOrParameterReferenceWalker.GetInstance(symbol, semanticModel, cancellationToken); if (mustBeReferencedInsideWhileStatement) { walker.VisitWhileStatement(whileStatement); if (!walker.Result) { ContainsLocalOrParameterReferenceWalker.Free(walker); return(resultIndex); } } walker.Result = false; if (whileStatementIndex == -1) { whileStatementIndex = statements.IndexOf(whileStatement); } walker.VisitList(statements, whileStatementIndex + 1); if (walker.Result) { return(resultIndex); } } finally { if (walker != null) { ContainsLocalOrParameterReferenceWalker.Free(walker); } } resultIndex = i; } } return(resultIndex); }
public override void VisitWhileStatement(WhileStatementSyntax node) { var whileBinder = new WhileBinder(this.method, enclosing, node); AddToMap(node, whileBinder); VisitPossibleEmbeddedStatement(node.Statement, whileBinder); }
public override void VisitWhileStatement(WhileStatementSyntax node) { IncreaseComplexityByNestingPlusOne(node.WhileKeyword); VisitWithNesting(node, base.VisitWhileStatement); }
public override void VisitWhileStatement(WhileStatementSyntax node) => CheckNesting(node.WhileKeyword, () => base.VisitWhileStatement(node));
private bool AnalyzeWhileStatement(WhileStatementSyntax whileStatement) => !whileStatement.Statement.IsKind(SyntaxKind.Block);
public WhileStatementTranslation(WhileStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Condition = syntax.Condition.Get<ExpressionTranslation>(this); Statement = syntax.Statement.Get<StatementTranslation>(this); }