Analyze included and rendered templates WIP

src/index.ts

@@ -6,7 +6,7 @@ export { Drop } from './drop'
 export { Emitter } from './emitters'
 export { defaultOperators, Operators, evalToken, evalQuotedToken, Expression, isFalsy, isTruthy } from './render'
 export { Context, Scope } from './context'
-export { Value, Hash, Template, FilterImplOptions, Tag, Filter, Output, Variable, VariableLocation, VariableSegments, Variables, analyze } from './template'
+export { Value, Hash, Template, FilterImplOptions, Tag, Filter, Output, Variable, VariableLocation, VariableSegments, Variables, analyzeSync } from './template'
 export { Token, TopLevelToken, TagToken, ValueToken } from './tokens'
 export { TokenKind, Tokenizer, ParseStream } from './parser'
 export { filters } from './filters'

src/tags/include.ts

@@ -1,8 +1,8 @@
 import { Template, ValueToken, TopLevelToken, Liquid, Tag, assert, evalToken, Hash, Emitter, TagToken, Context } from '..'
 import { BlockMode, Scope } from '../context'
 import { Parser } from '../parser'
-import { Arguments } from '../template'
-import { isValueToken } from '../util'
+import { Arguments, PartialScope } from '../template'
+import { isString, isValueToken, toValueSync } from '../util'
 import { parseFilePath, renderFilePath } from './render'
 
 export default class extends Tag {
@@ -23,7 +23,7 @@ export default class extends Tag {
       } else tokenizer.p = begin
     } else tokenizer.p = begin
 
-    this.hash = new Hash(tokenizer.remaining(), liquid.options.jekyllInclude || liquid.options.keyValueSeparator)
+    this.hash = new Hash(tokenizer, liquid.options.jekyllInclude || liquid.options.keyValueSeparator)
   }
   * render (ctx: Context, emitter: Emitter): Generator<unknown, void, unknown> {
     const { liquid, hash, withVar } = this
@@ -43,6 +43,29 @@ export default class extends Tag {
     ctx.restoreRegister(saved)
   }
 
+  public children (partials: boolean): Iterable<Template> {
+    if (partials && isString(this['file'])) {
+      // TODO: async
+      // TODO: throw error if this.file does not exist?
+      return toValueSync(this.liquid._parsePartialFile(this['file'], true, this['currentFile']))
+    }
+
+    // XXX: We're silently ignoring dynamically named partial templates.
+    return []
+  }
+
+  public partialScope (): PartialScope | undefined {
+    if (isString(this['file'])) {
+      const names = Object.keys(this.hash.hash)
+
+      if (this.withVar) {
+        names.push(this['file'])
+      }
+
+      return { name: this['file'], isolated: false, scope: names }
+    }
+  }
+
   public * arguments (): Arguments {
     yield * Object.values(this.hash.hash).filter(isValueToken)
 
@@ -54,12 +77,4 @@ export default class extends Tag {
       yield this.withVar
     }
   }
-
-  public * blockScope (): Iterable<string> {
-    for (const k of Object.keys(this.hash.hash)) {
-      yield k
-    }
-
-    // TODO: withVar
-  }
 }

src/tags/render.ts

@@ -1,9 +1,9 @@
 import { __assign } from 'tslib'
 import { ForloopDrop } from '../drop'
-import { isString, isValueToken, toEnumerable } from '../util'
+import { isString, isValueToken, toEnumerable, toValueSync } from '../util'
 import { TopLevelToken, assert, Liquid, Token, Template, evalQuotedToken, TypeGuards, Tokenizer, evalToken, Hash, Emitter, TagToken, Context, Tag } from '..'
 import { Parser } from '../parser'
-import { Arguments } from '../template'
+import { Arguments, PartialScope } from '../template'
 
 export type ParsedFileName = Template[] | Token | string | undefined
 
@@ -77,6 +77,34 @@ export default class extends Tag {
     }
   }
 
+  public children (partials: boolean): Iterable<Template> {
+    if (partials && isString(this['file'])) {
+      // TODO: async
+      // TODO: throw error if this.file does not exist?
+      return toValueSync(this.liquid._parsePartialFile(this['file'], true, this['currentFile']))
+    }
+
+    // XXX: We're silently ignoring dynamically named partial templates.
+    return []
+  }
+
+  public partialScope (): PartialScope | undefined {
+    if (isString(this['file'])) {
+      const names = Object.keys(this.hash.hash)
+
+      if (this['for']) {
+        const { alias } = this['for']
+        if (isString(alias)) {
+          names.push(alias)
+        } else if (isString(this.file)) {
+          names.push(this.file)
+        }
+      }
+
+      return { name: this['file'], isolated: true, scope: names }
+    }
+  }
+
   public * arguments (): Arguments {
     for (const v of Object.values(this.hash.hash)) {
       if (isValueToken(v)) {
@@ -95,21 +123,6 @@ export default class extends Tag {
       }
     }
   }
-
-  public * blockScope (): Iterable<string> {
-    yield * Object.keys(this.hash.hash)
-
-    if (this['for']) {
-      const { alias } = this['for']
-      if (isString(alias)) {
-        yield alias
-      } else if (isString(this.file)) {
-        yield this.file
-      }
-
-      yield 'forloop'
-    }
-  }
 }
 
 /**

src/template/analysis.ts

@@ -103,15 +103,19 @@ export interface StaticAnalysis {
 /**
  * Statically analyze a template and report variable usage.
  */
-export function analyze (templates: Template[]): StaticAnalysis {
+export function analyzeSync (templates: Template[], partials = true): StaticAnalysis {
   const variables = new VariableMap()
   const globals = new VariableMap()
   const locals = new VariableMap()
 
   const templateScope: Set<string> = new Set()
-  const scope = new DummyScope(templateScope)
+  const rootScope = new DummyScope(templateScope)
 
-  function updateVariables (variable: Variable): void {
+  // Names of partial templates that we've already analyzed.
+  // TODO: do we need to take special measures for relative template names?
+  const seen: Set<string | undefined> = new Set()
+
+  function updateVariables (variable: Variable, scope: DummyScope): void {
     variables.push(variable)
 
     // Variables that are not in scope are assumed to be global, that is,
@@ -124,16 +128,16 @@ export function analyze (templates: Template[]): StaticAnalysis {
     // recurse for nested Variables
     for (const segment of variable.segments) {
       if (segment instanceof Variable) {
-        updateVariables(segment)
+        updateVariables(segment, scope)
       }
     }
   }
 
-  function visit (template: Template): void {
+  function visit (template: Template, scope: DummyScope, isolated = false): void {
     if (template.arguments) {
       for (const arg of template.arguments()) {
         for (const variable of extractVariables(arg)) {
-          updateVariables(variable)
+          updateVariables(variable, scope)
         }
       }
     }
@@ -148,28 +152,44 @@ export function analyze (templates: Template[]): StaticAnalysis {
         } else {
           templateScope.add(ident.content)
           const [row, col] = ident.getPosition()
-          locals.push(new Variable([ident.content], { row, col, file: template.token.file }))
+          locals.push(new Variable([ident.content], { row, col, file: ident.file }))
         }
       }
     }
 
-    if (template.blockScope) {
-      scope.push(new Set(template.blockScope()))
-    }
-
     if (template.children) {
-      for (const child of template.children()) {
-        visit(child)
-      }
-    }
+      if (template.partialScope) {
+        const partial = template.partialScope()
+        if (partial === undefined || seen.has(partial.name)) return
+
+        const partialScope = partial.isolated
+          ? new DummyScope(new Set(partial.scope))
+          : scope.push(new Set(partial.scope))
+
+        for (const child of template.children(partials)) {
+          visit(child, partialScope)
+          seen.add(partial.name)
+        }
 
-    if (template.blockScope) {
-      scope.pop()
+        partialScope.pop()
+      } else {
+        if (template.blockScope) {
+          scope.push(new Set(template.blockScope()))
+        }
+
+        for (const child of template.children(partials)) {
+          visit(child, scope)
+        }
+
+        if (template.blockScope) {
+          scope.pop()
+        }
+      }
     }
   }
 
   for (const template of templates) {
-    visit(template)
+    visit(template, rootScope)
   }
 
   return {
@@ -198,8 +218,9 @@ class DummyScope {
     return false
   }
 
-  public push (scope: Set<string>): void {
+  public push (scope: Set<string>): DummyScope {
     this.stack.push(scope)
+    return this
   }
 
   public pop (): Set<string> | undefined {
@@ -248,12 +269,17 @@ function * extractValueTokenVariables (token: ValueToken): Generator<Variable> {
 function extractPropertyAccessVariable (token: PropertyAccessToken): Variable {
   const segments: VariableSegments = []
 
+  // token is not guaranteed to have `file` set. We'll try to get it from a prop if not.
+  let file: string | undefined = token.file
+
   if (isQuotedToken(token.variable) || isNumberToken(token.variable)) {
     // XXX: I think this is unreachable.
     segments.push(token.variable.content)
+    file = file || token.variable.file
   }
 
   for (const prop of token.props) {
+    file = file || prop.file
     if (isQuotedToken(prop) || isNumberToken(prop) || isWordToken(prop)) {
       segments.push(prop.content)
     } else if (isPropertyAccessToken(prop)) {
@@ -265,7 +291,7 @@ function extractPropertyAccessVariable (token: PropertyAccessToken): Variable {
   return new Variable(segments, {
     row,
     col,
-    file: token.file
+    file
   })
 }
 

src/template/hash.ts

@@ -15,12 +15,14 @@ type HashValueTokens = Record<string, Token | undefined>
  */
 export class Hash {
   hash: HashValueTokens = {}
-  constructor (markup: string, jekyllStyle?: boolean | string) {
-    const tokenizer = new Tokenizer(markup, {})
+
+  constructor (input: string | Tokenizer, jekyllStyle?: boolean | string) {
+    const tokenizer = input instanceof Tokenizer ? input : new Tokenizer(input, {})
     for (const hash of tokenizer.readHashes(jekyllStyle)) {
       this.hash[hash.name.content] = hash.value
     }
   }
+
   * render (ctx: Context): Generator<unknown, Record<string, any>, unknown> {
     const hash = {}
     for (const key of Object.keys(this.hash)) {

src/template/template.ts

@@ -6,12 +6,14 @@ import { Value } from './value'
 
 export type Argument = IdentifierToken | Value | ValueToken
 export type Arguments = Iterable<Argument>
+export type PartialScope = { name: string, isolated: boolean, scope: Iterable<string> }
 
 export interface Template {
   token: Token;
   render(ctx: Context, emitter: Emitter): any;
-  children?(): Iterable<Template>;
+  children?(partials: boolean): Iterable<Template>;
   arguments?(): Arguments;
   blockScope?(): Iterable<string>;
   localScope?(): Iterable<string | IdentifierToken | QuotedToken>;
+  partialScope?(): PartialScope | undefined;
 }