summaryrefslogtreecommitdiffstats
path: root/lib/handlebars/compiler/javascript-compiler.js
diff options
context:
space:
mode:
Diffstat (limited to 'lib/handlebars/compiler/javascript-compiler.js')
-rw-r--r--lib/handlebars/compiler/javascript-compiler.js341
1 files changed, 184 insertions, 157 deletions
diff --git a/lib/handlebars/compiler/javascript-compiler.js b/lib/handlebars/compiler/javascript-compiler.js
index d41cacd..af9c5de 100644
--- a/lib/handlebars/compiler/javascript-compiler.js
+++ b/lib/handlebars/compiler/javascript-compiler.js
@@ -1,5 +1,7 @@
import { COMPILER_REVISION, REVISION_CHANGES } from "../base";
import Exception from "../exception";
+import {isArray} from "../utils";
+import CodeGen from "./code-gen";
function Literal(value) {
this.value = value;
@@ -12,15 +14,13 @@ JavaScriptCompiler.prototype = {
// alternative compiled forms for name lookup and buffering semantics
nameLookup: function(parent, name /* , type*/) {
if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
- return parent + "." + name;
+ return [parent, ".", name];
} else {
- return parent + "['" + name + "']";
+ return [parent, "['", name, "']"];
}
},
depthedLookup: function(name) {
- this.aliases.lookup = 'this.lookup';
-
- return 'lookup(depths, "' + name + '")';
+ return [this.aliasable('this.lookup'), '(depths, "', name, '")'];
},
compilerInfo: function() {
@@ -29,15 +29,23 @@ JavaScriptCompiler.prototype = {
return [revision, versions];
},
- appendToBuffer: function(string) {
+ appendToBuffer: function(string, location, explicit) {
+ // Force a string as this simplifies the merge logic.
+ if (!isArray(string)) {
+ string = [string];
+ }
+ string = this.source.wrap(string, location);
+
if (this.environment.isSimple) {
- return "return " + string + ";";
+ return ['return ', string, ';'];
+ } else if (explicit) {
+ // This is a case where the buffer operation occurs as a child of another
+ // construct, generally braces. We have to explicitly output these buffer
+ // operations to ensure that the emitted code goes in the correct location.
+ return ['buffer += ', string, ';'];
} else {
- return {
- appendToBuffer: true,
- content: string,
- toString: function() { return "buffer += " + string + ";"; }
- };
+ string.appendToBuffer = true;
+ return string;
}
},
@@ -78,16 +86,20 @@ JavaScriptCompiler.prototype = {
var opcodes = environment.opcodes,
opcode,
+ firstLoc,
i,
l;
for (i = 0, l = opcodes.length; i < l; i++) {
opcode = opcodes[i];
+ this.source.currentLocation = opcode.loc;
+ firstLoc = firstLoc || opcode.loc;
this[opcode.opcode].apply(this, opcode.args);
}
// Flush any trailing content that might be pending.
+ this.source.currentLocation = firstLoc;
this.pushSource('');
/* istanbul ignore next */
@@ -123,7 +135,18 @@ JavaScriptCompiler.prototype = {
if (!asObject) {
ret.compiler = JSON.stringify(ret.compiler);
+
+ this.source.currentLocation = {firstLine: 1, firstColumn: 0};
ret = this.objectLiteral(ret);
+
+ if (options.srcName) {
+ ret = ret.toStringWithSourceMap({file: options.destName});
+ ret.map = ret.map && ret.map.toString();
+ } else {
+ ret = ret.toString();
+ }
+ } else {
+ ret.compilerOptions = this.options;
}
return ret;
@@ -136,7 +159,7 @@ JavaScriptCompiler.prototype = {
// track the last context pushed into place to allow skipping the
// getContext opcode when it would be a noop
this.lastContext = 0;
- this.source = [];
+ this.source = new CodeGen(this.options.srcName);
},
createFunctionContext: function(asObject) {
@@ -148,9 +171,18 @@ JavaScriptCompiler.prototype = {
}
// Generate minimizer alias mappings
+ //
+ // When using true SourceNodes, this will update all references to the given alias
+ // as the source nodes are reused in situ. For the non-source node compilation mode,
+ // aliases will not be used, but this case is already being run on the client and
+ // we aren't concern about minimizing the template size.
+ var aliasCount = 0;
for (var alias in this.aliases) {
- if (this.aliases.hasOwnProperty(alias)) {
- varDeclarations += ', ' + alias + '=' + this.aliases[alias];
+ var node = this.aliases[alias];
+
+ if (this.aliases.hasOwnProperty(alias) && node.children && node.referenceCount > 1) {
+ varDeclarations += ', alias' + (++aliasCount) + '=' + alias;
+ node.children[0] = 'alias' + aliasCount;
}
}
@@ -168,59 +200,67 @@ JavaScriptCompiler.prototype = {
return Function.apply(this, params);
} else {
- return 'function(' + params.join(',') + ') {\n ' + source + '}';
+ return this.source.wrap(['function(', params.join(','), ') {\n ', source, '}']);
}
},
mergeSource: function(varDeclarations) {
- var source = '',
- buffer,
+ var isSimple = this.environment.isSimple,
appendOnly = !this.forceBuffer,
- appendFirst;
+ appendFirst,
- for (var i = 0, len = this.source.length; i < len; i++) {
- var line = this.source[i];
+ sourceSeen,
+ bufferStart,
+ bufferEnd;
+ this.source.each(function(line) {
if (line.appendToBuffer) {
- if (buffer) {
- buffer = buffer + '\n + ' + line.content;
+ if (bufferStart) {
+ line.prepend(' + ');
} else {
- buffer = line.content;
+ bufferStart = line;
}
+ bufferEnd = line;
} else {
- if (buffer) {
- if (!source) {
+ if (bufferStart) {
+ if (!sourceSeen) {
appendFirst = true;
- source = buffer + ';\n ';
} else {
- source += 'buffer += ' + buffer + ';\n ';
+ bufferStart.prepend('buffer += ');
}
- buffer = undefined;
+ bufferEnd.add(';');
+ bufferStart = bufferEnd = undefined;
}
- source += line + '\n ';
- if (!this.environment.isSimple) {
+ sourceSeen = true;
+ if (!isSimple) {
appendOnly = false;
}
}
- }
+ });
+
if (appendOnly) {
- if (buffer || !source) {
- source += 'return ' + (buffer || '""') + ';\n';
+ if (bufferStart) {
+ bufferStart.prepend('return ');
+ bufferEnd.add(';');
+ } else {
+ this.source.push('return "";');
}
} else {
varDeclarations += ", buffer = " + (appendFirst ? '' : this.initializeBuffer());
- if (buffer) {
- source += 'return buffer + ' + buffer + ';\n';
+
+ if (bufferStart) {
+ bufferStart.prepend('return buffer + ');
+ bufferEnd.add(';');
} else {
- source += 'return buffer;\n';
+ this.source.push('return buffer;');
}
}
if (varDeclarations) {
- source = 'var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\n ') + source;
+ this.source.prepend('var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\n '));
}
- return source;
+ return this.source.merge();
},
// [blockValue]
@@ -233,15 +273,14 @@ JavaScriptCompiler.prototype = {
// replace it on the stack with the result of properly
// invoking blockHelperMissing.
blockValue: function(name) {
- this.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
-
- var params = [this.contextName(0)];
+ var blockHelperMissing = this.aliasable('helpers.blockHelperMissing'),
+ params = [this.contextName(0)];
this.setupParams(name, 0, params);
var blockName = this.popStack();
params.splice(1, 0, blockName);
- this.push('blockHelperMissing.call(' + params.join(', ') + ')');
+ this.push(this.source.functionCall(blockHelperMissing, 'call', params));
},
// [ambiguousBlockValue]
@@ -251,10 +290,9 @@ JavaScriptCompiler.prototype = {
// On stack, after, if no lastHelper: same as [blockValue]
// On stack, after, if lastHelper: value
ambiguousBlockValue: function() {
- this.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
-
// We're being a bit cheeky and reusing the options value from the prior exec
- var params = [this.contextName(0)];
+ var blockHelperMissing = this.aliasable('helpers.blockHelperMissing'),
+ params = [this.contextName(0)];
this.setupParams('', 0, params, true);
this.flushInline();
@@ -262,7 +300,10 @@ JavaScriptCompiler.prototype = {
var current = this.topStack();
params.splice(1, 0, current);
- this.pushSource("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
+ this.pushSource([
+ 'if (!', this.lastHelper, ') { ',
+ current, ' = ', this.source.functionCall(blockHelperMissing, 'call', params),
+ '}']);
},
// [appendContent]
@@ -274,6 +315,8 @@ JavaScriptCompiler.prototype = {
appendContent: function(content) {
if (this.pendingContent) {
content = this.pendingContent + content;
+ } else {
+ this.pendingLocation = this.source.currentLocation;
}
this.pendingContent = content;
@@ -289,13 +332,18 @@ JavaScriptCompiler.prototype = {
// If `value` is truthy, or 0, it is coerced into a string and appended
// Otherwise, the empty string is appended
append: function() {
- // Force anything that is inlined onto the stack so we don't have duplication
- // when we examine local
- this.flushInline();
- var local = this.popStack();
- this.pushSource('if (' + local + ' != null) { ' + this.appendToBuffer(local) + ' }');
- if (this.environment.isSimple) {
- this.pushSource("else { " + this.appendToBuffer("''") + " }");
+ if (this.isInline()) {
+ this.replaceStack(function(current) {
+ return [' != null ? ', current, ' : ""'];
+ });
+
+ this.pushSource(this.appendToBuffer(this.popStack()));
+ } else {
+ var local = this.popStack();
+ this.pushSource(['if (', local, ' != null) { ', this.appendToBuffer(local, undefined, true), ' }']);
+ if (this.environment.isSimple) {
+ this.pushSource(['else { ', this.appendToBuffer("''", undefined, true), ' }']);
+ }
}
},
@@ -306,9 +354,8 @@ JavaScriptCompiler.prototype = {
//
// Escape `value` and append it to the buffer
appendEscaped: function() {
- this.aliases.escapeExpression = 'this.escapeExpression';
-
- this.pushSource(this.appendToBuffer("escapeExpression(" + this.popStack() + ")"));
+ this.pushSource(this.appendToBuffer(
+ [this.aliasable('this.escapeExpression'), '(', this.popStack(), ')']));
},
// [getContext]
@@ -358,10 +405,10 @@ JavaScriptCompiler.prototype = {
// We want to ensure that zero and false are handled properly if the context (falsy flag)
// needs to have the special handling for these values.
if (!falsy) {
- return ' != null ? ' + lookup + ' : ' + current;
+ return [' != null ? ', lookup, ' : ', current];
} else {
// Otherwise we can use generic falsy handling
- return ' && ' + lookup;
+ return [' && ', lookup];
}
});
}
@@ -384,7 +431,7 @@ JavaScriptCompiler.prototype = {
var len = parts.length;
for (var i = 0; i < len; i++) {
this.replaceStack(function(current) {
- return ' && ' + this.nameLookup(current, parts[i], 'data');
+ return [' && ', this.nameLookup(current, parts[i], 'data')];
});
}
},
@@ -397,9 +444,7 @@ JavaScriptCompiler.prototype = {
// If the `value` is a lambda, replace it on the stack by
// the return value of the lambda
resolvePossibleLambda: function() {
- this.aliases.lambda = 'this.lambda';
-
- this.push('lambda(' + this.popStack() + ', ' + this.contextName(0) + ')');
+ this.push([this.aliasable('this.lambda'), '(', this.popStack(), ', ', this.contextName(0), ')']);
},
// [pushStringParam]
@@ -447,14 +492,14 @@ JavaScriptCompiler.prototype = {
this.hash = this.hashes.pop();
if (this.trackIds) {
- this.push('{' + hash.ids.join(',') + '}');
+ this.push(this.objectLiteral(hash.ids));
}
if (this.stringParams) {
- this.push('{' + hash.contexts.join(',') + '}');
- this.push('{' + hash.types.join(',') + '}');
+ this.push(this.objectLiteral(hash.contexts));
+ this.push(this.objectLiteral(hash.types));
}
- this.push('{\n ' + hash.values.join(',\n ') + '\n }');
+ this.push(this.objectLiteral(hash.values));
},
// [pushString]
@@ -467,17 +512,6 @@ JavaScriptCompiler.prototype = {
this.pushStackLiteral(this.quotedString(string));
},
- // [push]
- //
- // On stack, before: ...
- // On stack, after: expr, ...
- //
- // Push an expression onto the stack
- push: function(expr) {
- this.inlineStack.push(expr);
- return expr;
- },
-
// [pushLiteral]
//
// On stack, before: ...
@@ -516,13 +550,15 @@ JavaScriptCompiler.prototype = {
//
// If the helper is not found, `helperMissing` is called.
invokeHelper: function(paramSize, name, isSimple) {
- this.aliases.helperMissing = 'helpers.helperMissing';
-
var nonHelper = this.popStack();
var helper = this.setupHelper(paramSize, name);
+ var simple = isSimple ? [helper.name, ' || '] : '';
- var lookup = (isSimple ? helper.name + ' || ' : '') + nonHelper + ' || helperMissing';
- this.push('((' + lookup + ').call(' + helper.callParams + '))');
+ this.push(
+ this.source.functionCall(
+ ['('].concat(simple, nonHelper, ' || ', this.aliasable('helpers.helperMissing'), ')'),
+ 'call',
+ helper.callParams));
},
// [invokeKnownHelper]
@@ -534,7 +570,7 @@ JavaScriptCompiler.prototype = {
// so a `helperMissing` fallback is not required.
invokeKnownHelper: function(paramSize, name) {
var helper = this.setupHelper(paramSize, name);
- this.push(helper.name + ".call(" + helper.callParams + ")");
+ this.push(this.source.functionCall(helper.name, 'call', helper.callParams));
},
// [invokeAmbiguous]
@@ -550,8 +586,6 @@ JavaScriptCompiler.prototype = {
// and can be avoided by passing the `knownHelpers` and
// `knownHelpersOnly` flags at compile-time.
invokeAmbiguous: function(name, helperCall) {
- this.aliases.functionType = '"function"';
- this.aliases.helperMissing = 'helpers.helperMissing';
this.useRegister('helper');
var nonHelper = this.popStack();
@@ -561,10 +595,13 @@ JavaScriptCompiler.prototype = {
var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
- this.push(
- '((helper = (helper = ' + helperName + ' || ' + nonHelper + ') != null ? helper : helperMissing'
- + (helper.paramsInit ? '),(' + helper.paramsInit : '') + '),'
- + '(typeof helper === functionType ? helper.call(' + helper.callParams + ') : helper))');
+ this.push([
+ '((helper = (helper = ', helperName, ' || ', nonHelper, ') != null ? helper : ',
+ this.aliasable('helpers.helperMissing'),
+ (helper.paramsInit ? ['),(', helper.paramsInit] : []), '),',
+ '(typeof helper === ', this.aliasable('"function"'), ' ? ',
+ this.source.functionCall('helper','call', helper.callParams), ' : helper))'
+ ]);
},
// [invokePartial]
@@ -586,7 +623,7 @@ JavaScriptCompiler.prototype = {
params.push('depths');
}
- this.push("this.invokePartial(" + params.join(", ") + ")");
+ this.push(this.source.functionCall('this.invokePartial', '', params));
},
// [assignToHash]
@@ -611,15 +648,15 @@ JavaScriptCompiler.prototype = {
var hash = this.hash;
if (context) {
- hash.contexts.push("'" + key + "': " + context);
+ hash.contexts[key] = context;
}
if (type) {
- hash.types.push("'" + key + "': " + type);
+ hash.types[key] = type;
}
if (id) {
- hash.ids.push("'" + key + "': " + id);
+ hash.ids[key] = id;
}
- hash.values.push("'" + key + "': (" + value + ")");
+ hash.values[key] = value;
},
pushId: function(type, name) {
@@ -691,13 +728,23 @@ JavaScriptCompiler.prototype = {
}
},
+ push: function(expr) {
+ if (!(expr instanceof Literal)) {
+ expr = this.source.wrap(expr);
+ }
+
+ this.inlineStack.push(expr);
+ return expr;
+ },
+
pushStackLiteral: function(item) {
- return this.push(new Literal(item));
+ this.push(new Literal(item));
},
pushSource: function(source) {
if (this.pendingContent) {
- this.source.push(this.appendToBuffer(this.quotedString(this.pendingContent)));
+ this.source.push(
+ this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
this.pendingContent = undefined;
}
@@ -706,17 +753,8 @@ JavaScriptCompiler.prototype = {
}
},
- pushStack: function(item) {
- this.flushInline();
-
- var stack = this.incrStack();
- this.pushSource(stack + " = " + item + ";");
- this.compileStack.push(stack);
- return stack;
- },
-
replaceStack: function(callback) {
- var prefix = '',
+ var prefix = ['('],
inline = this.isInline(),
stack,
createdStack,
@@ -732,14 +770,15 @@ JavaScriptCompiler.prototype = {
if (top instanceof Literal) {
// Literals do not need to be inlined
- prefix = stack = top.value;
+ stack = [top.value];
+ prefix = ['(', stack];
usedLiteral = true;
} else {
// Get or create the current stack name for use by the inline
- createdStack = !this.stackSlot;
- var name = !createdStack ? this.topStackName() : this.incrStack();
+ createdStack = true;
+ var name = this.incrStack();
- prefix = '(' + this.push(name) + ' = ' + top + ')';
+ prefix = ['((', this.push(name), ' = ', top, ')'];
stack = this.topStack();
}
@@ -751,7 +790,7 @@ JavaScriptCompiler.prototype = {
if (createdStack) {
this.stackSlot--;
}
- this.push('(' + prefix + item + ')');
+ this.push(prefix.concat(item, ')'));
},
incrStack: function() {
@@ -764,15 +803,16 @@ JavaScriptCompiler.prototype = {
},
flushInline: function() {
var inlineStack = this.inlineStack;
- if (inlineStack.length) {
- this.inlineStack = [];
- for (var i = 0, len = inlineStack.length; i < len; i++) {
- var entry = inlineStack[i];
- if (entry instanceof Literal) {
- this.compileStack.push(entry);
- } else {
- this.pushStack(entry);
- }
+ this.inlineStack = [];
+ for (var i = 0, len = inlineStack.length; i < len; i++) {
+ var entry = inlineStack[i];
+ /* istanbul ignore if */
+ if (entry instanceof Literal) {
+ this.compileStack.push(entry);
+ } else {
+ var stack = this.incrStack();
+ this.pushSource([stack, ' = ', entry, ';']);
+ this.compileStack.push(stack);
}
}
},
@@ -802,6 +842,7 @@ JavaScriptCompiler.prototype = {
var stack = (this.isInline() ? this.inlineStack : this.compileStack),
item = stack[stack.length - 1];
+ /* istanbul ignore if */
if (item instanceof Literal) {
return item.value;
} else {
@@ -818,25 +859,25 @@ JavaScriptCompiler.prototype = {
},
quotedString: function(str) {
- return '"' + str
- .replace(/\\/g, '\\\\')
- .replace(/"/g, '\\"')
- .replace(/\n/g, '\\n')
- .replace(/\r/g, '\\r')
- .replace(/\u2028/g, '\\u2028') // Per Ecma-262 7.3 + 7.8.4
- .replace(/\u2029/g, '\\u2029') + '"';
+ return this.source.quotedString(str);
},
objectLiteral: function(obj) {
- var pairs = [];
+ return this.source.objectLiteral(obj);
+ },
- for (var key in obj) {
- if (obj.hasOwnProperty(key)) {
- pairs.push(this.quotedString(key) + ':' + obj[key]);
- }
+ aliasable: function(name) {
+ var ret = this.aliases[name];
+ if (ret) {
+ ret.referenceCount++;
+ return ret;
}
- return '{' + pairs.join(',') + '}';
+ ret = this.aliases[name] = this.source.wrap(name);
+ ret.aliasable = true;
+ ret.referenceCount = 1;
+
+ return ret;
},
setupHelper: function(paramSize, name, blockHelper) {
@@ -848,11 +889,11 @@ JavaScriptCompiler.prototype = {
params: params,
paramsInit: paramsInit,
name: foundHelper,
- callParams: [this.contextName(0)].concat(params).join(", ")
+ callParams: [this.contextName(0)].concat(params)
};
},
- setupOptions: function(helper, paramSize, params) {
+ setupParams: function(helper, paramSize, params, useRegister) {
var options = {}, contexts = [], types = [], ids = [], param, inverse, program;
options.name = this.quotedString(helper);
@@ -872,16 +913,8 @@ JavaScriptCompiler.prototype = {
// Avoid setting fn and inverse if neither are set. This allows
// helpers to do a check for `if (options.fn)`
if (program || inverse) {
- if (!program) {
- program = 'this.noop';
- }
-
- if (!inverse) {
- inverse = 'this.noop';
- }
-
- options.fn = program;
- options.inverse = inverse;
+ options.fn = program || 'this.noop';
+ options.inverse = inverse || 'this.noop';
}
// The parameters go on to the stack in order (making sure that they are evaluated in order)
@@ -901,29 +934,22 @@ JavaScriptCompiler.prototype = {
}
if (this.trackIds) {
- options.ids = "[" + ids.join(",") + "]";
+ options.ids = this.source.generateArray(ids);
}
if (this.stringParams) {
- options.types = "[" + types.join(",") + "]";
- options.contexts = "[" + contexts.join(",") + "]";
+ options.types = this.source.generateArray(types);
+ options.contexts = this.source.generateArray(contexts);
}
if (this.options.data) {
options.data = "data";
}
- return options;
- },
-
- // the params and contexts arguments are passed in arrays
- // to fill in
- setupParams: function(helperName, paramSize, params, useRegister) {
- var options = this.objectLiteral(this.setupOptions(helperName, paramSize, params));
-
+ options = this.objectLiteral(options);
if (useRegister) {
this.useRegister('options');
params.push('options');
- return 'options=' + options;
+ return ['options=', options];
} else {
params.push(options);
return '';
@@ -931,6 +957,7 @@ JavaScriptCompiler.prototype = {
}
};
+
var reservedWords = (
"break else new var" +
" case finally return void" +
generated by cgit v1.1 at 2025-05-29 02:33:39 +0000