Prefer next(stream) over stream.next()

Author: jg-rp

liquid/builtin/expressions/arguments.py

@@ -52,13 +52,13 @@ def parse(env: Environment, tokens: TokenStream) -> list[KeywordArgument]:
 
         # Leading commas are OK
         if tokens.current.kind == TOKEN_COMMA:
-            tokens.next()
+            next(tokens)
 
         while True:
-            token = tokens.next()
+            token = next(tokens)
 
             if token.kind == TOKEN_COMMA:
-                token = tokens.next()
+                token = next(tokens)
 
             if token.kind == TOKEN_EOF:
                 break
@@ -109,7 +109,7 @@ def parse(env: Environment, tokens: TokenStream) -> list[PositionalArgument]:
 
         while True:
             if tokens.current.kind == TOKEN_COMMA:
-                tokens.next()
+                next(tokens)
 
             if tokens.current.kind == TOKEN_EOF:
                 break
@@ -141,19 +141,19 @@ def parse(env: Environment, tokens: TokenStream) -> dict[str, Parameter]:
         )
 
         while True:
-            token = tokens.next()
+            token = next(tokens)
 
             if token.kind == TOKEN_COMMA:
                 # Leading and/or trailing commas are OK.
-                token = tokens.next()
+                token = next(tokens)
 
             if token.kind == TOKEN_EOF:
                 break
 
             if token.kind == TOKEN_WORD:
                 if tokens.current.kind in argument_separators:
                     # A parameter with a default value
-                    tokens.next()  # Move past ":" or "="
+                    next(tokens)  # Move past ":" or "="
                     value = parse_primitive(env, tokens)
                     params[token.value] = Parameter(token, token.value, value)
                 else:
@@ -179,7 +179,7 @@ def parse_arguments(
 
     # Leading commas are OK
     if tokens.current.kind == TOKEN_COMMA:
-        tokens.next()
+        next(tokens)
 
     while True:
         token = tokens.current
@@ -189,8 +189,8 @@ def parse_arguments(
 
         if token.kind == TOKEN_WORD:
             if tokens.peek.kind in argument_separators:
-                name_token = tokens.next()
-                tokens.next()  # = or :
+                name_token = next(tokens)
+                next(tokens)  # = or :
                 value = parse_primitive(env, tokens)
                 kwargs.append(KeywordArgument(name_token, token.value, value))
             else:

liquid/builtin/expressions/filtered.py

@@ -220,7 +220,7 @@ def parse(
         tail_filters: list[Filter] | None = None
 
         if tokens.current.kind == TOKEN_ELSE:
-            tokens.next()  # else
+            next(tokens)  # else
             alternative = parse_primitive(env, tokens)
 
             if tokens.current.kind == TOKEN_PIPE:
@@ -331,7 +331,7 @@ def parse(
         )
 
         while tokens.current.kind in delim:
-            tokens.next()
+            next(tokens)
             token = tokens.eat(TOKEN_WORD)
             args: list[Union[KeywordArgument, PositionalArgument]] = []
 
@@ -345,8 +345,8 @@ def parse(
                 tok = tokens.current
                 if tok.kind == TOKEN_WORD:
                     if tokens.peek.kind in argument_separators:
-                        tokens.next()  # word
-                        tokens.next()  # : or =
+                        next(tokens)  # word
+                        next(tokens)  # : or =
                         args.append(
                             KeywordArgument(
                                 tok, tok.value, parse_primitive(env, tokens)
@@ -378,7 +378,7 @@ def parse(
                             f"found {tokens.peek.kind}",
                             token=tokens.peek,
                         )
-                    tokens.next()
+                    next(tokens)
                 else:
                     break
 

liquid/builtin/expressions/logical.py

@@ -437,30 +437,30 @@ def parse_boolean_primitive(  # noqa: PLR0912
 
     if kind == TOKEN_TRUE:
         left = TrueLiteral(token)
-        tokens.next()
+        next(tokens)
     elif kind == TOKEN_FALSE:
         left = FalseLiteral(token)
-        tokens.next()
+        next(tokens)
     elif kind in (TOKEN_NIL, TOKEN_NULL):
         left = Nil(token)
-        tokens.next()
+        next(tokens)
     elif kind == TOKEN_INTEGER:
         left = IntegerLiteral(token, to_int(token.value))
-        tokens.next()
+        next(tokens)
     elif kind == TOKEN_FLOAT:
         left = FloatLiteral(token, float(token.value))
-        tokens.next()
+        next(tokens)
     elif kind == TOKEN_STRING:
         left = StringLiteral(token, token.value)
-        tokens.next()
+        next(tokens)
     elif kind == TOKEN_RANGE_LITERAL:
         left = RangeLiteral.parse(env, tokens)
     elif kind == TOKEN_BLANK:
         left = Blank(token)
-        tokens.next()
+        next(tokens)
     elif kind == TOKEN_EMPTY:
         left = Empty(token)
-        tokens.next()
+        next(tokens)
     elif kind in (TOKEN_WORD, TOKEN_IDENTSTRING, TOKEN_LBRACKET):
         left = Path.parse(env, tokens)
     elif kind == TOKEN_LPAREN:
@@ -493,7 +493,7 @@ def parse_infix_expression(  # noqa: PLR0911
     env: Environment, stream: TokenStream, left: Expression
 ) -> Expression:  # noqa: PLR0911
     """Return a logical, comparison, or membership expression parsed from _stream_."""
-    token = stream.next()
+    token = next(stream)
     assert token is not None
     precedence = PRECEDENCES.get(token.kind, PRECEDENCE_LOWEST)
 
@@ -553,7 +553,7 @@ def parse_grouped_expression(env: Environment, tokens: TokenStream) -> Expressio
 
     tokens.eat(TOKEN_LPAREN)
     expr = parse_boolean_primitive(env, tokens)
-    token = tokens.next()
+    token = next(tokens)
 
     while token.kind != TOKEN_RPAREN:
         if token is None:

liquid/builtin/expressions/loop.py

@@ -229,10 +229,10 @@ def parse(env: Environment, tokens: TokenStream) -> LoopExpression:
 
         # Leading commas are OK
         if tokens.current.kind == TOKEN_COMMA:
-            tokens.next()
+            next(tokens)
 
         while True:
-            arg_token = tokens.next()
+            arg_token = next(tokens)
             kind = arg_token.kind
 
             if kind == TOKEN_LIMIT:
@@ -244,7 +244,7 @@ def parse(env: Environment, tokens: TokenStream) -> LoopExpression:
                 tokens.eat_one_of(*argument_separators)
                 offset_token = tokens.current
                 if offset_token.kind == TOKEN_CONTINUE:
-                    tokens.next()
+                    next(tokens)
                     offset = StringLiteral(token=offset_token, value="continue")
                 else:
                     offset = parse_primitive(env, tokens)

liquid/builtin/expressions/path.py

@@ -107,7 +107,7 @@ def parse(env: Environment, tokens: TokenStream) -> Path:  # noqa: PLR0912
                 segments.append(value)
                 if tokens.peek.kind == TOKEN_WORD:
                     # Two consecutive words indicate end of path.
-                    tokens.next()
+                    next(tokens)
                     break
             elif kind == TOKEN_IDENTSTRING:
                 segments.append(value)
@@ -124,7 +124,7 @@ def parse(env: Environment, tokens: TokenStream) -> Path:  # noqa: PLR0912
                         token=tokens.peek,
                     )
             elif kind == TOKEN_LBRACKET:
-                tokens.next()
+                next(tokens)
                 segments.append(Path.parse(env, tokens))
                 tokens.expect(TOKEN_RBRACKET)
                 if env.mode == Mode.STRICT and tokens.peek.kind == TOKEN_WORD:
@@ -149,7 +149,7 @@ def parse(env: Environment, tokens: TokenStream) -> Path:  # noqa: PLR0912
             else:
                 break
 
-            tokens.next()
+            next(tokens)
 
         if not segments:
             raise LiquidSyntaxError(

liquid/builtin/expressions/primitive.py

@@ -281,23 +281,23 @@ def parse_primitive(env: Environment, tokens: TokenStream) -> Expression:  # noq
     kind = token.kind
 
     if kind == TOKEN_TRUE:
-        return TrueLiteral(tokens.next())
+        return TrueLiteral(next(tokens))
     if kind == TOKEN_FALSE:
-        return FalseLiteral(tokens.next())
+        return FalseLiteral(next(tokens))
     if kind in (TOKEN_NIL, TOKEN_NULL):
-        return Nil(tokens.next())
+        return Nil(next(tokens))
     if kind == TOKEN_INTEGER:
-        return IntegerLiteral(tokens.next(), to_int(token.value))
+        return IntegerLiteral(next(tokens), to_int(token.value))
     if kind == TOKEN_FLOAT:
-        return FloatLiteral(tokens.next(), float(token.value))
+        return FloatLiteral(next(tokens), float(token.value))
     if kind == TOKEN_STRING:
-        return StringLiteral(tokens.next(), token.value)
+        return StringLiteral(next(tokens), token.value)
     if kind == TOKEN_RANGE_LITERAL:
         return RangeLiteral.parse(env, tokens)
     if kind == TOKEN_EMPTY:
-        return Empty(tokens.next())
+        return Empty(next(tokens))
     if kind == TOKEN_BLANK:
-        return Blank(tokens.next())
+        return Blank(next(tokens))
     if kind in (TOKEN_WORD, TOKEN_IDENTSTRING, TOKEN_LBRACKET):
         return Path.parse(env, tokens)
 

liquid/builtin/illegal.py

@@ -20,7 +20,7 @@ def parse(self, stream: TokenStream) -> IllegalNode:
         token = stream.expect(TOKEN_TAG)
 
         if stream.peek.kind == TOKEN_EXPRESSION:
-            stream.next()
+            next(stream)
 
         msg = (
             "missing tag name" if not token.value else f"unexpected tag '{token.value}'"

liquid/builtin/tags/case_tag.py

@@ -148,17 +148,17 @@ def parse(self, stream: TokenStream) -> Node:
             stream.current.kind != TOKEN_TAG
             and stream.current.value not in ENDWHENBLOCK
         ):
-            stream.next()
+            next(stream)
 
         parse_block = get_parser(self.env).parse_block
         blocks: list[Union[MultiExpressionBlockNode, BlockNode]] = []
 
         while not stream.current.is_tag(TAG_ENDCASE):
             if stream.current.is_tag(TAG_ELSE):
-                stream.next()
+                next(stream)
                 blocks.append(parse_block(stream, ENDWHENBLOCK))
             elif stream.current.is_tag(TAG_WHEN):
-                alternative_token = stream.next()
+                alternative_token = next(stream)
                 expressions = self._parse_when_expression(
                     stream.into_inner(tag=alternative_token)
                 )
@@ -187,7 +187,7 @@ def parse(self, stream: TokenStream) -> Node:
     def _parse_when_expression(self, stream: TokenStream) -> list[Expression]:
         expressions: list[Expression] = [parse_primitive(self.env, stream)]
         while stream.current.kind in (TOKEN_COMMA, TOKEN_OR):
-            stream.next()
+            next(stream)
             try:
                 expressions.append(parse_primitive(self.env, stream))
             except LiquidSyntaxError:

liquid/builtin/tags/comment_tag.py

@@ -67,6 +67,6 @@ def parse(self, stream: TokenStream) -> CommentNode:
             ):
                 break
             text.append(stream.current.value)
-            stream.next()
+            next(stream)
 
         return self.node_class(token, text="".join(text))

liquid/builtin/tags/doc_tag.py

@@ -63,6 +63,6 @@ def parse(self, stream: TokenStream) -> DocNode:
             if stream.current.kind == TOKEN_EOF:
                 raise LiquidSyntaxError("doc tag wad never closed", token=token)
             text.append(stream.current.value)
-            stream.next()
+            next(stream)
 
         return self.node_class(token, text="".join(text))

liquid/builtin/tags/for_tag.py

@@ -209,7 +209,7 @@ def parse(self, stream: TokenStream) -> Node:
         default: Optional[BlockNode] = None
 
         if stream.current.is_tag(TAG_ELSE):
-            stream.next()
+            next(stream)
             default = parse_block(stream, ENDFORELSEBLOCK)
 
         stream.expect(TOKEN_TAG, value=TAG_ENDFOR)

liquid/builtin/tags/if_tag.py

@@ -159,7 +159,7 @@ def parse(self, stream: TokenStream) -> Node:
             # continue to parse more "elsif" expression, if any.
             try:
                 expr = BooleanExpression.parse(
-                    self.env, stream.into_inner(tag=stream.next())
+                    self.env, stream.into_inner(tag=next(stream))
                 )
             except LiquidSyntaxError as err:
                 self.env.error(err)
@@ -176,11 +176,11 @@ def parse(self, stream: TokenStream) -> Node:
         default: Optional[BlockNode] = None
 
         if stream.current.is_tag(TAG_ELSE):
-            stream.next()
+            next(stream)
             if stream.current.kind == TOKEN_EXPRESSION:
                 if self.mode == Mode.LAX:
                     # Superfluous expressions inside an `else` tag are ignored.
-                    stream.next()
+                    next(stream)
                 else:
                     raise LiquidSyntaxError(
                         "found an 'else' tag expression, did you mean 'elsif'?",
@@ -196,7 +196,7 @@ def parse(self, stream: TokenStream) -> Node:
                     and stream.current.value == TAG_ENDIF
                 ):
                     break
-                stream.next()
+                next(stream)
 
         stream.expect(TOKEN_TAG, value=TAG_ENDIF)
 

liquid/builtin/tags/include_tag.py

@@ -235,14 +235,14 @@ def parse(self, stream: TokenStream) -> Node:
 
         # Optionally bind a variable to the included template context
         if tokens.current.kind in BIND_TOKENS:
-            tokens.next()  # Eat 'with' or 'for'
+            next(tokens)  # Eat 'with' or 'for'
             tokens.expect(TOKEN_WORD)
             var = Path.parse(self.env, tokens)
 
             # The bound variable will take the name of the template by default,
             # or an alias if an identifier follows the "as" keyword.
             if tokens.current.kind == TOKEN_AS:
-                tokens.next()  # Eat 'as'
+                next(tokens)  # Eat 'as'
                 tokens.expect(TOKEN_WORD)
                 alias = parse_identifier(self.env, tokens)
 

liquid/builtin/tags/inline_comment_tag.py

@@ -38,7 +38,7 @@ def parse(self, stream: TokenStream) -> InlineCommentNode:
         token = stream.expect(TOKEN_TAG)
         # Empty comment tag?
         if stream.peek.kind == TOKEN_EXPRESSION:
-            stream.next()
+            next(stream)
             if RE_INVALID_INLINE_COMMENT.search(stream.current.value):
                 raise LiquidSyntaxError(
                     "every line of an inline comment must start with a '#' character",

liquid/builtin/tags/render_tag.py

@@ -298,14 +298,14 @@ def parse(self, stream: TokenStream) -> Node:
         # Optionally bind a variable to the included template context
         if tokens.current.kind in BIND_TAGS:
             loop = tokens.current.kind == TOKEN_FOR
-            tokens.next()  # Eat 'with' or 'for'
+            next(tokens)  # Eat 'with' or 'for'
             tokens.expect(TOKEN_WORD)
             var = Path.parse(self.env, tokens)
 
             # The bound variable will take the name of the template by default,
             # or an alias if an identifier follows the "as" keyword.
             if tokens.current.kind == TOKEN_AS:
-                tokens.next()  # Eat 'as'
+                next(tokens)  # Eat 'as'
                 tokens.expect(TOKEN_WORD)
                 alias = parse_identifier(self.env, tokens)