public void Visit(ForIn node) { if (node != null) { if (node.Body == null || node.Body.Count == 0) { DoesRequire = false; } else { node.Body.Accept(this); } } }
public void Visit(ForIn node) { // starts with a 'for', so we don't care }
public void Visit(ForIn node) { DebugEx.Fail("shouldn't get here"); }
//--------------------------------------------------------------------------------------- // ParseForStatement // // ForStatement : // 'for' '(' OptionalExpressionNoIn ';' OptionalExpression ';' OptionalExpression ')' // 'for' '(' 'var' VariableDeclarationListNoIn ';' OptionalExpression ';' OptionalExpression ')' // 'for' '(' LeftHandSideExpression 'in' Expression')' // 'for' '(' 'var' Identifier OptionalInitializerNoIn 'in' Expression')' // // OptionalExpressionNoIn : // <empty> | // ExpressionNoIn // same as Expression but does not process 'in' as an operator // // OptionalInitializerNoIn : // <empty> | // InitializerNoIn // same as initializer but does not process 'in' as an operator //--------------------------------------------------------------------------------------- private AstNode ParseForStatement() { m_blockType.Add(BlockType.Loop); AstNode forNode = null; try { Context forCtx = m_currentToken.Clone(); GetNextToken(); if (JSToken.LeftParenthesis != m_currentToken.Token) ReportError(JSError.NoLeftParenthesis); GetNextToken(); bool isForIn = false, recoveryInForIn = false; AstNode lhs = null, initializer = null, condOrColl = null, increment = null; try { if (JSToken.Var == m_currentToken.Token) { isForIn = true; Var varList = new Var(m_currentToken.Clone(), this); varList.Append(ParseIdentifierInitializer(JSToken.In, (FieldAttributes)0)); // a list of variable initializers is allowed only in a for(;;) while (JSToken.Comma == m_currentToken.Token) { isForIn = false; varList.Append(ParseIdentifierInitializer(JSToken.In, (FieldAttributes)0)); //initializer = new Comma(initializer.context.CombineWith(var.context), initializer, var); } initializer = varList; // if it could still be a for..in, now it's time to get the 'in' if (isForIn) { if (JSToken.In == m_currentToken.Token) { GetNextToken(); condOrColl = ParseExpression(); } else isForIn = false; } } else { if (JSToken.Semicolon != m_currentToken.Token) { bool isLHS; initializer = ParseUnaryExpression(out isLHS, false); if (isLHS && JSToken.In == m_currentToken.Token) { isForIn = true; lhs = initializer; initializer = null; GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); try { condOrColl = ParseExpression(); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = null; throw; } else { if (exc._partiallyComputedNode == null) condOrColl = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this); // what could we put here? else condOrColl = exc._partiallyComputedNode; } if (exc._token == JSToken.RightParenthesis) { GetNextToken(); recoveryInForIn = true; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); } } else initializer = ParseExpression(initializer, false, isLHS, JSToken.In); } } } catch (RecoveryTokenException exc) { // error is too early abort for exc._partiallyComputedNode = null; throw; } // at this point we know whether or not is a for..in if (isForIn) { if (!recoveryInForIn) { if (JSToken.RightParenthesis != m_currentToken.Token) ReportError(JSError.NoRightParenthesis); forCtx.UpdateWith(m_currentToken); GetNextToken(); } AstNode body = null; // if the statements aren't withing curly-braces, throw a possible error if (JSToken.LeftCurly != m_currentToken.Token) { ReportError(JSError.StatementBlockExpected, forCtx, true); } try { // parse a Statement, not a SourceElement body = ParseStatement(false); } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode == null) body = new Block(CurrentPositionContext(), this); else body = exc._partiallyComputedNode; exc._partiallyComputedNode = new ForIn(forCtx, this, (lhs != null ? lhs : initializer), condOrColl, body); throw; } // for (a in b) // lhs = a, initializer = null // for (var a in b) // lhs = null, initializer = var a forNode = new ForIn(forCtx, this, (lhs != null ? lhs : initializer), condOrColl, body); } else { m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); try { if (JSToken.Semicolon != m_currentToken.Token) { ReportError(JSError.NoSemicolon); if (JSToken.Colon == m_currentToken.Token) { m_noSkipTokenSet.Add(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet); try { SkipTokensAndThrow(); } catch (RecoveryTokenException) { if (JSToken.Semicolon == m_currentToken.Token) m_errorToken = null; else throw; } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet); } } } GetNextToken(); if (JSToken.Semicolon != m_currentToken.Token) { condOrColl = ParseExpression(); if (JSToken.Semicolon != m_currentToken.Token) ReportError(JSError.NoSemicolon); } GetNextToken(); if (JSToken.RightParenthesis != m_currentToken.Token) increment = ParseExpression(); if (JSToken.RightParenthesis != m_currentToken.Token) ReportError(JSError.NoRightParenthesis); forCtx.UpdateWith(m_currentToken); GetNextToken(); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = null; throw; } else { // discard any partial info, just genrate empty condition and increment and keep going exc._partiallyComputedNode = null; if (condOrColl == null) condOrColl = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this); } if (exc._token == JSToken.RightParenthesis) { GetNextToken(); } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); } AstNode body = null; // if the statements aren't withing curly-braces, throw a possible error if (JSToken.LeftCurly != m_currentToken.Token) { ReportError(JSError.StatementBlockExpected, forCtx, true); } try { // parse a Statement, not a SourceElement body = ParseStatement(false); } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode == null) body = new Block(CurrentPositionContext(), this); else body = exc._partiallyComputedNode; exc._partiallyComputedNode = new ForNode(forCtx, this, initializer, condOrColl, increment, body); throw; } forNode = new ForNode(forCtx, this, initializer, condOrColl, increment, body); } } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } return forNode; }
private static int RelocateForInVar(Block block, int insertAt, Var varStatement, ForIn forIn) { // there should only be one decl in the for-in var statement. There should not be any initializer. // If not, then ignore it VariableDeclaration varDecl; if (varStatement.Count == 1 && (varDecl = varStatement[0]).Initializer == null) { // if there are more than three names, then we don't want to move them var bindingNames = BindingsVisitor.Bindings(varDecl.Binding); //if (bindingNames.Count < 3) { // replace the varStatement in the for-in with a reference version of the binding forIn.Variable = BindingTransform.FromBinding(varDecl.Binding); // if this is a simple binding identifier, then leave it as-is. Otherwise we // need to flatten it for the move to the front of the scope. if (!(varDecl.Binding is BindingIdentifier)) { // then flatten all the name in the binding and add them to the var first = true; foreach (var declName in bindingNames) { if (first) { varStatement[0] = new VariableDeclaration(declName.Context) { Binding = new BindingIdentifier(declName.Context) { Name = declName.Name, VariableField = declName.VariableField } }; first = false; } else { // otherwise we want to insert a new one at the current position + 1 varStatement.Append(new VariableDeclaration(declName.Context) { Binding = new BindingIdentifier(declName.Context) { Name = declName.Name, VariableField = declName.VariableField } }); } } } // then move the var statement to the front of the scope // if the statement at the insertion point is a var-statement already, // then we just need to append our vardecls to it. Otherwise we'll insert our // var statement at the right point var existingVar = block[insertAt] as Var; if (existingVar != null) { // append the varstatement we want to move to the existing var, which will // transfer all the vardecls to it. existingVar.Append(varStatement); } else { // insert it at the insert point block.Insert(insertAt, varStatement); } } } return(insertAt); }
public override void Visit(ForIn node) { if (node != null) { // if we are stripping debugger statements and the body is // just a debugger statement, replace it with a null if (m_parser.Settings.StripDebugStatements && m_parser.Settings.IsModificationAllowed(TreeModifications.StripDebugStatements) && node.Body != null && node.Body.IsDebuggerStatement) { node.ReplaceChild(node.Body, null); } // recurse base.Visit(node); // if the body is now empty, make it null if (node.Body != null && node.Body.Count == 0) { node.ReplaceChild(node.Body, null); } } }
public void Visit(ForIn node) { ReportError(node); }
public void Visit(ForIn node) { // invalid! ignore IsValid = false; }