Exemplo n.º 1
0
        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);
		}
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 4
0
        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));
        }
Exemplo n.º 5
0
 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}."));
     }
 }
Exemplo n.º 6
0
        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();
        }
Exemplo n.º 7
0
 public virtual void VisitForeachStatement(ForeachStatement foreachStatement)
 {
     if (this.ThrowException)
     {
         throw (System.Exception) this.CreateException(foreachStatement);
     }
 }
Exemplo n.º 8
0
 public virtual void VisitForeachStatement(ForeachStatement foreachStatement)
 {
     if (ThrowException)
     {
         throw (Exception)CreateException(foreachStatement);
     }
 }
Exemplo n.º 9
0
        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);
 }
Exemplo n.º 12
0
 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()));
            }
Exemplo n.º 14
0
        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);
        }
Exemplo n.º 15
0
        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);
        }
Exemplo n.º 16
0
 public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
 {
     if (nameComparer.Equals(from, foreachStatement.VariableName))
     {
         foreachStatement.VariableName = to;
     }
     return(base.VisitForeachStatement(foreachStatement, data));
 }
Exemplo n.º 17
0
			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"));
			}
Exemplo n.º 18
0
        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));
        }
Exemplo n.º 19
0
        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)
 {
     if (node.Location == ((AstNode)obj).Location || found)
     {
         found = true;
         return(this.table);
     }
     return(base.Visit(node, obj));
 }
Exemplo n.º 21
0
 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);
 }
Exemplo n.º 22
0
        public override void VisitForeachStatement(ForeachStatement foreachStatement)
        {
            if (!(foreachStatement.EmbeddedStatement is BlockStatement))
            {
                Found = true;
            }

            base.VisitForeachStatement(foreachStatement);
        }
Exemplo n.º 23
0
        public override void VisitForeachStatement(ForeachStatement foreachStatement)
        {
            this.loopLevel++;

            foreachStatement.EmbeddedStatement = GetLoopBlock(foreachStatement.EmbeddedStatement);
            base.VisitForeachStatement(foreachStatement);

            this.loopLevel--;
        }
Exemplo n.º 24
0
        //-----------------------------------------------------------------------------------------------------------------------------------------------------

        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);
        }
Exemplo n.º 25
0
            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);
            }
Exemplo n.º 26
0
            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"));
                }
            }
Exemplo n.º 27
0
        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);
            }
        }
Exemplo n.º 28
0
            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));
            }
Exemplo n.º 29
0
        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));
        }
Exemplo n.º 30
0
        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);
        }
Exemplo n.º 31
0
        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);
        }
Exemplo n.º 32
0
        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);
        }
Exemplo n.º 33
0
 /// <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;
			}
		}
Exemplo n.º 35
0
        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);
        }
Exemplo n.º 36
0
        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));
        }
Exemplo n.º 37
0
            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"));
            }
Exemplo n.º 38
0
 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;
 }
Exemplo n.º 39
0
		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;
        }
Exemplo n.º 41
0
		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);
		}
Exemplo n.º 42
0
        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;
        }
Exemplo n.º 43
0
			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);
     }
 }
Exemplo n.º 45
0
 public abstract StringBuilder VisitForeachStatement(ForeachStatement foreachStatement, int data);
			public override void VisitForeachStatement (ForeachStatement foreachStatement)
			{
				variableNames.Add (foreachStatement.VariableName);
				base.VisitForeachStatement (foreachStatement);
			}
Exemplo n.º 47
0
        public virtual void Visit(ForeachStatement s)
        {
            VisitChildren (s);

            if (s.ForeachTypeList != null)
                foreach (var t in s.ForeachTypeList)
                    if(t != null)
                        t.Accept(this);
        }
Exemplo n.º 48
0
 public ForeachBlock(IEmitter emitter, ForeachStatement foreachStatement)
     : base(emitter, foreachStatement) {
     this.Emitter = emitter;
     this.ForeachStatement = foreachStatement;
 }
Exemplo n.º 49
0
 public override void VisitForeachStatement(ForeachStatement foreachStatement)
 {
 }
Exemplo n.º 50
0
			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);
			}
		}
Exemplo n.º 52
0
 public override void VisitForeachStatement(ForeachStatement foreachStatement)
 {
     if (findReturn)
     {
         base.VisitForeachStatement(foreachStatement);
     }
 }
		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);
		}
Exemplo n.º 54
0
        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);
		}
Exemplo n.º 56
0
		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);
		}
Exemplo n.º 57
0
			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);
			}
Exemplo n.º 59
0
		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);
		}
Exemplo n.º 60
0
        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;
        }