public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { if (!foreachStatement.EmbeddedStatement.IsNull) { AddVariable(foreachStatement.TypeReference, foreachStatement.VariableName, foreachStatement.EmbeddedStatement.StartLocation, foreachStatement.EndLocation, false, true, foreachStatement.Expression, null, false, foreachStatement.EmbeddedStatement.StartLocation); } if (foreachStatement.Expression != null) { foreachStatement.Expression.AcceptVisitor(this, data); } if (foreachStatement.EmbeddedStatement == null) { return(data); } return(foreachStatement.EmbeddedStatement.AcceptVisitor(this, data)); }
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { if (nameComparer.Equals(from, foreachStatement.VariableName)) { foreachStatement.VariableName = to; } return base.VisitForeachStatement(foreachStatement, data); }
public void Property() { program = @" namespace Test{ public class A { public IList children; public void Method() { foreach (INode child in children) { Debug.Assert(child != null); child.AcceptVisitor(visitor, data); } } } }" ; CompilationUnit compilationUnit = TestUtil.ParseProgram(program, SupportedLanguage.CSharp); NamespaceDeclaration ns = (NamespaceDeclaration)compilationUnit.Children[0]; TypeDeclaration ty = (TypeDeclaration)ns.Children[0]; MethodDeclaration md = (MethodDeclaration)ty.Children[1]; ForeachStatement f = (ForeachStatement)md.Body.Children[0]; IdentifierExpression id = (IdentifierExpression)f.Expression; Assert.IsNotNull(id); Assert.AreEqual("IList", GetType(id).Type); }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { ForeachStatement o = other as ForeachStatement; return(o != null && this.VariableType.DoMatch(o.VariableType, match) && this.VariableDesignation.DoMatch(o.VariableDesignation, match) && this.InExpression.DoMatch(o.InExpression, match) && this.EmbeddedStatement.DoMatch(o.EmbeddedStatement, match)); }
public override void ExitForeachStatement(ForeachStatement foreachStatement) { if (!foreachStatement.List.Type.IsList(foreachStatement.NearestAncestorOfType <Root>())) { Errors.Add(new CompilationError(foreachStatement.Context, $"Can not iterate over {foreachStatement.List.Type}.")); } }
public override void Accept(ForeachStatement foreachStmt) { IodineLabel foreachLabel = methodBuilder.CreateLabel(); IodineLabel breakLabel = methodBuilder.CreateLabel(); breakLabels.Push(breakLabel); continueLabels.Push(foreachLabel); foreachStmt.Iterator.Visit(this); int tmp = methodBuilder.CreateTemporary(); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.Dup); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.StoreLocal, tmp); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.IterReset); methodBuilder.MarkLabelPosition(foreachLabel); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.LoadLocal, tmp); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.IterMoveNext); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.JumpIfFalse, breakLabel); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.LoadLocal, tmp); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.IterGetNext); methodBuilder.EmitInstruction(foreachStmt.Iterator.Location, Opcode.StoreLocal, symbolTable.GetSymbol (foreachStmt.Item).Index); foreachStmt.Body.Visit(this); methodBuilder.EmitInstruction(foreachStmt.Body.Location, Opcode.Jump, foreachLabel); methodBuilder.MarkLabelPosition(breakLabel); breakLabels.Pop(); continueLabels.Pop(); }
public virtual void VisitForeachStatement(ForeachStatement foreachStatement) { if (this.ThrowException) { throw (System.Exception) this.CreateException(foreachStatement); } }
public virtual void VisitForeachStatement(ForeachStatement foreachStatement) { if (ThrowException) { throw (Exception)CreateException(foreachStatement); } }
public virtual void Visit(ForeachStatement s) { VisitChildren(s); if (s.ForeachTypeList != null) { foreach (var t in s.ForeachTypeList) { if (t != null) { t.Accept(this); } } } if (s.Aggregate != null) { s.Aggregate.Accept(this); } if (s.UpperAggregate != null) { s.UpperAggregate.Accept(this); } }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { base.VisitForeachStatement(foreachStatement); var rr = ctx.Resolve(foreachStatement) as ForEachResolveResult; if (rr == null) return; if (rr.ElementType.Kind == TypeKind.Unknown) return; if (ReflectionHelper.GetTypeCode(rr.ElementType) == TypeCode.Object) return; if (conversions == null) { conversions = CSharpConversions.Get(ctx.Compilation); } Conversion c = conversions.ImplicitConversion(rr.ElementType, rr.ElementVariable.Type); if (c.IsValid) return; var csResolver = ctx.GetResolverStateBefore(foreachStatement); var builder = new TypeSystemAstBuilder(csResolver); AstType elementType = builder.ConvertType(rr.ElementType); AstType variableType = foreachStatement.VariableType; string issueText = ctx.TranslateString("Collection element type '{0}' is not implicitly convertible to '{1}'"); string fixText = ctx.TranslateString("Use type '{0}'"); AddIssue(variableType, string.Format(issueText, elementType.GetText(), variableType.GetText()), new CodeAction(string.Format(fixText, elementType.GetText()), script => script.Replace(variableType, elementType))); }
public ReadOnlyForeachStatement(ForeachStatement foreachStatement) { type = new ReadOnlyTypeReference(foreachStatement.Type); variableName = foreachStatement.VariableName; iterator = new ReadOnlyExpressionStatement(foreachStatement.Iterator); statement = new ReadOnlyStatement(foreachStatement.Statement); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { if (findReturn) { base.VisitForeachStatement(foreachStatement); } }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { base.VisitForeachStatement(foreachStatement); var rr = ctx.Resolve(foreachStatement) as ForEachResolveResult; if (rr == null) { return; } if (rr.ElementType.Kind == TypeKind.Unknown) { return; } if (ReflectionHelper.GetTypeCode(rr.ElementType) == TypeCode.Object) { return; } if (conversions == null) { conversions = CSharpConversions.Get(ctx.Compilation); } Conversion c = conversions.ImplicitConversion(rr.ElementType, rr.ElementVariable.Type); if (c.IsValid) { return; } var csResolver = ctx.GetResolverStateBefore(foreachStatement); var builder = new TypeSystemAstBuilder(csResolver); AstType elementType = builder.ConvertType(rr.ElementType); AstType variableType = foreachStatement.VariableType; string text = ctx.TranslateString("Collection element type '{0}' is not implicitly convertible to '{1}'"); AddIssue(variableType, string.Format(text, elementType.GetText(), variableType.GetText())); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { var expression = string.Format("foreach ({0} {1} in {2})", foreachStatement.VariableType.GetText(), foreachStatement.VariableName, foreachStatement.InExpression.GetText()); var token = CreateBlock(expression, SDNodeRole.ForEach); _tokenList.Add(token); VisitChildren(token.Statements, foreachStatement.EmbeddedStatement); }
public override Object Visit(ForeachStatement node, Object obj) { node.ForEachDeclaration.Accept(this, obj); node.ForeachExp.Accept(this, obj); node.ForeachBlock.Accept(this, obj); return(null); }
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { if (nameComparer.Equals(from, foreachStatement.VariableName)) { foreachStatement.VariableName = to; } return(base.VisitForeachStatement(foreachStatement, data)); }
public override void VisitForeachStatement (ForeachStatement foreachStatement) { base.VisitForeachStatement (foreachStatement); if (HidesMember (ctx, foreachStatement, foreachStatement.VariableName)) AddIssue (foreachStatement.VariableNameToken, ctx.TranslateString ("Local variable has the same name as a member and hides it")); }
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { ForceSpacesBefore(foreachStatement.LPar, policy.ForeachParentheses); ForceSpacesAfter(foreachStatement.LPar, policy.WithinForEachParentheses); ForceSpacesBefore(foreachStatement.RPar, policy.WithinForEachParentheses); return(base.VisitForeachStatement(foreachStatement, data)); }
public override object Visit(ForeachStatement node, object obj) { if (node.Location == ((AstNode)obj).Location || found) { found = true; return(this.table); } return(base.Visit(node, obj)); }
public object VisitForeachStatement(ForeachStatement foreachStatement, object data) { B.ForStatement fs = new B.ForStatement(GetLexicalInfo(foreachStatement)); fs.EndSourceLocation = GetLocation(foreachStatement.EndLocation); fs.Iterator = ConvertExpression(foreachStatement.Expression); fs.Declarations.Add(new B.Declaration(foreachStatement.VariableName, ConvertTypeReference(foreachStatement.TypeReference))); fs.Block = ConvertBlock(foreachStatement.EmbeddedStatement); return(fs); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { if (!(foreachStatement.EmbeddedStatement is BlockStatement)) { Found = true; } base.VisitForeachStatement(foreachStatement); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { this.loopLevel++; foreachStatement.EmbeddedStatement = GetLoopBlock(foreachStatement.EmbeddedStatement); base.VisitForeachStatement(foreachStatement); this.loopLevel--; }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public IHappilForeachDoSyntax <T> ForeachElementIn <T>(IHappilOperand <IEnumerable <T> > collection) { var element = this.Local <T>(); var statement = new ForeachStatement <T>(element); AddStatement(statement); statement.In(collection); return(statement); }
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { var invocationExpression = foreachStatement.InExpression as InvocationExpression; if(invocationExpression != null && invocationExpression.Target.ToString().EndsWith("Enum.GetValues")) { UnlockWith(invocationExpression); } return base.VisitForeachStatement(foreachStatement, data); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { base.VisitForeachStatement(foreachStatement); if (HidesMember(ctx, foreachStatement, foreachStatement.VariableName)) { AddIssue(foreachStatement.VariableNameToken, ctx.TranslateString("Local variable has the same name as a member and hides it")); } }
public Ust VisitForControl(JavaParser.ForControlContext context) { JavaParser.EnhancedForControlContext forEach = context.enhancedForControl(); if (forEach != null) { // TODO: modifiers var type = (TypeToken)Visit(forEach.typeType()); var varDecId = (IdToken)Visit(forEach.variableDeclaratorId()); var expr = (Expression)Visit(forEach.expression()); var parent = (JavaParser.StatementContext)context.parent; var statement = (Statement)Visit(parent.statement(0)); var result = new ForeachStatement(type, varDecId, expr, statement, parent.GetTextSpan()); return(result); } else { var initializers = new List <Statement>(); var iterators = new List <Expression>(); JavaParser.ForInitContext forInit = context.forInit(); if (forInit != null) { var varDec = forInit.localVariableDeclaration(); if (varDec != null) { var varDecStatement = (VariableDeclarationExpression)Visit(varDec); initializers.Add(new ExpressionStatement(varDecStatement)); } else { initializers.AddRange(forInit.expressionList().expression() .Select(expr => { var ex = (Expression)Visit(expr); return(ex == null ? null : new ExpressionStatement(ex, expr.GetTextSpan())); }).Where(stmt => stmt != null).ToArray()); } } Expression condition = context.expression() == null ? null : (Expression)Visit(context.expression()); JavaParser.ExpressionListContext forUpdate = context.forUpdate; if (forUpdate != null) { iterators.AddRange(forUpdate.expression() .Select(expr => (Expression)Visit(expr)) .Where(iter => iter != null).ToArray()); } var parent = (JavaParser.StatementContext)context.parent; var statement = (Statement)Visit(parent.statement(0)); var result = new ForStatement(initializers, condition, iterators, statement, parent.GetTextSpan()); return(result); } }
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { var invocationExpression = foreachStatement.InExpression as InvocationExpression; if (invocationExpression != null && invocationExpression.Target.ToString().EndsWith("Enum.GetValues")) { UnlockWith(invocationExpression); } return(base.VisitForeachStatement(foreachStatement, data)); }
public virtual object Visit(ForeachStatement foreachStatement, object data) { Debug.Assert(foreachStatement != null); Debug.Assert(foreachStatement.TypeReference != null); Debug.Assert(foreachStatement.Expression != null); Debug.Assert(foreachStatement.EmbeddedStatement != null); foreachStatement.TypeReference.AcceptVisitor(this, data); foreachStatement.Expression.AcceptVisitor(this, data); return(foreachStatement.EmbeddedStatement.AcceptVisitor(this, data)); }
public JNode VisitForeachStatement(ForeachStatement node) { var node2 = new JForInStatement { Initializer = J.Var(node.VariableName, node.VariableType.Resolve().Type.JAccess()), Member = VisitExpression(node.InExpression), Statement = VisitStatement(node.EmbeddedStatement) }; return(node2); }
public override Object Visit(ForeachStatement node, Object obj) { int indent = Convert.ToInt32(obj); this.printIndentation(indent); this.output.WriteLine("ForeachStatement [{0}:{1}]", node.Location.Line, node.Location.Column); node.ForEachDeclaration.Accept(this, indent + 1); node.ForeachExp.Accept(this, indent + 1); node.ForeachBlock.Accept(this, indent + 1); return(null); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { if (foreachStatement.VariableNameToken != null && !foreachStatement.VariableNameToken.IsNull) { this.VariableNames.Add(foreachStatement.VariableName); var rr = (ForEachResolveResult)this.Emitter.Resolver.ResolveNode(foreachStatement, this.Emitter); this.Variables.Add(rr.ElementVariable); } base.VisitForeachStatement(foreachStatement); }
/// <summary> /// Retrieves the <see cref="ILVariable"/> associated with this <see cref="ForeachStatement"/>, /// or <c>null</c> if no variable is associated with this foreach statement. /// </summary> public static ILVariable GetILVariable(this ForeachStatement loop) { if (loop.Annotation <ResolveResult>() is ILVariableResolveResult rr) { return(rr.Variable); } else { return(null); } }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { bool oldIsInsideLoop = _isInsideLoop; try { _isInsideLoop = true; AddVariable(foreachStatement.VariableNameToken, foreachStatement.VariableName); base.VisitForeachStatement(foreachStatement); } finally { _isInsideLoop = oldIsInsideLoop; } }
public override UstNode VisitForEachStatement(ForEachStatementSyntax node) { var type = ConvertType(base.Visit(node.Type)); var var = new IdToken(node.Identifier.ValueText, node.Identifier.GetTextSpan(), FileNode); var inExpression = (Expression)base.Visit(node.Expression); var embedded = (Statement)base.Visit(node.Statement); var result = new ForeachStatement(type, var, inExpression, embedded, node.GetTextSpan(), FileNode); return(result); }
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { if (searchedMember is LocalVariable && foreachStatement.VariableName == searchedMemberName && searchedMemberLocation.Line == foreachStatement.StartLocation.Line && searchedMemberLocation.Column == foreachStatement.StartLocation.Column) { int line, col; SearchText(searchedMemberName, foreachStatement.StartLocation.Line, foreachStatement.StartLocation.Column, out line, out col); AddUniqueReference(line, col, searchedMemberName); } return(base.VisitForeachStatement(foreachStatement, data)); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { base.VisitForeachStatement (foreachStatement); var resolveResult = ctx.Resolve (foreachStatement.VariableNameToken) as LocalResolveResult; if (resolveResult == null) return; if (IsUsed (foreachStatement, resolveResult.Variable, foreachStatement.VariableNameToken)) return; AddIssue (foreachStatement.VariableNameToken, ctx.TranslateString ("Local variable is never used")); }
private ForeachStatement ParseForeachStatement(bool unsafeCode) { CsToken item = this.GetToken(CsTokenType.Foreach, SymbolType.Foreach); Microsoft.StyleCop.Node<CsToken> firstItemNode = this.tokens.InsertLast(item); Bracket bracketToken = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis); Microsoft.StyleCop.Node<CsToken> node2 = this.tokens.InsertLast(bracketToken); VariableDeclarationExpression expression = this.GetNextExpression(ExpressionPrecedence.None, unsafeCode, true, false) as VariableDeclarationExpression; if (expression == null) { throw this.CreateSyntaxException(); } this.tokens.Add(this.GetToken(CsTokenType.In, SymbolType.In)); Expression nextExpression = this.GetNextExpression(ExpressionPrecedence.None, unsafeCode); if (nextExpression == null) { throw this.CreateSyntaxException(); } Bracket bracket2 = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis); Microsoft.StyleCop.Node<CsToken> node3 = this.tokens.InsertLast(bracket2); bracketToken.MatchingBracketNode = node3; bracket2.MatchingBracketNode = node2; Statement nextStatement = this.GetNextStatement(unsafeCode); if (nextStatement == null) { throw this.CreateSyntaxException(); } CsTokenList tokens = new CsTokenList(this.tokens, firstItemNode, this.tokens.Last); ForeachStatement statement2 = new ForeachStatement(tokens, expression, nextExpression); statement2.EmbeddedStatement = nextStatement; foreach (VariableDeclaratorExpression expression3 in expression.Declarators) { Variable variable = new Variable(expression.Type, expression3.Identifier.Token.Text, VariableModifiers.None, expression3.Tokens.First.Value.Location.StartPoint, expression.Type.Generated); if (!statement2.Variables.Contains(expression3.Identifier.Token.Text)) { statement2.Variables.Add(variable); } } return statement2; }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { ForceSpacesBefore(foreachStatement.LParToken, policy.SpaceBeforeForeachParentheses); ForceSpacesAfter(foreachStatement.LParToken, policy.SpacesWithinForeachParentheses); ForceSpacesBefore(foreachStatement.RParToken, policy.SpacesWithinForeachParentheses); FixEmbeddedStatment(policy.StatementBraceStyle, policy.ForEachBraceForcement, foreachStatement.EmbeddedStatement); }
/// <summary> /// Reads the next foreach-statement from the file and returns it. /// </summary> /// <param name="parentReference">The parent code unit.</param> /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param> /// <returns>Returns the statement.</returns> private ForeachStatement ParseForeachStatement(Reference<ICodePart> parentReference, bool unsafeCode) { Param.AssertNotNull(parentReference, "parentReference"); Param.Ignore(unsafeCode); var statementReference = new Reference<ICodePart>(); // Get the foreach keyword. CsToken firstToken = this.GetToken(CsTokenType.Foreach, SymbolType.Foreach, parentReference, statementReference); Node<CsToken> firstTokenNode = this.tokens.InsertLast(firstToken); // Get the opening parenthesis. Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, statementReference); Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis); // Get the variable. VariableDeclarationExpression variable = this.GetNextExpression( ExpressionPrecedence.None, statementReference, unsafeCode, true, false) as VariableDeclarationExpression; if (variable == null) { throw this.CreateSyntaxException(); } // Get the 'in' keyword and add it. this.tokens.Add(this.GetToken(CsTokenType.In, SymbolType.In, statementReference)); // Get the item being iterated over. Expression item = this.GetNextExpression(ExpressionPrecedence.None, statementReference, unsafeCode); if (item == null) { throw this.CreateSyntaxException(); } // Get the closing parenthesis. Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, statementReference); Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis); openParenthesis.MatchingBracketNode = closeParenthesisNode; closeParenthesis.MatchingBracketNode = openParenthesisNode; // Get the embedded statement. Statement childStatement = this.GetNextStatement(statementReference, unsafeCode); if (childStatement == null) { throw this.CreateSyntaxException(); } // Create the token list for the statement. CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last); // Create the foreach-statement. ForeachStatement statement = new ForeachStatement(partialTokens, variable, item); statement.EmbeddedStatement = childStatement; statementReference.Target = statement; // Add the variable. foreach (VariableDeclaratorExpression declarator in variable.Declarators) { Variable localVariable = new Variable( variable.Type, declarator.Identifier.Token.Text, VariableModifiers.None, CodeLocation.Join(variable.Type.Location, declarator.Identifier.Token.Location), statementReference, variable.Type.Generated); // If there is already a variable in this scope with the same name, ignore this one. if (!statement.Variables.Contains(declarator.Identifier.Token.Text)) { statement.Variables.Add(localVariable); } } return statement; }
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { AddVariable(foreachStatement.TypeReference, foreachStatement.VariableName, foreachStatement.StartLocation, foreachStatement.EndLocation, false, true, foreachStatement.Expression, null); if (foreachStatement.Expression != null) { foreachStatement.Expression.AcceptVisitor(this, data); } if (foreachStatement.EmbeddedStatement == null) { return data; } return foreachStatement.EmbeddedStatement.AcceptVisitor(this, data); }
ForeachStatement ForeachStatement(IBlockNode Scope,IStatement Parent) { Step(); var dbs = new ForeachStatement() { Location = t.Location, IsReverse = t.Kind == Foreach_Reverse, Parent = Parent }; if(!Expect(OpenParenthesis)) return dbs; var tl = new List<DVariable>(); bool init=true; while(init || laKind == Comma) { if (init) init = false; else Step(); var forEachVar = new DVariable{ Parent = Scope }; forEachVar.Location = la.Location; CheckForStorageClasses(Scope); ApplyAttributes(forEachVar); if(IsEOF){ SynErr (Identifier, "Element variable name or type expected"); forEachVar.NameHash = DTokens.IncompleteIdHash; } else if (laKind == (Identifier) && (Lexer.CurrentPeekToken.Kind == (Semicolon) || Lexer.CurrentPeekToken.Kind == Comma)) { Step(); forEachVar.NameLocation = t.Location; forEachVar.Name = t.Value; } else { var type = BasicType(); var tnode = Declarator(type, false, Scope); if (!(tnode is DVariable)) break; if(forEachVar.Attributes != null) if(tnode.Attributes == null) tnode.Attributes = new List<DAttribute>(forEachVar.Attributes); else tnode.Attributes.AddRange(forEachVar.Attributes); tnode.Location = forEachVar.Location; forEachVar = tnode as DVariable; } forEachVar.EndLocation = t.EndLocation; tl.Add(forEachVar); } dbs.ForeachTypeList = tl.ToArray(); if(Expect(Semicolon)) dbs.Aggregate = Expression(Scope); // ForeachRangeStatement if (laKind == DoubleDot) { Step(); dbs.UpperAggregate = Expression(); } if(Expect(CloseParenthesis)) dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs); dbs.EndLocation = t.EndLocation; return dbs; }
public override object Visit (Foreach foreachStatement) { var result = new ForeachStatement (); var location = LocationsBag.GetLocations (foreachStatement); result.AddChild (new CSharpTokenNode (Convert (foreachStatement.loc), "foreach".Length), ForeachStatement.Roles.Keyword); if (location != null) result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForeachStatement.Roles.LPar); if (foreachStatement.TypeExpr == null) result.AddChild (ConvertToType (foreachStatement.TypeExpr), ForeachStatement.Roles.Type); if (foreachStatement.Variable != null) result.AddChild (new Identifier (foreachStatement.Variable.Name, Convert (foreachStatement.Variable.Location)), ForeachStatement.Roles.Identifier); if (location != null) result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), ForeachStatement.Roles.InKeyword); if (foreachStatement.Expr != null) result.AddChild ((MonoDevelop.CSharp.Ast.Expression)foreachStatement.Expr.Accept (this), ForeachStatement.Roles.Expression); if (location != null) result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ForeachStatement.Roles.RPar); result.AddChild ((MonoDevelop.CSharp.Ast.Statement)foreachStatement.Statement.Accept (this), ForeachStatement.Roles.EmbeddedStatement); return result; }
public virtual void VisitForeachStatement(ForeachStatement foreachStatement) { if (this.ThrowException) { throw (Exception)this.CreateException(foreachStatement); } }
public abstract StringBuilder VisitForeachStatement(ForeachStatement foreachStatement, int data);
public override void VisitForeachStatement (ForeachStatement foreachStatement) { variableNames.Add (foreachStatement.VariableName); base.VisitForeachStatement (foreachStatement); }
public virtual void Visit(ForeachStatement s) { VisitChildren (s); if (s.ForeachTypeList != null) foreach (var t in s.ForeachTypeList) if(t != null) t.Accept(this); }
public ForeachBlock(IEmitter emitter, ForeachStatement foreachStatement) : base(emitter, foreachStatement) { this.Emitter = emitter; this.ForeachStatement = foreachStatement; }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { }
public override object Visit(Foreach foreachStatement) { var result = new ForeachStatement(); var location = LocationsBag.GetLocations(foreachStatement); result.AddChild(new CSharpTokenNode(Convert(foreachStatement.loc), ForeachStatement.ForeachKeywordRole), ForeachStatement.ForeachKeywordRole); if (location != null) result.AddChild(new CSharpTokenNode(Convert(location [0]), Roles.LPar), Roles.LPar); if (foreachStatement.TypeExpression != null) result.AddChild(ConvertToType(foreachStatement.TypeExpression), Roles.Type); if (foreachStatement.Variable != null) result.AddChild(Identifier.Create(foreachStatement.Variable.Name, Convert(foreachStatement.Variable.Location)), Roles.Identifier); if (location != null && location.Count > 1) result.AddChild(new CSharpTokenNode(Convert(location [1]), ForeachStatement.InKeywordRole), ForeachStatement.InKeywordRole); if (foreachStatement.Expr != null) result.AddChild((Expression)foreachStatement.Expr.Accept(this), Roles.Expression); if (location != null && location.Count > 2) result.AddChild(new CSharpTokenNode(Convert(location [2]), Roles.RPar), Roles.RPar); if (foreachStatement.Statement != null) result.AddChild((Statement)foreachStatement.Statement.Accept(this), Roles.EmbeddedStatement); return result; }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { var ferr = (ForEachResolveResult)_resolver.Resolve(foreachStatement); var iterator = (LocalResolveResult)_resolver.Resolve(foreachStatement.VariableNameToken); var getEnumeratorMethod = (ferr.GetEnumeratorCall is InvocationResolveResult ? ((InvocationResolveResult)ferr.GetEnumeratorCall).Member as IMethod : null); var systemArray = _compilation.FindType(KnownTypeCode.Array); var inExpression = ResolveWithConversion(foreachStatement.InExpression); if (Equals(inExpression.Type, systemArray) || inExpression.Type.DirectBaseTypes.Contains(systemArray) || (getEnumeratorMethod != null && _metadataImporter.GetMethodSemantics(getEnumeratorMethod).EnumerateAsArray)) { var arrayResult = CompileExpression(foreachStatement.InExpression, CompileExpressionFlags.ReturnValueIsImportant); _result.AddRange(arrayResult.AdditionalStatements); var array = arrayResult.Expression; if (IsJsExpressionComplexEnoughToGetATemporaryVariable.Analyze(array)) { var tmpArray = CreateTemporaryVariable(ferr.CollectionType, foreachStatement.GetRegion()); _result.Add(JsStatement.Var(_variables[tmpArray].Name, array)); array = JsExpression.Identifier(_variables[tmpArray].Name); } var length = systemArray.GetProperties().SingleOrDefault(p => p.Name == "Length"); if (length == null) { _errorReporter.InternalError("Property Array.Length not found."); return; } var lengthSem = _metadataImporter.GetPropertySemantics(length); if (lengthSem.Type != PropertyScriptSemantics.ImplType.Field) { _errorReporter.InternalError("Property Array.Length is not implemented as a field."); return; } var index = CreateTemporaryVariable(_compilation.FindType(KnownTypeCode.Int32), foreachStatement.GetRegion()); var jsIndex = JsExpression.Identifier(_variables[index].Name); JsExpression iteratorValue = MaybeCloneValueType(JsExpression.Index(array, jsIndex), null, ferr.ElementType); if (_variables[iterator.Variable].UseByRefSemantics) iteratorValue = JsExpression.ObjectLiteral(new JsObjectLiteralProperty("$", iteratorValue)); var body = new[] { JsStatement.Var(_variables[iterator.Variable].Name, iteratorValue) } .Concat(CreateInnerCompiler().Compile(foreachStatement.EmbeddedStatement).Statements); _result.Add(JsStatement.For(JsStatement.Var(_variables[index].Name, JsExpression.Number(0)), JsExpression.Lesser(jsIndex, JsExpression.Member(array, lengthSem.FieldName)), JsExpression.PostfixPlusPlus(jsIndex), JsStatement.Block(body))); } else { var getEnumeratorCall = _expressionCompiler.Compile(ferr.GetEnumeratorCall, true); _result.AddRange(getEnumeratorCall.AdditionalStatements); var enumerator = CreateTemporaryVariable(ferr.EnumeratorType, foreachStatement.GetRegion()); _result.Add(JsStatement.Var(_variables[enumerator].Name, getEnumeratorCall.Expression)); var moveNextInvocation = _expressionCompiler.Compile(new CSharpInvocationResolveResult(new LocalResolveResult(enumerator), ferr.MoveNextMethod, new ResolveResult[0]), true); if (moveNextInvocation.AdditionalStatements.Count > 0) _errorReporter.InternalError("MoveNext() invocation is not allowed to require additional statements."); var getCurrent = _expressionCompiler.Compile(new MemberResolveResult(new LocalResolveResult(enumerator), ferr.CurrentProperty), true); JsExpression getCurrentValue = MaybeCloneValueType(getCurrent.Expression, null, ferr.ElementType); if (_variables[iterator.Variable].UseByRefSemantics) getCurrentValue = JsExpression.ObjectLiteral(new JsObjectLiteralProperty("$", getCurrentValue)); var preBody = getCurrent.AdditionalStatements.Concat(new[] { JsStatement.Var(_variables[iterator.Variable].Name, getCurrentValue) }).ToList(); var body = CreateInnerCompiler().Compile(foreachStatement.EmbeddedStatement); body = JsStatement.Block(preBody.Concat(body.Statements)); JsStatement disposer; var systemIDisposable = _compilation.FindType(KnownTypeCode.IDisposable); var disposeMethod = systemIDisposable.GetMethods().Single(m => m.Name == "Dispose"); var conversions = CSharpConversions.Get(_compilation); var disposableConversion = conversions.ImplicitConversion(enumerator.Type, systemIDisposable); if (disposableConversion.IsValid) { // If the enumerator is implicitly convertible to IDisposable, we should dispose it. var compileResult = _expressionCompiler.Compile(new CSharpInvocationResolveResult(new ConversionResolveResult(systemIDisposable, new LocalResolveResult(enumerator), disposableConversion), disposeMethod, new ResolveResult[0]), false); if (compileResult.AdditionalStatements.Count != 0) _errorReporter.InternalError("Call to IDisposable.Dispose must not return additional statements."); disposer = compileResult.Expression; } else if (enumerator.Type.GetDefinition().IsSealed) { // If the enumerator is sealed and not implicitly convertible to IDisposable, we need not dispose it. disposer = null; } else { // We don't know whether the enumerator is convertible to IDisposable, so we need to conditionally dispose it. var test = _expressionCompiler.Compile(new TypeIsResolveResult(new LocalResolveResult(enumerator), systemIDisposable, _compilation.FindType(KnownTypeCode.Boolean)), true); if (test.AdditionalStatements.Count > 0) _errorReporter.InternalError("\"is\" test must not return additional statements."); var innerStatements = _expressionCompiler.Compile(new CSharpInvocationResolveResult(new ConversionResolveResult(systemIDisposable, new LocalResolveResult(enumerator), conversions.ExplicitConversion(enumerator.Type, systemIDisposable)), disposeMethod, new ResolveResult[0]), false); disposer = JsStatement.If(test.Expression, JsStatement.Block(innerStatements.AdditionalStatements.Concat(new JsStatement[] { innerStatements.Expression })), null); } JsStatement stmt = JsStatement.While(moveNextInvocation.Expression, body); if (disposer != null) stmt = JsStatement.Try(stmt, null, disposer); _result.Add(stmt); } }
public virtual void Visit(ForeachStatement s) { VisitChildren(s); if (s.ForeachTypeList != null) foreach (var t in s.ForeachTypeList) t.Accept(this); if (s.UpperAggregate != null) s.UpperAggregate.Accept(this); if (s.Aggregate != null) s.Aggregate.Accept(this); }
public override void VisitForeachStatement(ForeachStatement foreachStatement) { this.loopLevel++; foreachStatement.EmbeddedStatement = GetLoopBlock (foreachStatement.EmbeddedStatement); base.VisitForeachStatement (foreachStatement); this.loopLevel--; }
public virtual void VisitForeachStatement (ForeachStatement foreachStatement) { VisitChildren (foreachStatement); }
public void VisitForeachStatement(ForeachStatement foreachStatement) { StartNode(foreachStatement); WriteKeyword(ForeachStatement.ForeachKeywordRole); Space(policy.SpaceBeforeForeachParentheses); LPar(); Space(policy.SpacesWithinForeachParentheses); foreachStatement.VariableType.AcceptVisitor(this); Space(); foreachStatement.VariableNameToken.AcceptVisitor(this); WriteKeyword(ForeachStatement.InKeywordRole); Space(); foreachStatement.InExpression.AcceptVisitor(this); Space(policy.SpacesWithinForeachParentheses); RPar(); WriteEmbeddedStatement(foreachStatement.EmbeddedStatement); EndNode(foreachStatement); }
public override object Visit (Foreach foreachStatement) { var result = new ForeachStatement (); var location = LocationsBag.GetLocations (foreachStatement); result.AddChild (new CSharpTokenNode (Convert (foreachStatement.loc), "foreach".Length), ForeachStatement.ForEachKeywordRole); if (location != null) result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForeachStatement.Roles.LPar); if (foreachStatement.TypeExpr == null) result.AddChild ((INode)foreachStatement.TypeExpr.Accept (this), ForeachStatement.Roles.ReturnType); if (foreachStatement.Variable != null) result.AddChild ((INode)foreachStatement.Variable.Accept (this), ForeachStatement.Roles.Identifier); if (location != null) result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), ForeachStatement.InKeywordRole); if (foreachStatement.Expr != null) result.AddChild ((INode)foreachStatement.Expr.Accept (this), ForeachStatement.Roles.Initializer); if (location != null) result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ForeachStatement.Roles.RPar); result.AddChild ((INode)foreachStatement.Statement.Accept (this), ForeachStatement.Roles.EmbeddedStatement); return result; }
public override void VisitForeachStatement (ForeachStatement foreachStatement) { CheckVariable (((LocalResolveResult)ctx.Resolve (foreachStatement.VariableNameToken)).Variable, foreachStatement); base.VisitForeachStatement (foreachStatement); }
AssignmentExpression GetTransformedAssignmentExpression (RefactoringContext context, ForeachStatement foreachStatement) { var enumerableToIterate = foreachStatement.InExpression.Clone(); Statement statement = foreachStatement.EmbeddedStatement; Expression leftExpression, rightExpression; if (!ExtractExpression(statement, out leftExpression, out rightExpression)) { return null; } if (leftExpression == null || rightExpression == null) { return null; } var type = context.Resolve(leftExpression).Type; if (!IsLinqSummableType(type)) { return null; } if (rightExpression.DescendantsAndSelf.OfType<AssignmentExpression>().Any()) { // Reject loops such as // int k = 0; // foreach (var x in y) { k += (z = 2); } return null; } if (rightExpression.DescendantsAndSelf.OfType<UnaryOperatorExpression>().Any(IsUnaryModifierExpression)) { // int k = 0; // foreach (var x in y) { k += (z++); } return null; } var zeroLiteral = new PrimitiveExpression(0); Expression baseExpression = enumerableToIterate; for (;;) { ConditionalExpression condition = rightExpression as ConditionalExpression; if (condition == null) { break; } if (SameNode(zeroLiteral, condition.TrueExpression)) { baseExpression = new InvocationExpression(new MemberReferenceExpression(baseExpression.Clone(), "Where"), BuildLambda(foreachStatement.VariableName, CSharpUtil.InvertCondition(condition.Condition))); rightExpression = condition.FalseExpression.Clone(); continue; } if (SameNode(zeroLiteral, condition.FalseExpression)) { baseExpression = new InvocationExpression(new MemberReferenceExpression(baseExpression.Clone(), "Where"), BuildLambda(foreachStatement.VariableName, condition.Condition.Clone())); rightExpression = condition.TrueExpression.Clone(); continue; } break; } var primitiveOne = new PrimitiveExpression(1); bool isPrimitiveOne = SameNode(primitiveOne, rightExpression); var arguments = new List<Expression>(); string method = isPrimitiveOne ? "Count" : "Sum"; if (!isPrimitiveOne && !IsIdentifier(rightExpression, foreachStatement.VariableName)) { var lambda = BuildLambda(foreachStatement.VariableName, rightExpression); arguments.Add(lambda); } var rightSide = new InvocationExpression(new MemberReferenceExpression(baseExpression, method), arguments); return new AssignmentExpression(leftExpression.Clone(), AssignmentOperatorType.Add, rightSide); }
ForeachStatement ForeachStatement(IBlockNode Scope,IStatement Parent) { Step(); var dbs = new ForeachStatement() { Location = t.Location, IsReverse = t.Kind == Foreach_Reverse, Parent = Parent }; LastParsedObject = dbs; if(!Expect(OpenParenthesis)) return dbs; var tl = new List<DVariable>(); bool init=true; while(init || laKind == Comma) { if (init) init = false; else Step(); var forEachVar = new DVariable{ Parent = Scope }; forEachVar.Location = la.Location; if (laKind == Ref || laKind == InOut) { Step(); if(forEachVar.Attributes == null) forEachVar.Attributes = new List<DAttribute>(); forEachVar.Attributes.Add(new Modifier(t.Kind)); } if(IsEOF){ TrackerVariables.ExpectingIdentifier = true; SynErr(t.Kind,"Basic type or iteration variable identifier expected."); return dbs; } LastParsedObject = forEachVar; if (laKind == (Identifier) && (Lexer.CurrentPeekToken.Kind == (Semicolon) || Lexer.CurrentPeekToken.Kind == Comma)) { Step(); forEachVar.NameLocation = t.Location; forEachVar.Name = t.Value; } else { var type = BasicType(); var tnode = Declarator(type, false, Scope); if (tnode == null) break; if(forEachVar.Attributes != null) if(tnode.Attributes == null) tnode.Attributes = new List<DAttribute>(forEachVar.Attributes); else tnode.Attributes.AddRange(forEachVar.Attributes); tnode.Location = forEachVar.Location; forEachVar = (DVariable)tnode; } forEachVar.EndLocation = t.EndLocation; tl.Add(forEachVar); } dbs.ForeachTypeList = tl.ToArray(); if(Expect(Semicolon)) dbs.Aggregate = Expression(Scope); // ForeachRangeStatement if (laKind == DoubleDot) { Step(); dbs.UpperAggregate = Expression(); } if(Expect(CloseParenthesis)) dbs.ScopedStatement = Statement(Scope: Scope, Parent: dbs); dbs.EndLocation = t.EndLocation; return dbs; }