public override SyntaxNode VisitForEachStatement(ForEachStatementSyntax node) { if (node.Identifier.ToString() == renameFrom.ToString()) node = node.WithIdentifier(renameTo); return base.VisitForEachStatement(node); }
public override SyntaxList <StatementSyntax> VisitForEachStatement(CSS.ForEachStatementSyntax node) { VisualBasicSyntaxNode variable; if (node.Type.IsVar) { variable = SyntaxFactory.IdentifierName(CommonConversions.ConvertIdentifier(node.Identifier)); } else { variable = SyntaxFactory.VariableDeclarator( SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(CommonConversions.ConvertIdentifier(node.Identifier))), SyntaxFactory.SimpleAsClause((TypeSyntax)node.Type.Accept(_nodesVisitor)), null ); } var expression = (ExpressionSyntax)node.Expression.Accept(_nodesVisitor); var stmt = ConvertBlock(node.Statement); var block = SyntaxFactory.ForEachBlock( SyntaxFactory.ForEachStatement(variable, expression), stmt, SyntaxFactory.NextStatement() ); return(SyntaxFactory.SingletonList <StatementSyntax>(block)); }
public override void VisitForEachStatement(ForEachStatementSyntax foreachStatement) { var expression = $"foreach ({foreachStatement.Type} {foreachStatement.Identifier} in {foreachStatement.InKeyword})"; var token = CreateBlock(expression, SDNodeRole.ForEach); _tokenList.Add(token); VisitChildren(token.Statements, foreachStatement.Statement); }
public static ForEachStatementSyntax AddBraces(ForEachStatementSyntax forEachStatement) { Debug.Assert(forEachStatement != null && NeedsBraces(forEachStatement)); return forEachStatement .WithStatement(SyntaxFactory.Block(forEachStatement.Statement)) .WithAdditionalAnnotations(Formatter.Annotation); }
public override void VisitForEachStatement(ForEachStatementSyntax node) { if (!(node.Statement is BlockSyntax)) { CreateAuditVariable(node.Statement); } base.VisitForEachStatement(node); }
internal ForeachCollectionProducerBlock(ForEachStatementSyntax foreachNode, Block successor) : base(successor) { if (foreachNode == null) { throw new ArgumentNullException(nameof(foreachNode)); } ForeachNode = foreachNode; }
public override SyntaxNode VisitForEachStatement(ForEachStatementSyntax node) { node = (ForEachStatementSyntax)base.VisitForEachStatement(node); if (!node.Statement.IsKind(SyntaxKind.Block)) { this.addedAnnotations = true; node = node.WithStatement(SyntaxFactory.Block(node.Statement)); } return node; }
private static SyntaxNode CalculateNewRoot(SyntaxNode root, ForEachStatementSyntax foreachSyntax, SemanticModel semanticModel) { var collection = foreachSyntax.Expression; var typeName = foreachSyntax.Type.ToString(); var invocationToAdd = GetOfTypeInvocation(typeName, collection); var namedTypes = semanticModel.LookupNamespacesAndTypes(foreachSyntax.SpanStart).OfType<INamedTypeSymbol>(); var isUsingAlreadyThere = namedTypes.Any(nt => nt.ToDisplayString() == ofTypeExtensionClass); if (isUsingAlreadyThere) { return root .ReplaceNode(collection, invocationToAdd) .WithAdditionalAnnotations(Formatter.Annotation); } else { var usingDirectiveToAdd = SyntaxFactory.UsingDirective( SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName("System"), SyntaxFactory.IdentifierName("Linq"))); var annotation = new SyntaxAnnotation("CollectionToChange"); var newRoot = root.ReplaceNode( collection, collection.WithAdditionalAnnotations(annotation)); var node = newRoot.GetAnnotatedNodes(annotation).First(); var closestNamespaceWithUsing = node.AncestorsAndSelf() .OfType<NamespaceDeclarationSyntax>() .FirstOrDefault(n => n.Usings.Count > 0); if (closestNamespaceWithUsing != null) { newRoot = newRoot.ReplaceNode( closestNamespaceWithUsing, closestNamespaceWithUsing.AddUsings(usingDirectiveToAdd)) .WithAdditionalAnnotations(Formatter.Annotation); } else { var compilationUnit = node.FirstAncestorOrSelf<CompilationUnitSyntax>(); newRoot = compilationUnit.AddUsings(usingDirectiveToAdd); } node = newRoot.GetAnnotatedNodes(annotation).First(); return newRoot .ReplaceNode(node, invocationToAdd) .WithAdditionalAnnotations(Formatter.Annotation); } }
public override void VisitForEachStatement(ForEachStatementSyntax node) { foreach (var invocation in node.DescendantNodes().OfType<InvocationExpressionSyntax>()) { var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(invocation).Symbol; if (symbol != null && symbol.IsTaskCreationMethod()) { Logs.TempLog2.Info("{0}{1}--------------------------", Document.FilePath, node.Parent.ToLog()); break; } if (symbol != null && symbol.IsThreadStart()) { Logs.TempLog5.Info("{0}{1}--------------------------", Document.FilePath, node.Parent.ToLog()); break; } } base.VisitForEachStatement(node); }
public override SyntaxList <StatementSyntax> VisitForEachStatement(CSS.ForEachStatementSyntax node) { VisualBasicSyntaxNode variable; if (node.Type.IsVar) { variable = SyntaxFactory.IdentifierName(_commonConversions.ConvertIdentifier(node.Identifier)); } else { variable = SyntaxFactory.VariableDeclarator( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.ModifiedIdentifier(_commonConversions.ConvertIdentifier(node.Identifier))), SyntaxFactory.SimpleAsClause((TypeSyntax)node.Type.Accept(_nodesVisitor)), null ); } return(CreateForEachStatement(variable, node.Expression, node.Statement)); }
private static bool TrySearchForIfThenContinueStatement(ForEachStatementSyntax fe, out IfStatementSyntax ifStatement, out string ifType) { if (fe.Statement is BlockSyntax) { var block = ((BlockSyntax)fe.Statement); if ((block.Statements.Count > 1 && block.Statements.First() is IfStatementSyntax) || (block.Statements.Count > 0 && block.Statements.First() is IfStatementSyntax && ((IfStatementSyntax)block.Statements.First()).Else != null) ) { ifStatement = (block.Statements.FirstOrDefault() as IfStatementSyntax); if (ifStatement?.Statement is ContinueStatementSyntax || ((ifStatement?.Statement as BlockSyntax)?.Statements)?.FirstOrDefault() is ContinueStatementSyntax) { ifType = IfWithContinueToWhere; return true; } } } ifStatement = null; ifType = null; return false; }
private async Task<Document> ConvertIfToLINQ(Document document, IfStatementSyntax ifStatement, ForEachStatementSyntax foreachStatement, CancellationToken c) { var generator = SyntaxGenerator.GetGenerator(document); var oldVariables = ifStatement.Condition.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Where(x => x.Identifier.Text == foreachStatement.Identifier.Text); var whereCall = generator.InvocationExpression( generator.MemberAccessExpression(foreachStatement.Expression, "Where"), generator.Argument( generator.ValueReturningLambdaExpression( new[] { generator.LambdaParameter("x") }, ifStatement.Condition.ReplaceNodes(oldVariables, (x, y) => generator.IdentifierName("x"))))); var root = await document.GetSyntaxRootAsync(c); var newFeStatement = foreachStatement .WithExpression((ExpressionSyntax)whereCall) .WithStatement(ifStatement.Statement.WithAdditionalAnnotations(Formatter.Annotation)); var newRoot = root.ReplaceNode(foreachStatement, newFeStatement); return document.WithSyntaxRoot(newRoot); }
public sealed override void VisitForEachStatement(ForEachStatementSyntax node) { _builder.Add(node); base.VisitForEachStatement(node); }
/// <summary> /// Handles the given foreach statement. /// </summary> /// <param name="stmt">Statement</param> /// <param name="successor">Successor</param> private void HandleForeachStatement(ForEachStatementSyntax stmt, ControlFlowGraphNode successor) { this.SyntaxNodes.Add(stmt.Expression); this.IsLoopHeadNode = true; if (successor != null) { this.ISuccessors.Add(successor); successor.IPredecessors.Add(this); this.LoopExitNode = successor; } var foreachNode = new ControlFlowGraphNode(this.Summary); this.ISuccessors.Add(foreachNode); foreachNode.IPredecessors.Add(this); if (stmt.Statement is BlockSyntax) { foreachNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, this); } else { foreachNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, this); } }
public override void VisitForEachStatement(ForEachStatementSyntax node) { VisitCommonForEachStatement(node); }
public ForEachStatementTranslation(ForEachStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Expression = syntax.Expression.Get<ExpressionTranslation>(this); Statement = syntax.Statement.Get<StatementTranslation>(this); Type = syntax.Type.Get<TypeTranslation>(this); }
public override SyntaxNode VisitForEachStatement(ForEachStatementSyntax node) { var info = this._semanticModel.GetTypeInfo(node.Expression); if (info.IsEnumerable()) { //Note:Here we use __idx${identifierName} as index _output.Write(node.ForEachKeyword, "for (var __idx${0} = 0; __idx${0} < ", node.Identifier.ValueText); VisitExpression(node.Expression); _output.Write(node.Identifier, ".length; __idx${0}++) ", node.Identifier.ValueText); _output.TrivialWriteLine('{'); _output.IncreaseIndent(); _output.Write(node.Identifier, "var {0} = ", node.Identifier.ValueText); Visit(node.Expression); _output.WriteLine(node.Identifier, "[__idx${0}];", node.Identifier.ValueText); this.Visit(node.Statement); this.AppendCompensateSemicolon(node.Statement); _output.DecreaseIndent(); _output.TrivialWrite('}'); } else { _output.Write(node.ForEachKeyword, "for (var {0} in ", node.Identifier.ValueText); VisitExpression(node.Expression); _output.TrivialWriteLine(") {"); _output.IncreaseIndent(); this.Visit(node.Statement); this.AppendCompensateSemicolon(node.Statement); _output.DecreaseIndent(); _output.TrivialWrite('}'); } return node; }
/// <summary> /// Add sequence point |here|: /// /// |foreach| (Type var in expr) { } /// </summary> /// <remarks> /// Hit once, before looping begins. /// </remarks> private void AddForEachKeywordSequencePoint(ForEachStatementSyntax forEachSyntax, ref BoundStatement result) { if (this.GenerateDebugInfo) { BoundSequencePointWithSpan foreachKeywordSequencePoint = new BoundSequencePointWithSpan(forEachSyntax, null, forEachSyntax.ForEachKeyword.Span); result = new BoundStatementList(forEachSyntax, ImmutableArray.Create<BoundStatement>(foreachKeywordSequencePoint, result)); } }
public override ForEachStatementInfo GetForEachStatementInfo(ForEachStatementSyntax node) { BoundForEachStatement boundForEach = (BoundForEachStatement)GetUpperBoundNode(node); if (boundForEach == null) { return default(ForEachStatementInfo); } ForEachEnumeratorInfo enumeratorInfoOpt = boundForEach.EnumeratorInfoOpt; Debug.Assert(enumeratorInfoOpt != null || boundForEach.HasAnyErrors); if (enumeratorInfoOpt == null) { return default(ForEachStatementInfo); } // Even though we usually pretend to be using System.Collection.IEnumerable // for arrays, that doesn't make sense for pointer arrays since object // (the type of System.Collections.IEnumerator.Current) isn't convertible // to pointer types. if (enumeratorInfoOpt.ElementType.IsPointerType()) { Debug.Assert(!enumeratorInfoOpt.CurrentConversion.IsValid); return default(ForEachStatementInfo); } // NOTE: we're going to list GetEnumerator, etc for array and string // collections, even though we know that's not how the implementation // actually enumerates them. return new ForEachStatementInfo( enumeratorInfoOpt.GetEnumeratorMethod, enumeratorInfoOpt.MoveNextMethod, (PropertySymbol)enumeratorInfoOpt.CurrentPropertyGetter.AssociatedSymbol, enumeratorInfoOpt.NeedsDisposeMethod ? (MethodSymbol)Compilation.GetSpecialTypeMember(SpecialMember.System_IDisposable__Dispose) : null, enumeratorInfoOpt.ElementType, boundForEach.ElementConversion, enumeratorInfoOpt.CurrentConversion); }
public override ForEachStatementInfo GetForEachStatementInfo(ForEachStatementSyntax node) { return GetForEachStatementInfo((CommonForEachStatementSyntax)node); }
public override void VisitForEachStatement(ForEachStatementSyntax node) { Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda); var patternBinder = new PatternVariableBinder(node.Expression, _enclosing); AddToMap(node.Expression, patternBinder); Visit(node.Expression, patternBinder); var binder = new ForEachLoopBinder(patternBinder, node); AddToMap(node, binder); VisitPossibleEmbeddedStatement(node.Statement, binder); }
private static TextSpan GetActiveSpan(ForEachStatementSyntax node, ForEachPart part) { switch (part) { case ForEachPart.ForEach: return node.ForEachKeyword.Span; case ForEachPart.VariableDeclaration: return TextSpan.FromBounds(node.Type.SpanStart, node.Identifier.Span.End); case ForEachPart.In: return node.InKeyword.Span; case ForEachPart.Expression: return node.Expression.Span; default: throw ExceptionUtilities.UnexpectedValue(part); } }
public override SyntaxNode VisitForEachStatement(ForEachStatementSyntax node) { SyntaxNode rewrittenNode = null; if (node.Statement != null) rewrittenNode = RewriteWithBlockIfRequired(node, node.Statement); return base.VisitForEachStatement((ForEachStatementSyntax)rewrittenNode ?? node); }
public override ForEachStatementInfo GetForEachStatementInfo(ForEachStatementSyntax node) { MemberSemanticModel memberModel = GetMemberModel(node); return memberModel == null ? default(ForEachStatementInfo) : memberModel.GetForEachStatementInfo(node); }
public override SyntaxList <VB.Syntax.StatementSyntax> VisitForEachStatement(CS.Syntax.ForEachStatementSyntax node) { VB.Syntax.ForEachStatementSyntax begin = VB.SyntaxFactory.ForEachStatement( VB.SyntaxFactory.IdentifierName(nodeVisitor.ConvertIdentifier(node.Identifier)), nodeVisitor.VisitExpression(node.Expression)); return(List <VB.Syntax.StatementSyntax>( VB.SyntaxFactory.ForEachBlock( begin, Visit(node.Statement), VB.SyntaxFactory.NextStatement()))); }
public BoundStatement BindForEach(ForEachStatementSyntax node, DiagnosticBag diagnostics) { Binder loopBinder = this.GetBinder(node); return loopBinder.BindForEachParts(diagnostics, loopBinder); }
private IEnumerable<ITypeSymbol> InferTypeInForEachStatement(ForEachStatementSyntax forEachStatementSyntax, ExpressionSyntax expressionOpt = null, SyntaxToken? previousToken = null) { // If we have a position, then we have to be after "foreach(... in" if (previousToken.HasValue && previousToken.Value != forEachStatementSyntax.InKeyword) { return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); } if (expressionOpt != null && expressionOpt != forEachStatementSyntax.Expression) { return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); } // foreach (int v = Foo()) var variableTypes = GetTypes(forEachStatementSyntax.Type); if (!variableTypes.Any()) { return SpecializedCollections.SingletonEnumerable( this.Compilation.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T) .Construct(Compilation.GetSpecialType(SpecialType.System_Object))); } var type = this.Compilation.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T); return variableTypes.Select(v => type.Construct(v)); }
public override void VisitForEachStatement(ForEachStatementSyntax node) { Debug.Assert((object)_method == _enclosing.ContainingMemberOrLambda); var binder = new ForEachLoopBinder(_enclosing, node); AddToMap(node, binder); VisitPossibleEmbeddedStatement(node.Statement, binder); }
/// <summary> /// Given a foreach statement, get the symbol for the iteration variable /// </summary> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="forEachStatement"></param> public ILocalSymbol GetDeclaredSymbol(ForEachStatementSyntax forEachStatement, CancellationToken cancellationToken = default(CancellationToken)) { Binder enclosingBinder = this.GetEnclosingBinder(GetAdjustedNodePosition(forEachStatement)); if (enclosingBinder == null) { return null; } Binder foreachBinder = enclosingBinder.GetBinder(forEachStatement); // Binder.GetBinder can fail in presence of syntax errors. if (foreachBinder == null) { return null; } LocalSymbol local = foreachBinder.GetDeclaredLocalsForScope(forEachStatement).FirstOrDefault(); return ((object)local != null && local.DeclarationKind == LocalDeclarationKind.ForEachIterationVariable) ? local : null; }
private static ForEachPart GetStatementPart(ForEachStatementSyntax node, int position) { return position < node.OpenParenToken.SpanStart ? ForEachPart.ForEach : position < node.InKeyword.SpanStart ? ForEachPart.VariableDeclaration : position < node.Expression.SpanStart ? ForEachPart.In : ForEachPart.Expression; }
/// <summary> /// Gets for each statement info. /// </summary> /// <param name="node">The node.</param> public abstract ForEachStatementInfo GetForEachStatementInfo(ForEachStatementSyntax node);
private static bool AreEquivalentActiveStatements(ForEachStatementSyntax oldNode, ForEachStatementSyntax newNode) { // This is conservative, we might be able to allow changing the type. return AreEquivalentIgnoringLambdaBodies(oldNode.Type, newNode.Type) && AreEquivalentIgnoringLambdaBodies(oldNode.Expression, newNode.Expression); }
private static double ComputeWeightedDistance(ForEachStatementSyntax left, ForEachStatementSyntax right) { double statementDistance = ComputeDistance(left.Statement, right.Statement); double expressionDistance = ComputeDistance(left.Expression, right.Expression); double identifierDistance = ComputeDistance(left.Identifier, right.Identifier); double distance = identifierDistance * 0.7 + expressionDistance * 0.2 + statementDistance * 0.1; return AdjustForLocalsInBlock(distance, left.Statement, right.Statement, localsWeight: 0.6); }