@rhinostone/swig 2.0.0-alpha.1 → 2.0.0-alpha.3

package/lib/lexer.js

@@ -3,7 +3,7 @@ var utils = require('./utils');
 // Token type enum lives in @rhinostone/swig-core so the shared
 // TokenParser (expression-level codegen) and every frontend lexer
 // agree on the numeric IDs. See .claude/architecture/multi-flavor-ir.md.
-var TYPES = require('../packages/swig-core/lib/tokentypes');
+var TYPES = require('@rhinostone/swig-core/lib/tokentypes');
 
 /**
  * A lexer token.

package/lib/loaders/filesystem.js

@@ -1,11 +1,9 @@
 /**
  * Phase 1 carve bridge — filesystem loader moved to @rhinostone/swig-core.
  *
- * Kept as a relative-path shim so the in-repo consumer (`lib/loaders/index.js`
- * → `require('./filesystem')`) keeps resolving and `browserify@2` — which
- * predates scoped packages and cannot resolve `@rhinostone/swig-core` —
- * keeps producing an identical browser bundle. See
+ * Kept as a shim so the in-repo consumer (`lib/loaders/index.js` →
+ * `require('./filesystem')`) keeps resolving. See
  * .claude/architecture/multi-flavor-ir.md.
  */
 
-module.exports = require('../../packages/swig-core/lib/loaders/filesystem');
+module.exports = require('@rhinostone/swig-core/lib/loaders/filesystem');

package/lib/loaders/index.js

@@ -1,10 +1,8 @@
 /**
  * Phase 1 carve bridge — loader aggregator moved to @rhinostone/swig-core.
  *
- * Kept as a relative-path shim so `lib/swig.js`'s `require('./loaders')`
- * keeps resolving and `browserify@2` — which predates scoped packages and
- * cannot resolve `@rhinostone/swig-core` — keeps producing an identical
- * browser bundle. See .claude/architecture/multi-flavor-ir.md.
+ * Kept as a shim so `lib/swig.js`'s `require('./loaders')` keeps resolving.
+ * See .claude/architecture/multi-flavor-ir.md.
  */
 
-module.exports = require('../../packages/swig-core/lib/loaders');
+module.exports = require('@rhinostone/swig-core/lib/loaders');

package/lib/loaders/memory.js

@@ -1,11 +1,9 @@
 /**
  * Phase 1 carve bridge — memory loader moved to @rhinostone/swig-core.
  *
- * Kept as a relative-path shim so the in-repo consumer
- * (`lib/loaders/index.js` → `require('./memory')`) keeps resolving and
- * `browserify@2` — which predates scoped packages and cannot resolve
- * `@rhinostone/swig-core` — keeps producing an identical browser bundle.
- * See .claude/architecture/multi-flavor-ir.md.
+ * Kept as a shim so the in-repo consumer (`lib/loaders/index.js` →
+ * `require('./memory')`) keeps resolving. See
+ * .claude/architecture/multi-flavor-ir.md.
  */
 
-module.exports = require('../../packages/swig-core/lib/loaders/memory');
+module.exports = require('@rhinostone/swig-core/lib/loaders/memory');

package/lib/parser.js

@@ -9,7 +9,7 @@ var _t = lexer.types;
 // receives filters + filename as per-call arguments so each flavor
 // frontend (native Swig, future Twig / Jinja2 / Django) plugs in its
 // own catalog. See .claude/architecture/multi-flavor-ir.md.
-var TokenParser = require('../packages/swig-core/lib/tokenparser').TokenParser;
+var TokenParser = require('@rhinostone/swig-core/lib/tokenparser').TokenParser;
 
 
 /**
@@ -116,25 +116,20 @@ exports.parse = function (swig, source, opts, tags, filters) {
   function parseVariable(str, line) {
     var tokens = lexer.read(utils.strip(str)),
       parser,
-      out;
+      node;
 
     parser = new TokenParser(tokens, filters, escape, line, opts.filename);
-    out = parser.parse().join('');
+    node = parser.parseOutput(tokens);
 
     if (parser.state.length) {
       utils.throwError('Unable to parse "' + str + '"', line, opts.filename);
     }
 
-    /**
-     * A parsed variable token.
-     * @typedef {object} VarToken
-     * @property {function} compile Method for compiling this token.
-     */
-    return {
-      compile: function () {
-        return '_output += ' + out + ';\n';
-      }
-    };
+    // Pre-built IR node. The backend walker detects the missing
+    // `.compile` and splices the node in directly (no second compile
+    // pass). See packages/swig-core/lib/backend.js § pre-built IR
+    // detection.
+    return node;
   }
   exports.parseVariable = parseVariable;
 
@@ -221,6 +216,11 @@ exports.parse = function (swig, source, opts, tags, filters) {
       break;
     }
 
+    var irExpr;
+    if (typeof tag.lowerExpr === 'function') {
+      irExpr = tag.lowerExpr(parser, tokens, chunks[1], line);
+    }
+
     /**
      * A parsed tag token.
      * @typedef {Object} TagToken
@@ -236,7 +236,8 @@ exports.parse = function (swig, source, opts, tags, filters) {
       args: args,
       content: [],
       ends: tag.ends,
-      name: tagName
+      name: tagName,
+      irExpr: irExpr
     };
   }
 
@@ -365,4 +366,4 @@ exports.parse = function (swig, source, opts, tags, filters) {
 // (packages/swig-core/lib/backend.js). Re-exported here so lib/swig.js
 // and lib/tags/import.js keep resolving `parser.compile` through the
 // same module path. See .claude/architecture/multi-flavor-ir.md.
-exports.compile = require('../packages/swig-core/lib/backend').compile;
+exports.compile = require('@rhinostone/swig-core/lib/backend').compile;

package/lib/swig.js

@@ -4,16 +4,16 @@ var utils = require('./utils'),
   parser = require('./parser'),
   dateformatter = require('./dateformatter'),
   loaders = require('./loaders'),
-  engine = require('../packages/swig-core/lib/engine');
+  engine = require('@rhinostone/swig-core/lib/engine');
 
 /**
  * Swig version number as a string.
  * @example
- * if (swig.version === "2.0.0-alpha.1") { ... }
+ * if (swig.version === "2.0.0-alpha.3") { ... }
  *
  * @type {String}
  */
-exports.version = "2.0.0-alpha.1";
+exports.version = "2.0.0-alpha.3";
 
 /**
  * Swig Options Object. This object can be passed to many of the API-level Swig methods to control various aspects of the engine. All keys are optional.

package/lib/tags/autoescape.js

@@ -1,6 +1,28 @@
 var utils = require('../utils'),
+  ir = require('@rhinostone/swig-core/lib/ir'),
   strings = ['html', 'js'];
 
+/*!
+ * Lower the frontend's raw autoescape-strategy token match into the
+ * typed shape IRAutoescape.strategy expects. The parser captures
+ * `token.match` verbatim (BOOL: 'true'/'false'; STRING: quoted like
+ * "'js'"). The native backend is a no-op on strategy (parser already
+ * baked escape behavior into the variable tokens at parse time), but
+ * a tight IR keeps the shape honest for future flavor backends.
+ * @private
+ */
+function lowerStrategy(raw) {
+  if (raw === 'true') { return true; }
+  if (raw === 'false') { return false; }
+  if (typeof raw === 'string' && raw.length >= 2) {
+    var first = raw.charAt(0), last = raw.charAt(raw.length - 1);
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return raw.slice(1, -1);
+    }
+  }
+  return raw;
+}
+
 /**
  * Control auto-escaping of variable output from within your templates.
  *
@@ -16,7 +38,8 @@ var utils = require('../utils'),
  * @param {boolean|string} control One of `true`, `false`, `"js"` or `"html"`.
  */
 exports.compile = function (compiler, args, content, parents, options, blockName) {
-  return compiler(content, parents, options, blockName);
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.autoescape(lowerStrategy(args[0]), [ir.legacyJS(bodyJS)]);
 };
 exports.parse = function (str, line, parser, types, stack, opts) {
   var matched;

package/lib/tags/block.js

@@ -1,3 +1,5 @@
+var ir = require('@rhinostone/swig-core/lib/ir');
+
 /**
  * Defines a block in a template that can be overridden by a template extending this one and/or will override the current template's parent template block of the same name.
  *
@@ -11,7 +13,8 @@
  * @param {literal}  name   Name of the block for use in parent and extended templates.
  */
 exports.compile = function (compiler, args, content, parents, options) {
-  return compiler(content, parents, options, args.join(''));
+  var name = args.join('');
+  return ir.block(name, [ir.legacyJS(compiler(content, parents, options, name))]);
 };
 
 exports.parse = function (str, line, parser) {

package/lib/tags/elseif.js

@@ -1,4 +1,5 @@
-var ifparser = require('./if').parse;
+var ifparser = require('./if').parse,
+  _t = require('@rhinostone/swig-core/lib/tokentypes');
 
 /**
  * Like <code data-language="swig">{% else %}</code>, except this tag can take more conditional statements.
@@ -22,6 +23,16 @@ exports.compile = function (compiler, args) {
   return '} else if (' + args.join(' ') + ') {\n';
 };
 
+exports.lowerExpr = function (parser, tokens) {
+  var i;
+  for (i = 0; i < tokens.length; i++) {
+    if (tokens[i].type === _t.FILTER || tokens[i].type === _t.FILTEREMPTY) {
+      return undefined;
+    }
+  }
+  return parser.parseExpr(tokens);
+};
+
 exports.parse = function (str, line, parser, types, stack) {
   var okay = ifparser(str, line, parser, types, stack);
   return okay && (stack.length && stack[stack.length - 1].name === 'if');

package/lib/tags/extends.js

@@ -10,6 +10,14 @@
  *
  * @param {string} parentFile  Relative path to the file that this template extends.
  */
+// Phase 2 (#T15): extends is a parse-time declaration, not an emit-time
+// construct. The engine's getParents / remapBlocks resolves the parent
+// chain before the backend walks the token tree, so by compile-time
+// there is nothing to emit. No IRExtends node exists — the Template IR
+// already carries `.parent` / `.blocks` metadata for flavors that want
+// to reason about inheritance before lowering. The compile function
+// returns undefined and the backend skips it via the `result === undefined`
+// check at the top of the emit loop. This stays this way post-Phase 2.
 exports.compile = function () {};
 
 exports.parse = function () {

package/lib/tags/filter.js

@@ -1,4 +1,6 @@
-var filters = require('../filters');
+var filters = require('../filters'),
+  ir = require('@rhinostone/swig-core/lib/ir'),
+  _t = require('@rhinostone/swig-core/lib/tokentypes');
 
 /**
  * Apply a filter to an entire block of template.
@@ -16,20 +18,77 @@ var filters = require('../filters');
  * @param {function} filter  The filter that should be applied to the contents of the tag.
  */
 
-exports.compile = function (compiler, args, content, parents, options, blockName) {
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
   var filter = args.shift().replace(/\($/, ''),
-    val = '(function () {\n' +
-      '  var _output = "";\n' +
-      compiler(content, parents, options, blockName) +
-      '  return _output;\n' +
-      '})()';
+    bodyJS = compiler(content, parents, options, blockName);
 
   if (args[args.length - 1] === ')') {
     args.pop();
   }
 
-  args = (args.length) ? ', ' + args.join('') : '';
-  return '_output += _filters["' + filter + '"](' + val + args + ');\n';
+  // Value prefers the lowered IRExpr[] carried on the token when
+  // lowerExpr produced one; otherwise fall back to the joined JS-source
+  // fragments the parse handler emitted (preserves userland setTag shape
+  // and the arg-less `{% filter name %}` case).
+  var irArgs = (token && token.irExpr) ? token.irExpr : (args.length ? args : undefined);
+  return ir.filter(filter, [ir.legacyJS(bodyJS)], irArgs);
+};
+
+exports.lowerExpr = function (parser, tokens) {
+  // Skip leading whitespace; find the filter-name token (VAR, FUNCTION,
+  // or FUNCTIONEMPTY).
+  var i = 0;
+  while (i < tokens.length && tokens[i].type === _t.WHITESPACE) { i += 1; }
+  if (i >= tokens.length) { return undefined; }
+  var head = tokens[i];
+  // Arg-less `{% filter name %}` — nothing to lower. Falling back keeps
+  // the userland setTag string-args path live for zero-arg filters.
+  if (head.type === _t.VAR) { return undefined; }
+  if (head.type === _t.FUNCTIONEMPTY) { return []; }
+  if (head.type !== _t.FUNCTION) { return undefined; }
+
+  // FUNCTION consumes its implicit open paren; walk forward tracking
+  // paren / bracket / curly depth. Slice at top-level COMMAs; stop at the
+  // PARENCLOSE that balances the FUNCTION's paren. Bail (return
+  // undefined) on any nested FILTER / FILTEREMPTY — filter pipes inside
+  // the argument expression are not part of the expression grammar
+  // (Output-site concern; Session 14+ work).
+  var depth = 1,
+    start = i + 1,
+    slices = [],
+    j;
+  for (j = i + 1; j < tokens.length; j += 1) {
+    var tk = tokens[j];
+    if (tk.type === _t.FILTER || tk.type === _t.FILTEREMPTY) {
+      return undefined;
+    }
+    if (tk.type === _t.PARENOPEN || tk.type === _t.FUNCTION ||
+        tk.type === _t.BRACKETOPEN || tk.type === _t.CURLYOPEN) {
+      depth += 1;
+      continue;
+    }
+    if (tk.type === _t.PARENCLOSE || tk.type === _t.BRACKETCLOSE ||
+        tk.type === _t.CURLYCLOSE) {
+      depth -= 1;
+      if (depth === 0) {
+        if (j > start) {
+          slices.push(tokens.slice(start, j));
+        }
+        break;
+      }
+      continue;
+    }
+    if (tk.type === _t.COMMA && depth === 1) {
+      slices.push(tokens.slice(start, j));
+      start = j + 1;
+    }
+  }
+  if (depth !== 0) { return undefined; }
+  var exprs = [];
+  for (j = 0; j < slices.length; j += 1) {
+    exprs.push(parser.parseExpr(slices[j]));
+  }
+  return exprs;
 };
 
 exports.parse = function (str, line, parser, types) {

package/lib/tags/for.js

@@ -1,11 +1,11 @@
-var ctx = '_ctx.',
-  ctxloop = ctx + 'loop';
+var ir = require('@rhinostone/swig-core/lib/ir'),
+  _t = require('@rhinostone/swig-core/lib/tokentypes');
 
 // CVE-2023-25345: prototype-chain properties that must not be used as loop
 // variable names. The for tag assigns loop variables to _ctx, so dangerous
 // names would pollute the prototype chain. Shared constant in
 // @rhinostone/swig-core — see .claude/security.md.
-var _dangerousProps = require('../../packages/swig-core/lib/security').dangerousProps;
+var _dangerousProps = require('@rhinostone/swig-core/lib/security').dangerousProps;
 
 /**
  * Loop over objects and arrays.
@@ -47,10 +47,9 @@ var _dangerousProps = require('../../packages/swig-core/lib/security').dangerous
  * @return {loop.first} True if the current object is the first in the object or array.
  * @return {loop.last} True if the current object is the last in the object or array.
  */
-exports.compile = function (compiler, args, content, parents, options, blockName) {
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
   var val = args.shift(),
     key = '__k',
-    ctxloopcache = (ctx + '__loopcache' + Math.random()).replace(/\./g, ''),
     last;
 
   if (args[0] && args[0] === ',') {
@@ -59,29 +58,28 @@ exports.compile = function (compiler, args, content, parents, options, blockName
     val = args.shift();
   }
 
-  last = args.join('');
-
-  return [
-    '(function () {\n',
-    '  var __l = ' + last + ', __len = (_utils.isArray(__l) || typeof __l === "string") ? __l.length : _utils.keys(__l).length;\n',
-    '  if (!__l) { return; }\n',
-    '    var ' + ctxloopcache + ' = { loop: ' + ctxloop + ', ' + val + ': ' + ctx + val + ', ' + key + ': ' + ctx + key + ' };\n',
-    '    ' + ctxloop + ' = { first: false, index: 1, index0: 0, revindex: __len, revindex0: __len - 1, length: __len, last: false };\n',
-    '  _utils.each(__l, function (' + val + ', ' + key + ') {\n',
-    '    ' + ctx + val + ' = ' + val + ';\n',
-    '    ' + ctx + key + ' = ' + key + ';\n',
-    '    ' + ctxloop + '.key = ' + key + ';\n',
-    '    ' + ctxloop + '.first = (' + ctxloop + '.index0 === 0);\n',
-    '    ' + ctxloop + '.last = (' + ctxloop + '.revindex0 === 0);\n',
-    '    ' + compiler(content, parents, options, blockName),
-    '    ' + ctxloop + '.index += 1; ' + ctxloop + '.index0 += 1; ' + ctxloop + '.revindex -= 1; ' + ctxloop + '.revindex0 -= 1;\n',
-    '  });\n',
-    '  ' + ctxloop + ' = ' + ctxloopcache + '.loop;\n',
-    '  ' + ctx + val + ' = ' + ctxloopcache + '.' + val + ';\n',
-    '  ' + ctx + key + ' = ' + ctxloopcache + '.' + key + ';\n',
-    '  ' + ctxloopcache + ' = undefined;\n',
-    '})();\n'
-  ].join('');
+  last = (token && token.irExpr) ? token.irExpr : args.join('');
+
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.forStmt(val, last, [ir.legacyJS(bodyJS)], key);
+};
+
+exports.lowerExpr = function (parser, tokens) {
+  var inIdx = -1, i;
+  for (i = 0; i < tokens.length; i++) {
+    if (tokens[i].type === _t.COMPARATOR && tokens[i].match === 'in') {
+      inIdx = i;
+      break;
+    }
+  }
+  if (inIdx === -1) { return undefined; }
+  var iterTokens = tokens.slice(inIdx + 1);
+  for (i = 0; i < iterTokens.length; i++) {
+    if (iterTokens[i].type === _t.FILTER || iterTokens[i].type === _t.FILTEREMPTY) {
+      return undefined;
+    }
+  }
+  return parser.parseExpr(iterTokens);
 };
 
 exports.parse = function (str, line, parser, types) {
@@ -106,6 +104,14 @@ exports.parse = function (str, line, parser, types) {
       return true;
     }
 
+    // CVE-2023-25345: the lexer folds dotted paths into a single VAR token
+    // (e.g. `foo.__proto__` matches as one VAR with .match === "foo.__proto__"),
+    // so the _dangerousProps indexOf check below misses the prototype segment.
+    // Loop variables bind to `_ctx.<name>` — bare identifiers only.
+    if (token.match.indexOf('.') !== -1) {
+      throw new Error('Loop variable "' + token.match + '" must be a bare identifier in "for" tag on line ' + line + '.');
+    }
+
     // CVE-2023-25345: block prototype-chain property names as loop variables
     if (_dangerousProps.indexOf(token.match) !== -1) {
       throw new Error('Unsafe loop variable "' + token.match + '" is not allowed (CVE-2023-25345) on line ' + line + '.');

package/lib/tags/if.js

@@ -1,3 +1,6 @@
+var ir = require('@rhinostone/swig-core/lib/ir'),
+  _t = require('@rhinostone/swig-core/lib/tokentypes');
+
 /**
  * Used to create conditional statements in templates. Accepts most JavaScript valid comparisons.
  *
@@ -39,10 +42,46 @@
  *
  * @param {...mixed} conditional Conditional statement that returns a truthy or falsy value.
  */
-exports.compile = function (compiler, args, content, parents, options, blockName) {
-  return 'if (' + args.join(' ') + ') { \n' +
-    compiler(content, parents, options, blockName) + '\n' +
-    '}';
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  // Phase 2 Session 14b Commit 11: filter-in-test fallback lifts into
+  // `IRLegacyJS` rather than a raw string. `if.lowerExpr` bails to
+  // `undefined` when the test contains FILTER/FILTEREMPTY because
+  // per-operand filter precedence (`a === b|upper` binds the filter to
+  // `b` only) can't be captured in flat IR — same widening recipe as
+  // `IROutput.expr` (Session 14b Commit 9). Backend dispatches
+  // `LegacyJS` before `emitExpr`. String fallback still valid for
+  // userland `setTag` compile functions that build branches manually.
+  var branches = [],
+    currentTest = (token && token.irExpr) ? token.irExpr : ir.legacyJS(args.join(' ')),
+    currentSlice = [],
+    i,
+    t;
+  for (i = 0; i < content.length; i++) {
+    t = content[i];
+    if (t && (t.name === 'elseif' || t.name === 'else')) {
+      branches.push(ir.ifBranch(currentTest, [ir.legacyJS(compiler(currentSlice, parents, options, blockName))]));
+      if (t.name === 'else') {
+        currentTest = null;
+      } else {
+        currentTest = (t.irExpr) ? t.irExpr : ir.legacyJS(t.args.join(' '));
+      }
+      currentSlice = [];
+    } else {
+      currentSlice.push(t);
+    }
+  }
+  branches.push(ir.ifBranch(currentTest, [ir.legacyJS(compiler(currentSlice, parents, options, blockName))]));
+  return ir.ifStmt(branches);
+};
+
+exports.lowerExpr = function (parser, tokens) {
+  var i;
+  for (i = 0; i < tokens.length; i++) {
+    if (tokens[i].type === _t.FILTER || tokens[i].type === _t.FILTEREMPTY) {
+      return undefined;
+    }
+  }
+  return parser.parseExpr(tokens);
 };
 
 exports.parse = function (str, line, parser, types) {

package/lib/tags/import.js

@@ -1,10 +1,25 @@
-var utils = require('../utils');
+// Phase 2 (#T15): the import tag stays on the IRLegacyJS escape hatch.
+// The compile function performs regex surgery over the compiled body
+// of each imported macro to rewrite `_ctx.<macroName>` into
+// `_ctx.<namespace>.<macroName>`, including sibling-macro references
+// (the `(?!' + allMacros + ')` negative lookahead). That rewrite is
+// swig-specific coupling on the exact JS source shape of a compiled
+// macro — it has no cross-flavor invariant and does not meet the
+// flavor-invariant test for a dedicated IR node. When TokenParser
+// migrates to IRExpr (Session 14+), the macro-name → namespace
+// rewrite moves into the emitter itself, at which point the import
+// tag collapses to an IRImport node. Until then, return a JS source
+// string; the backend lifts it into IRLegacyJS at the emit-loop
+// entry. See .claude/architecture/multi-flavor-ir.md § Flavor-
+// invariant test.
+var utils = require('../utils'),
+  backend = require('@rhinostone/swig-core/lib/backend');
 
 // CVE-2023-25345: prototype-chain properties that must not be used as import
 // aliases. The import tag assigns a namespace object to _ctx, so dangerous
 // names would pollute the prototype chain. Shared constant in
 // @rhinostone/swig-core — see .claude/security.md.
-var _dangerousProps = require('../../packages/swig-core/lib/security').dangerousProps;
+var _dangerousProps = require('@rhinostone/swig-core/lib/security').dangerousProps;
 
 /**
  * Allows you to import macros from another file directly into your current context.
@@ -70,7 +85,12 @@ exports.parse = function (str, line, parser, types, stack, opts, swig) {
           return;
         }
         macroName = token.args[0];
-        out += token.compile(compiler, token.args, token.content, [], compileOpts) + '\n';
+        // Phase 2 (#T15): macro.compile now returns an IRMacro node
+        // rather than a JS source string. Render it through the shared
+        // backend so import.js still gets the JS source it performs
+        // regex-surgery on for namespace-prefixing. The +'\n' trailing
+        // newline matches the pre-Phase-2 compile output exactly.
+        out += backend.compile([token.compile(compiler, token.args, token.content, [], compileOpts)], [], compileOpts) + '\n';
         self.out.push({compiled: out, name: macroName});
       });
       return;

package/lib/tags/include.js

@@ -1,3 +1,6 @@
+var ir = require('@rhinostone/swig-core/lib/ir'),
+  _t = require('@rhinostone/swig-core/lib/tokentypes');
+
 var ignore = 'ignore',
   missing = 'missing',
   only = 'only';
@@ -28,21 +31,78 @@ var ignore = 'ignore',
  * @param {literal}     [only]    Restricts to <strong>only</strong> passing the <code>with context</code> as local variables–the included template will not be aware of any other local variables in the parent template. For best performance, usage of this option is recommended if possible.
  * @param {literal}     [ignore missing] Will output empty string if not found instead of throwing an error.
  */
-exports.compile = function (compiler, args) {
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
   var file = args.shift(),
     onlyIdx = args.indexOf(only),
     onlyCtx = onlyIdx !== -1 ? args.splice(onlyIdx, 1) : false,
     parentFile = (args.pop() || '').replace(/\\/g, '\\\\'),
-    ignore = args[args.length - 1] === missing ? (args.pop()) : false,
+    ignoreMissing = args[args.length - 1] === missing ? (args.pop()) : false,
     w = args.join('');
 
-  return (ignore ? '  try {\n' : '') +
-    '_output += _swig.compileFile(' + file + ', {' +
-    'resolveFrom: "' + parentFile + '"' +
-    '})(' +
-    ((onlyCtx && w) ? w : (!w ? '_ctx' : '_utils.extend({}, _ctx, ' + w + ')')) +
-    ');\n' +
-    (ignore ? '} catch (e) {}\n' : '');
+  if (token && token.irExpr) {
+    file = token.irExpr.file;
+    if (token.irExpr.context !== undefined) {
+      w = token.irExpr.context;
+    } else {
+      w = undefined;
+    }
+  }
+
+  return ir.include(file, w || undefined, !!onlyCtx, !!ignoreMissing, parentFile);
+};
+
+exports.lowerExpr = function (parser, tokens) {
+  var i, tk, depth = 0,
+    withIdx = -1, onlyIdx = -1, ignoreIdx = -1;
+
+  for (i = 0; i < tokens.length; i++) {
+    tk = tokens[i];
+    if (tk.type === _t.FILTER || tk.type === _t.FILTEREMPTY) {
+      return undefined;
+    }
+    if (tk.type === _t.PARENOPEN || tk.type === _t.BRACKETOPEN ||
+        tk.type === _t.ARRAYOPEN || tk.type === _t.CURLYOPEN ||
+        tk.type === _t.FUNCTION || tk.type === _t.METHODOPEN) {
+      depth++;
+      continue;
+    }
+    if (tk.type === _t.PARENCLOSE || tk.type === _t.BRACKETCLOSE ||
+        tk.type === _t.CURLYCLOSE) {
+      depth--;
+      continue;
+    }
+    if (depth !== 0) { continue; }
+    if (tk.type === _t.VAR) {
+      if (withIdx === -1 && tk.match === 'with') {
+        withIdx = i;
+      } else if (withIdx !== -1 && onlyIdx === -1 && tk.match === only) {
+        onlyIdx = i;
+      } else if (ignoreIdx === -1 && tk.match === ignore) {
+        ignoreIdx = i;
+      }
+    }
+  }
+
+  var pathEnd = tokens.length;
+  if (withIdx !== -1) { pathEnd = withIdx; }
+  else if (ignoreIdx !== -1) { pathEnd = ignoreIdx; }
+
+  var pathTokens = tokens.slice(0, pathEnd);
+  if (pathTokens.length === 0) { return undefined; }
+
+  var result = { file: parser.parseExpr(pathTokens) };
+
+  if (withIdx !== -1) {
+    var ctxEnd = tokens.length;
+    if (onlyIdx !== -1) { ctxEnd = onlyIdx; }
+    else if (ignoreIdx !== -1) { ctxEnd = ignoreIdx; }
+    var ctxTokens = tokens.slice(withIdx + 1, ctxEnd);
+    if (ctxTokens.length > 0) {
+      result.context = parser.parseExpr(ctxTokens);
+    }
+  }
+
+  return result;
 };
 
 exports.parse = function (str, line, parser, types, stack, opts) {