python-liquid 1.12.1__py3-none-any.whl → 1.13.0__py3-none-any.whl

liquid/__init__.py

@@ -46,7 +46,7 @@ from .static_analysis import ContextualTemplateAnalysis
 
 from . import future
 
-__version__ = "1.12.1"
+__version__ = "1.13.0"
 
 __all__ = (
     "AwareBoundTemplate",

liquid/builtin/filters/array.py

@@ -33,6 +33,7 @@ if TYPE_CHECKING:
     from liquid import Environment
 
 ArrayT = Union[List[Any], Tuple[Any, ...]]
+"""Array-like objects."""
 
 # Send objects with missing keys to the end when sorting a list.
 MAX_CH = chr(0x10FFFF)
@@ -74,9 +75,12 @@ def _lower(obj: Any) -> str:
 @with_environment
 @sequence_filter
 def join(
-    sequence: Iterable[object], separator: object = " ", *, environment: Environment
+    sequence: Iterable[object],
+    separator: object = " ",
+    *,
+    environment: Environment,
 ) -> str:
-    """Concatenate an array of strings."""
+    """Return a string by joining items in _sequence_, separated by _separator_."""
     if not isinstance(separator, str):
         separator = str(separator)
 
@@ -88,7 +92,7 @@ def join(
 
 @liquid_filter
 def first(obj: Any) -> object:
-    """Return the first item of an array."""
+    """Return the first item of collection _obj_."""
     if isinstance(obj, str):
         return None
 
@@ -103,7 +107,7 @@ def first(obj: Any) -> object:
 
 @liquid_filter
 def last(obj: Sequence[Any]) -> object:
-    """Return the last item of an array."""
+    """Return the last item of array-like object _obj_."""
     if isinstance(obj, str):
         return None
 
@@ -115,7 +119,7 @@ def last(obj: Sequence[Any]) -> object:
 
 @sequence_filter
 def concat(sequence: ArrayT, second_array: ArrayT) -> ArrayT:
-    """Return two arrays joined together."""
+    """Return the concatenation of _sequence_ and _second_array_."""
     if not isinstance(second_array, (list, tuple)):
         raise FilterArgumentError(
             f"concat expected an array, found {type(second_array).__name__}"
@@ -129,7 +133,7 @@ def concat(sequence: ArrayT, second_array: ArrayT) -> ArrayT:
 
 @sequence_filter
 def map_(sequence: ArrayT, key: object) -> List[object]:
-    """Create an array of values from a map."""
+    """Return an array/list of items in _sequence_ selected by _key_."""
     try:
         return [_getitem(itm, str(key), default=NIL) for itm in sequence]
     except TypeError as err:
@@ -144,9 +148,9 @@ def reverse(array: ArrayT) -> List[object]:
 
 @array_filter
 def sort(sequence: ArrayT, key: object = None) -> List[object]:
-    """Sorts items in an array in case-sensitive order.
+    """Return a copy of _sequence_ in ascending order.
 
-    When a key string is provided, objects without the key property should
+    When a key string is provided, objects without the key property will
     be at the end of the output list/array.
     """
     if key:
@@ -161,7 +165,11 @@ def sort(sequence: ArrayT, key: object = None) -> List[object]:
 
 @array_filter
 def sort_natural(sequence: ArrayT, key: object = None) -> List[object]:
-    """Sorts items in an array in case-insensitive order."""
+    """Return a copy of _sequence_ in ascending order, with case-insensitive comparison.
+
+    When a key string is provided, objects without the key property will
+    be at the end of the output list/array.
+    """
     if key:
         item_getter = partial(_getitem, key=str(key), default=MAX_CH)
         return sorted(sequence, key=lambda obj: _lower(item_getter(obj)))
@@ -171,7 +179,7 @@ def sort_natural(sequence: ArrayT, key: object = None) -> List[object]:
 
 @sequence_filter
 def where(sequence: ArrayT, attr: object, value: object = None) -> List[object]:
-    """Create an array from a map where _attr_ equals _value_."""
+    """Return a list of items from _sequence_ where _attr_ equals _value_."""
     if value is not None and not is_undefined(value):
         return [itm for itm in sequence if _getitem(itm, attr) == value]
 
@@ -180,7 +188,7 @@ def where(sequence: ArrayT, attr: object, value: object = None) -> List[object]:
 
 @sequence_filter
 def uniq(sequence: ArrayT, key: object = None) -> List[object]:
-    """Removes any duplicate elements in an array."""
+    """Return a copy of _sequence_ with duplicate elements removed."""
     # Note that we're not using a dict or set for deduplication because we need
     # to handle sequences containing unhashable objects, like dictionaries.
 
@@ -209,7 +217,7 @@ def uniq(sequence: ArrayT, key: object = None) -> List[object]:
 
 @sequence_filter
 def compact(sequence: ArrayT, key: object = None) -> List[object]:
-    """Removes any nil values from an array."""
+    """Return a copy of _sequence_ with any nil values removed."""
     if key is not None:
         try:
             return [itm for itm in sequence if itm[key] is not None]
@@ -220,7 +228,7 @@ def compact(sequence: ArrayT, key: object = None) -> List[object]:
 
 @sequence_filter
 def sum_(sequence: ArrayT, key: object = None) -> Union[float, int, Decimal]:
-    """Return the sum of all numeric elements in an array.
+    """Return the sum of all numeric elements in _sequence_.
 
     If _key_ is given, it is assumed that sequence items are mapping-like,
     and the values at _item[key]_ will be summed instead.

liquid/builtin/filters/extra.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 @with_environment
 @string_filter
 def safe(val: str, *, environment: Environment) -> str:
-    """Stringify and mark as safe."""
+    """Return a copy of _val_ that will not be automatically HTML escaped on output."""
     if environment.autoescape:
         return Markup(val)
     return val

liquid/builtin/filters/math.py

@@ -1,4 +1,4 @@
-"""Maths related filter definitions."""
+"""Maths related filter functions."""
 
 import decimal
 import math
@@ -10,51 +10,44 @@ from liquid.exceptions import FilterArgumentError
 from liquid.filter import math_filter
 from liquid.filter import num_arg
 
-DecimalT = decimal.Decimal
-NumberT = Union[float, int]
+# TODO: Version 2 - Either handle all filter function argument type
+# conversions in a decorator or all in the function itself. Having these type
+# conversions split between decorators and calls to helper functions does not
+# help with readability, or make it easy to write good doc strings.
 
 
 @math_filter
-def abs_(num: NumberT) -> NumberT:
-    """Return the absolute value of a number.
-
-    Accepts an int, float or a string representations of an int or float.
-    """
+def abs_(num: Union[float, int]) -> Union[float, int]:
+    """Return the absolute value of number _num_."""
     return abs(num)
 
 
 @math_filter
-def at_most(num: NumberT, other: NumberT) -> NumberT:
-    """Return `val` or `args[0]`, whichever is smaller.
-
-    Accepts an int, float or a string representations of an int or float.
-    """
+def at_most(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return _val_ or _other_, whichever is smaller."""
     other = num_arg(other, default=0)
     return min(num, other)
 
 
 @math_filter
-def at_least(num: NumberT, other: NumberT) -> NumberT:
-    """Return `val` or `args[0]`, whichever is greater.
-
-    Accepts an int, float or a string representations of an int or float.
-    """
+def at_least(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return _val_ or _other_, whichever is greater."""
     other = num_arg(other, default=0)
     return max(num, other)
 
 
 @math_filter
-def ceil(num: NumberT) -> NumberT:
-    """Return the ceiling of x as an Integral.
-
-    Accepts an int, float or a string representations of an int or float.
-    """
+def ceil(num: Union[float, int]) -> Union[float, int]:
+    """Return _num_ rounded up to the next integer."""
     return math.ceil(num)
 
 
 @math_filter
-def divided_by(num: NumberT, other: object) -> NumberT:
-    """Divide `num` by `other`."""
+def divided_by(num: Union[float, int], other: object) -> Union[float, int]:
+    """Return the result of dividing _num_ by _other_.
+
+    If both _num_ and _other_ are integers, integer division is performed.
+    """
     other = num_arg(other, default=0)
 
     try:
@@ -62,41 +55,40 @@ def divided_by(num: NumberT, other: object) -> NumberT:
             return num // other
         return num / other
     except ZeroDivisionError as err:
+        # TODO: [VERSION_2] move inclusion of filter name in error messages to
+        # FilteredExpression, where the filter is applied.
         raise FilterArgumentError(f"divided_by: can't divide by {other}") from err
 
 
 @math_filter
-def floor(num: NumberT) -> NumberT:
-    """Return the floor of x as an Integral.
-
-    Accepts an int, float or a string representations of an int or float.
-    """
+def floor(num: Union[float, int]) -> Union[float, int]:
+    """Return _num_ rounded down to the next integer."""
     return math.floor(num)
 
 
 @math_filter
-def minus(num: NumberT, other: NumberT) -> NumberT:
-    """Subtract one number from another."""
+def minus(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the result of subtracting _other_ from _num_."""
     other = num_arg(other, default=0)
 
     if isinstance(num, int) and isinstance(other, int):
         return num - other
-    return float(DecimalT(str(num)) - DecimalT(str(other)))
+    return float(decimal.Decimal(str(num)) - decimal.Decimal(str(other)))
 
 
 @math_filter
-def plus(num: NumberT, other: NumberT) -> NumberT:
-    """Add one number to another."""
+def plus(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the result of adding _other_ to _num_."""
     other = num_arg(other, default=0)
 
     if isinstance(num, int) and isinstance(other, int):
         return num + other
-    return float(DecimalT(str(num)) + DecimalT(str(other)))
+    return float(decimal.Decimal(str(num)) + decimal.Decimal(str(other)))
 
 
 @math_filter
-def round_(num: NumberT, ndigits: Optional[int] = None) -> NumberT:
-    """Round a number to a given precision in decimal digits."""
+def round_(num: Union[float, int], ndigits: Optional[int] = None) -> Union[float, int]:
+    """Returns the result of rounding _num_ to _ndigits_ decimal digits."""
     if ndigits is None or is_undefined(ndigits):
         return round(num)
 
@@ -118,24 +110,25 @@ def round_(num: NumberT, ndigits: Optional[int] = None) -> NumberT:
 
 
 @math_filter
-def times(num: NumberT, other: NumberT) -> NumberT:
-    """Multiply a value by an integer or float."""
+def times(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the result of multiplying _num_ by _other_."""
     other = num_arg(other, default=0)
 
     if isinstance(num, int) and isinstance(other, int):
         return num * other
-    return float(DecimalT(str(num)) * DecimalT(str(other)))
+    return float(decimal.Decimal(str(num)) * decimal.Decimal(str(other)))
 
 
 @math_filter
-def modulo(num: NumberT, other: NumberT) -> NumberT:
-    """Divide a value by a number and returns the remainder."""
+def modulo(num: Union[float, int], other: Union[float, int]) -> Union[float, int]:
+    """Return the remainder of dividing _num_ by _other_."""
     other = num_arg(other, default=0)
 
     try:
         if isinstance(num, int) and isinstance(other, int):
             return num % other
-        return float(DecimalT(str(num)) % DecimalT(str(other)))
-
+        return float(decimal.Decimal(str(num)) % decimal.Decimal(str(other)))
     except ZeroDivisionError as err:
+        # TODO: [VERSION_2] move inclusion of filter name in error messages to
+        # FilteredExpression, where the filter is applied.
         raise FilterArgumentError(f"modulo: can't divide by {other}") from err

liquid/builtin/filters/misc.py

@@ -1,4 +1,4 @@
-"""Miscellaneous filters."""
+"""Miscellaneous filter functions."""
 from __future__ import annotations
 
 import datetime
@@ -27,7 +27,10 @@ if TYPE_CHECKING:
 
 @liquid_filter
 def size(obj: Any) -> int:
-    """Return the length of an array or string."""
+    """Return the length of _obj_.
+
+    _obj_ could be a dict, list, string or any class implementing _len_.
+    """
     try:
         return len(obj)
     except TypeError:
@@ -36,7 +39,7 @@ def size(obj: Any) -> int:
 
 @liquid_filter
 def default(obj: Any, default_: object = "", *, allow_false: bool = False) -> Any:
-    """Return a default value if the input is nil, false, or empty."""
+    """Return _obj_, or _default_ if _obj_ is nil, false, or empty."""
     _obj = obj
 
     # Return the default value immediately if the object defines a
@@ -69,7 +72,7 @@ def date(  # noqa: PLR0912 PLR0911
     *,
     environment: Environment,
 ) -> str:
-    """Format a datetime according the the given format string."""
+    """Return a string representation of _dat_ using format string _fmt_."""
     if is_undefined(dat):
         return ""
 

liquid/builtin/filters/string.py

@@ -1,4 +1,5 @@
 """Filter functions that operate on strings."""
+
 from __future__ import annotations
 
 import base64
@@ -38,7 +39,10 @@ if TYPE_CHECKING:
 
 @string_filter
 def append(val: str, arg: object) -> str:
-    """Concatenate two strings."""
+    """Return a copy of _val_ concatenated with _arg_.
+
+    If _arg_ is not a string, it will be converted to one before concatenation.
+    """
     if not isinstance(arg, str):
         arg = str(arg)
     return val + arg
@@ -46,20 +50,20 @@ def append(val: str, arg: object) -> str:
 
 @string_filter
 def capitalize(val: str) -> str:
-    """Make sure the first character of _val_ is upper case and the rest lowercase."""
+    """Return _val_ with the first character in uppercase and the rest lowercase."""
     return val.capitalize()
 
 
 @string_filter
 def downcase(val: str) -> str:
-    """Make all characters in a string lower case."""
+    """Return a copy of _val_ with all characters converted to lowercase."""
     return val.lower()
 
 
 @with_environment
 @string_filter
 def escape(val: str, *, environment: Environment) -> str:
-    """Convert the characters &, < and > in string s to HTML-safe sequences."""
+    """Return _val_ with the characters &, < and > converted to HTML-safe sequences."""
     if environment.autoescape:
         return markupsafe_escape(str(val))
     return html.escape(val)
@@ -68,7 +72,11 @@ def escape(val: str, *, environment: Environment) -> str:
 @with_environment
 @string_filter
 def escape_once(val: str, *, environment: Environment) -> str:
-    """Convert the characters &, < and > in string s to HTML-safe sequences."""
+    """Return _val_ with the characters &, < and > converted to HTML-safe sequences.
+
+    It is safe to use `escape_one` on string values that already contain HTML escape
+    sequences.
+    """
     if environment.autoescape:
         return Markup(val).unescape()
     return html.escape(html.unescape(val))
@@ -76,7 +84,7 @@ def escape_once(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def lstrip(val: str) -> str:
-    """Remove leading whitespace."""
+    """Return a copy of _val_ with leading whitespace removed."""
     return val.lstrip()
 
 
@@ -86,7 +94,7 @@ RE_LINETERM = re.compile(r"\r?\n")
 @with_environment
 @string_filter
 def newline_to_br(val: str, *, environment: Environment) -> str:
-    """Convert LF or CRLF to `<br />`, plus a newline."""
+    """Return a copy of _val_ with LF or CRLF converted to `<br />`, plus a newline."""
     # The reference implementation was changed to replace "\r\n" as well as "\n",
     # but they don't seem to care about "\r" (Mac OS).
     if environment.autoescape:
@@ -97,25 +105,25 @@ def newline_to_br(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def prepend(val: str, arg: str) -> str:
-    """Concatenate string value to argument string."""
+    """Return a copy of _arg_ concatenated with _val_."""
     return soft_str(arg) + val
 
 
 @string_filter
 def remove(val: str, arg: str) -> str:
-    """Remove all occurrences of argument string from value."""
+    """Return a copy of _val_ with all occurrences of _arg_ removed."""
     return val.replace(soft_str(arg), "")
 
 
 @string_filter
 def remove_first(val: str, arg: str) -> str:
-    """Remove the first occurrence of the argument string from value."""
+    """Return a copy of _val_ with the first occurrence of _arg_ removed."""
     return val.replace(soft_str(arg), "", 1)
 
 
 @string_filter
 def remove_last(val: str, arg: str) -> str:
-    """Remove the last occurrence of the argument string from value."""
+    """Return a copy of _val_ with last occurrence of _arg_ removed."""
     try:
         before, _, after = val.rpartition(soft_str(arg))
     except ValueError:
@@ -128,19 +136,19 @@ def remove_last(val: str, arg: str) -> str:
 
 @string_filter
 def replace(val: str, seq: str, sub: str = "") -> str:
-    """Replace occurrences of _seq_ in _val_ with _sub_."""
+    """Return a copy of _val_ with each occurrence of _seq_ replaced with _sub_."""
     return val.replace(soft_str(seq), soft_str(sub))
 
 
 @string_filter
 def replace_first(val: str, seq: str, sub: str = "") -> str:
-    """Replace the first occurrence of _seq_ in _val_ with _sub_."""
+    """Return a copy of _val_ with the first occurrence of _seq_ replaced with _sub_."""
     return val.replace(soft_str(seq), soft_str(sub), 1)
 
 
 @string_filter
 def replace_last(val: str, seq: str, sub: str) -> str:
-    """Replace the last occurrence of _seq_ in _val_ with _sub_."""
+    """Return a copy of _val_ with the last occurrence of _seq_ replaced with _sub_."""
     try:
         before, _, after = val.rpartition(soft_str(seq))
     except ValueError:
@@ -153,7 +161,7 @@ def replace_last(val: str, seq: str, sub: str) -> str:
 
 @string_filter
 def upcase(val: str) -> str:
-    """Make all characters in a string upper case."""
+    """Return a copy of _val_ with all characters converted to uppercase."""
     return val.upper()
 
 
@@ -211,7 +219,7 @@ def slice_(val: Any, start: Any, length: Any = 1) -> Union[str, List[object]]:
 
 @string_filter
 def split(val: str, seq: str) -> List[str]:
-    """Split a string into a list of string, using the argument as a delimiter."""
+    """Return a list of strings from splitting _value_ on _seq_."""
     if not seq:
         return list(val)
 
@@ -220,20 +228,20 @@ def split(val: str, seq: str) -> List[str]:
 
 @string_filter
 def strip(val: str) -> str:
-    """Remove leading and trailing whitespace."""
+    """Return a copy of _val_ with leading and trailing whitespace removed."""
     return val.strip()
 
 
 @string_filter
 def rstrip(val: str) -> str:
-    """Remove trailing whitespace."""
+    """Return a copy of _val_ with trailing whitespace removed."""
     return val.rstrip()
 
 
 @with_environment
 @string_filter
 def strip_html(val: str, *, environment: Environment) -> str:
-    """Return the given HTML with all HTML tags removed."""
+    """Return a copy of _val_ with all HTML tags removed."""
     stripped = strip_tags(val)
     if environment.autoescape and isinstance(val, Markup):
         return Markup(stripped)
@@ -243,7 +251,7 @@ def strip_html(val: str, *, environment: Environment) -> str:
 @with_environment
 @string_filter
 def strip_newlines(val: str, *, environment: Environment) -> str:
-    """Return the given string with all newline characters removed."""
+    """Return ta copy of _val_ with all newline characters removed."""
     if environment.autoescape:
         val = markupsafe_escape(val)
         return Markup(RE_LINETERM.sub("", val))
@@ -252,7 +260,7 @@ def strip_newlines(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def truncate(val: str, num: Any = 50, end: str = "...") -> str:
-    """Truncate a string if it is longer than the specified number of characters."""
+    """Return a copy of _val_ truncated to _num_ characters."""
     if is_undefined(num):
         raise FilterArgumentError("truncate expected an integer, found Undefined")
 
@@ -273,7 +281,7 @@ MAX_TRUNC_WORDS = (1 << 31) - 1
 
 @string_filter
 def truncatewords(val: str, num: Any = 15, end: str = "...") -> str:
-    """Shorten a string down to the given number of words."""
+    """Return a copy of _val_ truncated to at most _num_ words."""
     if is_undefined(num):
         raise FilterArgumentError("truncate expected an integer, found Undefined")
 
@@ -306,7 +314,7 @@ def truncatewords(val: str, num: Any = 15, end: str = "...") -> str:
 @with_environment
 @string_filter
 def url_encode(val: str, *, environment: Environment) -> str:
-    """Percent encode a string so it is useable in a URL."""
+    """Return a percent-encoded copy of _val_ so it is useable in a URL."""
     if environment.autoescape:
         return Markup(urllib.parse.quote_plus(val))
     return urllib.parse.quote_plus(val)
@@ -314,20 +322,20 @@ def url_encode(val: str, *, environment: Environment) -> str:
 
 @string_filter
 def url_decode(val: str) -> str:
-    """Decode a string that has been URL encoded."""
+    """Return a copy of _val_ after decoding percent-encoded sequences."""
     # Assuming URL decoded strings are all unsafe.
     return urllib.parse.unquote_plus(val)
 
 
 @string_filter
 def base64_encode(val: str) -> str:
-    """Encode a string to base64."""
+    """Return _val_ encoded in base64."""
     return base64.b64encode(val.encode()).decode()
 
 
 @string_filter
 def base64_decode(val: str) -> str:
-    """Decode a string from base64.
+    """Return _val_ decoded as base64.
 
     The decoded value is assumed to be UTF-8 and will be decoded as UTF-8.
     """
@@ -339,13 +347,13 @@ def base64_decode(val: str) -> str:
 
 @string_filter
 def base64_url_safe_encode(val: str) -> str:
-    """Encode a string to URL safe base64."""
+    """Return _val_ encoded in URL-safe base64."""
     return base64.urlsafe_b64encode(val.encode()).decode()
 
 
 @string_filter
 def base64_url_safe_decode(val: str) -> str:
-    """Decode a URL safe string from base64.
+    """Return _val_ decoded as URL-safe base64.
 
     The decoded value is assumed to be UTF-8 and will be decoded as UTF-8.
     """

liquid/builtin/loaders/base_loader.py

@@ -1,4 +1,5 @@
 """Base template loader."""
+
 from __future__ import annotations
 
 from abc import ABC
@@ -48,7 +49,7 @@ class BaseLoader(ABC):  # noqa: B024
 
     Attributes:
         caching_loader (bool): Indicates if this loader implements its own cache.
-            Setting this sto `True` will cause the `Environment` to disable its cache
+            Setting this to `True` will cause the `Environment` to disable its cache
             when initialized with a caching loader.
     """
 

liquid/builtin/statement.py

@@ -60,4 +60,6 @@ class Statement(Tag):
     def parse(self, stream: TokenStream) -> StatementNode:
         tok = stream.current
         expect(stream, TOKEN_STATEMENT)
-        return self.node_class(tok, self.env.parse_filtered_expression_value(tok.value))
+        return self.node_class(
+            tok, self.env.parse_filtered_expression_value(tok.value, tok.linenum)
+        )

liquid/builtin/tags/assign_tag.py

@@ -65,8 +65,8 @@ class AssignTag(Tag):
     block = False
     node_class = AssignNode
 
-    def _parse_expression(self, value: str) -> Expression:
-        return self.env.parse_filtered_expression_value(value)
+    def _parse_expression(self, value: str, linenum: int) -> Expression:
+        return self.env.parse_filtered_expression_value(value, linenum)
 
     def parse(self, stream: TokenStream) -> AssignNode:
         expect(stream, TOKEN_TAG, value=TAG_ASSIGN)
@@ -83,5 +83,9 @@ class AssignTag(Tag):
             )
 
         return self.node_class(
-            tok, AssignmentExpression(name, self._parse_expression(right))
+            tok,
+            AssignmentExpression(
+                name,
+                self._parse_expression(right, stream.current.linenum),
+            ),
         )

liquid/builtin/tags/case_tag.py

@@ -1,4 +1,5 @@
 """Tag and node definition for the built-in "case" tag."""
+
 from __future__ import annotations
 
 import sys
@@ -193,14 +194,16 @@ class CaseTag(Tag):
 
     def _parse_case_expression(self, expr: str, linenum: int) -> Expression:
         stream = ExpressionTokenStream(
-            tokenize_common_expression(expr, linenum=linenum)
+            tokenize_common_expression(expr, linenum=linenum),
+            shorthand_indexes=self.env.shorthand_indexes,
         )
         return parse_common_expression(stream)
 
     def _parse_when_expression(self, expr: str, linenum: int) -> List[Expression]:
         expressions = []
         stream = ExpressionTokenStream(
-            tokenize_common_expression(expr, linenum=linenum)
+            tokenize_common_expression(expr, linenum=linenum),
+            shorthand_indexes=self.env.shorthand_indexes,
         )
 
         while True:

liquid/builtin/tags/decrement_tag.py

@@ -63,7 +63,9 @@ class DecrementTag(Tag):
             tok=tok,
             identifier=str(
                 parse_unchained_identifier(
-                    ExprTokenStream(tokenize(stream.current.value))
+                    ExprTokenStream(
+                        tokenize(stream.current.value, stream.current.linenum)
+                    )
                 )
             ),
         )