Provisional static analysis of snippets

Author: jg-rp

liquid/builtin/tags/render_tag.py

@@ -244,6 +244,7 @@ def children(
         """Return this node's children."""
         if isinstance(self.name, Identifier):
             # We're expecting an inline snippet.
+            # Always visit inline snippets, even if include_partials is False.
             template: Optional[BoundTemplate] = static_context.resolve(
                 self.name, token=self.token, default=None
             )
@@ -307,7 +308,13 @@ def partial_scope(self) -> Optional[Partial]:
                     )
                 )
 
-        return Partial(name=self.name, scope=PartialScope.ISOLATED, in_scope=scope)
+        # Static analysis will use the parent template name if Partial.name is
+        # empty. Which is what we want for inline snippets.
+        return Partial(
+            name=self.name if isinstance(self.name, StringLiteral) else "",
+            scope=PartialScope.ISOLATED,
+            in_scope=scope,
+        )
 
 
 BIND_TAGS = frozenset((TOKEN_WITH, TOKEN_FOR))

liquid/builtin/tags/snippet.py

@@ -61,7 +61,18 @@ def children(
         include_partials: bool = True,  # noqa: ARG002
     ) -> Iterable[Node]:
         """Return this node's children."""
-        yield self.block
+        # Snippets are only visited when rendered so we get accurate variable
+        # scope analysis.
+        static_context.assign(
+            self.name,
+            BoundTemplate(
+                static_context.env,
+                self.block.nodes,
+                static_context.template.name,
+                static_context.template.path,
+            ),
+        )
+        return []
 
     def template_scope(self) -> Iterable[Identifier]:
         """Return variables this node adds to the template local scope."""

liquid/static_analysis.py

@@ -179,9 +179,15 @@ def _visit(node: Node, template_name: str, scope: _StaticScope) -> None:
                 else str(partial.name.evaluate(static_context))
             )
 
-            if partial_name in seen:
+            # XXX: what about rendering the same partial with different arguments?
+            # TODO: to avoid double counting, we'll only want to count globals if we've
+            # seen a partial before, and only if the arguments differ.
+            # TODO: protect against recursive include/render!
+            if partial_name and partial_name in seen:
                 return
 
+            partial_name = partial_name or template_name
+
             partial_scope = (
                 _StaticScope(set(partial.in_scope))
                 if partial.scope == PartialScope.ISOLATED

tests/test_static_analysis.py

@@ -936,3 +936,33 @@ def test_analyze_translate(env: Environment) -> None:
             "translate": [Span("", 4)],
         },
     )
+
+
+def test_analyze_snippet(env: Environment) -> None:
+    source = "\n".join(
+        [
+            "{% snippet foo %}",
+            "  Hi!",
+            "  {{ bar }}",
+            "  {{ baz }}",
+            "{% endsnippet %}",
+            "",
+            "{% render foo, bar: '42' %}",
+        ]
+    )
+
+    _assert(
+        env.from_string(source, name="x"),
+        locals={"foo": [Variable(["foo"], Span("x", 11))]},
+        globals={
+            "baz": [Variable(["baz"], Span("x", 41))],
+        },
+        variables={
+            "baz": [Variable(["baz"], Span("x", 41))],
+            "bar": [Variable(["bar"], Span("x", 29))],
+        },
+        tags={
+            "snippet": [Span("x", 3)],
+            "render": [Span("x", 69)],
+        },
+    )